nesoi 3.0.0

package/lib/compiler/treeshake.js

@@ -0,0 +1,424 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Treeshake = void 0;
+const dependency_1 = require("../engine/dependency");
+const bucket_graph_builder_1 = require("../elements/entities/bucket/graph/bucket_graph.builder");
+const externals_builder_1 = require("../elements/blocks/externals/externals.builder");
+const log_1 = require("../engine/util/log");
+const string_1 = require("../engine/util/string");
+const error_1 = require("../engine/data/error");
+const constants_builder_1 = require("../elements/entities/constants/constants.builder");
+class Treeshake {
+    /* Externals */
+    static externals(node, depth = 1) {
+        const b = node.builder;
+        const $b = b.$b;
+        const buckets = b.buckets;
+        const jobs = b.jobs;
+        log_1.Log.trace('compiler', 'treeshake', `${'  '.repeat(depth)} └ Treeshaking node ${(0, log_1.scopeTag)($b, node.name)}`);
+        node.dependencies = [
+            ...Object.values(buckets),
+            ...Object.values(jobs)
+        ];
+        node.dependencies = this.cleanNodeDependencies(node);
+    }
+    /* Bucket */
+    static bucket(node, depth = 1) {
+        const b = node.builder;
+        const $b = b.$b;
+        const _extend = b._extend;
+        const graphLinks = b._graph;
+        const name = b.name;
+        const _model = b._model;
+        log_1.Log.trace('compiler', 'treeshake', `${'  '.repeat(depth)} └ Treeshaking node ${(0, log_1.scopeTag)($b, node.name)}`);
+        node.dependencies = [];
+        if (_extend) {
+            node.dependencies.push(_extend);
+        }
+        if (_model) {
+            node.dependencies.push(...Treeshake.bucketModelFields(node, _model.fields));
+        }
+        const graph = new bucket_graph_builder_1.BucketGraphBuilder().links(graphLinks);
+        node.dependencies.push(...Treeshake.bucketGraph(node, graph));
+        node.dependencies = this.cleanNodeDependencies(node);
+    }
+    static bucketModelFields(node, fields) {
+        const dependencies = [];
+        Object.values(fields).forEach(field => {
+            if (field._enum?.dep) {
+                dependencies.push(field._enum.dep);
+            }
+            if (field.children?.length) {
+                dependencies.push(...Treeshake.bucketModelFields(node, field.children));
+            }
+        });
+        return dependencies;
+    }
+    static bucketGraph(node, builder) {
+        const b = builder;
+        const _links = b._links;
+        return Object.values(_links).map((link) => {
+            const dep = Treeshake.bucketGraphLink(link);
+            if (dep.module === node.module && dep.name === node.name) {
+                return undefined;
+            }
+            return dep;
+        }).filter(d => !!d);
+    }
+    static bucketGraphLink(builder) {
+        const b = builder;
+        const bucket = b.bucket;
+        return bucket;
+    }
+    /* Message */
+    static message(node, depth = 1) {
+        const b = node.builder;
+        const $b = b.$b;
+        const _fields = b._template._fields;
+        log_1.Log.trace('compiler', 'treeshake', `${'  '.repeat(depth)} └ Treeshaking node ${(0, log_1.scopeTag)($b, node.name)}`);
+        node.dependencies = Treeshake.messageFieldTree(node, _fields);
+        node.dependencies = this.cleanNodeDependencies(node);
+    }
+    static messageFieldTree(node, tree) {
+        const dependencies = [];
+        Object.values(tree).forEach(child => {
+            const c = child;
+            if (c.__ext) {
+                dependencies.push(c.__ext);
+            }
+            if (c.type === 'enum') {
+                if (typeof c.value.enum.options === 'string') {
+                    dependencies.push(c.value.enum.dep);
+                }
+            }
+            else if (c.type === 'id') {
+                const ref = c.value.id.bucket;
+                dependencies.push(ref);
+            }
+            else if (c.type === 'msg') {
+                dependencies.push(c.value.msg);
+            }
+            else if (c.children) {
+                dependencies.push(...Treeshake.messageFieldTree(node, c.children));
+            }
+        });
+        return dependencies;
+    }
+    /* Block */
+    static blockIO(node) {
+        const b = node.builder;
+        const _inputMsgs = b._inputMsgs;
+        const _inlineNodes = b._inlineNodes;
+        const nonInlineIO = [
+            ..._inputMsgs.filter(dep => !_inlineNodes.some(node => node.module === dep.module
+                && node.type === dep.type
+                && node.name === dep.name))
+        ];
+        return nonInlineIO;
+    }
+    static blockInlineNodes(node, depth = 1) {
+        const b = node.builder;
+        const _inlineNodes = b._inlineNodes;
+        const dependencies = [];
+        const nestedInlines = [];
+        // Finds the dependencies of each inline node
+        for (const inlineNode of _inlineNodes) {
+            // Inherit information from parent node
+            inlineNode.filepath = node.filepath;
+            inlineNode.tag = `${inlineNode.module}::${inlineNode.type}:${inlineNode.name}`;
+            if (inlineNode.type === 'message') {
+                Treeshake.message(inlineNode, depth + 1);
+                dependencies.push(...inlineNode.dependencies);
+            }
+            else if (inlineNode.type === 'job') {
+                const deps = Treeshake.job(inlineNode, depth + 1);
+                dependencies.push(...inlineNode.dependencies);
+                nestedInlines.push(...deps.inlines);
+            }
+        }
+        // Inlines have a dependency on their parent node
+        const inlines = [..._inlineNodes, ...nestedInlines];
+        inlines.forEach(inline => {
+            inline.dependencies.push(new dependency_1.$Dependency(node.module, node.type, node.name));
+        });
+        return {
+            dependencies,
+            inlines
+        };
+    }
+    /* Job */
+    static job(node, depth = 0) {
+        const builder = node.builder;
+        log_1.Log.trace('compiler', 'treeshake', `${'  '.repeat(depth)} └ Treeshaking node ${(0, log_1.scopeTag)(builder.$b, node.name)}`);
+        const inlineTreeshake = Treeshake.blockInlineNodes(node, depth);
+        node.dependencies = [
+            ...Treeshake.blockIO(node),
+            ...inlineTreeshake.dependencies
+        ];
+        node.dependencies = this.cleanNodeDependencies(node);
+        return { inlines: inlineTreeshake.inlines };
+    }
+    /* Resource */
+    static resource(node, depth = 1) {
+        const b = node.builder;
+        const $b = b.$b;
+        const _bucket = b._bucket;
+        log_1.Log.trace('compiler', 'treeshake', `${'  '.repeat(depth)} └ Treeshaking node ${(0, log_1.scopeTag)($b, node.name)}`);
+        const inlineTreeshake = Treeshake.blockInlineNodes(node, depth);
+        node.dependencies = [
+            _bucket,
+            ...inlineTreeshake.dependencies
+        ];
+        node.dependencies = this.cleanNodeDependencies(node);
+        return { inlines: inlineTreeshake.inlines };
+    }
+    /* Machine */
+    static machine(node, depth = 1) {
+        const b = node.builder;
+        const $b = b.$b;
+        const _buckets = b._buckets;
+        log_1.Log.trace('compiler', 'treeshake', `${'  '.repeat(depth)} └ Treeshaking node ${(0, log_1.scopeTag)($b, node.name)}`);
+        const buckets = _buckets;
+        node.dependencies = [...buckets];
+        const inlineTreeshake = Treeshake.blockInlineNodes(node, depth);
+        node.dependencies.push(...inlineTreeshake.dependencies);
+        node.dependencies = this.cleanNodeDependencies(node);
+        return { inlines: inlineTreeshake.inlines };
+    }
+    /* Controller */
+    static controller(node) {
+        const b = node.builder;
+        node.dependencies = [];
+    }
+    static queue(node) {
+        const b = node.builder;
+        node.dependencies = [];
+    }
+    /* Module */
+    /**
+     * Scans the module directory, imports the builders and lists
+     * all nodes found.
+     *
+     * @returns A list of all `BuilderNodes` found on the module folder
+     */
+    static async module(module, config) {
+        log_1.Log.debug('compiler', 'treeshake', `Treeshaking ${(0, log_1.scopeTag)('module', module.name)}`);
+        const nodes = [];
+        const merge = (node) => {
+            // Merge constants in a single builder
+            if (node.type === 'constants') {
+                node.filepath = [node.filepath];
+                const constants = nodes.find(node => node.type === 'constants');
+                if (constants) {
+                    constants_builder_1.ConstantsBuilder.merge(constants.builder, node.builder);
+                    constants.filepath = [...constants.filepath, ...node.filepath];
+                    return;
+                }
+            }
+            // Merge externals in a single builder
+            if (node.type === 'externals') {
+                node.filepath = [node.filepath];
+                const externals = nodes.find(node => node.type === 'externals');
+                if (externals) {
+                    externals_builder_1.ExternalsBuilder.merge(externals.builder, node.builder);
+                    externals.filepath = [...externals.filepath, ...node.filepath];
+                    return;
+                }
+            }
+            nodes.push(node);
+        };
+        if (module.boot && 'path' in module.boot) {
+            const files = module.scanFiles(module.boot.path, config?.exclude);
+            for (const file of files) {
+                const fileNodes = await Treeshake.file(module.name, file);
+                fileNodes.forEach(merge);
+            }
+        }
+        else if (module.boot?.builders) {
+            const builders = module.boot.builders;
+            for (const builder of builders) {
+                const builderNodes = await Treeshake.builder(module.name, builder);
+                builderNodes.forEach(merge);
+            }
+        }
+        log_1.Log.trace('compiler', 'treeshake', `Node list of module ${(0, log_1.scopeTag)('module', module.name)}:`);
+        this.logNodeList(nodes);
+        log_1.Log.trace('compiler', 'treeshake', `Node tree of module ${(0, log_1.scopeTag)('module', module.name)}:`);
+        this.logNodeTree(nodes.filter(node => !node.isInline));
+        return nodes;
+    }
+    /**
+     * Shakes a file to find all the builders declared on that file, and returns
+     * them as BuilderNodes:
+     * - Root-level (exported) builders
+     * - Inline builders
+     * - Nested inline builders
+     */
+    static async file(module, filepath) {
+        log_1.Log.debug('compiler', 'treeshake', ` └ Treeshaking file ${(0, string_1.colored)(filepath, 'blue')}`);
+        const fileBuilders = await Promise.resolve(`${filepath}`).then(s => __importStar(require(s)));
+        const nodes = [];
+        for (const key in fileBuilders) {
+            const builder = fileBuilders[key];
+            if (!builder.$b) {
+                log_1.Log.warn('compiler', 'treeshake', `No builder found on file ${filepath}, move it to a library folder or it won't work on the built version.`);
+                continue;
+            }
+            nodes.push(...Treeshake.builder(module, builder, filepath));
+        }
+        log_1.Log.debug('compiler', 'treeshake', ` - Nodes: ${(0, string_1.colored)(nodes.map(node => node.tag).join(', '), 'purple')}`);
+        return nodes;
+    }
+    /**
+     * Shakes a file to find all the builders declared on that file, and returns
+     * them as BuilderNodes:
+     * - Root-level (exported) builders
+     * - Inline builders
+     * - Nested inline builders
+     */
+    static builder(module, builder, filepath = '*') {
+        log_1.Log.debug('compiler', 'treeshake', ` └ Treeshaking builder ${(0, string_1.colored)(builder.$b, 'blue')}`);
+        const name = builder.name;
+        const node = {
+            module,
+            type: builder.$b,
+            name,
+            tag: `${module}::${builder.$b}:${name}`,
+            builder,
+            filepath: filepath,
+            dependencies: []
+        };
+        const nodes = [];
+        if (builder.$b === 'constants') {
+            //
+        }
+        else if (builder.$b === 'externals') {
+            Treeshake.externals(node);
+        }
+        else if (builder.$b === 'bucket') {
+            Treeshake.bucket(node);
+        }
+        else if (builder.$b === 'message') {
+            Treeshake.message(node);
+        }
+        else if (builder.$b === 'job') {
+            const { inlines } = Treeshake.job(node);
+            inlines.forEach(inline => {
+                nodes.push({
+                    ...inline,
+                    module,
+                    filepath
+                });
+            });
+        }
+        else if (builder.$b === 'resource') {
+            const { inlines } = Treeshake.resource(node);
+            inlines.forEach(inline => {
+                nodes.push({
+                    ...inline,
+                    module,
+                    filepath
+                });
+            });
+        }
+        else if (builder.$b === 'machine') {
+            // TODO
+            const { inlines } = Treeshake.machine(node);
+            inlines.forEach(inline => {
+                nodes.push({
+                    ...inline,
+                    module,
+                    filepath
+                });
+            });
+        }
+        else if (builder.$b === 'controller') {
+            Treeshake.controller(node);
+        }
+        else if (builder.$b === 'queue') {
+            Treeshake.queue(node);
+        }
+        else {
+            throw error_1.NesoiError.Module.UnknownBuilderType({}, filepath, '', builder.$b);
+        }
+        nodes.push(node);
+        return nodes;
+    }
+    // Utility
+    static cleanNodeDependencies(node) {
+        let filtered = [];
+        // Remove duplicates
+        node.dependencies.forEach(dep => {
+            if (!filtered.find(f => dep.tag === f.tag)) {
+                filtered.push(dep);
+            }
+        });
+        // Removes self-dependency
+        filtered = filtered
+            .filter(dep => dep.tag !== node.tag);
+        return filtered;
+    }
+    static logNodeList(nodes) {
+        nodes
+            .map(node => ({
+            node,
+            tag: (0, log_1.scopeTag)(node.type, node.name)
+        }))
+            .sort((a, b) => a.tag.localeCompare(b.tag))
+            .forEach(({ node, tag }) => {
+            log_1.Log.trace('compiler', 'treeshake', `  └ ${tag} ` + (0, string_1.colored)(`@ ${node.filepath}`, 'purple'));
+        });
+    }
+    static logNodeTree(nodes, depth = 1) {
+        nodes
+            .map(node => ({
+            node,
+            tag: (0, log_1.scopeTag)(node.type, node.name)
+        }))
+            .sort((a, b) => a.tag.localeCompare(b.tag))
+            .forEach(({ node, tag }) => {
+            log_1.Log.trace('compiler', 'treeshake', `${'  '.repeat(depth)} └ ${tag} ` + (0, string_1.colored)(`@ ${node.filepath}`, 'purple'));
+            if (node.dependencies.length) {
+                log_1.Log.trace('compiler', 'treeshake', (0, string_1.colored)(`${'  '.repeat(depth)}   (depends on: ${node.dependencies.map(dep => dep.tag).join(', ')})`, 'purple'));
+            }
+            if ('_inlineNodes' in node.builder) {
+                const inlineNodes = node.builder['_inlineNodes'];
+                this.logNodeTree(inlineNodes, depth + 1);
+            }
+        });
+    }
+}
+exports.Treeshake = Treeshake;

package/lib/compiler/typescript/bridge/extract.d.ts

@@ -0,0 +1,11 @@
+import { Compiler } from "../../compiler";
+import { ResolvedBuilderNode } from "../../../engine/dependency";
+import { tsFnQueryResult } from '../typescript_compiler';
+export declare class TSBridgeExtract {
+    static imports(compiler: Compiler, node: ResolvedBuilderNode): string[] | undefined;
+    static types(compiler: Compiler, node: ResolvedBuilderNode): {
+        path: string;
+        type: string;
+    }[] | undefined;
+    static functions(compiler: Compiler, node: ResolvedBuilderNode): tsFnQueryResult[] | undefined;
+}