nesoi 3.2.9 → 3.3.1

package/lib/engine/tree.js

@@ -2,11 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ModuleTree = void 0;
 const dependency_1 = require("./dependency");
-const error_1 = require("../compiler/error");
 const log_1 = require("./util/log");
 const string_1 = require("./util/string");
-const treeshake_1 = require("../compiler/treeshake");
-const progressive_1 = require("../compiler/progressive");
+const treeshake_1 = require("./treeshake");
+const error_1 = require("./data/error");
+/* @nesoi:browser ignore-end */
 /**
  * A tree of module elements which allows building in the correct order.
  *
@@ -29,7 +29,22 @@ class ModuleTree {
      * - Groups tree into layers which can be built in isolation
      */
     async resolve(cache) {
-        cache ?? (cache = progressive_1.ProgressiveBuild.empty());
+        cache ?? (cache = {
+            nesoidir: '',
+            hash: {
+                $: '',
+                files: {},
+                modules: {},
+                space: ''
+            },
+            files: {},
+            modules: {},
+            types: {
+                space: {},
+                modules: {},
+                elements: {}
+            }
+        });
         const nodesByModule = await this.treeshake(cache);
         const resolvedNodes = await this.resolveDependencies(nodesByModule);
         this.layers = this.resolveLayers(resolvedNodes);
@@ -41,7 +56,7 @@ class ModuleTree {
      * @returns A dictionary of nodes by module name
      */
     async treeshake(cache) {
-        log_1.Log.debug('compiler', 'tree', 'Treeshaking');
+        log_1.Log.debug('builder', 'tree', 'Treeshaking');
         const nodesByModule = {};
         for (const m in this.modules) {
             const module = this.modules[m];
@@ -51,79 +66,112 @@ class ModuleTree {
         return nodesByModule;
     }
     /**
-     * Each element declares it's dependencies as a `$Dependency`.
+     * Each element declares it's dependencies as a list of `Dependency`.
      * In order to assemble the build layers, it's necessary to
      * resolve them into a graph of `ResolvedBuilderNode`s.
      * This also resolves the inline nodes, to allow merging the schemas
-     * of inline nodes on build.
+     * of inline nodes on compile.
      *
      * @param nodesByModule A dictionary of builder nodes by module name
      * @returns A dictionary of resolved builder nodes
      */
     async resolveDependencies(nodesByModule) {
-        log_1.Log.debug('compiler', 'tree', 'Resolving dependencies');
+        log_1.Log.debug('builder', 'tree', 'Resolving dependencies');
         const resolved = {};
         Object.entries(nodesByModule).forEach(([module, nodes]) => {
-            log_1.Log.debug('compiler', 'tree', `Resolving dependencies of ${(0, log_1.scopeTag)('module', module)}`);
+            const externals = nodes.find(node => node.tag.type === 'externals');
+            log_1.Log.debug('builder', 'tree', `Resolving dependencies of ${(0, log_1.scopeTag)('module', module)}`);
             nodes.forEach(node => {
-                log_1.Log.trace('compiler', 'tree', ` └ ${(0, log_1.scopeTag)(node.type, node.name)}`);
+                log_1.Log.trace('builder', 'tree', ` └ ${(0, log_1.scopeTag)(node.tag.type, node.tag.name)}`);
                 const dependencies = node.dependencies.map(dep => {
                     // Find dependency module
-                    const depModuleNodes = nodesByModule[dep.module || module];
+                    const depModuleNodes = nodesByModule[dep.tag.module];
                     if (!depModuleNodes) {
-                        throw error_1.CompilerError.UnmetModuleDependency(node.name + '.' + node.type, dep.module || module);
+                        throw error_1.NesoiError.Builder.UnmetModuleDependency({ from: node.tag.full, dep: dep.tag.full });
                     }
                     // Find dependency node
-                    const depNode = depModuleNodes.find(mNode => mNode.tag === dep.tag);
+                    const depNode = depModuleNodes.find(mNode => dependency_1.Tag.isSameNodeAs(mNode.tag, dep.tag));
                     if (!depNode) {
-                        throw error_1.CompilerError.UnmetDependency(node.tag, dep.tag);
+                        throw error_1.NesoiError.Builder.UnmetDependency({ from: node.tag.full, dep: dep.tag.full });
+                    }
+                    // Check constants nodes
+                    if (dep.tag.type === 'constants.enum') {
+                        const enums = depNode.builder.enums;
+                        if (!Object.keys(enums).some(v => v === dep.tag.name
+                            || v.startsWith(dep.tag.name + '.'))) {
+                            throw error_1.NesoiError.Builder.UnmetDependencyEnum({ from: node.tag.full, dep: dep.tag.full });
+                        }
+                    }
+                    else if (dep.tag.type === 'constants.value') {
+                        const values = depNode.builder._values;
+                        if (!(dep.tag.name in values)) {
+                            throw error_1.NesoiError.Builder.UnmetDependencyValue({ from: node.tag.full, dep: dep.tag.full });
+                        }
+                    }
+                    // Check for externals
+                    if (dep.tag.module !== module) {
+                        const external = externals
+                            ? dependency_1.Tag.resolveExternal(dep.tag, externals.builder)
+                            : undefined;
+                        if (!external) {
+                            throw error_1.NesoiError.Builder.NotImportedDependency({ from: node.tag.full, dep: dep.tag.full });
+                        }
                     }
-                    log_1.Log.trace('compiler', 'tree', `   ~ ${(0, string_1.colored)('OK', 'green')} ${(0, string_1.colored)(dep.module + '::' + dep.type + ':' + dep.name, 'purple')}`);
+                    log_1.Log.trace('builder', 'tree', `   ~ ${(0, string_1.colored)('OK', 'green')} ${(0, string_1.colored)(dep.tag.full, 'purple')}`);
                     // If dependency node was not resolved yet, create a shared reference
                     // on which the `dependencies` and `inlines` will be populated on future iterations.
-                    if (!(dep.tag in resolved)) {
-                        resolved[dep.tag] = {
+                    const tag = ['constants.enum', 'constants.value'].includes(dep.tag.type)
+                        ? new dependency_1.Tag(dep.tag.module, 'constants', '*').full
+                        : dep.tag.full;
+                    if (!(tag in resolved)) {
+                        resolved[tag] = {
                             ...depNode,
                             dependencies: [],
                             inlines: {}
                         };
                     }
-                    return { node: resolved[dep.tag], soft: dep.soft };
+                    return { node: resolved[tag], dep };
                 });
                 const inlines = {};
                 if (!node.progressive) {
                     if ('_inlineNodes' in node.builder) {
                         const inlineNodes = node.builder._inlineNodes;
                         inlineNodes.forEach((inline) => {
-                            log_1.Log.trace('compiler', 'tree', `   └ ${(0, string_1.colored)('OK', 'green')} ${(0, string_1.colored)(inline.module + '::' + inline.type + ':' + inline.name, 'lightcyan')}`);
+                            log_1.Log.trace('builder', 'tree', `   └ ${(0, string_1.colored)('OK', 'green')} ${(0, string_1.colored)(inline.tag.full, 'lightcyan')}`);
                             // If inline node was not resolved yet, create a shared reference
                             // on which the `dependencies` and `inlines` will be populated on future iterations.
-                            if (!(inline.tag in resolved)) {
-                                resolved[inline.tag] = {
+                            const tag = ['constants.enum', 'constants.value'].includes(inline.tag.type)
+                                ? new dependency_1.Tag(inline.tag.module, 'constants', '*').full
+                                : inline.tag.full;
+                            if (!(tag in resolved)) {
+                                resolved[tag] = {
                                     ...inline,
                                     dependencies: [],
                                     inlines: {}
                                 };
                             }
-                            const type = inline.type;
+                            const type = inline.tag.type;
                             if (!(type in inlines)) {
                                 inlines[type] = {
-                                    [inline.name]: resolved[inline.tag]
+                                    [inline.tag.name]: resolved[tag]
                                 };
                             }
-                            inlines[type][inline.name] = resolved[inline.tag];
+                            inlines[type][inline.tag.name] = resolved[tag];
                         });
                     }
                 }
                 // If node was already created when resolving a dependendant,
                 // just fill the dependencies and inlines.
-                if (node.tag in resolved) {
-                    resolved[node.tag].dependencies = dependencies;
-                    resolved[node.tag].inlines = inlines;
+                const tag = ['constants.enum', 'constants.value'].includes(node.tag.type)
+                    ? new dependency_1.Tag(node.tag.module, 'constants', '*').full
+                    : node.tag.full;
+                if (tag in resolved) {
+                    resolved[tag].dependencies = dependencies;
+                    resolved[tag].inlines = inlines;
                 }
                 // If not, create the resolved node
                 else {
-                    resolved[node.tag] = {
+                    resolved[tag] = {
                         ...node,
                         dependencies,
                         inlines
@@ -182,16 +230,16 @@ class ModuleTree {
      * @returns A list of module tree layers
      */
     resolveLayers(nodes) {
-        log_1.Log.debug('compiler', 'tree', 'Resolving Layers');
+        log_1.Log.debug('builder', 'tree', 'Resolving Layers');
         nodes.forEach(node => {
             node._dependencies = [...(node.dependencies || [])]
-                .filter(dep => !dep.soft)
+                .filter(dep => dep.dep.build)
                 .map(dep => dep.node);
         });
         const layers = [];
         while (nodes.length) {
-            log_1.Log.trace('compiler', 'tree', ` └ ${(0, string_1.colored)(`layer.${layers.length}`, 'lightblue')}`);
-            let layer = [];
+            log_1.Log.trace('builder', 'tree', ` └ ${(0, string_1.colored)(`layer.${layers.length}`, 'lightblue')}`);
+            const layer = [];
             const future = [];
             nodes.forEach(node => {
                 // Node has no dependency, it belongs to the current list
@@ -199,7 +247,7 @@ class ModuleTree {
                 if (node._dependencies.length == 0) {
                     layer.push(node);
                     node.layered = true;
-                    log_1.Log.trace('compiler', 'tree', `   └ ${node.module}::${(0, log_1.scopeTag)(node.type, node.name)}` + (node.root ? (0, string_1.colored)(` @ ${node.root?.tag}`, 'purple') : ''));
+                    log_1.Log.trace('builder', 'tree', `   └ ${node.tag.module}::${(0, log_1.scopeTag)(node.tag.type, node.tag.name)}` + (node.root ? (0, string_1.colored)(` @ ${node.root?.tag}`, 'purple') : ''));
                 }
                 // Node has dependencies, so it must be on future layers.
                 else {
@@ -215,16 +263,12 @@ class ModuleTree {
             // are not permitted.
             if (future.length === nodes.length) {
                 nodes.forEach(node => {
-                    log_1.Log.trace('compiler', 'tree', `   └ ${(0, string_1.colored)('(future)', 'lightred')} ${node.module}::${(0, log_1.scopeTag)(node.type, node.name)}` + (node.root ? (0, string_1.colored)(` @ ${node.root?.tag}`, 'purple') : ''));
-                    log_1.Log.trace('compiler', 'tree', (0, string_1.colored)(`     depends on: ${node._dependencies.map(dep => dep.module + '::' + dep.type + ':' + dep.name + (dep.layered ? '(OK)' : '')).join(', ')}`, 'purple'));
+                    log_1.Log.trace('builder', 'tree', `   └ ${(0, string_1.colored)('(future)', 'lightred')} ${node.tag.module}::${(0, log_1.scopeTag)(node.tag.type, node.tag.name)}` + (node.root ? (0, string_1.colored)(` @ ${node.root?.tag}`, 'purple') : ''));
+                    log_1.Log.trace('builder', 'tree', (0, string_1.colored)(`     depends on: ${node._dependencies.map(dep => dep.tag.full + (dep.layered ? '(OK)' : '')).join(', ')}`, 'purple'));
                 });
-                throw error_1.CompilerError.CircularDependency();
+                throw error_1.NesoiError.Builder.CircularDependency({});
             }
             nodes = future;
-            // Reorder layer so that externals are built first
-            const externals = layer.filter(node => node.type === 'externals');
-            const internals = layer.filter(node => node.type !== 'externals');
-            layer = [...externals, ...internals];
             layers.push(layer);
         }
         layers.forEach(layer => {
@@ -244,26 +288,12 @@ class ModuleTree {
     async traverse(actionAlias, fn) {
         for (let i = 0; i < this.layers.length; i++) {
             const layer = this.layers[i];
-            log_1.Log.debug('compiler', 'tree', `${actionAlias} ${(0, log_1.scopeTag)('layer', i.toString())}`);
+            log_1.Log.debug('builder', 'tree', `${actionAlias} ${(0, log_1.scopeTag)('layer', i.toString())}`);
             for (const node of layer) {
                 await fn(node);
             }
         }
     }
-    /**
-     * Get schema of a dependency-like object.
-     *
-     * @param node A dependency-like object
-     * @return An element schema
-     */
-    getSchema(node) {
-        const mod = this.modules[node.module];
-        const schema = dependency_1.$Dependency.resolve(mod.schema, node);
-        if (!schema) {
-            throw error_1.CompilerError.UnmetDependency('tree', node.name);
-        }
-        return schema;
-    }
     /**
      * Return a list of all nodes of all modules on the tree.
      *
@@ -288,8 +318,8 @@ class ModuleTree {
         const modules = {};
         for (const layer of this.layers) {
             for (const node of layer) {
-                modules[_a = node.module] ?? (modules[_a] = []);
-                modules[node.module].push(node);
+                modules[_a = node.tag.module] ?? (modules[_a] = []);
+                modules[node.tag.module].push(node);
             }
         }
         return modules;

package/lib/{compiler → engine}/treeshake.d.ts

@@ -1,40 +1,12 @@
-import { $Dependency, BuilderNode } from "../engine/dependency";
+import { Dependency, BuilderNode } from "./dependency";
 import { BucketGraphBuilder } from "../elements/entities/bucket/graph/bucket_graph.builder";
-import { AnyModule } from "../engine/module";
-import { $BucketModelFields } from "../elements/entities/bucket/model/bucket_model.schema";
-import { ProgressiveBuildCache } from './progressive';
+import { AnyModule } from "./module";
 export type TreeshakeConfig = {
     exclude?: string[];
 };
+import { ProgressiveBuildCache } from '../compiler/progressive';
+import { BucketModelFieldBuilders } from "../elements/entities/bucket/model/bucket_model_field.builder";
 export declare class Treeshake {
-    static externals(node: BuilderNode, depth?: number): void;
-    static bucket(node: BuilderNode, depth?: number): void;
-    static bucketModelFields(node: BuilderNode, fields: $BucketModelFields): $Dependency[];
-    static bucketGraph(node: BuilderNode, builder: BucketGraphBuilder<any>): $Dependency[];
-    private static bucketGraphLink;
-    static message(node: BuilderNode, depth?: number): void;
-    private static messageFieldTree;
-    protected static blockIO(node: BuilderNode): $Dependency[];
-    protected static blockInlineNodes(node: BuilderNode, depth?: number): {
-        dependencies: $Dependency[];
-        inlines: BuilderNode[];
-    };
-    static job(node: BuilderNode, depth?: number): {
-        inlines: BuilderNode[];
-    };
-    static resource(node: BuilderNode, depth?: number): {
-        inlines: BuilderNode[];
-    };
-    static machine(node: BuilderNode, depth?: number): {
-        inlines: BuilderNode[];
-    };
-    static controller(node: BuilderNode): void;
-    static queue(node: BuilderNode): {
-        inlines: BuilderNode[];
-    };
-    static topic(node: BuilderNode): {
-        inlines: BuilderNode[];
-    };
     /**
      * Scans the module directory, imports the builders and lists
      * all nodes found.
@@ -58,6 +30,34 @@ export declare class Treeshake {
      * - Nested inline builders
      */
     private static builder;
+    static externals(node: BuilderNode, depth?: number): void;
+    static message(node: BuilderNode, depth?: number): void;
+    private static messageFieldTree;
+    static bucket(node: BuilderNode, depth?: number): void;
+    static bucketModelFields(node: BuilderNode, fields: BucketModelFieldBuilders<any>): Dependency[];
+    static bucketGraph(node: BuilderNode, builder: BucketGraphBuilder<any>): Dependency[];
+    private static bucketGraphLink;
+    protected static blockIO(node: BuilderNode): Dependency[];
+    protected static blockInlineNodes(node: BuilderNode, depth?: number): {
+        dependencies: Dependency[];
+        inlines: BuilderNode[];
+    };
+    static job(node: BuilderNode, depth?: number): {
+        inlines: BuilderNode[];
+    };
+    static resource(node: BuilderNode, depth?: number): {
+        inlines: BuilderNode[];
+    };
+    static machine(node: BuilderNode, depth?: number): {
+        inlines: BuilderNode[];
+    };
+    static controller(node: BuilderNode): void;
+    static queue(node: BuilderNode): {
+        inlines: BuilderNode[];
+    };
+    static topic(node: BuilderNode): {
+        inlines: BuilderNode[];
+    };
     private static cleanNodeDependencies;
     private static logNodeList;
     private static logNodeTree;