@diplodoc/transform 4.0.0

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

@@ -0,0 +1,166 @@
+import {bold} from 'chalk';
+import GithubSlugger from 'github-slugger';
+
+import {headingInfo} from '../../utils';
+import {CUSTOM_ID_REGEXP, CUSTOM_ID_EXCEPTION} from './constants';
+import StateCore from 'markdown-it/lib/rules_core/state_core';
+import Token from 'markdown-it/lib/token';
+import {escapeHtml} from 'markdown-it/lib/common/utils';
+import {MarkdownItPluginCb} from '../typings';
+
+const slugify: (str: string, opts: {}) => string = require('slugify');
+
+function createLinkTokens(state: StateCore, id: string, title: string, setId = false) {
+    const open = new state.Token('link_open', 'a', 1);
+    const close = new state.Token('link_close', 'a', -1);
+
+    if (setId) {
+        open.attrSet('id', id);
+    }
+    open.attrSet('href', '#' + id);
+    open.attrSet('class', 'yfm-anchor');
+    open.attrSet('aria-hidden', 'true');
+
+    // SEO: render invisible heading title because link must have text content.
+    const hiddenDesc = new state.Token('anchor_hidden_desc', '', 0);
+
+    hiddenDesc.content = title;
+
+    return [open, hiddenDesc, close];
+}
+
+const getCustomIds = (content: string) => {
+    const ids: string[] = [];
+
+    content.replace(CUSTOM_ID_REGEXP, (match, customId) => {
+        if (match !== CUSTOM_ID_EXCEPTION) {
+            ids.push(customId);
+        }
+
+        return '';
+    });
+
+    return ids.length ? ids : null;
+};
+
+const removeCustomId = (content: string) => {
+    if (CUSTOM_ID_REGEXP.test(content)) {
+        return content
+            .replace(CUSTOM_ID_REGEXP, (match) => {
+                if (match === CUSTOM_ID_EXCEPTION) {
+                    return match;
+                }
+
+                return '';
+            })
+            .trim();
+    }
+
+    return content;
+};
+const removeCustomIds = (token: Token) => {
+    token.content = removeCustomId(token.content);
+    token.children?.forEach((child) => {
+        child.content = removeCustomId(child.content);
+    });
+};
+
+interface Options {
+    extractTitle?: boolean;
+    supportGithubAnchors?: boolean;
+}
+
+const index: MarkdownItPluginCb<Options> = (
+    md,
+    {extractTitle, path, log, supportGithubAnchors},
+) => {
+    const plugin = (state: StateCore) => {
+        /* Do not use the plugin if it is included in the file */
+        if (state.env.includes && state.env.includes.length) {
+            return;
+        }
+
+        const ids: Record<string, number> = {};
+        const tokens = state.tokens;
+        let i = 0;
+        const slugger = new GithubSlugger();
+
+        while (i < tokens.length) {
+            const token = tokens[i];
+            const isHeading = token.type === 'heading_open';
+
+            if (isHeading) {
+                const {title, level} = headingInfo(tokens, i);
+
+                const inlineToken = tokens[i + 1];
+                let id = token.attrGet('id');
+                let ghId: string;
+
+                if (!title) {
+                    log.warn(`Header without title${path ? ` in ${bold(path)}` : ''}`);
+                }
+
+                if (level < 2 && extractTitle) {
+                    i += 3;
+                    continue;
+                }
+
+                const customIds = getCustomIds(inlineToken.content);
+                if (customIds) {
+                    id = customIds[0];
+                    removeCustomIds(tokens[i + 1]);
+                } else {
+                    id = slugify(title, {
+                        lower: true,
+                        remove: /[*+~.()'"!:@`ь]/g,
+                    });
+                    ghId = slugger.slug(title);
+                }
+
+                token.attrSet('id', id);
+
+                if (ids[id]) {
+                    id = id + ids[id]++;
+                    token.attrSet('id', id);
+                } else {
+                    ids[id] = 1;
+                }
+
+                const allAnchorIds = customIds ? customIds : [id];
+                const anchorTitle = removeCustomId(title).replace(/`/g, '');
+                allAnchorIds.forEach((customId) => {
+                    const setId = id !== customId;
+                    const linkTokens = createLinkTokens(state, customId, anchorTitle, setId);
+
+                    inlineToken.children?.unshift(...linkTokens);
+
+                    if (supportGithubAnchors) {
+                        const ghLinkTokens = createLinkTokens(state, ghId, anchorTitle, true);
+                        inlineToken.children?.unshift(...ghLinkTokens);
+                    }
+                });
+
+                i += 3;
+                continue;
+            }
+
+            i++;
+        }
+    };
+
+    try {
+        md.core.ruler.after('includes', 'anchors', plugin);
+    } catch {
+        try {
+            md.core.ruler.after('curly_attributes', 'anchors', plugin);
+        } catch {
+            md.core.ruler.push('anchors', plugin);
+        }
+    }
+
+    md.renderer.rules.anchor_hidden_desc = function (tokens, index) {
+        return '<span class="visually-hidden">' + escapeHtml(tokens[index].content) + '</span>';
+    };
+};
+
+export = index;

package/src/transform/plugins/changelog/collect.ts

@@ -0,0 +1,66 @@
+import {bold} from 'chalk';
+import {ChangelogItem} from './types';
+import initMarkdownit from '../../md';
+import changelogPlugin from './index';
+import imsize from '../imsize';
+import {MarkdownItPluginOpts} from '../typings';
+
+const BLOCK_START = '{% changelog %}';
+const BLOCK_END = '{% endchangelog %}\n';
+
+function parseChangelogs(str: string, path?: string) {
+    const {parse, compile, env} = initMarkdownit({
+        plugins: [changelogPlugin, imsize],
+        extractChangelogs: true,
+        path,
+    });
+
+    compile(parse(str));
+
+    return env.changelogs || [];
+}
+
+type Options = Pick<MarkdownItPluginOpts, 'path' | 'log'> & {
+    changelogs?: ChangelogItem[];
+    extractChangelogs?: boolean;
+};
+
+const collect = (input: string, {path: filepath, log, changelogs, extractChangelogs}: Options) => {
+    let result = input;
+    let lastPos = 0;
+    const rawChanges = [];
+
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const pos = result.indexOf(BLOCK_START, lastPos);
+        lastPos = pos;
+        if (pos === -1) {
+            break;
+        }
+        const endPos = result.indexOf(BLOCK_END, pos + BLOCK_START.length);
+        if (endPos === -1) {
+            log.error(`Changelog block must be closed${filepath ? ` in ${bold(filepath)}` : ''}`);
+            break;
+        }
+
+        const change = result.slice(pos, endPos + BLOCK_END.length);
+
+        rawChanges.push(change);
+
+        result = result.slice(0, pos) + result.slice(endPos + BLOCK_END.length);
+    }
+
+    if (rawChanges.length && changelogs && extractChangelogs) {
+        const parsedChangelogs = parseChangelogs(rawChanges.join('\n\n'), filepath);
+        if (parsedChangelogs.length !== rawChanges.length) {
+            log.error(
+                `Parsed cahngelogs less than expected${filepath ? ` in ${bold(filepath)}` : ''}`,
+            );
+        }
+        changelogs.push(...parsedChangelogs);
+    }
+
+    return result;
+};
+
+export = collect;

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

@@ -0,0 +1,164 @@
+import {MarkdownItPluginCb} from '../typings';
+import Core from 'markdown-it/lib/parser_core';
+import Token from 'markdown-it/lib/token';
+import {bold} from 'chalk';
+import yaml from 'js-yaml';
+import StateCore from 'markdown-it/lib/rules_core/state_core';
+
+interface Options {
+    extractChangelogs?: boolean;
+}
+
+const CHANGELOG_OPEN_RE = /^\{% changelog %}/;
+const CHANGELOG_CLOSE_RE = /^\{% endchangelog %}/;
+
+function isOpenToken(tokens: Token[], i: number) {
+    return (
+        tokens[i].type === 'paragraph_open' &&
+        tokens[i + 1].type === 'inline' &&
+        tokens[i + 2].type === 'paragraph_close' &&
+        CHANGELOG_OPEN_RE.test(tokens[i + 1].content)
+    );
+}
+
+function isCloseToken(tokens: Token[], i: number) {
+    return (
+        tokens[i]?.type === 'paragraph_open' &&
+        tokens[i + 1].type === 'inline' &&
+        tokens[i + 2].type === 'paragraph_close' &&
+        CHANGELOG_CLOSE_RE.test(tokens[i + 1].content)
+    );
+}
+
+function isTitle(tokens: Token[], i = 0) {
+    return (
+        tokens[i].type === 'heading_open' &&
+        tokens[i + 1].type === 'inline' &&
+        tokens[i + 2].type === 'heading_close'
+    );
+}
+
+function isImageParagraph(tokens: Token[], i = 0) {
+    return (
+        tokens[i].type === 'paragraph_open' &&
+        tokens[i + 1].type === 'inline' &&
+        tokens[i + 2].type === 'paragraph_close' &&
+        tokens[i + 1].children?.some((t) => t.type === 'image')
+    );
+}
+
+function parseBody(tokens: Token[], state: StateCore) {
+    const {md, env} = state;
+
+    const metadataToken = tokens.shift();
+    if (metadataToken?.type !== 'fence') {
+        throw new Error('Metadata tag not found');
+    }
+
+    let metadata: object = {};
+    const rawMetadata = yaml.load(metadataToken.content, {
+        schema: yaml.JSON_SCHEMA,
+    });
+    if (rawMetadata && typeof rawMetadata === 'object') {
+        metadata = rawMetadata;
+    }
+
+    if (!isTitle(tokens)) {
+        throw new Error('Title tag not found');
+    }
+    const title = tokens.splice(0, 3)[1].content;
+
+    let image;
+    if (isImageParagraph(tokens)) {
+        const paragraphTokens = tokens.splice(0, 3);
+        const imageToken = paragraphTokens[1]?.children?.find((token) => token.type === 'image');
+        if (imageToken) {
+            const width = Number(imageToken.attrGet('width'));
+            const height = Number(imageToken.attrGet('height'));
+            let ratio;
+            if (Number.isFinite(width) && Number.isFinite(height)) {
+                ratio = height / width;
+            }
+            let alt = imageToken.attrGet('title') || '';
+            if (!alt && imageToken.children) {
+                alt = md.renderer.renderInlineAsText(imageToken.children, md.options, env);
+            }
+            image = {
+                src: imageToken.attrGet('src'),
+                alt,
+                ratio,
+            };
+        }
+    }
+
+    const description = md.renderer.render(tokens, md.options, env);
+
+    return {
+        ...metadata,
+        title,
+        image,
+        description,
+    };
+}
+
+const changelog: MarkdownItPluginCb<Options> = function (md, {extractChangelogs, log, path}) {
+    const plugin: Core.RuleCore = (state) => {
+        const {tokens, env} = state;
+
+        for (let i = 0, len = tokens.length; i < len; i++) {
+            const isOpen = isOpenToken(tokens, i);
+            if (!isOpen) continue;
+
+            const openAt = i;
+            let isCloseFound = false;
+            while (i < len) {
+                i++;
+                if (isCloseToken(tokens, i)) {
+                    isCloseFound = true;
+                    break;
+                }
+            }
+
+            if (!isCloseFound) {
+                log.error(`Changelog close tag in not found: ${bold(path)}`);
+                break;
+            }
+
+            const closeAt = i + 2;
+
+            if (env && extractChangelogs) {
+                const content = tokens.slice(openAt, closeAt + 1);
+
+                // cut open
+                content.splice(0, 3);
+                // cut close
+                content.splice(-3);
+
+                try {
+                    const change = parseBody(content, state);
+
+                    if (!env.changelogs) {
+                        env.changelogs = [];
+                    }
+
+                    env.changelogs.push(change);
+                } catch (err) {
+                    log.error(`Changelog error: ${(err as Error).message} in ${bold(path)}`);
+                    continue;
+                }
+            }
+
+            tokens.splice(openAt, closeAt + 1 - openAt);
+            len = tokens.length;
+            i = openAt - 1;
+        }
+    };
+
+    try {
+        md.core.ruler.before('curly_attributes', 'changelog', plugin);
+    } catch (e) {
+        md.core.ruler.push('changelog', plugin);
+    }
+};
+
+export = changelog;

package/src/transform/plugins/changelog/types.ts

@@ -0,0 +1,10 @@
+export interface ChangelogItem {
+    title: string;
+    image: {
+        src: string;
+        alt: string;
+        ratio?: string;
+    };
+    description: string;
+    [x: string]: unknown;
+}

package/src/transform/plugins/checkbox/checkbox.ts

@@ -0,0 +1,107 @@
+import type MarkdownIt from 'markdown-it';
+import type StateCore from 'markdown-it/lib/rules_core/state_core';
+import type Token from 'markdown-it/lib/token';
+
+// eslint-disable-next-line no-useless-escape
+const pattern = /^\[(X|\s|\_|\-)\]\s(.*)/i;
+
+function matchOpenToken(tokens: Token[], i: number) {
+    return (
+        tokens[i].type === 'paragraph_open' &&
+        tokens[i + 1].type === 'inline' &&
+        tokens[i + 1].content.match(pattern)
+    );
+}
+
+export type CheckboxOptions = {
+    idPrefix?: string;
+    divClass?: string;
+};
+
+export const checkboxReplace = function (_md: MarkdownIt, opts: CheckboxOptions) {
+    let lastId = 0;
+    const defaults = {
+        divClass: 'checkbox',
+        idPrefix: 'checkbox',
+    };
+    const options = Object.assign(defaults, opts);
+
+    const createTokens = function (state: StateCore, checked: boolean, label: string, i: number) {
+        let token: Token;
+        const nodes = [];
+
+        /**
+         * <div class="checkbox">
+         */
+        token = new state.Token('checkbox_open', 'div', 1);
+        token.block = true;
+        token.map = state.tokens[i].map;
+        token.attrs = [['class', options.divClass]];
+        nodes.push(token);
+
+        /**
+         * <input type="checkbox" id="checkbox{n}" checked="true">
+         */
+        const id = options.idPrefix + lastId;
+        lastId += 1;
+        token = new state.Token('checkbox_input', 'input', 0);
+        token.block = true;
+        token.map = state.tokens[i].map;
+        token.attrs = [
+            ['type', 'checkbox'],
+            ['id', id],
+            ['disabled', ''],
+        ];
+        if (checked === true) {
+            token.attrs.push(['checked', 'true']);
+        }
+        nodes.push(token);
+
+        /**
+         * <label for="checkbox{n}">
+         */
+        token = new state.Token('checkbox_label_open', 'label', 1);
+        token.attrs = [['for', id]];
+        nodes.push(token);
+
+        /**
+         * content of label tag
+         */
+        token = state.md.parseInline(label, state.env)[0];
+        nodes.push(token);
+
+        /**
+         * closing tags
+         */
+        token = new state.Token('checkbox_label_close', 'label', -1);
+        token.block = true;
+        token.map = state.tokens[i].map;
+        nodes.push(token);
+        token = new state.Token('checkbox_close', 'div', -1);
+        token.block = true;
+        token.map = state.tokens[i].map;
+        nodes.push(token);
+
+        return nodes;
+    };
+    const splitTextToken = function (state: StateCore, matches: RegExpMatchArray, i: number) {
+        let checked = false;
+        const value = matches[1];
+        const label = matches[2];
+        if (value === 'X' || value === 'x') {
+            checked = true;
+        }
+        return createTokens(state, checked, label, i);
+    };
+    return function (state: StateCore) {
+        const blockTokens = state.tokens;
+        for (let i = 0; i < blockTokens.length; i++) {
+            const match = matchOpenToken(blockTokens, i);
+            if (!match) {
+                continue;
+            }
+
+            blockTokens.splice(i, 3, ...splitTextToken(state, match, i));
+        }
+    };
+};

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

@@ -0,0 +1,15 @@
+import MarkdownIt from 'markdown-it';
+import {CheckboxOptions, checkboxReplace} from './checkbox';
+
+/**
+ * Checkbox plugin for markdown-it.
+ * Forked from https://github.com/mcecot/markdown-it-checkbox
+ */
+
+const checkbox = (md: MarkdownIt, options: CheckboxOptions) => {
+    md.core.ruler.push('checkbox', checkboxReplace(md, options));
+
+    return md;
+};
+
+export = checkbox;

package/src/transform/plugins/code.ts

@@ -0,0 +1,79 @@
+/* eslint-disable max-len */
+
+import {MarkdownItPluginCb} from './typings';
+import {generateID} from './utils';
+
+const wrapInClipboard = (element: string | undefined, id: number) => {
+    return `
+    <div class="yfm-clipboard">
+    ${element}
+    <svg width="16" height="16" viewBox="0 0 24 24" class="yfm-clipboard-button" data-animation="${id}">
+        <path
+            fill="currentColor"
+            d="M19,21H8V7H19M19,5H8A2,2 0 0,0 6,7V21A2,2 0 0,0 8,23H19A2,2 0 0,0 21,21V7A2,2 0 0,0 19,5M16,1H4A2,2 0 0,0 2,3V17H4V3H16V1Z"
+        />
+        <path
+            stroke="currentColor"
+            fill="transparent"
+            stroke-width="1.5"
+            d="M9.5 13l3 3l5 -5"
+            visibility="hidden"
+        >
+            <animate
+                id="visibileAnimation-${id}"
+                attributeName="visibility"
+                from="hidden"
+                to="visible"
+                dur="0.2s"
+                fill="freeze"
+                begin=""
+            />
+            <animate
+                id="hideAnimation-${id}"
+                attributeName="visibility"
+                from="visible"
+                to="hidden"
+                dur="1s"
+                begin="visibileAnimation-${id}.end+1"
+                fill="freeze"
+            />
+        </path>
+    </svg>
+    </div>
+`;
+};
+
+interface EnvTerm {
+    terms: {
+        [keys: string]: string;
+    };
+}
+
+function termReplace(str: string, env: EnvTerm): string {
+    const regTerms = Object.keys(env.terms)
+        .map((el) => el.substr(1))
+        .join('|');
+    const regText = '\\[([^\\[]+)\\](\\(\\*(' + regTerms + ')\\))';
+    const reg = new RegExp(regText, 'g');
+
+    const termCode = str.replace(
+        reg,
+        (_match: string, p1: string, _p2: string, p3: string) =>
+            `<i class="yfm yfm-term_title" term-key=":${p3}" id="${generateID()}">${p1}</i>`,
+    );
+
+    return termCode || str;
+}
+
+const code: MarkdownItPluginCb = (md) => {
+    const superCodeRenderer = md.renderer.rules.fence;
+    md.renderer.rules.fence = function (tokens, idx, options, env, self) {
+        const superCode = superCodeRenderer?.(tokens, idx, options, env, self);
+        const superCodeWithTerms =
+            superCode && env?.terms ? termReplace(superCode, env) : superCode;
+
+        return wrapInClipboard(superCodeWithTerms, idx);
+    };
+};
+
+export = code;