nesoi 3.2.8 → 3.3.0

package/lib/{compiler → engine}/treeshake.js

@@ -4,224 +4,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Treeshake = void 0;
-const dependency_1 = require("../engine/dependency");
+const dependency_1 = require("./dependency");
 const bucket_graph_builder_1 = require("../elements/entities/bucket/graph/bucket_graph.builder");
 const externals_builder_1 = require("../elements/edge/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 log_1 = require("./util/log");
+const string_1 = require("./util/string");
+const error_1 = require("./data/error");
 const constants_builder_1 = require("../elements/entities/constants/constants.builder");
-const progressive_1 = require("./progressive");
 const path_1 = __importDefault(require("path"));
+/* @nesoi:browser ignore-start */
+const progressive_1 = require("../compiler/progressive");
+/* @nesoi:browser ignore-end */
 class Treeshake {
-    /* Externals */
-    static externals(node, depth = 1) {
-        const b = node.builder;
-        const $b = b.$b;
-        const buckets = b.buckets;
-        const messages = b.messages;
-        const jobs = b.jobs;
-        const enums = b.enums;
-        log_1.Log.trace('compiler', 'treeshake', `${'  '.repeat(depth)} └ Treeshaking node ${(0, log_1.scopeTag)($b, node.name)}`);
-        node.dependencies = [
-            ...Object.values(buckets),
-            ...Object.values(messages),
-            ...Object.values(jobs),
-            ...Object.values(enums).map(dep => new dependency_1.$Dependency(node.module, 'constants', `${dep.module}::*`))
-        ];
-        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.meta?.enum?.dep) {
-                dependencies.push(field.meta?.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 = [];
-        if (tree.__ext) {
-            dependencies.push(tree.__ext);
-        }
-        Object.values(tree).forEach(child => {
-            const c = child;
-            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 are a dependency of their parent node
-        const inlines = [..._inlineNodes, ...nestedInlines];
-        inlines.forEach(inline => {
-            dependencies.push(new dependency_1.$Dependency(inline.module, inline.type, inline.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 builder = node.builder;
-        log_1.Log.trace('compiler', 'treeshake', `└ Treeshaking node ${(0, log_1.scopeTag)(builder.$b, node.name)}`);
-        const inlineTreeshake = Treeshake.blockInlineNodes(node);
-        node.dependencies = [
-            ...Treeshake.blockIO(node),
-            ...inlineTreeshake.dependencies
-        ];
-        node.dependencies = this.cleanNodeDependencies(node);
-        return { inlines: inlineTreeshake.inlines };
-    }
-    static topic(node) {
-        const builder = node.builder;
-        log_1.Log.trace('compiler', 'treeshake', `└ Treeshaking node ${(0, log_1.scopeTag)(builder.$b, node.name)}`);
-        const inlineTreeshake = Treeshake.blockInlineNodes(node);
-        node.dependencies = [
-            ...Treeshake.blockIO(node),
-            ...inlineTreeshake.dependencies
-        ];
-        node.dependencies = this.cleanNodeDependencies(node);
-        return { inlines: inlineTreeshake.inlines };
-    }
-    /* Module */
+    /* Entry-Points */
     /**
      * Scans the module directory, imports the builders and lists
      * all nodes found.
@@ -229,23 +24,46 @@ class Treeshake {
      * @returns A list of all `BuilderNodes` found on the module folder
      */
     static async module(module, cache, config) {
-        log_1.Log.debug('compiler', 'treeshake', `Treeshaking ${(0, log_1.scopeTag)('module', module.name)}`);
+        log_1.Log.debug('engine', 'treeshake', `Treeshaking ${(0, log_1.scopeTag)('module', module.name)}`);
         const nodes = [];
         const merge = (node) => {
             // Merge constants in a single builder
-            if (node.type === 'constants') {
+            if (node.tag.type.startsWith('constants')) {
                 node.filepath = [node.filepath];
-                const constants = nodes.find(node => node.type === 'constants');
+                const constants = nodes.find(node => node.tag.type === 'constants');
                 if (constants) {
                     constants_builder_1.ConstantsBuilder.merge(constants.builder, node.builder);
                     constants.filepath = [...constants.filepath, ...node.filepath];
                     return;
                 }
+                else {
+                    nodes.push({
+                        ...node,
+                        tag: new dependency_1.Tag(node.tag.module, 'constants', '*')
+                    });
+                    return;
+                }
             }
             // Merge externals in a single builder
-            if (node.type === 'externals') {
+            if (node.tag.type === 'externals') {
                 node.filepath = [node.filepath];
-                const externals = nodes.find(node => node.type === 'externals');
+                // If the external references constants, ensure a constants node is present
+                // This ensures there will be a container for the external values, which
+                // are copied as "static externals"
+                const enums = node.builder.enums;
+                const values = node.builder.values;
+                if (Object.keys(enums).length || Object.keys(values).length) {
+                    const constants = nodes.find(node => node.tag.type === 'constants');
+                    if (!constants) {
+                        nodes.push(new dependency_1.BuilderNode({
+                            tag: new dependency_1.Tag(node.tag.module, 'constants', '*'),
+                            filepath: [],
+                            dependencies: [],
+                            builder: new constants_builder_1.ConstantsBuilder(node.tag.module),
+                        }));
+                    }
+                }
+                const externals = nodes.find(node => node.tag.type === 'externals');
                 if (externals) {
                     externals_builder_1.ExternalsBuilder.merge(externals.builder, node.builder);
                     externals.filepath = [...externals.filepath, ...node.filepath];
@@ -268,9 +86,9 @@ class Treeshake {
                 builderNodes.forEach(merge);
             }
         }
-        log_1.Log.trace('compiler', 'treeshake', `Node list of module ${(0, log_1.scopeTag)('module', module.name)}:`);
+        log_1.Log.trace('builder', '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)}:`);
+        log_1.Log.trace('builder', 'treeshake', `Node tree of module ${(0, log_1.scopeTag)('module', module.name)}:`);
         this.logNodeTree(nodes.filter(node => !node.isInline));
         return nodes;
     }
@@ -282,13 +100,15 @@ class Treeshake {
      * - Nested inline builders
      */
     static async file(module, filepath, cache) {
+        /* @nesoi:browser ignore-start */
         if (cache && filepath in cache.files) {
             const nodes = await progressive_1.ProgressiveBuild.treeshake(cache, filepath);
             if (nodes) {
                 return nodes;
             }
         }
-        log_1.Log.debug('compiler', 'treeshake', ` └ Treeshaking file ${(0, string_1.colored)(filepath, 'blue')}`);
+        /* @nesoi:browser ignore-end */
+        log_1.Log.debug('engine', 'treeshake', ` └ Treeshaking file ${(0, string_1.colored)(filepath, 'blue')}`);
         // Require is used here to avoid cache - which allows watch mode
         delete require.cache[filepath];
         // eslint-disable-next-line @typescript-eslint/no-require-imports
@@ -299,15 +119,15 @@ class Treeshake {
             if (!builder.$b) {
                 // TODO: check lib paths to re-enable this message
                 // without annoying
-                // 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.`);
+                // Log.warn('builder', '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')}`);
+        log_1.Log.debug('engine', 'treeshake', ` - Nodes: ${(0, string_1.colored)(nodes.map(node => node.tag.full).join(', '), 'purple')}`);
         cache.files[filepath] = {
-            type: nodes.map(node => node.type),
-            elements: nodes.map(node => path_1.default.join(cache.nesoidir, module, `${node.type}__${node.name}.ts`)).flat(1)
+            type: nodes.map(node => node.tag.type),
+            elements: nodes.map(node => path_1.default.join(cache.nesoidir, module, `${node.tag.type}__${node.tag.name}.ts`)).flat(1)
         };
         return nodes;
     }
@@ -319,13 +139,10 @@ class Treeshake {
      * - Nested inline builders
      */
     static builder(module, builder, filepath = '*') {
-        log_1.Log.debug('compiler', 'treeshake', ` └ Treeshaking builder ${(0, string_1.colored)(builder.$b, 'blue')}`);
+        log_1.Log.debug('engine', '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}`,
+            tag: new dependency_1.Tag(module, builder.$b, name),
             builder,
             filepath: filepath,
             dependencies: []
@@ -348,7 +165,6 @@ class Treeshake {
             inlines.forEach(inline => {
                 nodes.push({
                     ...inline,
-                    module,
                     filepath
                 });
             });
@@ -358,7 +174,6 @@ class Treeshake {
             inlines.forEach(inline => {
                 nodes.push({
                     ...inline,
-                    module,
                     filepath
                 });
             });
@@ -369,7 +184,6 @@ class Treeshake {
             inlines.forEach(inline => {
                 nodes.push({
                     ...inline,
-                    module,
                     filepath
                 });
             });
@@ -382,7 +196,6 @@ class Treeshake {
             inlines.forEach(inline => {
                 nodes.push({
                     ...inline,
-                    module,
                     filepath
                 });
             });
@@ -392,7 +205,6 @@ class Treeshake {
             inlines.forEach(inline => {
                 nodes.push({
                     ...inline,
-                    module,
                     filepath
                 });
             });
@@ -403,12 +215,230 @@ class Treeshake {
         nodes.push(node);
         return nodes;
     }
+    /* Externals */
+    static externals(node, depth = 1) {
+        const b = node.builder;
+        const $b = b.$b;
+        const enums = b.enums;
+        const values = b.values;
+        const buckets = b.buckets;
+        const messages = b.messages;
+        const jobs = b.jobs;
+        const machines = b.machines;
+        log_1.Log.trace('builder', 'treeshake', `${'  '.repeat(depth)} └ Treeshaking node ${(0, log_1.scopeTag)($b, node.tag.name)}`);
+        node.dependencies = [
+            ...Object.values(enums),
+            ...Object.values(values),
+            ...Object.values(buckets),
+            ...Object.values(messages),
+            ...Object.values(jobs),
+            ...Object.values(machines),
+        ];
+        node.dependencies = this.cleanNodeDependencies(node);
+    }
+    /* Message */
+    static message(node, depth = 1) {
+        const b = node.builder;
+        const $b = b.$b;
+        const _fields = b._template._fields;
+        log_1.Log.trace('builder', 'treeshake', `${'  '.repeat(depth)} └ Treeshaking node ${(0, log_1.scopeTag)($b, node.tag.name)}`);
+        node.dependencies = Treeshake.messageFieldTree(node, _fields);
+        node.dependencies = this.cleanNodeDependencies(node);
+    }
+    static messageFieldTree(node, tree) {
+        const dependencies = [];
+        if (tree.__ext) {
+            dependencies.push(tree.__ext);
+        }
+        Object.values(tree).forEach(child => {
+            const c = child;
+            if (c.type === 'enum') {
+                if ('dep' in c.meta.enum) {
+                    dependencies.push(c.meta.enum.dep);
+                }
+            }
+            else if (c.type === 'id') {
+                const ref = c.meta.id.bucket;
+                dependencies.push(ref);
+            }
+            else if (c.type === 'msg') {
+                dependencies.push(c.meta.msg);
+            }
+            else if (c.children) {
+                dependencies.push(...Treeshake.messageFieldTree(node, c.children));
+            }
+        });
+        return dependencies;
+    }
+    /* Bucket */
+    static bucket(node, depth = 1) {
+        const b = node.builder;
+        const $b = b.$b;
+        const _extend = b._extend;
+        const graphLinks = b._graph;
+        const _model = b._model;
+        log_1.Log.trace('builder', 'treeshake', `${'  '.repeat(depth)} └ Treeshaking node ${(0, log_1.scopeTag)($b, node.tag.name)}`);
+        node.dependencies = [];
+        if (_extend) {
+            node.dependencies.push(_extend);
+        }
+        if (_model) {
+            const builders = b._model.builders;
+            node.dependencies.push(...Treeshake.bucketModelFields(node, builders));
+        }
+        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) => {
+            const meta = field.meta;
+            const crypto = field.crypto;
+            const children = field.children;
+            if (meta?.enum && 'dep' in meta.enum) {
+                dependencies.push(meta.enum.dep);
+            }
+            if (crypto) {
+                dependencies.push(crypto.value);
+            }
+            if (children?.length) {
+                dependencies.push(...Treeshake.bucketModelFields(node, 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.tag.full === node.tag.full) {
+                return undefined;
+            }
+            return dep;
+        }).filter(d => !!d);
+    }
+    static bucketGraphLink(builder) {
+        const b = builder;
+        const bucket = b.bucket;
+        return bucket;
+    }
+    /* 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.tag.full === dep.tag.full))
+        ];
+        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;
+            if (inlineNode.tag.type === 'message') {
+                Treeshake.message(inlineNode, depth + 1);
+                dependencies.push(...inlineNode.dependencies);
+            }
+            else if (inlineNode.tag.type === 'job') {
+                const deps = Treeshake.job(inlineNode, depth + 1);
+                dependencies.push(...inlineNode.dependencies);
+                nestedInlines.push(...deps.inlines);
+            }
+        }
+        const inlines = [..._inlineNodes, ...nestedInlines];
+        // Inlines were a build dependency of their parent node
+        // Now, inlines are ignored on build order
+        //
+        // inlines.forEach(inline => {
+        //     dependencies.push(new Dependency(node.tag.module, inline.tag, { build: true }));
+        // });
+        return {
+            dependencies,
+            inlines
+        };
+    }
+    /* Job */
+    static job(node, depth = 0) {
+        const builder = node.builder;
+        log_1.Log.trace('builder', 'treeshake', `${'  '.repeat(depth)} └ Treeshaking node ${(0, log_1.scopeTag)(builder.$b, node.tag.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('builder', 'treeshake', `${'  '.repeat(depth)} └ Treeshaking node ${(0, log_1.scopeTag)($b, node.tag.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('builder', 'treeshake', `${'  '.repeat(depth)} └ Treeshaking node ${(0, log_1.scopeTag)($b, node.tag.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 = [];
+    }
+    /* Queue */
+    static queue(node) {
+        const builder = node.builder;
+        log_1.Log.trace('builder', 'treeshake', `└ Treeshaking node ${(0, log_1.scopeTag)(builder.$b, node.tag.name)}`);
+        const inlineTreeshake = Treeshake.blockInlineNodes(node);
+        node.dependencies = [
+            ...Treeshake.blockIO(node),
+            ...inlineTreeshake.dependencies
+        ];
+        node.dependencies = this.cleanNodeDependencies(node);
+        return { inlines: inlineTreeshake.inlines };
+    }
+    /* Topic */
+    static topic(node) {
+        const builder = node.builder;
+        log_1.Log.trace('builder', 'treeshake', `└ Treeshaking node ${(0, log_1.scopeTag)(builder.$b, node.tag.name)}`);
+        const inlineTreeshake = Treeshake.blockInlineNodes(node);
+        node.dependencies = [
+            ...Treeshake.blockIO(node),
+            ...inlineTreeshake.dependencies
+        ];
+        node.dependencies = this.cleanNodeDependencies(node);
+        return { inlines: inlineTreeshake.inlines };
+    }
     // Utility
     static cleanNodeDependencies(node) {
         let filtered = [];
         // Remove duplicates
         node.dependencies.forEach(dep => {
-            if (!filtered.find(f => dep.tag === f.tag)) {
+            if (!filtered.find(f => dependency_1.Tag.matches(dep.tag, f.tag))) {
                 filtered.push(dep);
             }
         });
@@ -421,28 +451,28 @@ class Treeshake {
         nodes
             .map(node => ({
             node,
-            tag: (0, log_1.scopeTag)(node.type, node.name)
+            tag: (0, log_1.scopeTag)(node.tag.type, node.tag.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'));
+            log_1.Log.trace('builder', '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)
+            tag: (0, log_1.scopeTag)(node.tag.type, node.tag.name)
         }))
             .sort((a, b) => a.tag.localeCompare(b.tag))
             .forEach(({ node, tag }) => {
-            log_1.Log.debug('compiler', 'treeshake', `${'  '.repeat(depth)} └ ${tag} ` + (0, string_1.colored)(`@ ${node.filepath}`, 'purple'));
+            log_1.Log.debug('engine', 'treeshake', `${'  '.repeat(depth)} └ ${tag} ` + (0, string_1.colored)(`@ ${node.filepath}`, 'purple'));
             if (node.progressive) {
-                log_1.Log.debug('compiler', 'treeshake', `${'  '.repeat(depth + 1)}` + (0, string_1.colored)('[cache]', 'green'));
+                log_1.Log.debug('engine', 'treeshake', `${'  '.repeat(depth + 1)}` + (0, string_1.colored)('[cache]', 'green'));
                 return;
             }
             if (node.dependencies.length) {
-                log_1.Log.debug('compiler', 'treeshake', (0, string_1.colored)(`${'  '.repeat(depth)}   (depends on: ${node.dependencies.map(dep => dep.tag).join(', ')})`, 'purple'));
+                log_1.Log.debug('engine', 'treeshake', (0, string_1.colored)(`${'  '.repeat(depth)}   (depends on: ${node.dependencies.map(dep => dep.tag.full).join(', ')})`, 'purple'));
             }
             if ('_inlineNodes' in node.builder) {
                 const inlineNodes = node.builder['_inlineNodes'];

package/lib/engine/util/console.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const package_json_1 = __importDefault(require("../../../package.json"));
+const log_1 = require("./log");
 const string_1 = require("./string");
 class Console {
     // Prints a step message to the terminal
@@ -12,6 +13,8 @@ class Console {
     }
     // Prints the header
     static header(module) {
+        if (['off', 'error', 'warn'].includes(log_1.Log.level))
+            return;
         console.log((0, string_1.colored)('┏          ┓', 'lightcyan'));
         console.log((0, string_1.colored)('  ┏┓┳┓┏┏┓┏', 'lightblue'));
         console.log((0, string_1.colored)('  ┛╹┗ ┛┗┛╹', 'lightblue'));