@ng-doc/builder 15.0.0-beta.19 → 15.0.0-beta.21

package/engine/.cache/libs/builder/engine/post-processors/html-plugins/autolink-headings.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const is = require('hast-util-is-element');
+const visit = require('unist-util-visit-parents');
+const HEADINGS = ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'];
+const NO_ANCHOR_CLASS = 'no-anchor';
+const hasClass = (node, cls) => {
+    const className = node.properties.className;
+    return className && className.includes(cls);
+};
+/**
+ *
+ * @param options
+ * @param parentRoute
+ */
+function autolinkHeading(parentRoute) {
+    return (tree) => visit(tree, 'element', (node) => {
+        if (parentRoute && is(node, HEADINGS) && node.properties.id && !hasClass(node, NO_ANCHOR_CLASS)) {
+            node.children.push({
+                type: 'element',
+                tagName: 'a',
+                properties: {
+                    title: 'Link to heading',
+                    className: ['ng-doc-header-link'],
+                    href: `${parentRoute}#${node.properties.id}`
+                },
+                children: [{
+                        type: 'element',
+                        tagName: 'ng-doc-icon',
+                        properties: {
+                            icon: "link-2",
+                            size: 16,
+                        },
+                    }]
+            });
+        }
+    });
+}
+exports.default = autolinkHeading;

package/engine/.cache/libs/builder/engine/post-processors/html-plugins/keywords-processor.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_1 = require("../../../helpers");
+const visit = require('unist-util-visit-parents');
+const is = require('hast-util-is-element');
+const textContent = require('hast-util-to-string');
+/**
+ *
+ * @param entityStore
+ * @param entity
+ */
+function keywordsProcessor(entityStore, entity) {
+    if (entity) {
+        entity.usedKeywords = new Set();
+    }
+    return (tree) => visit(tree, 'element', (node, ancestors) => {
+        if (!isCodeNode(node)) {
+            return;
+        }
+        const parent = ancestors[ancestors.length - 1];
+        const isInlineCode = !is(parent, 'pre');
+        visit(node, 'text', (node, ancestors) => {
+            if (hasLinkAncestor(ancestors)) {
+                return;
+            }
+            const parent = ancestors[ancestors.length - 1];
+            const index = parent.children.indexOf(node);
+            // Parse the text for words that we can convert to links
+            const nodes = getNodes(node, parent, entityStore, isInlineCode, entity);
+            // Replace the text node with the links and leftover text nodes
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            Array.prototype.splice.apply(parent.children, [index, 1].concat(nodes));
+            // Do not visit this node's children or the newly added nodes
+            return [visit.SKIP, index + nodes.length];
+        });
+    });
+}
+exports.default = keywordsProcessor;
+/**
+ *
+ * @param ancestors
+ */
+function hasLinkAncestor(ancestors) {
+    return ancestors.some((ancestor) => is(ancestor, 'a'));
+}
+/**
+ *
+ * @param node
+ */
+function isCodeNode(node) {
+    return is(node, 'code') || is(node, 'ng-doc-code');
+}
+/**
+ *
+ * @param node
+ * @param parent
+ * @param entityStore
+ * @param inlineLink
+ * @param e
+ */
+function getNodes(node, parent, entityStore, inlineLink, e) {
+    const KeywordRegexp = /([A-Za-z0-9_.-/*]+)/;
+    return textContent(node)
+        .split(KeywordRegexp)
+        .filter((word) => word.length)
+        .map((word) => {
+        if (e && KeywordRegexp.test(word)) {
+            e.usedKeywords.add(word);
+        }
+        const keyword = entityStore.getByKeyword(word);
+        if (inlineLink && /^\*\w+/gm.test(word) && !keyword) {
+            (0, helpers_1.printWarning)(`Keyword "${word}" is missing.`);
+        }
+        // Convert code tag to link if it's a link to the page entity
+        if (inlineLink && (keyword === null || keyword === void 0 ? void 0 : keyword.isCodeLink) === false) {
+            parent.tagName = 'a';
+            parent.properties = { href: keyword.path };
+            return { type: 'text', value: keyword.title };
+        }
+        else if (inlineLink && keyword) {
+            parent.properties.class = 'ng-doc-code-with-link';
+        }
+        // Add link inside the code if it's a link to the API entity
+        return keyword
+            ? createLinkNode(inlineLink ? keyword.title : word, keyword.path)
+            : { type: 'text', value: word };
+    });
+}
+/**
+ *
+ * @param text
+ * @param href
+ */
+function createLinkNode(text, href) {
+    return {
+        type: 'element',
+        tagName: 'a',
+        properties: { href: href, class: 'ng-doc-code-anchor' },
+        children: [{ type: 'text', value: text }],
+    };
+}

package/engine/.cache/libs/builder/engine/post-processors/html-post-processor.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.htmlPostProcessor = void 0;
+const helpers_1 = require("../../helpers");
+const autolink_headings_1 = require("./html-plugins/autolink-headings");
+const keywords_processor_1 = require("./html-plugins/keywords-processor");
+/**
+ *
+ * @param builder
+ * @param entity
+ * @param content
+ */
+function htmlPostProcessor(entity, content) {
+    return Object.assign(Object.assign({}, content), { content: require('rehype')()
+            .use(require('rehype-format'))
+            .use(require('rehype-highlight'))
+            .use(require('rehype-slug'))
+            .use(autolink_headings_1.default, (0, helpers_1.isRouteEntity)(entity) ? entity.fullRoute : undefined)
+            .use(keywords_processor_1.default, entity.builder.entities, (0, helpers_1.isRouteEntity)(entity) ? entity : undefined)
+            .processSync(content.content)
+            .toString() });
+}
+exports.htmlPostProcessor = htmlPostProcessor;

package/engine/.cache/libs/builder/engine/post-processors/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./html-post-processor"), exports);

package/engine/.cache/libs/builder/engine/renderer.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NgDocRenderer = void 0;
+const core_1 = require("@ng-doc/core");
+const fs = require("fs");
+const nunjucks_1 = require("nunjucks");
+const path = require("path");
+const rxjs_1 = require("rxjs");
+const ts_morph_1 = require("ts-morph");
+const filters = require("./template-filters");
+const variables_1 = require("./variables");
+class NgDocRelativeLoader {
+    constructor(path, dependenciesStore) {
+        this.path = path;
+        this.dependenciesStore = dependenciesStore;
+    }
+    getSource(name) {
+        var _a;
+        const fullPath = path.join(this.path, name);
+        (_a = this.dependenciesStore) === null || _a === void 0 ? void 0 : _a.add(fullPath);
+        return {
+            src: fs.readFileSync(fullPath, 'utf-8'),
+            path: fullPath,
+            noCache: true,
+        };
+    }
+}
+class NgDocRenderer {
+    constructor(builder, context, dependenciesStore) {
+        this.builder = builder;
+        this.context = context;
+        this.dependenciesStore = dependenciesStore;
+    }
+    render(template, options) {
+        return new rxjs_1.Observable((observer) => {
+            this.getEnvironment(options).render(template, this.getContext(options === null || options === void 0 ? void 0 : options.overrideContext), (err, data) => {
+                if (err) {
+                    observer.error(err);
+                }
+                else {
+                    observer.next(data !== null && data !== void 0 ? data : '');
+                    observer.complete();
+                }
+            });
+        });
+    }
+    getContext(context) {
+        return Object.assign({}, (context !== null && context !== void 0 ? context : this.context));
+    }
+    getEnvironment(options) {
+        var _a;
+        let environment = new nunjucks_1.Environment(new NgDocRelativeLoader((_a = options === null || options === void 0 ? void 0 : options.scope) !== null && _a !== void 0 ? _a : variables_1.TEMPLATES_PATH, this.dependenciesStore), { autoescape: false });
+        (0, core_1.objectKeys)(filters).forEach((filter) => (environment = environment.addFilter(filter, filters[filter])));
+        environment.addGlobal('Node', ts_morph_1.Node);
+        environment.addGlobal('NgDocBuilder', this.builder);
+        return environment;
+    }
+}
+exports.NgDocRenderer = NgDocRenderer;

package/engine/.cache/libs/builder/engine/template-filters.js

@@ -0,0 +1,19 @@
+"use strict";
+/* Just export filters from this file, they will be included to the template renderer automatically */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.humanizeDeclarationName = exports.variablePresentation = exports.typeAliasPresentation = exports.noLineBreaks = exports.methodPresentation = exports.marked = exports.filterByStatic = exports.filterByScope = exports.extractSelectors = exports.extractSeeDocs = exports.extractParameterDocs = exports.extractDocs = exports.displayType = void 0;
+var helpers_1 = require("../helpers");
+Object.defineProperty(exports, "displayType", { enumerable: true, get: function () { return helpers_1.displayType; } });
+Object.defineProperty(exports, "extractDocs", { enumerable: true, get: function () { return helpers_1.extractDocs; } });
+Object.defineProperty(exports, "extractParameterDocs", { enumerable: true, get: function () { return helpers_1.extractParameterDocs; } });
+Object.defineProperty(exports, "extractSeeDocs", { enumerable: true, get: function () { return helpers_1.extractSeeDocs; } });
+Object.defineProperty(exports, "extractSelectors", { enumerable: true, get: function () { return helpers_1.extractSelectors; } });
+Object.defineProperty(exports, "filterByScope", { enumerable: true, get: function () { return helpers_1.filterByScope; } });
+Object.defineProperty(exports, "filterByStatic", { enumerable: true, get: function () { return helpers_1.filterByStatic; } });
+Object.defineProperty(exports, "marked", { enumerable: true, get: function () { return helpers_1.marked; } });
+Object.defineProperty(exports, "methodPresentation", { enumerable: true, get: function () { return helpers_1.methodPresentation; } });
+Object.defineProperty(exports, "noLineBreaks", { enumerable: true, get: function () { return helpers_1.noLineBreaks; } });
+Object.defineProperty(exports, "typeAliasPresentation", { enumerable: true, get: function () { return helpers_1.typeAliasPresentation; } });
+Object.defineProperty(exports, "variablePresentation", { enumerable: true, get: function () { return helpers_1.variablePresentation; } });
+var core_1 = require("@ng-doc/core");
+Object.defineProperty(exports, "humanizeDeclarationName", { enumerable: true, get: function () { return core_1.humanizeDeclarationName; } });

package/engine/.cache/libs/builder/engine/ts-doc-formatter.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TsDocFormatter = void 0;
+const tsdoc_1 = require("@microsoft/tsdoc");
+const hiddenExcerptKinds = [tsdoc_1.ExcerptKind.BlockTag];
+class TsDocFormatter {
+    static renderDocNode(docNode) {
+        let result = '';
+        if (docNode) {
+            tsdoc_1.DocBlockTag;
+            if (docNode instanceof tsdoc_1.DocExcerpt && !hiddenExcerptKinds.includes(docNode.excerptKind)) {
+                result += docNode.content.toString();
+            }
+            for (const childNode of docNode.getChildNodes()) {
+                result += TsDocFormatter.renderDocNode(childNode);
+            }
+        }
+        return result;
+    }
+    static renderDocNodes(docNodes) {
+        let result = '';
+        for (const docNode of docNodes) {
+            result += TsDocFormatter.renderDocNode(docNode);
+        }
+        return result;
+    }
+}
+exports.TsDocFormatter = TsDocFormatter;

package/engine/.cache/libs/builder/engine/variables.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TEMPLATES_PATH = exports.CACHE_PATH = exports.PLAYGROUND_PATTERN = exports.API_PATTERN = exports.PAGE_DEPENDENCY_PATTERN = exports.CATEGORY_PATTERN = exports.PAGE_PATTERN = exports.RENDERED_PAGE_NAME = exports.PLAYGROUND_NAME = exports.API_NAME = exports.PAGE_DEPENDENCIES_NAME = exports.CATEGORY_NAME = exports.PAGE_NAME = void 0;
+const path = require("path");
+exports.PAGE_NAME = 'ng-doc.page.ts';
+exports.CATEGORY_NAME = 'ng-doc.category.ts';
+exports.PAGE_DEPENDENCIES_NAME = 'ng-doc.dependencies.ts';
+exports.API_NAME = 'ng-doc.api.ts';
+exports.PLAYGROUND_NAME = 'ng-doc.playground.ts';
+exports.RENDERED_PAGE_NAME = 'index.html';
+exports.PAGE_PATTERN = `**/${exports.PAGE_NAME}`;
+exports.CATEGORY_PATTERN = `**/${exports.CATEGORY_NAME}`;
+exports.PAGE_DEPENDENCY_PATTERN = `**/${exports.PAGE_DEPENDENCIES_NAME}`;
+exports.API_PATTERN = `**/${exports.API_NAME}`;
+exports.PLAYGROUND_PATTERN = `**/${exports.PLAYGROUND_NAME}`;
+exports.CACHE_PATH = path.join(__dirname, '.cache');
+exports.TEMPLATES_PATH = path.join(__dirname, '../templates');

package/engine/.cache/libs/builder/engine/watcher.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NgDocWatcher = void 0;
+const chokidar = require("chokidar");
+const minimatch_1 = require("minimatch");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+class NgDocWatcher {
+    constructor(files) {
+        this.change$ = new rxjs_1.Subject();
+        this.add$ = new rxjs_1.Subject();
+        this.unlink$ = new rxjs_1.Subject();
+        this.ready$ = new rxjs_1.Subject();
+        this.watcher = chokidar.watch(files !== null && files !== void 0 ? files : [], {
+            /*  `useFsEvents` causes problems on Mac when chokidar doesn't fire `unlink` event if the file has been moved */
+            useFsEvents: false,
+        });
+        this.watcher
+            .on('add', (path) => this.add$.next(path))
+            .on('change', (path) => this.change$.next(path))
+            .on('unlink', (path) => this.unlink$.next(path))
+            .on('ready', () => this.ready$.next());
+    }
+    watch(paths) {
+        this.watcher.add(paths);
+        return this;
+    }
+    unwatch(paths) {
+        this.watcher.unwatch(paths);
+    }
+    onAdd(...filterPaths) {
+        return this.add$.pipe((0, operators_1.filter)((path) => !filterPaths || filterPaths.some((p) => (0, minimatch_1.default)(path, p))));
+    }
+    onChange(...filterPaths) {
+        return this.change$.pipe((0, operators_1.filter)((path) => !filterPaths || filterPaths.some((p) => (0, minimatch_1.default)(path, p))));
+    }
+    onUnlink(...filterPaths) {
+        return this.unlink$.pipe((0, operators_1.filter)((path) => !filterPaths || filterPaths.some((p) => (0, minimatch_1.default)(path, p))));
+    }
+    onReady() {
+        return this.ready$;
+    }
+    close() {
+        this.watcher.close();
+    }
+}
+exports.NgDocWatcher = NgDocWatcher;

package/engine/.cache/libs/builder/helpers/build-assets.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAssets = void 0;
+const fs = require("fs");
+const code_type_from_ext_1 = require("./code-type-from-ext");
+const process_snippets_1 = require("./process-snippets");
+const unique_name_1 = require("./unique-name");
+/**
+ * Builds an asset from a file.
+ *
+ * @param {string} filePath The path to the file.
+ * @param {NgDocStyleType} styleType The inline style path.
+ * @returns {NgDocAsset} The array of assets.
+ */
+function buildAssets(filePath, styleType) {
+    try {
+        const fileContent = fs.readFileSync(filePath, 'utf8').trim();
+        const snippets = (0, process_snippets_1.processSnippets)(fileContent);
+        const codeType = (0, code_type_from_ext_1.codeTypeFromExt)(filePath);
+        if (snippets.length) {
+            return snippets.map((snippet) => ({
+                title: snippet.name,
+                name: (0, unique_name_1.uniqueName)('Asset'),
+                originalPath: filePath,
+                output: snippet.content,
+                type: snippet.type === 'styles'
+                    ? ['CSS', 'SCSS', 'SASS', 'LESS'].includes(codeType)
+                        ? codeType
+                        : styleType
+                    : snippet.type,
+            }));
+        }
+        else if (fileContent) {
+            return [
+                {
+                    title: codeType,
+                    name: (0, unique_name_1.uniqueName)('Asset'),
+                    originalPath: filePath,
+                    output: fileContent,
+                    type: codeType,
+                },
+            ];
+        }
+    }
+    catch (e) {
+        console.error(e);
+    }
+    return [];
+}
+exports.buildAssets = buildAssets;

package/engine/.cache/libs/builder/helpers/build-global-indexes.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildGlobalIndexes = void 0;
+const core_1 = require("@ng-doc/core");
+const lunr_1 = require("lunr");
+const path = require("path");
+const posthtml_parser_1 = require("posthtml-parser");
+const entities_1 = require("../engine/entities");
+const route_entity_1 = require("../engine/entities/abstractions/route.entity");
+/**
+ *
+ * @param entities
+ */
+function buildGlobalIndexes(entities) {
+    return buildIndexes(entities, route_entity_1.NgDocRouteEntity);
+}
+exports.buildGlobalIndexes = buildGlobalIndexes;
+/**
+ *
+ * @param entities
+ * @param entityType
+ */
+function buildIndexes(entities, entityType) {
+    const indexes = [];
+    entities.filter((entity) => entity instanceof entityType).forEach((entity) => {
+        const pageIndexes = entity.artifacts
+            .filter((artifact) => path.extname(artifact.filePath) === '.html')
+            .map((artifact) => {
+            const nodes = (0, posthtml_parser_1.parser)(artifact.content);
+            return extractIndexes(entity, nodes);
+        })
+            .flat();
+        indexes.push(...pageIndexes);
+    });
+    const queryLexer = lunr_1.default.QueryLexer;
+    queryLexer.termSeparator = lunr_1.default.tokenizer.separator = /\s+/;
+    const index = (0, lunr_1.default)((builder) => {
+        builder.pipeline.remove(lunr_1.default.stemmer);
+        builder.ref('route');
+        builder.field('heading', { boost: 10 });
+        builder.field('content', { boost: 5 });
+        indexes.forEach((index) => builder.add(index));
+    });
+    const pages = indexes.reduce((pages, index) => {
+        pages[index.route] = {
+            route: index.route,
+            title: index.title,
+            type: index.type,
+            kind: index.kind,
+        };
+        return pages;
+    }, {});
+    return [JSON.stringify(pages, undefined, 2), JSON.stringify(index, undefined, 2)];
+}
+/**
+ *
+ * @param entity
+ * @param nodes
+ * @param parentIndex
+ * @param indexes
+ */
+function extractIndexes(entity, nodes, indexes = []) {
+    if (!indexes.length) {
+        indexes.push({
+            route: entity.fullRoute,
+            type: getTypeFromEntity(entity),
+            title: entity.title,
+            heading: entity.title,
+            content: '',
+            kind: getKindFromEntity(entity),
+        });
+    }
+    nodes.forEach((node) => {
+        if ((0, core_1.isNodeTag)(node)) {
+            if (!isIgnoredTag(node)) {
+                if (isHeadingTag(node)) {
+                    indexes.push({
+                        route: entity.fullRoute,
+                        type: getTypeFromEntity(entity),
+                        title: entity.title,
+                        heading: extractText(node),
+                        content: '',
+                        kind: getKindFromEntity(entity),
+                    });
+                }
+                else if (Array.isArray(node.content)) {
+                    indexes[indexes.length - 1].content += extractText(node);
+                    extractIndexes(entity, (0, core_1.asArray)(node.content).flat(), indexes);
+                }
+            }
+        }
+    });
+    return indexes;
+}
+/**
+ *
+ * @param node
+ */
+function isIgnoredTag(node) {
+    return ['pre', 'code', 'div', 'span'].includes(String(node.tag));
+}
+/**
+ *
+ * @param node
+ */
+function extractText(node) {
+    if ((0, core_1.isNodeTag)(node)) {
+        return isIgnoredTag(node)
+            ? ''
+            : (0, core_1.asArray)(node.content)
+                .flat()
+                .filter((node) => typeof node === 'string')
+                .map((str) => str.trim())
+                .join('\n');
+    }
+    else {
+        return String(node);
+    }
+}
+/**
+ *
+ * @param entity
+ */
+function getTypeFromEntity(entity) {
+    if (entity instanceof entities_1.NgDocApiPageEntity) {
+        return 'api';
+    }
+    return 'guide';
+}
+/**
+ *
+ * @param node
+ */
+function isHeadingTag(node) {
+    return ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'].includes(String(node.tag));
+}
+/**
+ *
+ * @param node
+ */
+function isHeaderTag(node) {
+    return ['header'].includes(String(node.tag));
+}
+/**
+ *
+ * @param node
+ */
+function isSectionTag(node) {
+    return ['section'].includes(String(node.tag));
+}
+/**
+ *
+ * @param node
+ */
+function isParagraph(node) {
+    return ['p'].includes(String(node.tag));
+}
+/**
+ *
+ * @param entity
+ */
+function getKindFromEntity(entity) {
+    var _a, _b;
+    if (entity instanceof entities_1.NgDocApiPageEntity) {
+        return (0, core_1.humanizeDeclarationName)((_b = (_a = entity.declaration) === null || _a === void 0 ? void 0 : _a.getKindName()) !== null && _b !== void 0 ? _b : '');
+    }
+    return undefined;
+}

package/engine/.cache/libs/builder/helpers/code-type-from-ext.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codeTypeFromExt = void 0;
+/**
+ *
+ * @param filePath
+ */
+function codeTypeFromExt(filePath) {
+    const ext = filePath.split('.').pop();
+    switch (ext) {
+        case 'ts':
+            return 'TypeScript';
+        case 'html':
+            return 'HTML';
+        case 'css':
+            return 'CSS';
+        case 'scss':
+            return 'SCSS';
+        case 'less':
+            return 'LESS';
+        case 'sass':
+            return 'SASS';
+        default:
+            return 'unknown';
+    }
+}
+exports.codeTypeFromExt = codeTypeFromExt;

package/engine/.cache/libs/builder/helpers/create-builder-context.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBuilderContext = void 0;
+const core_1 = require("@ng-doc/core");
+const path = require("path");
+/**
+ *
+ * @param targetOptions
+ * @param options
+ * @param context
+ * @param project
+ */
+function createBuilderContext(targetOptions, options, context) {
+    var _a, _b, _c, _d, _e, _f;
+    const buildPath = path.join(context.workspaceRoot, '.ng-doc', (_b = (_a = context.target) === null || _a === void 0 ? void 0 : _a.project) !== null && _b !== void 0 ? _b : 'app');
+    return {
+        tsConfig: String(targetOptions['tsConfig']),
+        options,
+        context,
+        inlineStyleLanguage: (_c = targetOptions === null || targetOptions === void 0 ? void 0 : targetOptions['inlineStyleLanguage']) !== null && _c !== void 0 ? _c : 'CSS',
+        pagesPaths: ((_e = (_d = options.ngDoc) === null || _d === void 0 ? void 0 : _d.pages) === null || _e === void 0 ? void 0 : _e.length) ? (0, core_1.asArray)((_f = options.ngDoc) === null || _f === void 0 ? void 0 : _f.pages) : [path.dirname(options.main)],
+        assetsPath: path.join(buildPath, 'assets'),
+        buildPath,
+        apiPath: path.join(buildPath, 'api'),
+        modulesPath: path.join(buildPath, 'modules'),
+    };
+}
+exports.createBuilderContext = createBuilderContext;

package/engine/.cache/libs/builder/helpers/declaration-folder-name.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.declarationFolderName = void 0;
+const ts_morph_1 = require("ts-morph");
+/**
+ *
+ * @param declaration
+ */
+function declarationFolderName(declaration) {
+    if (ts_morph_1.Node.isClassDeclaration(declaration)) {
+        return 'classes';
+    }
+    else if (ts_morph_1.Node.isInterfaceDeclaration(declaration)) {
+        return 'interfaces';
+    }
+    else if (ts_morph_1.Node.isEnumDeclaration(declaration)) {
+        return 'enums';
+    }
+    else if (ts_morph_1.Node.isFunctionDeclaration(declaration)) {
+        return 'functions';
+    }
+    else if (ts_morph_1.Node.isVariableDeclaration(declaration)) {
+        return 'variables';
+    }
+    else if (ts_morph_1.Node.isTypeAliasDeclaration(declaration)) {
+        return 'types';
+    }
+    else if (ts_morph_1.Node.isModuleDeclaration(declaration)) {
+        return 'modules';
+    }
+    else {
+        return 'unknowns';
+    }
+}
+exports.declarationFolderName = declarationFolderName;