rudeshark.net/src/client/app/common/views/components/mfm.ts

292 lines
6.8 KiB
TypeScript
Raw Normal View History

2018-09-11 20:32:47 +02:00
import Vue, { VNode } from 'vue';
import { length } from 'stringz';
import { Node } from '../../../../../mfm/parser';
import parse from '../../../../../mfm/parse';
import MkUrl from './url.vue';
2018-12-08 17:00:03 +01:00
import { concat, sum } from '../../../../../prelude/array';
2018-11-16 09:55:48 +01:00
import MkFormula from './formula.vue';
import MkGoogle from './google.vue';
import { toUnicode } from 'punycode';
import syntaxHighlight from '../../../../../mfm/syntax-highlight';
2018-11-21 17:51:26 +01:00
function getTextCount(tokens: Node[]): number {
let count = 0;
const extract = (tokens: Node[]) => {
2018-12-08 17:00:03 +01:00
count += sum(tokens.filter(x => x.name === 'text').map(x => length(x.props.text)));
tokens.filter(x => x.children).forEach(x => {
extract(x.children);
});
};
extract(tokens);
2018-11-21 17:51:26 +01:00
return count;
}
function getChildrenCount(tokens: Node[]): number {
let count = 0;
const extract = (tokens: Node[]) => {
tokens.filter(x => x.children).forEach(x => {
count++;
extract(x.children);
});
};
extract(tokens);
return count;
}
2018-06-20 12:55:34 +02:00
export default Vue.component('misskey-flavored-markdown', {
props: {
text: {
type: String,
required: true
},
ast: {
type: [],
required: false
},
shouldBreak: {
type: Boolean,
default: true
},
plainText: {
type: Boolean,
default: false
},
author: {
type: Object,
default: null
},
i: {
type: Object,
default: null
},
customEmojis: {
required: false,
}
},
render(createElement) {
if (this.text == null || this.text == '') return;
2018-12-08 19:44:37 +01:00
const ast = this.ast == null ?
parse(this.text, this.plainText) : // Parse text to ast
this.ast as Node[];
let bigCount = 0;
let motionCount = 0;
const genEl = (ast: Node[]) => concat(ast.map((token): VNode[] => {
switch (token.name) {
case 'text': {
const text = token.props.text.replace(/(\r\n|\n|\r)/g, '\n');
if (this.shouldBreak) {
const x = text.split('\n')
.map(t => t == '' ? [createElement('br')] : [createElement('span', t), createElement('br')]);
x[x.length - 1].pop();
return x;
} else {
2018-09-11 20:32:47 +02:00
return [createElement('span', text.replace(/\n/g, ' '))];
}
}
case 'bold': {
return [createElement('b', genEl(token.children))];
}
2018-08-03 16:27:37 +02:00
case 'strike': {
return [createElement('del', genEl(token.children))];
}
2018-12-05 09:39:26 +01:00
case 'italic': {
return (createElement as any)('i', {
attrs: {
style: 'font-style: oblique;'
},
}, genEl(token.children));
}
case 'big': {
bigCount++;
2018-11-21 17:51:26 +01:00
const isLong = getTextCount(token.children) > 10 || getChildrenCount(token.children) > 5;
const isMany = bigCount > 3;
2018-08-03 16:27:37 +02:00
return (createElement as any)('strong', {
attrs: {
2018-08-05 16:38:31 +02:00
style: `display: inline-block; font-size: ${ isMany ? '100%' : '150%' };`
2018-08-03 16:27:37 +02:00
},
directives: [this.$store.state.settings.disableAnimatedMfm || isLong || isMany ? {} : {
2018-08-03 16:27:37 +02:00
name: 'animate-css',
value: { classes: 'tada', iteration: 'infinite' }
}]
}, genEl(token.children));
}
2018-12-05 12:11:54 +01:00
case 'small': {
return [createElement('small', genEl(token.children))];
}
2018-11-25 05:36:40 +01:00
case 'center': {
return [createElement('div', {
attrs: {
style: 'text-align:center;'
}
}, genEl(token.children))];
}
case 'motion': {
motionCount++;
2018-11-21 17:51:26 +01:00
const isLong = getTextCount(token.children) > 10 || getChildrenCount(token.children) > 5;
const isMany = motionCount > 3;
2018-08-05 05:33:51 +02:00
return (createElement as any)('span', {
attrs: {
style: 'display: inline-block;'
},
directives: [this.$store.state.settings.disableAnimatedMfm || isLong || isMany ? {} : {
2018-08-05 05:33:51 +02:00
name: 'animate-css',
value: { classes: 'rubberBand', iteration: 'infinite' }
}]
}, genEl(token.children));
}
2018-08-05 05:33:51 +02:00
case 'url': {
2018-09-11 20:32:47 +02:00
return [createElement(MkUrl, {
key: Math.random(),
props: {
url: token.props.url,
2018-10-08 08:47:41 +02:00
target: '_blank',
style: 'color:var(--mfmLink);'
}
2018-09-11 20:32:47 +02:00
})];
}
case 'link': {
2018-09-11 20:32:47 +02:00
return [createElement('a', {
attrs: {
class: 'link',
href: token.props.url,
target: '_blank',
title: token.props.url,
2018-10-08 08:47:41 +02:00
style: 'color:var(--mfmLink);'
}
}, genEl(token.children))];
}
case 'mention': {
const host = token.props.host == null && this.author && this.author.host != null ? this.author.host : token.props.host;
const canonical = host != null ? `@${token.props.username}@${toUnicode(host)}` : `@${token.props.username}`;
return (createElement as any)('router-link', {
key: Math.random(),
attrs: {
to: `/${canonical}`,
// TODO
//dataIsMe: (this as any).i && getAcct((this as any).i) == getAcct(token),
2018-10-08 08:47:41 +02:00
style: 'color:var(--mfmMention);'
},
directives: [{
name: 'user-preview',
value: canonical
}]
}, canonical);
}
case 'hashtag': {
return [createElement('router-link', {
key: Math.random(),
attrs: {
to: `/tags/${encodeURIComponent(token.props.hashtag)}`,
2018-10-08 08:47:41 +02:00
style: 'color:var(--mfmHashtag);'
}
}, `#${token.props.hashtag}`)];
}
case 'blockCode': {
2018-09-11 20:32:47 +02:00
return [createElement('pre', {
2018-04-19 08:05:39 +02:00
class: 'code'
}, [
createElement('code', {
domProps: {
innerHTML: syntaxHighlight(token.props.code)
}
})
2018-09-11 20:32:47 +02:00
])];
}
case 'inlineCode': {
2018-09-11 20:32:47 +02:00
return [createElement('code', {
domProps: {
innerHTML: syntaxHighlight(token.props.code)
}
2018-09-11 20:32:47 +02:00
})];
}
case 'quote': {
if (this.shouldBreak) {
2018-09-11 20:32:47 +02:00
return [createElement('div', {
attrs: {
class: 'quote'
}
}, genEl(token.children))];
} else {
2018-09-11 20:32:47 +02:00
return [createElement('span', {
attrs: {
class: 'quote'
}
}, genEl(token.children))];
}
}
case 'title': {
2018-09-11 20:32:47 +02:00
return [createElement('div', {
2018-04-19 08:05:39 +02:00
attrs: {
class: 'title'
}
}, genEl(token.children))];
}
2018-04-19 08:05:39 +02:00
case 'emoji': {
2018-11-09 00:13:34 +01:00
const customEmojis = (this.$root.getMetaSync() || { emojis: [] }).emojis || [];
2018-11-05 03:19:40 +01:00
return [createElement('mk-emoji', {
key: Math.random(),
2018-11-05 12:49:02 +01:00
attrs: {
emoji: token.props.emoji,
name: token.props.name
2018-11-05 12:49:02 +01:00
},
props: {
customEmojis: this.customEmojis || customEmojis,
normal: this.plainText
2018-11-05 12:49:02 +01:00
}
2018-11-05 03:19:40 +01:00
})];
}
2018-11-16 09:03:52 +01:00
case 'math': {
2018-11-16 09:55:48 +01:00
//const MkFormula = () => import('./formula.vue').then(m => m.default);
2018-11-16 09:03:52 +01:00
return [createElement(MkFormula, {
key: Math.random(),
2018-11-16 09:03:52 +01:00
props: {
formula: token.props.formula
2018-11-16 09:03:52 +01:00
}
})];
}
case 'search': {
2018-11-16 09:55:48 +01:00
//const MkGoogle = () => import('./google.vue').then(m => m.default);
2018-09-11 20:32:47 +02:00
return [createElement(MkGoogle, {
key: Math.random(),
2018-04-21 11:59:16 +02:00
props: {
q: token.props.query
2018-04-21 11:59:16 +02:00
}
2018-09-11 20:32:47 +02:00
})];
}
2018-04-21 11:59:16 +02:00
default: {
console.log('unknown ast type:', token.name);
2018-09-11 20:32:47 +02:00
return [];
}
}
}));
// Parse ast to DOM
return createElement('span', genEl(ast));
}
});