@diplodoc/transform 4.0.0

package/src/transform/utils.ts

@@ -0,0 +1,91 @@
+import Token from 'markdown-it/lib/token';
+
+export function isLocalUrl(url: string) {
+    return !/^(?:[a-z]+:)?\/\//i.test(url);
+}
+
+export function findBlockTokens(tokens: Token[], id: string) {
+    let blockTokens: Token[] = [];
+    let i = 0,
+        startToken,
+        start,
+        end;
+    while (i < tokens.length) {
+        const token = tokens[i];
+
+        if (typeof start === 'number' && startToken) {
+            if (startToken.type === 'paragraph_open' && token.type === 'paragraph_close') {
+                end = i + 1;
+                break;
+            } else if (startToken.type === 'heading_open') {
+                if (token.type === 'heading_open' && token.tag === startToken.tag) {
+                    end = i;
+                    break;
+                } else if (i === tokens.length - 1) {
+                    end = tokens.length;
+                }
+            }
+        }
+
+        if (
+            (token.type === 'paragraph_open' || token.type === 'heading_open') &&
+            token.attrGet('id') === id &&
+            typeof start === 'undefined'
+        ) {
+            startToken = token;
+            start = i;
+        }
+
+        i++;
+    }
+
+    if (typeof start === 'number' && typeof end === 'number') {
+        blockTokens = tokens.slice(start, end);
+    }
+
+    return blockTokens;
+}
+
+export function headingInfo(tokens: Token[], idx: number) {
+    const openToken = tokens[idx];
+    const inlineToken = tokens[idx + 1];
+
+    let lastTextToken,
+        i = 0;
+    while (inlineToken.children && i < inlineToken.children.length) {
+        const token = inlineToken.children[i];
+
+        if (token.type === 'text') {
+            lastTextToken = token;
+        }
+
+        i++;
+    }
+
+    const level = Number.parseInt(openToken.tag.slice(1), 10);
+    const title = (lastTextToken && lastTextToken.content) || inlineToken.content;
+
+    return {
+        level,
+        title,
+    };
+}
+
+export function isExternalHref(href: string) {
+    return href.startsWith('http') || href.startsWith('//');
+}
+
+export function transformLinkToOriginalArticle(opts: {root: string; currentPath: string}) {
+    const {root, currentPath} = opts;
+
+    return currentPath.replace(root, '').replace(/\.(md|ya?ml|html)$/i, '');
+}
+
+export function getHrefTokenAttr(token: Token) {
+    let href = token.attrGet('href') || '';
+    try {
+        href = decodeURI(href);
+    } catch (e) {}
+
+    return href;
+}

package/src/transform/utilsFS.ts

@@ -0,0 +1,128 @@
+import _, {Dictionary} from 'lodash';
+import {readFileSync, statSync} from 'fs';
+
+import {parse, resolve, join, sep} from 'path';
+
+import liquid from './liquid';
+import {StateCore} from './typings';
+
+const filesCache: Record<string, string> = {};
+
+export function isFileExists(file: string) {
+    try {
+        const stats = statSync(file);
+
+        return stats.isFile();
+    } catch (e) {
+        return false;
+    }
+}
+
+export function resolveRelativePath(fromPath: string, relativePath: string) {
+    const {dir: fromDir} = parse(fromPath);
+
+    return resolve(fromDir, relativePath);
+}
+
+export type GetFileTokensOpts = {
+    getVarsPerFile?: (path: string) => Record<string, string>;
+    vars?: Record<string, unknown>;
+    disableLiquid?: boolean;
+    disableLint?: boolean;
+    lintMarkdown?: (opts: {input: string; path: string; sourceMap?: Dictionary<string>}) => void;
+    disableTitleRefSubstitution?: boolean;
+    disableCircularError?: boolean;
+    inheritVars?: boolean;
+    conditionsInCode?: boolean;
+};
+
+export function getFileTokens(path: string, state: StateCore, options: GetFileTokensOpts) {
+    const {
+        getVarsPerFile,
+        vars,
+        disableLiquid,
+        disableLint,
+        lintMarkdown,
+        disableTitleRefSubstitution,
+        disableCircularError,
+        inheritVars = true,
+        conditionsInCode,
+    } = options;
+    let content;
+
+    const builtVars = (getVarsPerFile && !inheritVars ? getVarsPerFile(path) : vars) || {};
+
+    if (filesCache[path]) {
+        content = filesCache[path];
+    } else {
+        content = readFileSync(path, 'utf8');
+        filesCache[path] = content;
+    }
+
+    let sourceMap;
+
+    if (!disableLiquid) {
+        const liquidResult = liquid(content, builtVars, path, {
+            withSourceMap: true,
+            conditionsInCode,
+        });
+
+        content = liquidResult.output;
+        sourceMap = liquidResult.sourceMap;
+    }
+
+    if (!disableLint && lintMarkdown) {
+        lintMarkdown({
+            input: content,
+            path,
+            sourceMap,
+        });
+    }
+
+    const meta = state.md.meta;
+    const tokens = state.md.parse(content, {
+        ...state.env,
+        path,
+        disableTitleRefSubstitution,
+        disableCircularError,
+    });
+    state.md.meta = meta;
+
+    return tokens;
+}
+
+export const getFullIncludePath = (includePath: string, root: string, path: string) => {
+    let fullIncludePath;
+    if (includePath.startsWith(sep)) {
+        fullIncludePath = join(root, includePath);
+    } else {
+        fullIncludePath = resolveRelativePath(path, includePath);
+    }
+
+    return fullIncludePath;
+};
+
+export function getSinglePageAnchorId(args: {
+    root: string;
+    currentPath: string;
+    pathname?: string;
+    hash?: string | null;
+}) {
+    const {root, currentPath, pathname, hash} = args;
+    let resultAnchor = currentPath;
+
+    if (pathname) {
+        resultAnchor = resolveRelativePath(currentPath, pathname);
+    }
+
+    resultAnchor = resultAnchor
+        .replace(root, '')
+        .replace(/\.(md|ya?ml|html)$/i, '')
+        .replace(new RegExp(_.escapeRegExp(sep), 'gi'), '_');
+
+    if (hash) {
+        resultAnchor = resultAnchor + '_' + hash.slice(1);
+    }
+
+    return `#${resultAnchor}`;
+}

package/src/transform/yfmlint/README.md

@@ -0,0 +1,48 @@
+# YFM rules
+
+[All markdownlint rules](https://github.com/DavidAnson/markdownlint/blob/main/doc/Rules.md)
+
+## YFM001 - Inline code line length
+
+Tags: line_length
+
+Aliases: inline-code-length
+
+Parameters: maximum
+
+This rule is triggered when there are lines that are longer than the
+configured `value` (default: 100 characters). 
+
+## YFM002 - No header found in the file for the link text
+
+Tags: links
+
+Aliases: no-header-found-for-link
+
+This rule is triggered when there are no headers in the file referenced by the link.
+
+## YFM003 - Link is unreachable
+
+Tags: links
+
+Aliases: unreachable-link
+
+This rule is triggered when there is no file referenced by the link.
+
+## YFM004 - Table not closed
+
+Tags: table
+
+Aliases: table-not-closed
+
+This rule is triggered when table don't have close token.
+
+## YFM005 - Tab list not closed
+
+Tags: tab
+
+Aliases: tab-list-not-closed
+
+This rule is triggered when tab list don't have close token.
+
+

package/src/transform/yfmlint/index.ts

@@ -0,0 +1,124 @@
+import {Rule, sync} from 'markdownlint';
+import merge from 'lodash/merge';
+import union from 'lodash/union';
+import attrs from 'markdown-it-attrs';
+import baseDefaultLintConfig from './yfmlint';
+
+import {
+    yfm001,
+    yfm002,
+    yfm003,
+    yfm004,
+    yfm005,
+    yfm006,
+    yfm007,
+    yfm008,
+} from './markdownlint-custom-rule';
+
+import {errorToString, getLogLevel} from './utils';
+import {Options} from './typings';
+import {Dictionary} from 'lodash';
+import {Logger, LogLevels} from '../log';
+import {yfm009} from './markdownlint-custom-rule/yfm009';
+
+const defaultLintRules = [yfm001, yfm002, yfm003, yfm004, yfm005, yfm006, yfm007, yfm008, yfm009];
+
+const lintCache = new Set();
+
+function yfmlint(opts: Options) {
+    const {input, plugins: customPlugins, pluginOptions, customLintRules, sourceMap} = opts;
+    const {path = 'input', log} = pluginOptions;
+
+    pluginOptions.isLintRun = true;
+
+    const {
+        LogLevels: {ERROR, WARN, DISABLED},
+    } = log;
+
+    if (lintCache.has(path)) {
+        return;
+    }
+
+    lintCache.add(path);
+
+    const defaultLintConfig = opts.defaultLintConfig || baseDefaultLintConfig;
+
+    let lintConfig = defaultLintConfig;
+    if (opts.lintConfig) {
+        lintConfig = merge({}, defaultLintConfig, opts.lintConfig);
+    }
+
+    let lintRules = defaultLintRules;
+    if (customLintRules) {
+        lintRules = union(lintRules, customLintRules);
+    }
+
+    const plugins = customPlugins && [attrs, ...customPlugins];
+    const preparedPlugins = plugins && plugins.map((plugin) => [plugin, pluginOptions]);
+
+    let result;
+    try {
+        result = sync({
+            strings: {[path]: input},
+            markdownItPlugins: preparedPlugins,
+            handleRuleFailures: true,
+            config: lintConfig,
+            customRules: lintRules,
+        });
+    } catch {}
+
+    const errors = result && result[path];
+    if (!errors) {
+        return;
+    }
+
+    const logLevelsConfig = lintConfig['log-levels'];
+
+    for (const error of errors) {
+        const message = errorToString(path, error, sourceMap);
+        const logLevel = getLogLevel({
+            logLevelsConfig,
+            ruleNames: error.ruleNames,
+            defaultLevel: WARN,
+        });
+
+        switch (logLevel) {
+            case ERROR:
+                log.error(message);
+                break;
+            case WARN:
+                log.warn(message);
+                break;
+            case DISABLED:
+            default:
+                break;
+        }
+    }
+}
+
+export = yfmlint;
+
+// eslint-disable-next-line @typescript-eslint/no-namespace
+namespace yfmlint {
+    export interface LintMarkdownFunctionOptions {
+        input: string;
+        path: string;
+        sourceMap?: Dictionary<string>;
+    }
+
+    export interface PluginOptions {
+        log: Logger;
+        path?: string;
+        disableLint?: boolean;
+        lintMarkdown?: (opts: LintMarkdownFunctionOptions) => void;
+        [key: string]: unknown;
+    }
+
+    export interface LintConfig {
+        default?: boolean;
+        'log-levels': Record<string, LogLevels>;
+        [x: string]: unknown;
+    }
+
+    export type LintRule = Rule;
+}

package/src/transform/yfmlint/markdownlint-custom-rule/index.ts

@@ -0,0 +1,9 @@
+export {yfm001} from './yfm001';
+export {yfm002} from './yfm002';
+export {yfm003} from './yfm003';
+export {yfm004} from './yfm004';
+export {yfm005} from './yfm005';
+export {yfm006} from './yfm006';
+export {yfm007} from './yfm007';
+export {yfm008} from './yfm008';
+export {yfm009} from './yfm009';

package/src/transform/yfmlint/markdownlint-custom-rule/yfm001.ts

@@ -0,0 +1,36 @@
+// @ts-expect-error
+import {addErrorDetailIf, filterTokens, forEachInlineCodeSpan} from 'markdownlint-rule-helpers';
+
+import {MarkdownItToken, Rule} from 'markdownlint';
+
+export const yfm001: Rule = {
+    names: ['YFM001', 'inline-code-length'],
+    description: 'Inline code length',
+    tags: ['line_length'],
+    function: function YFM001(params, onError) {
+        const {config} = params;
+        const maxLength = Number(config.maximum || 100);
+
+        filterTokens(params, 'inline', (token: MarkdownItToken) => {
+            if (!token.children?.some((child) => child.type === 'code_inline') || !token.map) {
+                return;
+            }
+
+            const tokenLines = params.lines.slice(token.map[0], token.map[1]);
+            forEachInlineCodeSpan(tokenLines.join('\n'), (code: string, currentLine: number) => {
+                if (code.length <= maxLength) {
+                    return;
+                }
+
+                addErrorDetailIf(
+                    onError,
+                    token.lineNumber + currentLine,
+                    maxLength,
+                    code.length,
+                    null,
+                    code,
+                );
+            });
+        });
+    },
+};

package/src/transform/yfmlint/markdownlint-custom-rule/yfm002.ts

@@ -0,0 +1,33 @@
+import {Rule} from 'markdownlint';
+
+export const yfm002: Rule = {
+    names: ['YFM002', 'no-header-found-for-link'],
+    description: 'No header found in the file for the link text',
+    tags: ['links'],
+    function: function YFM002(params, onError) {
+        const {config} = params;
+        if (!config) {
+            return;
+        }
+
+        params.tokens
+            .filter((token) => {
+                return token.type === 'inline';
+            })
+            .forEach((inline) => {
+                inline.children
+                    ?.filter((child) => {
+                        return child.type === 'link_open';
+                    })
+                    .forEach((link) => {
+                        // @ts-expect-error bad markdownlint typings
+                        if (link.attrGet('YFM002')) {
+                            onError({
+                                lineNumber: link.lineNumber,
+                                context: link.line,
+                            });
+                        }
+                    });
+            });
+    },
+};

package/src/transform/yfmlint/markdownlint-custom-rule/yfm003.ts

@@ -0,0 +1,33 @@
+import {Rule} from 'markdownlint';
+
+export const yfm003: Rule = {
+    names: ['YFM003', 'unreachable-link'],
+    description: 'Link is unreachable',
+    tags: ['links'],
+    function: function YFM003(params, onError) {
+        const {config} = params;
+        if (!config) {
+            return;
+        }
+
+        params.tokens
+            .filter((token) => {
+                return token.type === 'inline';
+            })
+            .forEach((inline) => {
+                inline.children
+                    ?.filter((child) => {
+                        return child.type === 'link_open';
+                    })
+                    .forEach((link) => {
+                        // @ts-expect-error bad markdownlint typings
+                        if (link.attrGet('YFM003')) {
+                            onError({
+                                lineNumber: link.lineNumber,
+                                context: link.line,
+                            });
+                        }
+                    });
+            });
+    },
+};

package/src/transform/yfmlint/markdownlint-custom-rule/yfm004.ts

@@ -0,0 +1,27 @@
+import {Rule} from 'markdownlint';
+
+export const yfm004: Rule = {
+    names: ['YFM004', 'table-not-closed'],
+    description: 'Table not closed',
+    tags: ['table'],
+    function: function YFM004(params, onError) {
+        const {config} = params;
+        if (!config) {
+            return;
+        }
+
+        params.tokens
+            .filter((token) => {
+                return token.type === '__yfm_lint';
+            })
+            .forEach((table) => {
+                // @ts-expect-error bad markdownlint typings
+                if (table.attrGet('YFM004')) {
+                    onError({
+                        lineNumber: table.lineNumber,
+                        context: table.line,
+                    });
+                }
+            });
+    },
+};

package/src/transform/yfmlint/markdownlint-custom-rule/yfm005.ts

@@ -0,0 +1,27 @@
+import {Rule} from 'markdownlint';
+
+export const yfm005: Rule = {
+    names: ['YFM005', 'tab-list-not-closed'],
+    description: 'Tab list not closed',
+    tags: ['tab'],
+    function: function YFM005(params, onError) {
+        const {config} = params;
+        if (!config) {
+            return;
+        }
+
+        params.tokens
+            .filter((token) => {
+                return token.type === 'paragraph_open';
+            })
+            .forEach((table) => {
+                // @ts-expect-error bad markdownlint typings
+                if (table.attrGet('YFM005')) {
+                    onError({
+                        lineNumber: table.lineNumber,
+                        context: table.line,
+                    });
+                }
+            });
+    },
+};

package/src/transform/yfmlint/markdownlint-custom-rule/yfm006.ts

@@ -0,0 +1,26 @@
+import {Rule} from 'markdownlint';
+
+export const yfm006: Rule = {
+    names: ['YFM006', 'term-definition-duplicated'],
+    description: 'Term definition duplicated',
+    tags: ['term'],
+    function: function YFM006(params, onError) {
+        const {config} = params;
+        if (!config) {
+            return;
+        }
+        params.tokens
+            .filter((token) => {
+                return token.type === '__yfm_lint';
+            })
+            .forEach((term) => {
+                // @ts-expect-error bad markdownlint typings
+                if (term.attrGet('YFM006')) {
+                    onError({
+                        lineNumber: term.lineNumber,
+                        context: term.line,
+                    });
+                }
+            });
+    },
+};

package/src/transform/yfmlint/markdownlint-custom-rule/yfm007.ts

@@ -0,0 +1,28 @@
+import {Rule} from 'markdownlint';
+
+export const yfm007: Rule = {
+    names: ['YFM007', 'term-used-without-definition'],
+    description: 'Term used without definition',
+    tags: ['term'],
+    function: function YFM007(params, onError) {
+        const {config} = params;
+        if (!config) {
+            return;
+        }
+        params.tokens.forEach((el) =>
+            el.children
+                ?.filter((token) => {
+                    return token.type === '__yfm_lint';
+                })
+                .forEach((term) => {
+                    // @ts-expect-error bad markdownlint typings
+                    if (term.attrGet('YFM007')) {
+                        onError({
+                            lineNumber: term.lineNumber,
+                            context: term.line,
+                        });
+                    }
+                }),
+        );
+    },
+};

package/src/transform/yfmlint/markdownlint-custom-rule/yfm008.ts

@@ -0,0 +1,26 @@
+import {Rule} from 'markdownlint';
+
+export const yfm008: Rule = {
+    names: ['YFM008', 'term-inside-definition-not-allowed'],
+    description: 'Term inside definition not allowed',
+    tags: ['term'],
+    function: function YFM008(params, onError) {
+        const {config} = params;
+        if (!config) {
+            return;
+        }
+        params.tokens
+            .filter((token) => {
+                return token.type === '__yfm_lint';
+            })
+            .forEach((term) => {
+                // @ts-expect-error bad markdownlint typings
+                if (term.attrGet('YFM008')) {
+                    onError({
+                        lineNumber: term.lineNumber,
+                        context: term.line,
+                    });
+                }
+            });
+    },
+};