@diplodoc/transform 4.0.0

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

@@ -0,0 +1,214 @@
+import type MarkdownIt from 'markdown-it';
+import type ParserInline from 'markdown-it/lib/parser_inline';
+import type Token from 'markdown-it/lib/token';
+import {ImsizeAttr} from './const';
+import {parseImageSize} from './helpers';
+
+export const imageWithSize = (md: MarkdownIt): ParserInline.RuleInline => {
+    // eslint-disable-next-line complexity
+    return (state, silent) => {
+        if (state.src.charCodeAt(state.pos) !== 0x21 /* ! */) {
+            return false;
+        }
+
+        if (state.src.charCodeAt(state.pos + 1) !== 0x5b /* [ */) {
+            return false;
+        }
+
+        const labelStart = state.pos + 2;
+        const labelEnd = md.helpers.parseLinkLabel(state, state.pos + 1, false);
+
+        // parser failed to find ']', so it's not a valid link
+        if (labelEnd < 0) {
+            return false;
+        }
+
+        let href = '';
+        let title = '';
+        let width = '';
+        let height = '';
+
+        const oldPos = state.pos;
+        const max = state.posMax;
+
+        let pos = labelEnd + 1;
+        if (pos < max && state.src.charCodeAt(pos) === 0x28 /* ( */) {
+            //
+            // Inline link
+            //
+
+            // [link](  <href>  "title"  )
+            //        ^^ skipping these spaces
+            pos++;
+            for (; pos < max; pos++) {
+                const code = state.src.charCodeAt(pos);
+                if (code !== 0x20 && code !== 0x0a) {
+                    break;
+                }
+            }
+            if (pos >= max) {
+                return false;
+            }
+
+            // [link](  <href>  "title"  )
+            //          ^^^^^^ parsing link destination
+            let start = pos;
+            const destResult = md.helpers.parseLinkDestination(state.src, pos, state.posMax);
+            if (destResult.ok) {
+                href = state.md.normalizeLink(destResult.str);
+                if (state.md.validateLink(href)) {
+                    pos = destResult.pos;
+                } else {
+                    href = '';
+                }
+            }
+
+            // [link](  <href>  "title"  )
+            //                ^^ skipping these spaces
+            start = pos;
+            for (; pos < max; pos++) {
+                const code = state.src.charCodeAt(pos);
+                if (code !== 0x20 && code !== 0x0a) {
+                    break;
+                }
+            }
+
+            // [link](  <href>  "title"  )
+            //                  ^^^^^^^ parsing link title
+            const titleResult = md.helpers.parseLinkTitle(state.src, pos, state.posMax);
+            if (pos < max && start !== pos && titleResult.ok) {
+                title = titleResult.str;
+                pos = titleResult.pos;
+
+                // [link](  <href>  "title"  )
+                //                         ^^ skipping these spaces
+                for (; pos < max; pos++) {
+                    const code = state.src.charCodeAt(pos);
+                    if (code !== 0x20 && code !== 0x0a) {
+                        break;
+                    }
+                }
+            } else {
+                title = '';
+            }
+
+            // [link](  <href>  "title" =WxH  )
+            //                          ^^^^ parsing image size
+            if (pos - 1 >= 0) {
+                const code = state.src.charCodeAt(pos - 1);
+
+                // there must be at least one white spaces
+                // between previous field and the size
+                if (code === 0x20) {
+                    const sizeResult = parseImageSize(state.src, pos, state.posMax);
+                    if (sizeResult.ok) {
+                        width = sizeResult.width;
+                        height = sizeResult.height;
+                        pos = sizeResult.pos;
+
+                        // [link](  <href>  "title" =WxH  )
+                        //                              ^^ skipping these spaces
+                        for (; pos < max; pos++) {
+                            const code = state.src.charCodeAt(pos);
+                            // eslint-disable-next-line max-depth
+                            if (code !== 0x20 && code !== 0x0a) {
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+
+            if (pos >= max || state.src.charCodeAt(pos) !== 0x29 /* ) */) {
+                state.pos = oldPos;
+                return false;
+            }
+            pos++;
+        } else {
+            //
+            // Link reference
+            //
+            if (typeof state.env.references === 'undefined') {
+                return false;
+            }
+
+            // [foo]  [bar]
+            //      ^^ optional whitespace (can include newlines)
+            for (; pos < max; pos++) {
+                const code = state.src.charCodeAt(pos);
+                if (code !== 0x20 && code !== 0x0a) {
+                    break;
+                }
+            }
+
+            let label = '';
+
+            if (pos < max && state.src.charCodeAt(pos) === 0x5b /* [ */) {
+                const start = pos + 1;
+                pos = md.helpers.parseLinkLabel(state, pos);
+                if (pos >= 0) {
+                    label = state.src.slice(start, pos++);
+                } else {
+                    pos = labelEnd + 1;
+                }
+            } else {
+                pos = labelEnd + 1;
+            }
+
+            // covers label === '' and label === undefined
+            // (collapsed reference link and shortcut reference link respectively)
+            if (!label) {
+                label = state.src.slice(labelStart, labelEnd);
+            }
+
+            const ref = state.env.references[md.utils.normalizeReference(label)];
+            if (!ref) {
+                state.pos = oldPos;
+                return false;
+            }
+            href = ref.href;
+            title = ref.title;
+        }
+
+        //
+        // We found the end of the link, and know for a fact it's a valid link;
+        // so all that's left to do is to call tokenizer.
+        //
+        if (!silent) {
+            state.pos = labelStart;
+            state.posMax = labelEnd;
+
+            const tokens: Token[] = [];
+            const newState = new state.md.inline.State(
+                state.src.slice(labelStart, labelEnd),
+                state.md,
+                state.env,
+                tokens,
+            );
+            newState.md.inline.tokenize(newState);
+
+            const token = state.push('image', 'img', 0);
+            token.children = tokens;
+            token.attrs = [
+                [ImsizeAttr.Src, href],
+                [ImsizeAttr.Alt, ''],
+            ];
+
+            if (title) {
+                token.attrs.push([ImsizeAttr.Title, title]);
+            }
+
+            if (width !== '') {
+                token.attrs.push([ImsizeAttr.Width, width]);
+            }
+
+            if (height !== '') {
+                token.attrs.push([ImsizeAttr.Height, height]);
+            }
+        }
+
+        state.pos = pos;
+        state.posMax = max;
+        return true;
+    };
+};

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

@@ -0,0 +1,73 @@
+import {relative} from 'path';
+import {bold} from 'chalk';
+
+import {isFileExists, resolveRelativePath} from '../../utilsFS';
+import {MarkdownItPluginOpts} from '../typings';
+
+const includesPaths: string[] = [];
+
+type Opts = MarkdownItPluginOpts & {
+    destPath: string;
+    copyFile(path: string, dest: string, opts: Opts): void;
+    singlePage: Boolean;
+};
+
+const collect = (input: string, options: Opts) => {
+    const {root, path, destPath = '', log, copyFile, singlePage} = options;
+    const INCLUDE_REGEXP = /{%\s*include\s*(notitle)?\s*\[(.+?)]\((.+?)\)\s*%}/g;
+
+    let match,
+        result = input;
+
+    while ((match = INCLUDE_REGEXP.exec(result)) !== null) {
+        let [, , , relativePath] = match;
+        const [matchedInclude] = match;
+
+        let includePath = resolveRelativePath(path, relativePath);
+        const hashIndex = relativePath.lastIndexOf('#');
+        if (hashIndex > -1 && !isFileExists(includePath)) {
+            includePath = includePath.slice(0, includePath.lastIndexOf('#'));
+            relativePath = relativePath.slice(0, hashIndex);
+        }
+
+        const targetDestPath = resolveRelativePath(destPath, relativePath);
+
+        if (includesPaths.includes(includePath)) {
+            log.error(`Circular includes: ${bold(includesPaths.concat(path).join(' ▶ '))}`);
+            break;
+        }
+
+        if (singlePage && !includesPaths.length) {
+            const newRelativePath = relative(root, includePath);
+            const newInclude = matchedInclude.replace(relativePath, newRelativePath);
+
+            result = result.replace(matchedInclude, newInclude);
+
+            const delta = matchedInclude.length - newInclude.length;
+            INCLUDE_REGEXP.lastIndex = INCLUDE_REGEXP.lastIndex - delta;
+        }
+
+        includesPaths.push(includePath);
+        const includeOptions = {
+            ...options,
+            path: includePath,
+            destPath: targetDestPath,
+        };
+
+        try {
+            copyFile(includePath, targetDestPath, includeOptions);
+        } catch (e) {
+            log.error(`No such file or has no access to ${bold(includePath)} in ${bold(path)}`);
+        } finally {
+            includesPaths.pop();
+        }
+    }
+
+    if (singlePage) {
+        return result;
+    }
+
+    return null;
+};
+
+export = collect;

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

@@ -0,0 +1,127 @@
+import {bold} from 'chalk';
+
+import {getFileTokens, GetFileTokensOpts, getFullIncludePath, isFileExists} from '../../utilsFS';
+import {findBlockTokens} from '../../utils';
+import Token from 'markdown-it/lib/token';
+import {MarkdownItPluginCb, MarkdownItPluginOpts} from '../typings';
+import {StateCore} from 'src/transform/typings';
+
+const INCLUDE_REGEXP = /^{%\s*include\s*(notitle)?\s*\[(.+?)]\((.+?)\)\s*%}$/;
+
+function stripTitleTokens(tokens: Token[]) {
+    if (tokens[0].type === 'heading_open' && tokens[2].type === 'heading_close') {
+        tokens.splice(0, 3);
+    }
+}
+
+type Options = MarkdownItPluginOpts &
+    GetFileTokensOpts & {
+        notFoundCb: (v: string) => void;
+        noReplaceInclude: boolean;
+    };
+
+function unfoldIncludes(state: StateCore, path: string, options: Options) {
+    const {root, notFoundCb, log, noReplaceInclude = false} = options;
+    const {tokens} = state;
+    let i = 0;
+
+    while (i < tokens.length) {
+        const openToken = tokens[i];
+        const contentToken = tokens[i + 1];
+        const closeToken = tokens[i + 2];
+        let match;
+
+        if (
+            openToken.type === 'paragraph_open' &&
+            contentToken.type === 'inline' &&
+            (match = contentToken.content.match(INCLUDE_REGEXP)) &&
+            closeToken.type === 'paragraph_close'
+        ) {
+            try {
+                const [, keyword /* description */, , includePath] = match;
+
+                const fullIncludePath = getFullIncludePath(includePath, root, path);
+                let pathname = fullIncludePath;
+                let hash = '';
+                const hashIndex = fullIncludePath.lastIndexOf('#');
+                if (hashIndex > -1 && !isFileExists(pathname)) {
+                    pathname = fullIncludePath.slice(0, hashIndex);
+                    hash = fullIncludePath.slice(hashIndex + 1);
+                }
+
+                if (!pathname.startsWith(root)) {
+                    i++;
+
+                    continue;
+                }
+
+                const fileTokens = getFileTokens(pathname, state, options);
+
+                let includedTokens;
+                if (hash) {
+                    includedTokens = findBlockTokens(fileTokens, hash);
+                } else {
+                    includedTokens = fileTokens;
+                }
+
+                if (keyword === 'notitle') {
+                    stripTitleTokens(includedTokens);
+                }
+
+                if (noReplaceInclude) {
+                    i++;
+                } else {
+                    tokens.splice(i, 3, ...includedTokens);
+
+                    i += includedTokens.length;
+                }
+            } catch (e) {
+                // @ts-ignore for some reason typescript fails here
+                const errPath = e.path.replace(root, '');
+
+                if (notFoundCb) {
+                    notFoundCb(errPath);
+                }
+                log.error(`Skip error: ${e} in ${errPath}`);
+
+                i++;
+            }
+        } else {
+            i++;
+        }
+    }
+}
+
+const index: MarkdownItPluginCb<Options> = (md, options) => {
+    const {path: optPath, log} = options;
+
+    const plugin = (state: StateCore) => {
+        const {env} = state;
+        const path = env.path || optPath;
+
+        env.includes = env.includes || [];
+
+        const isCircularInclude = env.includes.includes(path);
+
+        if (isCircularInclude && state.env.disableCircularError) {
+            return;
+        }
+
+        if (isCircularInclude) {
+            log.error(`Circular includes: ${bold(env.includes.concat(path).join(' ▶ '))}`);
+            process.exit(1);
+        }
+
+        env.includes.push(path);
+        unfoldIncludes(state, path, options);
+        env.includes.pop();
+    };
+
+    try {
+        md.core.ruler.before('curly_attributes', 'includes', plugin);
+    } catch (e) {
+        md.core.ruler.push('includes', plugin);
+    }
+};
+
+export = index;

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

@@ -0,0 +1,92 @@
+import MarkdownIt from 'markdown-it';
+import {sep} from 'path';
+import url from 'url';
+import {getHrefTokenAttr, isLocalUrl} from '../../utils';
+import {getSinglePageAnchorId, resolveRelativePath} from '../../utilsFS';
+import index from './index';
+import {PAGE_LINK_REGEXP} from './constants';
+
+const replaceLinkHref = (input: string, href: string, newHref: string) => {
+    /* Try not replace include syntax */
+    return input.replace(`](${href})`, `](${newHref})`);
+};
+
+type Options = {
+    root: string;
+    path: string;
+    singlePage: boolean;
+};
+
+/* Replace the links to the markdown and yaml files if the singlePage option is passed in the options
+ *  Example: replace [Text](../../path/to/file.md#anchor) with [Text](#_path_to_file_anchor)
+ * */
+const collect = (input: string, options: Options) => {
+    const {root, path: startPath, singlePage} = options;
+
+    if (!singlePage) {
+        return;
+    }
+
+    let result = input;
+
+    /* Syntax "{% include [Text](_includes/file.md) %}" is parsed as link. Need to ignore errors */
+    const needSkipLinkFn = (href: string) => href.includes(`_includes${sep}`);
+    const transformLink = (href: string) => href;
+    const md = new MarkdownIt().use(index, {...options, transformLink, needSkipLinkFn});
+    const tokens = md.parse(result, {});
+
+    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';
+
+                if (!isLinkOpenToken) {
+                    j++;
+                    continue;
+                }
+
+                const linkToken = childrenTokens[j];
+                const href = getHrefTokenAttr(linkToken);
+
+                const isIncludeLink = resolveRelativePath(startPath, href).includes(
+                    `_includes${sep}`,
+                );
+
+                if (!href || !isLocalUrl(href) || isIncludeLink) {
+                    j++;
+                    continue;
+                }
+
+                const {pathname, hash} = url.parse(href);
+                if (pathname) {
+                    const isPageFile = PAGE_LINK_REGEXP.test(pathname);
+                    if (isPageFile) {
+                        const newHref = getSinglePageAnchorId({
+                            root,
+                            currentPath: startPath,
+                            pathname,
+                            hash,
+                        });
+                        result = replaceLinkHref(result, href, newHref);
+                    }
+                } else if (hash) {
+                    const newHref = getSinglePageAnchorId({root, currentPath: startPath, hash});
+                    result = replaceLinkHref(result, href, newHref);
+                }
+
+                j++;
+            }
+        }
+
+        i++;
+    }
+
+    // eslint-disable-next-line consistent-return
+    return result;
+};
+
+export = collect;

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

@@ -0,0 +1 @@
+export const PAGE_LINK_REGEXP = /\.(md|ya?ml)$/i;