@diplodoc/transform 4.0.0

package/src/transform/plugins/cut.ts

@@ -0,0 +1,98 @@
+import type Core from 'markdown-it/lib/parser_core';
+import type Token from 'markdown-it/lib/token';
+import {MarkdownItPluginCb} from './typings';
+import {MatchTokenFunction, nestedCloseTokenIdxFactory as closeTokenFactory} from './utils';
+
+const CUT_REGEXP = /^{%\s*cut\s*["|'](.*)["|']\s*%}/;
+
+const matchCloseToken: MatchTokenFunction = (tokens, i) => {
+    return (
+        tokens[i].type === 'paragraph_open' &&
+        tokens[i + 1].type === 'inline' &&
+        tokens[i + 1].content.trim() === '{% endcut %}'
+    );
+};
+
+const matchOpenToken = (tokens: Token[], i: number) => {
+    return (
+        tokens[i].type === 'paragraph_open' &&
+        tokens[i + 1].type === 'inline' &&
+        tokens[i + 1].content.match(CUT_REGEXP)
+    );
+};
+
+const findCloseTokenIdx = closeTokenFactory('Cut', matchOpenToken, matchCloseToken);
+
+const cut: MarkdownItPluginCb = (md, {path, log}) => {
+    const plugin: Core.RuleCore = (state) => {
+        const tokens = state.tokens;
+        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 newOpenToken = new state.Token('yfm_cut_open', 'div', 1);
+                newOpenToken.attrSet('class', 'yfm-cut');
+                newOpenToken.map = tokens[i].map;
+
+                const titleOpen = new state.Token('yfm_cut_title_open', 'div', 1);
+                titleOpen.attrSet('class', 'yfm-cut-title');
+
+                const titleInline = state.md.parseInline(
+                    match[1] === undefined ? 'ad' : match[1],
+                    state.env,
+                )[0];
+
+                const titleClose = new state.Token('yfm_cut_title_close', 'div', -1);
+
+                const contentOpen = new state.Token('yfm_cut_content_open', 'div', 1);
+                contentOpen.attrSet('class', 'yfm-cut-content');
+
+                if (newOpenToken.map) {
+                    const contentOpenStart = newOpenToken.map[0] + 1;
+                    const contentOpenEnd = newOpenToken.map[0] + 2;
+
+                    contentOpen.map = [contentOpenStart, contentOpenEnd];
+                }
+
+                const contentClose = new state.Token('yfm_cut_content_close', 'div', -1);
+
+                const newCloseToken = new state.Token('yfm_cut_close', 'div', -1);
+                newCloseToken.map = tokens[closeTokenIdx].map;
+
+                const insideTokens = [
+                    newOpenToken,
+                    titleOpen,
+                    titleInline,
+                    titleClose,
+                    contentOpen,
+                    ...tokens.slice(i + 3, closeTokenIdx),
+                    contentClose,
+                    newCloseToken,
+                ];
+
+                tokens.splice(i, closeTokenIdx - i + 3, ...insideTokens);
+
+                i++;
+            } else {
+                i++;
+            }
+        }
+    };
+
+    try {
+        md.core.ruler.before('curly_attributes', 'cut', plugin);
+    } catch (e) {
+        md.core.ruler.push('cut', plugin);
+    }
+};
+
+export = cut;

package/src/transform/plugins/deflist.ts

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

package/src/transform/plugins/file/README.md

@@ -0,0 +1,34 @@
+# YFM File plugin
+
+```md
+{% file src="path/to/file" name='readme.md' %}
+
+==>
+
+<a href="path/to/file" download="readme.md" class="yfm-file"><span class="yfm-file__icon"></span>readme.md</a>
+```
+
+## Attributes
+
+|Name|Required|Description|
+|---|---|---|
+|`src`|yes|URL of the file. Will be mapped to [`href` attribute](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#attr-href)|
+|`name`|yes|Name of the file. Will be mapped to [`download` attribute](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#attr-download)|
+|`lang`|-|Language of the file content. Will be mapped to [`hreflang` attribute](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#attr-hreflang)|
+|`referrerpolicy`|-|[`referrerpolicy` attribute](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#attr-referrerpolicy)|
+|`rel`|-|[`rel` attribute](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#attr-rel)|
+|`target`|-|[`target` attribute](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#attr-target)|
+|`type`|-|[`type` attribute](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#attr-type)|
+
+> _Note: other attributes will be ignored_
+
+## Plugin options
+
+|Name|Type|Description|
+|---|---|---|
+|`fileExtraAttrs`|`[string, string][]`|Adds additional attributes to rendered hyperlink|
+
+## CSS public variables
+
+* `--yfm-file-icon` – sets custom file icon image
+* `--yfm-file-icon-color` – sets custom file icon color

package/src/transform/plugins/file/const.ts

@@ -0,0 +1,46 @@
+export enum FileSpecialAttr {
+    Src = 'src',
+    Name = 'name',
+    Lang = 'lang',
+}
+
+// https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#attributes
+export enum LinkHtmlAttr {
+    Download = 'download',
+    Href = 'href',
+    HrefLang = 'hreflang',
+    Media = 'media',
+    Ping = 'ping',
+    ReferrerPolicy = 'referrerpolicy',
+    Rel = 'rel',
+    Target = 'target',
+    Type = 'type',
+}
+
+export const FILE_TO_LINK_ATTRS_MAP: Record<FileSpecialAttr, LinkHtmlAttr> = {
+    [FileSpecialAttr.Src]: LinkHtmlAttr.Href,
+    [FileSpecialAttr.Name]: LinkHtmlAttr.Download,
+    [FileSpecialAttr.Lang]: LinkHtmlAttr.HrefLang,
+};
+
+export const RULE_NAME = 'yfm_file_inline';
+export const KNOWN_ATTRS: readonly string[] = [
+    FileSpecialAttr.Src,
+    FileSpecialAttr.Name,
+    FileSpecialAttr.Lang,
+    LinkHtmlAttr.ReferrerPolicy,
+    LinkHtmlAttr.Rel,
+    LinkHtmlAttr.Target,
+    LinkHtmlAttr.Type,
+];
+export const REQUIRED_ATTRS: readonly string[] = [FileSpecialAttr.Src, FileSpecialAttr.Name];
+
+export const FILE_TOKEN = 'yfm_file';
+
+export const PREFIX = '{% file ';
+export const PREFIX_LENGTH = PREFIX.length;
+
+export enum FileClassName {
+    Link = 'yfm-file',
+    Icon = 'yfm-file__icon',
+}

package/src/transform/plugins/file/file.ts

@@ -0,0 +1,82 @@
+import type MarkdownIt from 'markdown-it';
+import type ParserInline from 'markdown-it/lib/parser_inline';
+import type Renderer from 'markdown-it/lib/renderer';
+
+import {
+    FileClassName,
+    FileSpecialAttr,
+    FILE_TOKEN,
+    FILE_TO_LINK_ATTRS_MAP,
+    KNOWN_ATTRS,
+    PREFIX,
+    PREFIX_LENGTH,
+    REQUIRED_ATTRS,
+} from './const';
+
+export type FileOptions = {
+    fileExtraAttrs: [string, string][];
+};
+
+export const fileRenderer = (md: MarkdownIt): Renderer.RenderRule => {
+    const iconHtml = `<span class="${md.utils.escapeHtml(FileClassName.Icon)}"></span>`;
+    return (tokens, idx, _opts, _env, self) => {
+        const token = tokens[idx];
+        return `<a${self.renderAttrs(token)}>${iconHtml}${md.utils.escapeHtml(token.content)}</a>`;
+    };
+};
+
+export const fileParser = (_md: MarkdownIt, opts?: FileOptions): ParserInline.RuleInline => {
+    return (state, silent) => {
+        if (state.src.substring(state.pos, state.pos + PREFIX_LENGTH) !== PREFIX) return false;
+
+        // the rest of line after '{% file '
+        const searchStr = state.src.slice(state.pos + PREFIX_LENGTH, state.posMax);
+        // loking for pattern 'src="..." name="..." etc="value" %}'
+        const matchResult = searchStr.match(/^((?:\s*\w+=(?:"[^"]+"|'[^']+')\s)+)\s*%}/);
+        if (!matchResult) return false;
+
+        const paramsGroupLength = matchResult[0].length; // '(src="..." name="...")'.length
+        const paramsStr = matchResult[1]; // 'src="..." name="..."'
+
+        // find pairs of key="foo" or key='bar'
+        const params = paramsStr.match(/\w+=(?:"[^"]+"|'[^']+')/g);
+        if (!params) return false;
+
+        const attrsObj: Record<string, string> = {};
+        params.forEach((param) => {
+            const indexKey = param.indexOf('=');
+            const key = param.slice(0, indexKey);
+            const value = param.slice(indexKey + 2, -1);
+            if (KNOWN_ATTRS.includes(key) && value) {
+                attrsObj[key] = value;
+            }
+        });
+
+        const hasAllRequiredAttrs = REQUIRED_ATTRS.every((attr) => attr in attrsObj);
+        if (!hasAllRequiredAttrs) return false;
+
+        if (!silent) {
+            const token = state.push(FILE_TOKEN, '', 0);
+            token.block = false;
+            token.markup = PREFIX;
+            token.content = attrsObj[FileSpecialAttr.Name];
+            token.attrs = Object.entries(attrsObj);
+            token.attrSet('class', FileClassName.Link);
+
+            for (const attr of token.attrs) {
+                if (attr[0] in FILE_TO_LINK_ATTRS_MAP) {
+                    attr[0] = FILE_TO_LINK_ATTRS_MAP[attr[0] as FileSpecialAttr];
+                }
+            }
+
+            if (Array.isArray(opts?.fileExtraAttrs)) {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                token.attrs.push(...opts!.fileExtraAttrs);
+            }
+        }
+
+        state.pos = state.pos + PREFIX_LENGTH + paramsGroupLength;
+
+        return true;
+    };
+};

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

@@ -0,0 +1,10 @@
+import type {PluginWithOptions} from 'markdown-it';
+import {FILE_TOKEN, RULE_NAME} from './const';
+import {FileOptions, fileParser, fileRenderer} from './file';
+
+const filePlugin: PluginWithOptions<FileOptions> = (md, opts) => {
+    md.inline.ruler.push(RULE_NAME, fileParser(md, opts));
+    md.renderer.rules[FILE_TOKEN] = fileRenderer(md);
+};
+
+export = filePlugin;

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

@@ -0,0 +1,60 @@
+import MarkdownIt from 'markdown-it';
+import {relative} from 'path';
+
+import {isLocalUrl} from '../../utils';
+import {resolveRelativePath} from '../../utilsFS';
+import imsize from '../imsize';
+import {MarkdownItPluginOpts} from '../typings';
+
+type Options = MarkdownItPluginOpts & {
+    destPath: string;
+    copyFile: (path: string, dest: string) => void;
+    singlePage: boolean;
+};
+
+const collect = (input: string, options: Options) => {
+    const md = new MarkdownIt().use(imsize);
+
+    const {root, path, destPath = '', copyFile, singlePage} = options;
+    const tokens = md.parse(input, {});
+    let result = input;
+
+    tokens.forEach((token) => {
+        if (token.type !== 'inline') {
+            return;
+        }
+
+        const children = token.children || [];
+
+        children.forEach((childToken) => {
+            if (childToken.type !== 'image') {
+                return;
+            }
+
+            const src = childToken.attrGet('src') || '';
+
+            if (!isLocalUrl(src)) {
+                return;
+            }
+
+            const targetPath = resolveRelativePath(path, src);
+            const targetDestPath = resolveRelativePath(destPath, src);
+
+            if (singlePage && !path.includes('_includes/')) {
+                const newSrc = relative(root, resolveRelativePath(path, src));
+
+                result = result.replace(src, newSrc);
+            }
+
+            copyFile(targetPath, targetDestPath);
+        });
+    });
+
+    if (singlePage) {
+        return result;
+    }
+
+    return null;
+};
+
+export = collect;

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

@@ -0,0 +1,119 @@
+import {readFileSync} from 'fs';
+import {join, sep} from 'path';
+import {bold} from 'chalk';
+
+import {resolveRelativePath, isFileExists} from '../../utilsFS';
+import {isLocalUrl, isExternalHref} from '../../utils';
+import Token from 'markdown-it/lib/token';
+import {MarkdownItPluginCb, MarkdownItPluginOpts} from '../typings';
+import {StateCore} from '../../typings';
+
+interface ImageOpts extends MarkdownItPluginOpts {
+    assetsPublicPath: string;
+}
+
+function replaceImageSrc(
+    token: Token,
+    state: StateCore,
+    {assetsPublicPath = sep, root = '', path: optsPath, log}: ImageOpts,
+) {
+    const src = token.attrGet('src') || '';
+    const currentPath = state.env.path || optsPath;
+
+    if (!isLocalUrl(src)) {
+        return;
+    }
+
+    const path = resolveRelativePath(currentPath, src);
+
+    if (isFileExists(path)) {
+        state.md.assets?.push(path);
+    } else {
+        log.error(`Asset not found: ${bold(src)} in ${bold(currentPath)}`);
+    }
+
+    const relativeToRoot = path.replace(root + sep, '');
+    const publicSrc = join(assetsPublicPath, relativeToRoot);
+
+    token.attrSet('src', publicSrc);
+}
+
+interface SVGOpts extends MarkdownItPluginOpts {
+    notFoundCb: (s: string) => void;
+}
+
+function convertSvg(
+    token: Token,
+    state: StateCore,
+    {path: optsPath, log, notFoundCb, root}: SVGOpts,
+) {
+    const currentPath = state.env.path || optsPath;
+    const path = resolveRelativePath(currentPath, token.attrGet('src') || '');
+
+    try {
+        const content = readFileSync(path, 'utf8');
+        const svgToken = new state.Token('image_svg', '', 0);
+        svgToken.attrSet('content', content);
+
+        return svgToken;
+    } catch (e) {
+        log.error(`SVG ${path} from ${currentPath} not found`);
+
+        if (notFoundCb) {
+            notFoundCb(path.replace(root, ''));
+        }
+
+        return token;
+    }
+}
+
+type Opts = SVGOpts & ImageOpts;
+
+const index: MarkdownItPluginCb<Opts> = (md, opts) => {
+    md.assets = [];
+
+    const plugin = (state: StateCore) => {
+        const tokens = state.tokens;
+        let i = 0;
+
+        while (i < tokens.length) {
+            if (tokens[i].type !== 'inline') {
+                i++;
+                continue;
+            }
+
+            const childrenTokens = tokens[i].children || [];
+            let j = 0;
+
+            while (j < childrenTokens.length) {
+                if (childrenTokens[j].type === 'image') {
+                    const imgSrc = childrenTokens[j].attrGet('src') || '';
+
+                    if (imgSrc.endsWith('.svg') && !isExternalHref(imgSrc)) {
+                        childrenTokens[j] = convertSvg(childrenTokens[j], state, opts);
+                    } else {
+                        replaceImageSrc(childrenTokens[j], state, opts);
+                    }
+                }
+
+                j++;
+            }
+
+            i++;
+        }
+    };
+
+    try {
+        md.core.ruler.before('includes', 'images', plugin);
+    } catch (e) {
+        md.core.ruler.push('images', plugin);
+    }
+
+    md.renderer.rules.image_svg = (tokens, index) => {
+        const token = tokens[index];
+
+        return token.attrGet('content') || '';
+    };
+};
+
+export = index;

package/src/transform/plugins/imsize/const.ts

@@ -0,0 +1,7 @@
+export enum ImsizeAttr {
+    Src = 'src',
+    Alt = 'alt',
+    Title = 'title',
+    Width = 'width',
+    Height = 'height',
+}

package/src/transform/plugins/imsize/helpers.ts

@@ -0,0 +1,75 @@
+/* eslint-disable no-param-reassign */
+export function parseImageSize(str: string, pos: number, max: number) {
+    const result = {
+        ok: false,
+        pos: 0,
+        width: '',
+        height: '',
+    };
+
+    if (pos >= max) {
+        return result;
+    }
+
+    let code = str.charCodeAt(pos);
+
+    if (code !== 0x3d /* = */) {
+        return result;
+    }
+
+    pos++;
+
+    // size must follow = without any white spaces as follows
+    // (1) =300x200
+    // (2) =300x
+    // (3) =x200
+    code = str.charCodeAt(pos);
+    if (code !== 0x78 /* x */ && (code < 0x30 || code > 0x39) /* [0-9] */) {
+        return result;
+    }
+
+    // parse width
+    const resultW = parseNextNumber(str, pos, max);
+    pos = resultW.pos;
+
+    // next charactor must be 'x'
+    code = str.charCodeAt(pos);
+    if (code !== 0x78 /* x */) {
+        return result;
+    }
+
+    pos++;
+
+    // parse height
+    const resultH = parseNextNumber(str, pos, max);
+    pos = resultH.pos;
+
+    result.width = resultW.value;
+    result.height = resultH.value;
+    result.pos = pos;
+    result.ok = true;
+
+    return result;
+}
+
+function parseNextNumber(str: string, pos: number, max: number) {
+    let code;
+    const start = pos;
+    const result = {
+        pos,
+        ok: false,
+        value: '',
+    };
+
+    code = str.charCodeAt(pos);
+
+    while ((pos < max && code >= 0x30 /* 0 */ && code <= 0x39) /* 9 */ || code === 0x25 /* % */) {
+        code = str.charCodeAt(++pos);
+    }
+
+    result.ok = true;
+    result.pos = pos;
+    result.value = str.slice(start, pos);
+
+    return result;
+}

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

@@ -0,0 +1,14 @@
+import {PluginSimple} from 'markdown-it';
+import {imageWithSize} from './plugin';
+
+/**
+ * Imsize plugin for markdown-it.
+ * This plugin overloads original image renderer.
+ * Forked from https://github.com/tatsy/markdown-it-imsize
+ */
+
+const imsize: PluginSimple = (md) => {
+    md.inline.ruler.before('emphasis', 'image', imageWithSize(md));
+};
+
+export = imsize;