@diplodoc/transform 4.0.0

package/src/transform/plugins/links/index.ts

@@ -0,0 +1,218 @@
+import url from 'url';
+import {bold} from 'chalk';
+import {isLocalUrl, findBlockTokens, headingInfo, getHrefTokenAttr} from '../../utils';
+import {isFileExists, getFileTokens} from '../../utilsFS';
+import {PAGE_LINK_REGEXP} from './constants';
+import Token from 'markdown-it/lib/token';
+import {Logger} from 'src/transform/log';
+import {MarkdownItPluginCb, MarkdownItPluginOpts} from '../typings';
+import path, {isAbsolute, parse, relative, resolve} from 'path';
+import {StateCore} from 'src/transform/typings';
+
+function defaultTransformLink(href: string) {
+    const parsed = url.parse(href);
+
+    return url.format({
+        ...parsed,
+        pathname: parsed.pathname?.replace(PAGE_LINK_REGEXP, '.html'),
+    });
+}
+
+function getTitleFromTokens(tokens: Token[]) {
+    let title = '';
+
+    let i = 0;
+    while (i < tokens.length) {
+        const token = tokens[i];
+
+        if (token.type === 'heading_open') {
+            ({title = ''} = headingInfo(tokens, i));
+
+            break;
+        }
+
+        i += 2;
+    }
+
+    return title;
+}
+
+type Options = {
+    hash: string | null;
+    file: string;
+    state: StateCore;
+    opts: object;
+    isEmptyLink: boolean;
+    tokens: Token[];
+    idx: number;
+    nextToken: Token;
+    href: string;
+    currentPath: string;
+    log: Logger;
+};
+
+const addTitle = (options: Options) => {
+    const {hash, file, state, opts, isEmptyLink, tokens, idx, nextToken, href, currentPath, log} =
+        options;
+
+    const id = hash && hash.slice(1);
+    const fileTokens = getFileTokens(file, state, {
+        ...opts,
+        disableLint: true,
+        disableTitleRefSubstitution: true,
+        disableCircularError: true,
+        inheritVars: false,
+    });
+    const sourceTokens = id ? findBlockTokens(fileTokens, id) : fileTokens;
+    const title = getTitleFromTokens(sourceTokens);
+
+    if (title) {
+        let textToken;
+
+        if (isEmptyLink) {
+            textToken = new state.Token('text', '', 0);
+            tokens.splice(idx + 1, 0, textToken);
+        } else {
+            textToken = nextToken;
+        }
+
+        textToken.content = title;
+    } else {
+        log.warn(`Title not found: ${bold(href)} in ${bold(currentPath)}`);
+    }
+};
+
+interface ProcOpts extends MarkdownItPluginOpts {
+    transformLink: (v: string) => string;
+    notFoundCb: (v: string) => void;
+    needSkipLinkFn: (v: string) => boolean;
+}
+
+// eslint-disable-next-line complexity
+function processLink(state: StateCore, tokens: Token[], idx: number, opts: ProcOpts) {
+    const {path: startPath, root, transformLink, notFoundCb, needSkipLinkFn, log} = opts;
+    const currentPath = state.env.path || startPath;
+    const linkToken = tokens[idx];
+    const nextToken = tokens[idx + 1];
+
+    let href = getHrefTokenAttr(linkToken);
+
+    if (!href) {
+        log.error(`Empty link in ${bold(startPath)}`);
+        return;
+    }
+
+    const {pathname, hash} = url.parse(href);
+    let file;
+    let fileExists;
+    let isPageFile;
+
+    if (!isLocalUrl(href)) {
+        linkToken.attrSet('target', '_blank');
+        linkToken.attrSet('rel', 'noreferrer noopener');
+        return;
+    }
+
+    if (pathname) {
+        file = resolve(path.parse(currentPath).dir, pathname);
+        fileExists = isFileExists(file);
+        isPageFile = PAGE_LINK_REGEXP.test(pathname);
+
+        if (isPageFile && !fileExists) {
+            let needShowError = true;
+            if (needSkipLinkFn) {
+                needShowError = !needSkipLinkFn(href);
+            }
+
+            if (notFoundCb && needShowError) {
+                notFoundCb(file.replace(root, ''));
+            }
+
+            if (needShowError) {
+                log.error(`Link is unreachable: ${bold(href)} in ${bold(currentPath)}`);
+            }
+        }
+    } else if (hash) {
+        file = startPath;
+        fileExists = true;
+        isPageFile = true;
+    } else {
+        return;
+    }
+
+    const isEmptyLink = nextToken.type === 'link_close';
+    const isTitleRefLink = nextToken.type === 'text' && nextToken.content === '{#T}';
+    if (
+        (isEmptyLink || isTitleRefLink) &&
+        fileExists &&
+        isPageFile &&
+        !state.env.disableTitleRefSubstitution
+    ) {
+        addTitle({
+            hash,
+            file,
+            state,
+            opts,
+            isEmptyLink,
+            tokens,
+            idx,
+            nextToken,
+            href,
+            currentPath,
+            log,
+        });
+    }
+
+    let newPathname = '';
+    if (!isAbsolute(href) && currentPath !== startPath) {
+        newPathname = relative(parse(startPath).dir, file);
+
+        href = url.format({
+            ...url.parse(href),
+            pathname: newPathname,
+        });
+    }
+
+    if (pathname || newPathname) {
+        const transformer = transformLink || defaultTransformLink;
+        linkToken.attrSet('href', transformer(href));
+    }
+}
+
+const index: MarkdownItPluginCb<ProcOpts & Options> = (md, opts) => {
+    const plugin = (state: StateCore) => {
+        const tokens = state.tokens;
+        let i = 0;
+
+        while (i < tokens.length) {
+            if (tokens[i].type === 'inline') {
+                const childrenTokens = tokens[i].children || [];
+                let j = 0;
+
+                while (j < childrenTokens.length) {
+                    const isLinkOpenToken = childrenTokens[j].type === 'link_open';
+                    const tokenClass = childrenTokens[j].attrGet('class');
+
+                    /*  Don't process anchor links */
+                    const isYfmAnchor = tokenClass ? tokenClass.includes('yfm-anchor') : false;
+
+                    if (isLinkOpenToken && !isYfmAnchor) {
+                        processLink(state, childrenTokens, j, opts);
+                    }
+
+                    j++;
+                }
+            }
+
+            i++;
+        }
+    };
+
+    try {
+        md.core.ruler.before('includes', 'links', plugin);
+    } catch (e) {
+        md.core.ruler.push('links', plugin);
+    }
+};
+
+export = index;

package/src/transform/plugins/meta.ts

@@ -0,0 +1,5 @@
+// @ts-expect-error
+import meta from 'markdown-it-meta';
+import {MarkdownItPluginCb} from './typings';
+
+export = meta as MarkdownItPluginCb;

package/src/transform/plugins/monospace.ts

@@ -0,0 +1,141 @@
+import StateInline, {Delimiter} from 'markdown-it/lib/rules_inline/state_inline';
+import {MarkdownItPluginCb} from './typings';
+
+const monospace: MarkdownItPluginCb = (md) => {
+    function postProcess(state: StateInline, delimiters: Delimiter[]) {
+        let token;
+        const loneMarkers = [];
+
+        for (let i = 0; i < delimiters.length; i++) {
+            const startDelim = delimiters[i];
+
+            if (startDelim.marker !== 0x23 /* # */) {
+                continue;
+            }
+
+            if (startDelim.end === -1) {
+                continue;
+            }
+
+            const endDelim = delimiters[startDelim.end];
+
+            token = state.tokens[startDelim.token];
+            token.type = 'monospace_open';
+            token.tag = 'samp';
+            token.nesting = 1;
+            token.markup = '##';
+            token.content = '';
+
+            token = state.tokens[endDelim.token];
+            token.type = 'monospace_close';
+            token.tag = 'samp';
+            token.nesting = -1;
+            token.markup = '##';
+            token.content = '';
+
+            if (
+                state.tokens[endDelim.token - 1].type === 'text' &&
+                state.tokens[endDelim.token - 1].content === '#'
+            ) {
+                loneMarkers.push(endDelim.token - 1);
+            }
+        }
+
+        // If a marker sequence has an odd number of characters, it's splitted
+        // like this: `#####` -> `#` + `##` + `##`, leaving one marker at the
+        // start of the sequence.
+        //
+        // So, we have to move all those markers after subsequent s_close tags.
+        //
+        while (loneMarkers.length) {
+            const currentMarker = loneMarkers.pop();
+            if (typeof currentMarker === 'number') {
+                let nextMarker = currentMarker + 1;
+
+                while (
+                    nextMarker < state.tokens.length &&
+                    state.tokens[nextMarker].type === 'monospace_close'
+                ) {
+                    nextMarker++;
+                }
+
+                nextMarker--;
+
+                if (currentMarker !== nextMarker) {
+                    token = state.tokens[nextMarker];
+                    state.tokens[nextMarker] = state.tokens[currentMarker];
+                    state.tokens[currentMarker] = token;
+                }
+            }
+        }
+    }
+
+    md.inline.ruler.before('emphasis', 'monospace', (state, silent) => {
+        let token;
+        const start = state.pos;
+        const marker = state.src.charCodeAt(start);
+
+        if (silent) {
+            return false;
+        }
+
+        if (marker !== 0x23 /* # */) {
+            return false;
+        }
+
+        const scanned = state.scanDelims(state.pos, true);
+        let len = scanned.length;
+        const ch = String.fromCharCode(marker);
+
+        if (len < 2) {
+            return false;
+        }
+
+        if (len % 2) {
+            token = state.push('text', '', 0);
+            token.content = ch;
+            len--;
+        }
+
+        for (let i = 0; i < len; i += 2) {
+            token = state.push('text', '', 0);
+            token.content = ch + ch;
+
+            if (!scanned.can_open && !scanned.can_close) {
+                continue;
+            }
+
+            state.delimiters.push({
+                marker: marker,
+                length: 0, // disable "rule of 3" length checks meant for emphasis
+                jump: i / 2, // 1 delimiter = 2 characters
+                token: state.tokens.length - 1,
+                end: -1,
+                open: scanned.can_open,
+                close: scanned.can_close,
+            });
+        }
+
+        state.pos += scanned.length;
+
+        return true;
+    });
+
+    md.inline.ruler2.before('emphasis', 'monospace', (state) => {
+        const tokensMeta = state.tokens_meta;
+        const max = (state.tokens_meta || []).length;
+
+        postProcess(state, state.delimiters);
+
+        for (let curr = 0; curr < max; curr++) {
+            const currentToken = tokensMeta[curr];
+            if (currentToken && currentToken.delimiters) {
+                postProcess(state, currentToken.delimiters);
+            }
+        }
+
+        return true;
+    });
+};
+
+export = monospace;

package/src/transform/plugins/notes.ts

@@ -0,0 +1,134 @@
+import {bold} from 'chalk';
+import StateCore from 'markdown-it/lib/rules_core/state_core';
+import Token from 'markdown-it/lib/token';
+import {MarkdownItPluginCb} from './typings';
+
+import {MatchTokenFunction, nestedCloseTokenIdxFactory as closeTokenFactory} from './utils';
+
+const ALERT_RE = /^{% note (alert|info|tip|warning)\s*(?:"(.*?)")? %}$/;
+const WRONG_NOTES = /^{% note (.*)%}/;
+
+const titles: Record<string, Record<string, string>> = {
+    ru: {
+        info: 'Примечание',
+        tip: 'Совет',
+        alert: 'Внимание',
+        warning: 'Важно',
+    },
+    en: {
+        info: 'Note',
+        tip: 'Tip',
+        alert: 'Alert',
+        warning: 'Warning',
+    },
+};
+
+function getTitle(type: string, originLang: keyof typeof titles) {
+    let lang = originLang;
+
+    if (!lang || !Object.keys(titles).includes(lang)) {
+        lang = 'ru';
+    }
+
+    return titles[lang][type];
+}
+const matchCloseToken: MatchTokenFunction = (tokens, i) => {
+    return (
+        tokens[i].type === 'paragraph_open' &&
+        tokens[i + 1].type === 'inline' &&
+        tokens[i + 1].content.trim() === '{% endnote %}'
+    );
+};
+
+function matchOpenToken(tokens: Token[], i: number) {
+    return (
+        tokens[i].type === 'paragraph_open' &&
+        tokens[i + 1].type === 'inline' &&
+        tokens[i + 1].content.match(ALERT_RE)
+    );
+}
+
+function matchWrongNotes(tokens: Token[], i: number) {
+    return (
+        tokens[i].type === 'paragraph_open' &&
+        tokens[i + 1].type === 'inline' &&
+        tokens[i + 1].content.match(WRONG_NOTES)
+    );
+}
+
+const findCloseTokenIdx = closeTokenFactory('Note', matchOpenToken, matchCloseToken);
+
+const notes: MarkdownItPluginCb = (md, {lang, path: optPath, log}) => {
+    const plugin = (state: StateCore) => {
+        const {tokens, env} = state;
+        const path = env.path || optPath;
+        let i = 0;
+
+        while (i < tokens.length) {
+            const match = matchOpenToken(tokens, i);
+
+            if (match) {
+                const closeTokenIdx = findCloseTokenIdx(tokens, i + 4, path, log);
+
+                if (!closeTokenIdx) {
+                    i += 3;
+                    continue;
+                }
+
+                const type = match[1].toLowerCase();
+                const newOpenToken = new state.Token('yfm_note_open', 'div', 1);
+                newOpenToken.attrSet('class', `yfm-note yfm-accent-${type}`);
+                newOpenToken.attrSet('note-type', type);
+                newOpenToken.map = tokens[i].map;
+
+                const newCloseToken = new state.Token('yfm_note_close', 'div', -1);
+                newCloseToken.map = tokens[closeTokenIdx].map;
+
+                // Add extra paragraph
+                const titleOpen = new state.Token('yfm_note_title_open', 'p', 1);
+                titleOpen.attrSet('class', 'yfm-note-title');
+                const titleInline = new state.Token('inline', '', 0);
+                const titleClose = new state.Token('yfm_note_title_close', 'p', -1);
+
+                if (match[2]) titleOpen.attrSet('yfm2xliff-explicit', 'true');
+                titleOpen.block = true;
+                titleClose.block = true;
+
+                titleInline.content = match[2] === undefined ? getTitle(type, lang) : match[2];
+                titleInline.children = [];
+                state.md.inline.parse(
+                    titleInline.content,
+                    state.md,
+                    state.env,
+                    titleInline.children,
+                );
+
+                const insideTokens = [
+                    newOpenToken,
+                    titleOpen,
+                    titleInline,
+                    titleClose,
+                    ...tokens.slice(i + 3, closeTokenIdx),
+                    newCloseToken,
+                ];
+                tokens.splice(i, closeTokenIdx - i + 3, ...insideTokens);
+
+                i++;
+            } else if (matchWrongNotes(tokens, i) && tokens[i + 1].content !== '{% endnote %}') {
+                log.warn(`Incorrect syntax for notes${path ? `, file ${bold(path)}` : ''}`);
+
+                i += 3;
+            } else {
+                i++;
+            }
+        }
+    };
+
+    try {
+        md.core.ruler.before('curly_attributes', 'notes', plugin);
+    } catch (e) {
+        md.core.ruler.push('notes', plugin);
+    }
+};
+
+export = notes;

package/src/transform/plugins/sup.ts

@@ -0,0 +1,5 @@
+// @ts-expect-error
+import sup from 'markdown-it-sup';
+import {MarkdownItPluginCb} from './typings';
+
+export = sup as MarkdownItPluginCb;