npm - @diplodoc/cli - Versions diffs - 4.0.0 - Mend

@diplodoc/cli 4.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (74) hide show

package/CHANGELOG.md +785 -0
package/LICENSE +21 -0
package/README.md +62 -0
package/README.ru.md +63 -0
package/build/app.client.css +47 -0
package/build/app.client.js +3 -0
package/build/index.js +3993 -0
package/build/index.js.map +7 -0
package/build/lib.js +3374 -0
package/build/lib.js.map +7 -0
package/build/linter.js +1265 -0
package/build/linter.js.map +7 -0
package/package.json +126 -0
package/src/cmd/build/index.ts +304 -0
package/src/cmd/index.ts +4 -0
package/src/cmd/publish/index.ts +92 -0
package/src/cmd/publish/upload.ts +61 -0
package/src/cmd/translate/index.ts +261 -0
package/src/cmd/xliff/compose.ts +222 -0
package/src/cmd/xliff/extract.ts +237 -0
package/src/cmd/xliff/index.ts +27 -0
package/src/constants.ts +122 -0
package/src/globals.d.ts +1 -0
package/src/index.ts +54 -0
package/src/models.ts +249 -0
package/src/packages/credentials/index.ts +1 -0
package/src/packages/credentials/yandex-oauth.ts +42 -0
package/src/resolvers/index.ts +3 -0
package/src/resolvers/lintPage.ts +119 -0
package/src/resolvers/md2html.ts +142 -0
package/src/resolvers/md2md.ts +147 -0
package/src/services/argv.ts +38 -0
package/src/services/authors.ts +64 -0
package/src/services/contributors.ts +104 -0
package/src/services/includers/batteries/common.ts +34 -0
package/src/services/includers/batteries/generic.ts +130 -0
package/src/services/includers/batteries/index.ts +3 -0
package/src/services/includers/batteries/sourcedocs.ts +33 -0
package/src/services/includers/batteries/unarchive.ts +97 -0
package/src/services/includers/index.ts +157 -0
package/src/services/index.ts +6 -0
package/src/services/leading.ts +88 -0
package/src/services/metadata.ts +249 -0
package/src/services/plugins.ts +76 -0
package/src/services/preset.ts +55 -0
package/src/services/tocs.ts +401 -0
package/src/services/utils.ts +151 -0
package/src/steps/index.ts +6 -0
package/src/steps/processAssets.ts +36 -0
package/src/steps/processExcludedFiles.ts +47 -0
package/src/steps/processLinter.ts +100 -0
package/src/steps/processLogs.ts +18 -0
package/src/steps/processMapFile.ts +35 -0
package/src/steps/processPages.ts +312 -0
package/src/steps/processServiceFiles.ts +95 -0
package/src/steps/publishFilesToS3.ts +47 -0
package/src/utils/file.ts +17 -0
package/src/utils/glob.ts +14 -0
package/src/utils/index.ts +8 -0
package/src/utils/logger.ts +42 -0
package/src/utils/markup.ts +125 -0
package/src/utils/path.ts +24 -0
package/src/utils/presets.ts +20 -0
package/src/utils/singlePage.ts +228 -0
package/src/utils/toc.ts +87 -0
package/src/utils/url.ts +3 -0
package/src/utils/worker.ts +10 -0
package/src/validator.ts +150 -0
package/src/vcs-connector/client/github.ts +52 -0
package/src/vcs-connector/connector-models.ts +76 -0
package/src/vcs-connector/connector-validator.ts +114 -0
package/src/vcs-connector/github.ts +333 -0
package/src/vcs-connector/index.ts +15 -0
package/src/workers/linter/index.ts +62 -0

package/src/utils/markup.ts ADDED Viewed

@@ -0,0 +1,125 @@
+import {platform} from 'process';
+import {CUSTOM_STYLE, Platforms, ResourceType} from '../constants';
+import {SinglePageResult, Resources} from '../models';
+import {ArgvService, PluginService} from '../services';
+import {preprocessPageHtmlForSinglePage} from './singlePage';
+import {render, DocInnerProps, DocPageData} from '@diplodoc/client';
+import client from '../../scripts/client';
+export interface TitleMeta {
+    title?: string;
+}
+export type Meta = TitleMeta & Resources;
+export function generateStaticMarkup(props: DocInnerProps<DocPageData>, pathToBundle: string): string {
+    const {title: metaTitle, style, script} = props.data.meta as Meta || {};
+    const {title: tocTitle} = props.data.toc;
+    const {title: pageTitle} = props.data;
+    const title = getTitle({
+        metaTitle,
+        tocTitle: tocTitle as string,
+        pageTitle,
+    });
+    const resources = getResources({style, script});
+    const {staticContent} = ArgvService.getConfig();
+    const html = staticContent ? render(props) : '';
+    return `
+        <!DOCTYPE html>
+        <html lang="${props.lang}">
+            <head>
+                <meta charset="utf-8">
+                ${getMetadata(props.data.meta as Record<string, string>)}
+                <meta name="viewport" content="width=device-width, initial-scale=1.0">
+                <title>${title}</title>
+                <style type="text/css">
+                    body {
+                        height: 100vh;
+                    }
+                </style>
+                <link type="text/css" rel="stylesheet" href="${client.bundle.css(pathToBundle)}" />
+                ${PluginService.getHeadContent()}
+                ${resources}
+            </head>
+            <body class="yc-root yc-root_theme_light">
+                <div id="root">${html}</div>
+                <script type="application/javascript">
+                   window.STATIC_CONTENT = ${staticContent}
+                   window.__DATA__ = ${JSON.stringify(props)};
+                </script>
+                <script type="application/javascript" src="${client.bundle.js(pathToBundle)}"></script>
+            </body>
+        </html>
+    `;
+}
+interface GetTitleOptions {
+    tocTitle?: string;
+    metaTitle?: string;
+    pageTitle?: string;
+}
+function getTitle({tocTitle, metaTitle, pageTitle}: GetTitleOptions) {
+    const resultPageTitle = metaTitle || pageTitle;
+    if (!resultPageTitle && tocTitle) {
+        return tocTitle;
+    }
+    if (resultPageTitle && !tocTitle) {
+        return resultPageTitle;
+    }
+    return resultPageTitle && tocTitle ? `${resultPageTitle} | ${tocTitle}` : '';
+}
+function getMetadata(metadata: Record<string, string>): string {
+    if (!metadata) {
+        return '';
+    }
+    // Exclude resources from meta, proceed them separately
+    const metaEntries = Object.entries(metadata).filter(([key]) => !Object.keys(ResourceType).includes(key));
+    return metaEntries
+        .map(([name, content]) => {
+            return `<meta name="${name}" content="${content}">`;
+        })
+        .join('\n');
+}
+function getResources({style, script}: Resources) {
+    const resourcesTags: string[] = [];
+    if (style) {
+        style.forEach((el, id) => resourcesTags.push(
+            `<link rel="stylesheet" type="text/css" href="${el}" ${id === 0 && `id="${CUSTOM_STYLE}"`}>`,
+        ));
+    }
+    if (script) {
+        script.forEach((el) => resourcesTags.push(
+            `<script src="${el}"></script>`,
+        ));
+    }
+    return resourcesTags.join('\n');
+}
+export const сarriage = platform === Platforms.WINDOWS ? '\r\n' : '\n';
+export function joinSinglePageResults(singlePageResults: SinglePageResult[], root: string, tocDir: string): string {
+    const delimeter = `${сarriage}${сarriage}<hr class="yfm-page__delimeter">${сarriage}${сarriage}`;
+    return singlePageResults
+        .filter(({content}) => content)
+        .map(({content, path, title}) => preprocessPageHtmlForSinglePage(content, {root, path, tocDir, title}))
+        .join(delimeter);
+}
+export function replaceDoubleToSingleQuotes(str: string): string {
+    return str.replace(/"/g, '\'');
+}

package/src/utils/path.ts ADDED Viewed

@@ -0,0 +1,24 @@
+import {sep} from 'path';
+import {Platforms} from '../constants';
+export function addSlashPrefix(path: string): string {
+    const slashPrefix = path.startsWith(sep) ? '' : sep;
+    return `${slashPrefix}${path}`;
+}
+export function convertBackSlashToSlash(path: string): string {
+    if (process.platform === Platforms.WINDOWS) {
+        return path.replace(/\\/g, '/');
+    }
+    return path;
+}
+export function convertSlashToWindowsBackSlashes(path: string): string {
+    if (process.platform === Platforms.WINDOWS) {
+        return path.replace(/\//g, '\\\\');
+    }
+    return path;
+}

package/src/utils/presets.ts ADDED Viewed

@@ -0,0 +1,20 @@
+import {dirname, relative, resolve} from 'path';
+import {ArgvService, PresetService} from '../services';
+export function getVarsPerFile(filePath: string): Record<string, string> {
+    const {vars: argVars} = ArgvService.getConfig();
+    return {
+        ...PresetService.get(dirname(filePath)),
+        ...argVars,
+    };
+}
+export function getVarsPerRelativeFile(filePath: string): Record<string, string> {
+    const {input} = ArgvService.getConfig();
+    const root = resolve(input);
+    const relativeFilePath = relative(root, filePath);
+    return getVarsPerFile(relativeFilePath);
+}

package/src/utils/singlePage.ts ADDED Viewed

@@ -0,0 +1,228 @@
+import HTMLElement from 'node-html-parser/dist/nodes/html';
+import {parse} from 'node-html-parser';
+import {resolve, sep, relative} from 'path';
+import {resolveRelativePath} from '@doc-tools/transform/lib/utilsFS';
+import url from 'url';
+import _ from 'lodash';
+import {isExternalHref} from './url';
+interface ModifyNode {
+    innerHTML: string;
+    rawTagName: string;
+    attrEntries?: string[][];
+}
+interface PreprocessSinglePageOptions {
+    root: string;
+    path: string;
+    tocDir: string;
+    title?: string;
+}
+const HEADERS_SELECTOR = 'h1, h2, h3, h4, h5, h6';
+function getNewNode(options: ModifyNode): HTMLElement | null {
+    const {rawTagName, innerHTML, attrEntries} = options;
+    const nodeNew = parse(`<html><${rawTagName}></${rawTagName}></html>`)
+        .querySelector(`${rawTagName}`);
+    if (!nodeNew) {
+        return null;
+    }
+    if (attrEntries) {
+        for (const [name, value] of attrEntries) {
+            nodeNew.setAttribute(name, value);
+        }
+    }
+    nodeNew.innerHTML = innerHTML;
+    return nodeNew;
+}
+export function decreaseHeadingLevels(root: HTMLElement) {
+    const headersSelector = 'h1, h2, h3, h4, h5';
+    root.querySelectorAll(headersSelector).forEach((node) => {
+        const {rawTagName} = node;
+        const newHeadingLevel = Number(rawTagName.charAt(1)) + 1;
+        node.rawTagName = `h${newHeadingLevel}`;
+    });
+}
+export function tryFixFirstPageHeader(root: HTMLElement) {
+    const firstPageHeader = root.querySelector(HEADERS_SELECTOR);
+    if (!firstPageHeader || firstPageHeader.rawTagName === 'h1') {
+        return;
+    }
+    firstPageHeader.rawTagName = 'h1';
+}
+export function replaceLinks(rootEl: HTMLElement, options: PreprocessSinglePageOptions) {
+    const {root, path, tocDir} = options;
+    rootEl.querySelectorAll('a:not(.yfm-anchor):not([target="_blank"])').forEach((node) => {
+        const href = node.getAttribute('href') || '';
+        const resolvedPath = resolve(root, path);
+        const linkFullPath = resolveRelativePath(resolvedPath, href);
+        const isLinkOutOfToc = !linkFullPath.startsWith(tocDir);
+        let preparedHref = href;
+        if (isLinkOutOfToc) {
+            preparedHref = relative(tocDir, linkFullPath);
+        } else {
+            const {pathname, hash} = url.parse(href);
+            if (pathname) {
+                preparedHref = getSinglePageAnchorId({
+                    root,
+                    currentPath: resolvedPath,
+                    pathname,
+                    hash,
+                });
+            } else if (hash) {
+                preparedHref = getSinglePageAnchorId({root, currentPath: resolvedPath, hash});
+            }
+        }
+        node.setAttribute('href', preparedHref);
+    });
+}
+export function replaceImages(rootEl: HTMLElement, options: PreprocessSinglePageOptions) {
+    const {root, path, tocDir} = options;
+    rootEl.querySelectorAll('img').forEach((node) => {
+        const href = node.getAttribute('src') || '';
+        if (isExternalHref(href)) {
+            return;
+        }
+        const resolvedPath = resolve(root, path);
+        const linkFullPath = resolveRelativePath(resolvedPath, href);
+        const preparedHref = relative(tocDir, linkFullPath);
+        node.setAttribute('src', preparedHref);
+    });
+}
+function prepareAnchorAttr(name: string, value: string, pageId: string) {
+    switch (name) {
+        case 'href':
+            return `#${pageId}_${value.slice(1)}`;
+        case 'id':
+            return `${pageId}_${value}`;
+        default:
+            return value;
+    }
+}
+function prepareAnchorAttrs(node: HTMLElement, pageId: string) {
+    for (const [name, value] of Object.entries(node.attributes)) {
+        const preparedValue = prepareAnchorAttr(name, value, pageId);
+        node.setAttribute(name, preparedValue);
+    }
+}
+export function addPagePrefixToAnchors(rootEl: HTMLElement, options: PreprocessSinglePageOptions) {
+    const {root, path} = options;
+    const resolvedPath = resolve(root, path);
+    const pageIdAnchor = getSinglePageAnchorId({root, currentPath: resolvedPath});
+    const originalArticleHref = transformLinkToOriginalArticle({root, currentPath: resolvedPath});
+    const pageId = pageIdAnchor.slice(1);
+    const anchorSelector = '.yfm-anchor';
+    // Add the page prefix id to all existing anchors
+    rootEl.querySelectorAll(anchorSelector).forEach((node) => {
+        prepareAnchorAttrs(node, pageId);
+    });
+    const mainHeader = rootEl.querySelector('h1');
+    if (mainHeader) {
+        const anchor = parse(`<a class="yfm-anchor" aria-hidden="true" href="${pageIdAnchor}" id="${pageId}"></a>`);
+        if (!anchor) {
+            return;
+        }
+        mainHeader.setAttribute('data-original-article', `${originalArticleHref}.html`);
+        mainHeader.appendChild(anchor);
+    }
+    rootEl.querySelectorAll(HEADERS_SELECTOR).forEach((node) => {
+        prepareAnchorAttrs(node, pageId);
+    });
+}
+export function addMainTitle(rootEl: HTMLElement, options: PreprocessSinglePageOptions) {
+    const {title} = options;
+    if (!title) {
+        return;
+    }
+    const mainTitle = getNewNode({innerHTML: title, rawTagName: 'h1'});
+    if (!mainTitle) {
+        return;
+    }
+    rootEl.insertAdjacentHTML('afterbegin', mainTitle.toString());
+}
+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}`;
+}
+export function transformLinkToOriginalArticle(opts: {root: string; currentPath: string}) {
+    const {root, currentPath} = opts;
+    return currentPath.replace(root, '').replace(/\.(md|ya?ml|html)$/i, '');
+}
+export function preprocessPageHtmlForSinglePage(content: string, options: PreprocessSinglePageOptions) {
+    const root = parse(content);
+    addMainTitle(root, options);
+    tryFixFirstPageHeader(root);
+    addPagePrefixToAnchors(root, options);
+    decreaseHeadingLevels(root);
+    replaceLinks(root, options);
+    replaceImages(root, options);
+    return root.toString();
+}

package/src/utils/toc.ts ADDED Viewed

@@ -0,0 +1,87 @@
+import {relative, dirname, basename, extname, format, join} from 'path';
+import {YfmToc} from '../models';
+import {filterFiles} from '../services/utils';
+import {isExternalHref} from './url';
+import {getSinglePageAnchorId} from './singlePage';
+export function transformToc(toc: YfmToc | null, pathToFileDirectory: string): YfmToc | null {
+    if (!toc) {
+        return null;
+    }
+    const localToc: YfmToc = JSON.parse(JSON.stringify(toc));
+    if (localToc.items) {
+        localToc.items = filterFiles(localToc.items, 'items', {}, {
+            removeHiddenTocItems: true,
+        });
+    }
+    const baseTocPath: string = localToc.base || '';
+    const navigationItemQueue = [localToc];
+    while (navigationItemQueue.length) {
+        const navigationItem = navigationItemQueue.shift();
+        if (!navigationItem) {
+            continue;
+        }
+        const {items, href} = navigationItem;
+        if (items) {
+            navigationItemQueue.push(...navigationItem.items);
+        }
+        if (href && !isExternalHref(href)) {
+            /* Path to directory with toc.yaml */
+            const pathToIndexDirectory: string = relative(pathToFileDirectory, baseTocPath);
+            const fileExtension: string = extname(href);
+            const filename: string = basename(href, fileExtension);
+            const transformedFilename: string = format({
+                name: filename,
+                ext: '.html',
+            });
+            navigationItem.href = join(pathToIndexDirectory, dirname(href), transformedFilename);
+        }
+    }
+    return localToc;
+}
+export function transformTocForSinglePage(toc: YfmToc | null, options: {root: string; currentPath: string}) {
+    const {root, currentPath} = options;
+    if (!toc) {
+        return null;
+    }
+    const localToc: YfmToc = JSON.parse(JSON.stringify(toc));
+    if (localToc.items) {
+        localToc.items = filterFiles(localToc.items, 'items', {}, {
+            removeHiddenTocItems: true,
+        });
+    }
+    function processItems(items: YfmToc[]) {
+        items.forEach((item) => {
+            if (item.items) {
+                processItems(item.items);
+            }
+            if (item.href && !isExternalHref(item.href)) {
+                item.href = getSinglePageAnchorId({root, currentPath, pathname: item.href});
+            }
+        });
+    }
+    processItems(localToc.items);
+    localToc.singlePage = true;
+    return localToc;
+}

package/src/utils/url.ts ADDED Viewed

@@ -0,0 +1,3 @@
+export function isExternalHref(href: string) {
+    return href.startsWith('http') || href.startsWith('//');
+}

package/src/utils/worker.ts ADDED Viewed

@@ -0,0 +1,10 @@
+export function splitOnChunks<T>(array: T[], chunkSize = 1000) {
+    const chunks: (T[])[] = [];
+    for (let i = 0, j = array.length; i < j; i += chunkSize) {
+        const chunk: T[] = array.slice(i, i + chunkSize);
+        chunks.push(chunk);
+    }
+    return chunks;
+}

package/src/validator.ts ADDED Viewed

@@ -0,0 +1,150 @@
+import {Arguments} from 'yargs';
+import {join, resolve} from 'path';
+import {readFileSync} from 'fs';
+import {load} from 'js-yaml';
+import merge from 'lodash/merge';
+import log from '@doc-tools/transform/lib/log';
+import {REDIRECTS_FILENAME, LINT_CONFIG_FILENAME, YFM_CONFIG_FILENAME} from './constants';
+import {ConnectorValidatorProps} from './vcs-connector/connector-models';
+function notEmptyStringValidator(value: unknown): Boolean {
+    if (typeof value === 'string') {
+        return Boolean(value);
+    }
+    return false;
+}
+function requiredValueValidator(value: unknown): Boolean {
+    return Boolean(value);
+}
+const validators: Record<string, ConnectorValidatorProps> = {
+    'storageEndpoint': {
+        errorMessage: 'Endpoint of S3 storage must be provided when publishes.',
+        validateFn: notEmptyStringValidator,
+    },
+    'storageBucket': {
+        errorMessage: 'Bucket name of S3 storage must be provided when publishes.',
+        validateFn: notEmptyStringValidator,
+    },
+    'storageKeyId': {
+        errorMessage: 'Key Id of S3 storage must be provided when publishes.',
+        validateFn: notEmptyStringValidator,
+        defaultValue: process.env.YFM_STORAGE_KEY_ID,
+    },
+    'storageSecretKey': {
+        errorMessage: 'Secret key of S3 storage must be provided when publishes.',
+        validateFn: notEmptyStringValidator,
+        defaultValue: process.env.YFM_STORAGE_SECRET_KEY,
+    },
+    'storageRegion': {
+        errorMessage: 'Region of S3 storage must be provided when publishes.',
+        validateFn: notEmptyStringValidator,
+        defaultValue: 'eu-central-1',
+    },
+};
+interface Redirect {
+    from: string;
+    to: string;
+}
+interface RedirectsConfig {
+    common: Redirect[];
+    [lang: string]: Redirect[];
+}
+function validateRedirects(redirectsConfig: RedirectsConfig, pathToRedirects: string) {
+    const redirects: Redirect[] = Object.keys(redirectsConfig).reduce((res, redirectSectionName) => {
+        const sectionRedirects = redirectsConfig[redirectSectionName];
+        res.push(...sectionRedirects);
+        return res;
+    }, [] as Redirect[]);
+    const getContext = (from: string, to: string) => ` [Context: \n- from: ${from}\n- to: ${to} ]`;
+    const formatMessage = (message: string, pathname: string, from: string, to: string) => (
+        `${pathname}: ${message} ${getContext(from, to)}`
+    );
+    redirects.forEach((redirect) => {
+        const {from, to} = redirect;
+        if (!from || !to) {
+            throw new Error(formatMessage('One of the two parameters is missing', pathToRedirects, from, to));
+        }
+        if (from === to) {
+            throw new Error(formatMessage('Parameters must be different', pathToRedirects, from, to));
+        }
+    });
+}
+export function argvValidator(argv: Arguments<Object>): Boolean {
+    try {
+        // Combine passed argv and properties from configuration file.
+        const pathToConfig = argv.config ? String(argv.config) : join(String(argv.input), YFM_CONFIG_FILENAME);
+        const content = readFileSync(resolve(pathToConfig), 'utf8');
+        Object.assign(argv, load(content) || {});
+    } catch (error) {
+        if (error.name === 'YAMLException') {
+            log.error(`Error to parse ${YFM_CONFIG_FILENAME}: ${error.message}`);
+        }
+    }
+    let lintConfig: unknown = {};
+    try {
+        const pathToConfig = join(String(argv.input), LINT_CONFIG_FILENAME);
+        const content = readFileSync(resolve(pathToConfig), 'utf8');
+        lintConfig = load(content) || {};
+    } catch (error) {
+        if (error.name === 'YAMLException') {
+            log.error(`Error to parse ${LINT_CONFIG_FILENAME}: ${error.message}`);
+        }
+    } finally {
+        const preparedLintConfig = merge(lintConfig, {
+            'log-levels': {
+                MD033: argv.allowHTML ? 'disabled' : 'error',
+            },
+        });
+        Object.assign(argv, {lintConfig: preparedLintConfig});
+    }
+    try {
+        const pathToRedirects = join(String(argv.input), REDIRECTS_FILENAME);
+        const redirectsContent = readFileSync(resolve(pathToRedirects), 'utf8');
+        const redirects = load(redirectsContent);
+        validateRedirects(redirects as RedirectsConfig, pathToRedirects);
+    } catch (error) {
+        if (error.name === 'YAMLException') {
+            log.error(`Error to parse ${REDIRECTS_FILENAME}: ${error.message}`);
+        }
+        if (error.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+    if (argv.publish) {
+        for (const [field, validator] of Object.entries(validators)) {
+            const value = argv[field] ?? validator.defaultValue;
+            if (!validator) {
+                continue;
+            }
+            const validateFn = validator.validateFn ?? requiredValueValidator;
+            if (!validateFn(value)) {
+                throw new Error(validator.errorMessage);
+            }
+            argv[field] = value;
+        }
+    }
+    return true;
+}