@diplodoc/cli 4.0.0 → 4.2.0

package/src/services/tocs.ts

@@ -3,8 +3,8 @@ import {copyFileSync, readFileSync, writeFileSync, existsSync} from 'fs';
 import {load, dump} from 'js-yaml';
 import shell from 'shelljs';
 import walkSync from 'walk-sync';
-import liquid from '@doc-tools/transform/lib/liquid';
-import log from '@doc-tools/transform/lib/log';
+import liquid from '@diplodoc/transform/lib/liquid';
+import log from '@diplodoc/transform/lib/log';
 import {bold} from 'chalk';
 
 import {ArgvService, PresetService} from './index';
@@ -49,11 +49,9 @@ async function add(path: string) {
     };
 
     if (parsedToc.title) {
-        parsedToc.title = firstFilterTextItems(
-            parsedToc.title,
-            combinedVars,
-            {resolveConditions: true},
-        );
+        parsedToc.title = firstFilterTextItems(parsedToc.title, combinedVars, {
+            resolveConditions: true,
+        });
     }
 
     if (typeof parsedToc.title === 'string') {
@@ -92,10 +90,7 @@ async function processTocItems(
     sourcesDir: string,
     vars: Record<string, string>,
 ) {
-    const {
-        resolveConditions,
-        removeHiddenTocItems,
-    } = ArgvService.getConfig();
+    const {resolveConditions, removeHiddenTocItems} = ArgvService.getConfig();
 
     let preparedItems = items;
 
@@ -115,7 +110,7 @@ async function processTocItems(
     return _replaceIncludes(path, preparedItems, tocDir, sourcesDir, vars);
 }
 
-function getForPath(path: string): YfmToc|undefined {
+function getForPath(path: string): YfmToc | undefined {
     return storage.get(path);
 }
 
@@ -131,11 +126,11 @@ function prepareNavigationPaths(parsedToc: YfmToc, dirPath: string) {
     function processItems(items: YfmToc[], pathToDir: string) {
         items.forEach((item) => {
             if (!parsedToc.singlePage && item.items) {
-                const preparedSubItems = item.items.map(((yfmToc: YfmToc, index: number) => {
+                const preparedSubItems = item.items.map((yfmToc: YfmToc, index: number) => {
                     // Generate personal id for each navigation item
                     yfmToc.id = `${yfmToc.name}-${index}-${Math.random()}`;
                     return yfmToc;
-                }));
+                });
                 processItems(preparedSubItems, pathToDir);
             }
 
@@ -308,9 +303,10 @@ async function _replaceIncludes(
 
         if (item.include) {
             const {mode = IncludeMode.ROOT_MERGE} = item.include;
-            const includeTocPath = mode === IncludeMode.ROOT_MERGE
-                ? resolve(sourcesDir, item.include.path)
-                : resolve(tocDir, item.include.path);
+            const includeTocPath =
+                mode === IncludeMode.ROOT_MERGE
+                    ? resolve(sourcesDir, item.include.path)
+                    : resolve(tocDir, item.include.path);
             const includeTocDir = dirname(includeTocPath);
 
             try {
@@ -332,11 +328,21 @@ async function _replaceIncludes(
 
                 /* Resolve nested toc inclusions */
                 const baseTocDir = mode === IncludeMode.LINK ? includeTocDir : tocDir;
-                includedTocItems = await processTocItems(path, includedTocItems, baseTocDir, sourcesDir, vars);
+                includedTocItems = await processTocItems(
+                    path,
+                    includedTocItems,
+                    baseTocDir,
+                    sourcesDir,
+                    vars,
+                );
 
                 /* Make hrefs relative to the main toc */
                 if (mode === IncludeMode.LINK) {
-                    includedTocItems = _replaceIncludesHrefs(includedTocItems, includeTocDir, tocDir);
+                    includedTocItems = _replaceIncludesHrefs(
+                        includedTocItems,
+                        includeTocDir,
+                        tocDir,
+                    );
                 }
 
                 if (item.name) {
@@ -345,9 +351,9 @@ async function _replaceIncludes(
                     includedInlineItems = includedTocItems;
                 }
             } catch (err) {
-                const message = (
-                    `Error while including toc: ${bold(includeTocPath)} to ${bold(join(tocDir, 'toc.yaml'))}`
-                );
+                const message = `Error while including toc: ${bold(includeTocPath)} to ${bold(
+                    join(tocDir, 'toc.yaml'),
+                )}`;
 
                 log.error(message);
 
@@ -375,7 +381,6 @@ function getTocDir(pagePath: string): string {
     const tocDir = dirname(pagePath);
     const tocPath = resolve(tocDir, 'toc.yaml');
 
-
     if (!tocDir.includes(inputFolderPath)) {
         throw new Error('Error while finding toc dir');
     }

package/src/services/utils.ts

@@ -1,6 +1,6 @@
-import evalExp from '@doc-tools/transform/lib/liquid/evaluation';
+import evalExp from '@diplodoc/transform/lib/liquid/evaluation';
 import {Filter, TextItems} from '../models';
-import liquid from '@doc-tools/transform/lib/liquid';
+import liquid from '@diplodoc/transform/lib/liquid';
 import {ArgvService} from './index';
 
 export interface FilterFilesOptions {
@@ -93,14 +93,20 @@ export function firstFilterTextItems(
     return filteredItems[0] || '';
 }
 
-function shouldProcessItem<T extends Filter>(item: T, vars: Record<string, string>, options?: FilterFilesOptions) {
+function shouldProcessItem<T extends Filter>(
+    item: T,
+    vars: Record<string, string>,
+    options?: FilterFilesOptions,
+) {
     const {resolveConditions, removeHiddenTocItems} = options || {};
     let useItem = true;
 
     if (resolveConditions) {
         const {when} = item;
         useItem =
-            when === true || when === undefined || (typeof when === 'string' && evalExp(when, vars));
+            when === true ||
+            when === undefined ||
+            (typeof when === 'string' && evalExp(when, vars));
 
         delete item.when;
     }
@@ -114,7 +120,11 @@ function shouldProcessItem<T extends Filter>(item: T, vars: Record<string, strin
     return useItem;
 }
 
-export function liquidFields(fields: undefined | string | string[], vars: Record<string, unknown>, path: string) {
+export function liquidFields(
+    fields: undefined | string | string[],
+    vars: Record<string, unknown>,
+    path: string,
+) {
     if (typeof fields === 'string') {
         return liquidField(fields, vars, path);
     }

package/src/steps/processAssets.ts

@@ -11,18 +11,12 @@ import {copyFiles} from '../utils';
  * @return {void}
  */
 export function processAssets(outputBundlePath: string) {
-    const {
-        input: inputFolderPath,
-        output: outputFolderPath,
-    } = ArgvService.getConfig();
+    const {input: inputFolderPath, output: outputFolderPath} = ArgvService.getConfig();
 
     const assetFilePath: string[] = walkSync(inputFolderPath, {
         directories: false,
         includeBasePath: false,
-        ignore: [
-            '**/*.yaml',
-            '**/*.md',
-        ],
+        ignore: ['**/*.yaml', '**/*.md'],
     });
 
     copyFiles(inputFolderPath, outputFolderPath, assetFilePath);

package/src/steps/processExcludedFiles.ts

@@ -10,38 +10,29 @@ import {convertBackSlashToSlash} from '../utils';
  * @return {void}
  */
 export function processExcludedFiles() {
-    const {
-        input: inputFolderPath,
-        output: outputFolderPath,
-        ignore,
-    } = ArgvService.getConfig();
+    const {input: inputFolderPath, output: outputFolderPath, ignore} = ArgvService.getConfig();
 
     const allContentFiles: string[] = walkSync(inputFolderPath, {
         directories: false,
         includeBasePath: true,
-        globs: [
-            '**/*.md',
-            '**/index.yaml',
-            ...ignore,
-        ],
+        globs: ['**/*.md', '**/index.yaml', ...ignore],
         // Ignores service directories like "_includes", "_templates" and etc.
         ignore: ['**/_*/**/*'],
     });
-    const navigationPaths = TocService.getNavigationPaths()
-        .map((filePath) => convertBackSlashToSlash(resolve(inputFolderPath, filePath)));
+    const navigationPaths = TocService.getNavigationPaths().map((filePath) =>
+        convertBackSlashToSlash(resolve(inputFolderPath, filePath)),
+    );
     const tocSpecifiedFiles = new Set(navigationPaths);
-    const excludedFiles = allContentFiles
-        .filter((filePath) => !tocSpecifiedFiles.has(filePath));
+    const excludedFiles = allContentFiles.filter((filePath) => !tocSpecifiedFiles.has(filePath));
 
     shell.rm('-f', excludedFiles);
 
-    const includedTocPaths = TocService.getIncludedTocPaths()
-        .map((filePath) => {
-            const relativeTocPath = relative(inputFolderPath, filePath);
-            const destTocPath = resolve(outputFolderPath, relativeTocPath);
+    const includedTocPaths = TocService.getIncludedTocPaths().map((filePath) => {
+        const relativeTocPath = relative(inputFolderPath, filePath);
+        const destTocPath = resolve(outputFolderPath, relativeTocPath);
 
-            return convertBackSlashToSlash(destTocPath);
-        });
+        return convertBackSlashToSlash(destTocPath);
+    });
 
     shell.rm('-rf', includedTocPaths);
 }

package/src/steps/processLinter.ts

@@ -1,4 +1,4 @@
-import log from '@doc-tools/transform/lib/log';
+import log from '@diplodoc/transform/lib/log';
 import {spawn, Worker, Thread} from 'threads';
 import {extname} from 'path';
 
@@ -10,7 +10,7 @@ import {lintPage} from '../resolvers';
 import {splitOnChunks} from '../utils/worker';
 
 let processLinterWorkers: (ProcessLinterWorker & Thread)[];
-let navigationPathsChunks: (string[])[];
+let navigationPathsChunks: string[][];
 
 export async function processLinter(): Promise<void> {
     const argvConfig = ArgvService.getConfig();
@@ -70,15 +70,16 @@ export async function initLinterWorkers() {
         return;
     }
 
-    navigationPathsChunks = splitOnChunks(navigationPaths, chunkSize)
-        .filter((arr) => arr.length);
+    navigationPathsChunks = splitOnChunks(navigationPaths, chunkSize).filter((arr) => arr.length);
 
     const workersCount = navigationPathsChunks.length;
 
-    processLinterWorkers = await Promise.all((new Array(workersCount)).fill(null).map(() => {
-        // TODO: get linter path from env
-        return spawn<ProcessLinterWorker>(new Worker('./linter'), {timeout: 60000});
-    }));
+    processLinterWorkers = await Promise.all(
+        new Array(workersCount).fill(null).map(() => {
+            // TODO: get linter path from env
+            return spawn<ProcessLinterWorker>(new Worker('./linter'), {timeout: 60000});
+        }),
+    );
 }
 
 function getChunkSize(arr: string[]) {

package/src/steps/processLogs.ts

@@ -1,15 +1,10 @@
-import log from '@doc-tools/transform/lib/log';
+import log from '@diplodoc/transform/lib/log';
 import _uniq from 'lodash/uniq';
 
 export function processLogs(inputFolder: string) {
     const replacementRegExp = new RegExp(inputFolder, 'ig');
     const {info, warn, error} = log.get();
-    const outputLogs = _uniq([
-        '', ...info,
-        '', ...warn,
-        '', ...error,
-        '',
-    ]);
+    const outputLogs = _uniq(['', ...info, '', ...warn, '', ...error, '']);
 
     for (const outputLog of outputLogs) {
         const preparedLog = outputLog.replace(replacementRegExp, '');

package/src/steps/processMapFile.ts

@@ -13,20 +13,17 @@ type TocItem = {
 type TocItems = TocItem[];
 
 export function prepareMapFile(): void {
-    const {
-        output: outputFolderPath,
-    } = ArgvService.getConfig();
+    const {output: outputFolderPath} = ArgvService.getConfig();
 
-    const navigationPathsWithoutExtensions =
-        TocService.getNavigationPaths().map((path) => {
-            let preparedPath = convertBackSlashToSlash(path.replace(extname(path), ''));
+    const navigationPathsWithoutExtensions = TocService.getNavigationPaths().map((path) => {
+        let preparedPath = convertBackSlashToSlash(path.replace(extname(path), ''));
 
-            if (preparedPath.endsWith('/index')) {
-                preparedPath = preparedPath.substring(0, preparedPath.length - 5);
-            }
+        if (preparedPath.endsWith('/index')) {
+            preparedPath = preparedPath.substring(0, preparedPath.length - 5);
+        }
 
-            return preparedPath;
-        });
+        return preparedPath;
+    });
     const navigationPaths = {files: [...new Set(navigationPathsWithoutExtensions)]};
     const filesMapBuffer = Buffer.from(JSON.stringify(navigationPaths, null, '\t'), 'utf8');
     const mapFile = join(outputFolderPath, 'files.json');

package/src/steps/processPages.ts

@@ -6,11 +6,16 @@ import {bold} from 'chalk';
 import {dump, load} from 'js-yaml';
 import {mapLimit, asyncify} from 'async';
 
-import log from '@doc-tools/transform/lib/log';
+import log from '@diplodoc/transform/lib/log';
 
 import {ArgvService, LeadingService, TocService, PluginService} from '../services';
 import {resolveMd2HTML, resolveMd2Md} from '../resolvers';
-import {generateStaticMarkup, joinSinglePageResults, logger, transformTocForSinglePage} from '../utils';
+import {
+    generateStaticMarkup,
+    joinSinglePageResults,
+    logger,
+    transformTocForSinglePage,
+} from '../utils';
 import {
     MetaDataOptions,
     SinglePageResult,
@@ -21,11 +26,7 @@ import {
 } from '../models';
 import {VCSConnector} from '../vcs-connector/connector-models';
 import {getVCSConnector} from '../vcs-connector';
-import {
-    SINGLE_PAGE_FILENAME,
-    SINGLE_PAGE_DATA_FILENAME,
-    Lang, ResourceType,
-} from '../constants';
+import {SINGLE_PAGE_FILENAME, SINGLE_PAGE_DATA_FILENAME, Lang, ResourceType} from '../constants';
 
 const singlePageResults: Record<string, SinglePageResult[]> = {};
 const singlePagePaths: Record<string, Set<string>> = {};
@@ -47,15 +48,34 @@ export async function processPages(outputBundlePath: string): Promise<void> {
     const navigationPaths = TocService.getNavigationPaths();
     const concurrency = 500;
 
-    await mapLimit(navigationPaths, concurrency, asyncify(async (pathToFile: string) => {
-        const pathData = getPathData(pathToFile, inputFolderPath, outputFolderPath, outputFormat, outputBundlePath);
-
-        logger.proc(pathToFile);
-
-        const metaDataOptions = getMetaDataOptions(pathData, inputFolderPath.length, vcsConnector);
-
-        await preparingPagesByOutputFormat(pathData, metaDataOptions, resolveConditions, singlePage);
-    }));
+    await mapLimit(
+        navigationPaths,
+        concurrency,
+        asyncify(async (pathToFile: string) => {
+            const pathData = getPathData(
+                pathToFile,
+                inputFolderPath,
+                outputFolderPath,
+                outputFormat,
+                outputBundlePath,
+            );
+
+            logger.proc(pathToFile);
+
+            const metaDataOptions = getMetaDataOptions(
+                pathData,
+                inputFolderPath.length,
+                vcsConnector,
+            );
+
+            await preparingPagesByOutputFormat(
+                pathData,
+                metaDataOptions,
+                resolveConditions,
+                singlePage,
+            );
+        }),
+    );
 
     if (singlePage) {
         await saveSinglePages(outputBundlePath);
@@ -106,44 +126,50 @@ async function saveSinglePages(outputBundlePath: string) {
     } = ArgvService.getConfig();
 
     try {
-        await Promise.all(Object.keys(singlePageResults).map(async (tocDir) => {
-            if (!singlePageResults[tocDir].length) {
-                return;
-            }
+        await Promise.all(
+            Object.keys(singlePageResults).map(async (tocDir) => {
+                if (!singlePageResults[tocDir].length) {
+                    return;
+                }
 
-            const singlePageBody = joinSinglePageResults(singlePageResults[tocDir], inputFolderPath, tocDir);
-            const tocPath = join(relative(inputFolderPath, tocDir), 'toc.yaml');
-            const toc: YfmToc|null = TocService.getForPath(tocPath) || null;
-            const preparedToc = transformTocForSinglePage(toc, {
-                root: inputFolderPath,
-                currentPath: join(tocDir, SINGLE_PAGE_FILENAME),
-            }) as YfmToc;
-
-            const pageData = {
-                data: {
-                    leading: false as const,
-                    html: singlePageBody,
-                    headings: [],
-                    meta: resources || {},
-                    toc: preparedToc,
-                },
-                router: {
-                    pathname: SINGLE_PAGE_FILENAME,
-                },
-                lang: lang || Lang.RU,
-            };
-
-            const outputTocDir = resolve(outputFolderPath, relative(inputFolderPath, tocDir));
-            const relativeOutputBundlePath = relative(outputTocDir, outputBundlePath);
-
-            // Save the full single page for viewing locally
-            const singlePageFn = join(tocDir, SINGLE_PAGE_FILENAME);
-            const singlePageDataFn = join(tocDir, SINGLE_PAGE_DATA_FILENAME);
-            const singlePageContent = generateStaticMarkup(pageData, relativeOutputBundlePath);
-
-            writeFileSync(singlePageFn, singlePageContent);
-            writeFileSync(singlePageDataFn, JSON.stringify(pageData));
-        }));
+                const singlePageBody = joinSinglePageResults(
+                    singlePageResults[tocDir],
+                    inputFolderPath,
+                    tocDir,
+                );
+                const tocPath = join(relative(inputFolderPath, tocDir), 'toc.yaml');
+                const toc: YfmToc | null = TocService.getForPath(tocPath) || null;
+                const preparedToc = transformTocForSinglePage(toc, {
+                    root: inputFolderPath,
+                    currentPath: join(tocDir, SINGLE_PAGE_FILENAME),
+                }) as YfmToc;
+
+                const pageData = {
+                    data: {
+                        leading: false as const,
+                        html: singlePageBody,
+                        headings: [],
+                        meta: resources || {},
+                        toc: preparedToc,
+                    },
+                    router: {
+                        pathname: SINGLE_PAGE_FILENAME,
+                    },
+                    lang: lang || Lang.RU,
+                };
+
+                const outputTocDir = resolve(outputFolderPath, relative(inputFolderPath, tocDir));
+                const relativeOutputBundlePath = relative(outputTocDir, outputBundlePath);
+
+                // Save the full single page for viewing locally
+                const singlePageFn = join(tocDir, SINGLE_PAGE_FILENAME);
+                const singlePageDataFn = join(tocDir, SINGLE_PAGE_DATA_FILENAME);
+                const singlePageContent = generateStaticMarkup(pageData, relativeOutputBundlePath);
+
+                writeFileSync(singlePageFn, singlePageContent);
+                writeFileSync(singlePageDataFn, JSON.stringify(pageData));
+            }),
+        );
     } catch (error) {
         console.log(error);
     }
@@ -172,7 +198,10 @@ function savePageResultForSinglePage(pageProps: DocInnerProps, pathData: PathDat
     });
 }
 
-function getMetaDataOptions(pathData: PathData, inputFolderPathLength: number, vcsConnector?: VCSConnector,
+function getMetaDataOptions(
+    pathData: PathData,
+    inputFolderPathLength: number,
+    vcsConnector?: VCSConnector,
 ): MetaDataOptions {
     const {contributors, addSystemMeta, resources, allowCustomResources} = ArgvService.getConfig();
 
@@ -187,7 +216,6 @@ function getMetaDataOptions(pathData: PathData, inputFolderPathLength: number, v
         addSystemMeta,
     };
 
-
     if (allowCustomResources && resources) {
         const allowedResources = Object.entries(resources).reduce((acc: Resources, [key, val]) => {
             if (Object.keys(ResourceType).includes(key)) {
@@ -199,7 +227,6 @@ function getMetaDataOptions(pathData: PathData, inputFolderPathLength: number, v
         metaDataOptions.resources = allowedResources;
     }
 
-
     return metaDataOptions;
 }
 
@@ -234,8 +261,10 @@ async function preparingPagesByOutputFormat(
             return;
         }
 
-        if (outputFormat === 'md' && isYamlFileExtension ||
-            outputFormat === 'html' && !isYamlFileExtension && fileExtension !== '.md') {
+        if (
+            (outputFormat === 'md' && isYamlFileExtension) ||
+            (outputFormat === 'html' && !isYamlFileExtension && fileExtension !== '.md')
+        ) {
             copyFileWithoutChanges(resolvedPathToFile, outputDir, filename);
             return;
         }
@@ -275,7 +304,11 @@ function processingYamlFile(path: PathData, metaDataOptions: MetaDataOptions) {
     writeFileSync(resolve(outputFolderPath, pathToFile), dump(parsedContent));
 }
 
-function copyFileWithoutChanges(resolvedPathToFile: string, outputDir: string, filename: string): void {
+function copyFileWithoutChanges(
+    resolvedPathToFile: string,
+    outputDir: string,
+    filename: string,
+): void {
     const from = resolvedPathToFile;
     const to = resolve(outputDir, filename);
 
@@ -292,14 +325,11 @@ async function processingFileToMd(path: PathData, metaDataOptions: MetaDataOptio
     });
 }
 
-async function processingFileToHtml(path: PathData, metaDataOptions: MetaDataOptions): Promise<DocInnerProps> {
-    const {
-        outputBundlePath,
-        filename,
-        fileExtension,
-        outputPath,
-        pathToFile,
-    } = path;
+async function processingFileToHtml(
+    path: PathData,
+    metaDataOptions: MetaDataOptions,
+): Promise<DocInnerProps> {
+    const {outputBundlePath, filename, fileExtension, outputPath, pathToFile} = path;
 
     return resolveMd2HTML({
         inputPath: pathToFile,

package/src/steps/processServiceFiles.ts

@@ -2,7 +2,7 @@ import {dirname, resolve} from 'path';
 import walkSync from 'walk-sync';
 import {readFileSync, writeFileSync} from 'fs';
 import {load, dump} from 'js-yaml';
-import log from '@doc-tools/transform/lib/log';
+import log from '@diplodoc/transform/lib/log';
 
 import {ArgvService, PresetService, TocService} from '../services';
 import {logger} from '../utils';
@@ -79,7 +79,9 @@ function saveFilteredPresets(path: string, parsedPreset: DocPreset): void {
     writeFileSync(outputPath, outputPreset);
 }
 
-async function preparingTocFiles(getFilePathsByGlobals: GetFilePathsByGlobalsFunction): Promise<void> {
+async function preparingTocFiles(
+    getFilePathsByGlobals: GetFilePathsByGlobalsFunction,
+): Promise<void> {
     try {
         const tocFilePaths = getFilePathsByGlobals(['**/toc.yaml']);
 

package/src/steps/publishFilesToS3.ts

@@ -21,7 +21,9 @@ export async function publishFilesToS3(): Promise<void> {
     } = ArgvService.getConfig();
 
     const s3Client = new S3({
-        endpoint, accessKeyId, secretAccessKey,
+        endpoint,
+        accessKeyId,
+        secretAccessKey,
     });
 
     const filesToPublish: string[] = walkSync(resolve(outputFolderPath), {
@@ -30,18 +32,20 @@ export async function publishFilesToS3(): Promise<void> {
         ignore,
     });
 
-    await Promise.all(filesToPublish.map(async (pathToFile) => {
-        const mimeType = mime.lookup(pathToFile);
+    await Promise.all(
+        filesToPublish.map(async (pathToFile) => {
+            const mimeType = mime.lookup(pathToFile);
 
-        const params: S3.Types.PutObjectRequest = {
-            ContentType: mimeType ? mimeType : undefined,
-            Bucket: bucket,
-            Key: convertBackSlashToSlash(join(prefix, pathToFile)),
-            Body: readFileSync(resolve(outputFolderPath, pathToFile)),
-        };
+            const params: S3.Types.PutObjectRequest = {
+                ContentType: mimeType ? mimeType : undefined,
+                Bucket: bucket,
+                Key: convertBackSlashToSlash(join(prefix, pathToFile)),
+                Body: readFileSync(resolve(outputFolderPath, pathToFile)),
+            };
 
-        logger.upload(pathToFile);
+            logger.upload(pathToFile);
 
-        return s3Client.upload(params).promise();
-    }));
+            return s3Client.upload(params).promise();
+        }),
+    );
 }

package/src/utils/file.ts

@@ -3,7 +3,11 @@ import shell from 'shelljs';
 import {copyFileSync} from 'fs';
 import {logger} from './logger';
 
-export function copyFiles(inputFolderPath: string, outputFolderPath: string, files: string[]): void {
+export function copyFiles(
+    inputFolderPath: string,
+    outputFolderPath: string,
+    files: string[],
+): void {
     for (const pathToAsset of files) {
         const outputDir: string = resolve(outputFolderPath, dirname(pathToAsset));
         const from = resolve(inputFolderPath, pathToAsset);

package/src/utils/glob.ts

@@ -4,9 +4,7 @@ export type Glob = {state: IGlob};
 
 const glob = async (pattern: string, options: IOptions): Promise<Glob> =>
     new Promise((res, rej) => {
-        const state: IGlob = libglob(pattern, options, (err) =>
-            err ? rej(err) : res({state}),
-        );
+        const state: IGlob = libglob(pattern, options, (err) => (err ? rej(err) : res({state})));
     });
 
 export {glob};

package/src/utils/logger.ts

@@ -1,4 +1,4 @@
-import log from '@doc-tools/transform/lib/log';
+import log from '@diplodoc/transform/lib/log';
 import {blue, green, grey, red, yellow} from 'chalk';
 import {ArgvService} from '../services';