nesoi 3.0.12 → 3.0.14

package/lib/compiler/apps/monolyth/stages/2_build_typescript_stage.js

@@ -62,8 +62,11 @@ class BuildTypescriptStage {
             return space_1.Space.path(compiler.space, path);
         });
         const info = app_1.App.getInfo(this.app);
-        const modulePaths = info.spaceModules.map(mod => {
-            return space_1.Space.path(compiler.space, '.nesoi', mod);
+        const modulePaths = [];
+        space_1.Space.scan(compiler.space, (name) => {
+            if (info.spaceModules.includes(name)) {
+                modulePaths.push(space_1.Space.path(compiler.space, '.nesoi', name));
+            }
         });
         const space = compiler.space;
         const spacePath = space_1.Space.path(space);

package/lib/compiler/apps/monolyth/stages/3_copy_types_stage.js

@@ -57,8 +57,8 @@ class CopyTypesStage {
         const { compiler, dirs } = this.monolyth;
         const info = app_1.App.getInfo(this.app);
         // Copy module types to types folder
-        for (const key of info.spaceModules) {
-            const module = compiler.modules[key];
+        for (const name of info.spaceModules) {
+            const module = compiler.modules[name];
             const from = space_1.Space.path(compiler.space, '.nesoi', module.lowName + '.module.ts');
             const to = path.resolve(dirs.build_types, module.lowName + '.module.ts');
             log_1.Log.debug('compiler', 'monolyth', `Copying module types from ${from} to ${to}`);

package/lib/compiler/apps/monolyth/stages/4_dump_modules_stage.js

@@ -54,8 +54,8 @@ class DumpModulesStage {
         log_1.Log.info('compiler', 'monolyth', 'Dumping modules to build/modules folder...');
         const { compiler, dirs } = this.monolyth;
         const info = app_1.App.getInfo(this.app);
-        for (const key of info.spaceModules) {
-            const module = compiler.modules[key];
+        for (const name of info.spaceModules) {
+            const module = compiler.modules[name];
             this.dumpModule(module, dirs.build_modules);
         }
     }

package/lib/compiler/apps/monolyth/stages/7_dump_package_json_stage.js

@@ -54,7 +54,10 @@ class DumpPackageJsonStage {
     async run() {
         log_1.Log.info('compiler', 'monolyth', 'Dumping package.json to build folder...');
         const { config, compiler, dirs } = this.monolyth;
-        const nesoiPackageJson = await Promise.resolve(`${`${config.nesoiPath || path.join('..', '..', '..', '..', '..', 'package.json')}`}`).then(s => __importStar(require(s)));
+        const packageJsonPath = config.nesoiPath
+            ? path.join(config.nesoiPath, 'package.json')
+            : path.join('..', '..', '..', '..', '..', 'package.json');
+        const nesoiPackageJson = await Promise.resolve(`${packageJsonPath}`).then(s => __importStar(require(s)));
         const spacePackageJson = await Promise.resolve(`${space_1.Space.path(compiler.space, 'package.json')}`).then(s => __importStar(require(s)));
         const filePath = path.resolve(dirs.build, 'package.json');
         const scripts = {

package/lib/compiler/compiler.d.ts

@@ -6,6 +6,8 @@ import { TypeScriptCompiler } from './typescript/typescript_compiler';
 export type CompilerConfig = {
     nesoiPath?: string;
     exclude?: string[];
+    reset?: boolean;
+    diagnose?: boolean;
 };
 export declare class Compiler {
     space: Space<$Space>;

package/lib/compiler/compiler.js

@@ -1,43 +1,9 @@
 "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;
-    };
-})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Compiler = void 0;
-const fs = __importStar(require("fs"));
 const tree_1 = require("../engine/tree");
 const space_1 = require("../engine/space");
 const typescript_compiler_1 = require("./typescript/typescript_compiler");
@@ -51,18 +17,22 @@ const _7_dump_stage_1 = require("./stages/7_dump_stage");
 const console_1 = __importDefault(require("../engine/util/console"));
 const log_1 = require("../engine/util/log");
 const _8_diagnose_stage_1 = require("./stages/8_diagnose_stage");
+const fs_1 = __importDefault(require("fs"));
 class Compiler {
     constructor(space, config) {
         this.space = space;
         this.config = config;
         this.modules = {};
         this.tree = new tree_1.ModuleTree({}, this.config);
+        console_1.default.header('Elements Compiler');
+        log_1.Log.info('compiler', 'ts', 'Loading TypeScript...');
         this.tsCompiler = new typescript_compiler_1.TypeScriptCompiler(space, config?.nesoiPath);
     }
     async run() {
-        console_1.default.header('Elements Compiler');
-        // Cleanup .nesoi folder
-        fs.rmSync(space_1.Space.path(this.space, '.nesoi'), { recursive: true, force: true });
+        if (this.config?.reset) {
+            // Cleanup .nesoi folder
+            fs_1.default.rmSync(space_1.Space.path(this.space, '.nesoi'), { recursive: true, force: true });
+        }
         try {
             await new _1_scan_stage_1.ScanStage(this).run();
             await new _2_treeshake_stage_1.TreeshakeStage(this).run();
@@ -71,7 +41,9 @@ class Compiler {
             await new _5_inject_ts_stage_1.InjectTSStage(this).run();
             await new _6_build_elements_stage_1.BuildElementsStage(this).run();
             await new _7_dump_stage_1.DumpStage(this).run();
-            await new _8_diagnose_stage_1.DiagnoseStage(this).run();
+            if (this.config?.diagnose) {
+                await new _8_diagnose_stage_1.DiagnoseStage(this).run();
+            }
         }
         catch (e) {
             log_1.Log.error('compiler', 'nesoi', e.toString(), { stack: e.stack });

package/lib/compiler/elements/cached.element.d.ts

@@ -0,0 +1,11 @@
+import { ResolvedBuilderNode } from "../../engine/dependency";
+import { Compiler } from '../compiler';
+import { Element } from './element';
+import { AnyElementSchema } from "../../engine/module";
+import { ProgressiveBuildCache } from '../progressive';
+export declare class CachedElement extends Element<AnyElementSchema> {
+    constructor(compiler: Compiler, node: ResolvedBuilderNode);
+    protected prepare(): void;
+    protected buildType(): string;
+    dumpTypeSchema(cache: ProgressiveBuildCache): string;
+}

package/lib/compiler/elements/cached.element.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CachedElement = void 0;
+const element_1 = require("./element");
+class CachedElement extends element_1.Element {
+    constructor(compiler, node) {
+        super(compiler, node.module, node.type, [node.filepath], node.progressive.schema, [], undefined, {});
+    }
+    prepare() {
+    }
+    buildType() {
+        return '';
+    }
+    dumpTypeSchema(cache) {
+        return cache.types.elements[this.tag];
+    }
+}
+exports.CachedElement = CachedElement;

package/lib/compiler/elements/element.d.ts

@@ -5,6 +5,7 @@ import { $Job } from "../../elements/blocks/job/job.schema";
 import { $Queue } from "../../elements/blocks/queue/queue.schema";
 import { Compiler } from '../compiler';
 import { $Block } from "../../elements/blocks/block.schema";
+import { ProgressiveBuildCache } from '../progressive';
 export type TypeAsObj = string | ({
     [x: string]: TypeAsObj;
 } & {
@@ -25,6 +26,7 @@ export declare abstract class Element<T extends AnyElementSchema> {
     static Any: any;
     static Never: any;
     type: TypeAsObj;
+    tag: string;
     lowName: string;
     highName: string;
     typeName: string;
@@ -35,7 +37,7 @@ export declare abstract class Element<T extends AnyElementSchema> {
     private bridgeImports;
     protected customImports(nesoiPath: string): string;
     dumpFileSchema(nesoiPath: string): string;
-    dumpTypeSchema(): string;
+    dumpTypeSchema(cache?: ProgressiveBuildCache): string;
     static makeAuthnType(authn: string[]): ({
         [x: string]: TypeAsObj;
     } & {

package/lib/compiler/elements/element.js

@@ -14,6 +14,7 @@ class Element {
         this.inlineRoot = inlineRoot;
         this.bridge = bridge;
         const names = name_helpers_1.NameHelpers.names(schema);
+        this.tag = `${module}::${$t}:${names.low}`;
         this.lowName = names.low;
         this.highName = names.high;
         this.typeName = names.type;
@@ -43,7 +44,8 @@ class Element {
             + `const ${this.typeName}: ${this.typeName} = ${dump_helpers_1.DumpHelpers.dumpSchema(this.schema)}\n`
             + `export default ${this.typeName}`;
     }
-    dumpTypeSchema() {
+    // Cache is only used on CachedElement
+    dumpTypeSchema(cache) {
         this.type = this.buildType();
         const typeschema = {
             'constants': '$Constants',

package/lib/compiler/elements/externals.element.d.ts

@@ -15,5 +15,5 @@ export declare class ExternalsElement extends Element<$Externals> {
     constructor(compiler: Compiler, module: string, $t: string, files: string[], schema: $Externals, dependencies: ResolvedBuilderNode[], inlineRoot?: ResolvedBuilderNode | undefined, bridge?: ResolvedBuilderNode['bridge']);
     protected buildType(): {};
     dumpFileSchema(): string;
-    dumpTypeSchema(): string;
+    getModuleDependencies(): string[];
 }

package/lib/compiler/elements/externals.element.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExternalsElement = void 0;
 const element_1 = require("./element");
-const name_helpers_1 = require("../helpers/name_helpers");
 const dump_helpers_1 = require("../helpers/dump_helpers");
 class ExternalsElement extends element_1.Element {
     constructor(compiler, module, $t, files, schema, dependencies, inlineRoot, bridge) {
@@ -19,45 +18,15 @@ class ExternalsElement extends element_1.Element {
             bucket: {},
             job: {}
         };
-        // Object.entries(schema.buckets).forEach(([key, ref]) => {
-        //     const element = compiler.modules[ref.module].elements
-        //         .find(el => el.lowName === ref.name && el.$t === 'bucket')
-        //     if (!element) {
-        //         throw new Error(`External bucket ${ref.name} not found`)
-        //     }
-        //     this.elements.bucket[key] = element as BucketElement;
-        // })
-        // Object.entries(schema.jobs).forEach(([key, ref]) => {
-        //     const element = compiler.modules[ref.module].elements
-        //         .find(el => el.lowName === ref.name && el.$t === 'job')
-        //     if (!element) {
-        //         throw new Error(`External job ${ref.name} not found`)
-        //     }
-        //     this.elements.job[key] = element as JobElement;
-        // })
-        // this.type = this.buildType();
     }
     buildType() {
         return {};
-        // if (!this.elements) {
-        //     return {};
-        // }
-        // const type = {
-        //     models: {},
-        //     buckets: {},
-        //     jobs: {}
-        // } as ObjTypeAsObj;
-        // Object.entries(this.elements.bucket).map(([tag, el]) => {
-        //     type.models[tag] = (el.type as ObjTypeAsObj).model;
-        //     type.buckets[tag] = (el.type as ObjTypeAsObj).bucket;
-        // })        
-        // return type;
     }
     dumpFileSchema() {
         return `const ${this.typeName} = ${dump_helpers_1.DumpHelpers.dumpSchema(this.schema)}\n`
             + `export default ${this.typeName}`;
     }
-    dumpTypeSchema() {
+    getModuleDependencies() {
         this.type = this.buildType();
         this.prepare();
         const externalModules = new Set();
@@ -75,9 +44,7 @@ class ExternalsElement extends element_1.Element {
                 }
             });
         });
-        return Array.from(externalModules)
-            .map(module => `import ${name_helpers_1.NameHelpers.nameLowToHigh(module)}Module from './${module}.module'`)
-            .join('\n');
+        return Array.from(externalModules);
     }
 }
 exports.ExternalsElement = ExternalsElement;

package/lib/compiler/module.d.ts

@@ -12,6 +12,7 @@ import { ResolvedBuilderNode } from "../engine/dependency";
 import { $Module } from "../schema";
 import { QueueElement } from './elements/queue.element';
 import { Element } from './elements/element';
+import { CachedElement } from './elements/cached.element';
 export declare class CompilerModule {
     compiler: Compiler;
     lowName: string;
@@ -19,6 +20,6 @@ export declare class CompilerModule {
     typeName: string;
     module: Module<any, $Module>;
     elements: Element<any>[];
-    constructor(compiler: Compiler, name: string, path: string);
-    buildElementNode(node: ResolvedBuilderNode): Promise<MessageElement | BucketElement | JobElement | ResourceElement | MachineElement | ControllerElement | ConstantsElement | ExternalsElement | QueueElement | undefined>;
+    constructor(compiler: Compiler, name: string, path: string, subdir?: string[]);
+    buildElementNode(node: ResolvedBuilderNode): Promise<MessageElement | BucketElement | JobElement | ResourceElement | MachineElement | ControllerElement | ConstantsElement | ExternalsElement | QueueElement | CachedElement | undefined>;
 }

package/lib/compiler/module.js

@@ -48,8 +48,9 @@ const constants_element_1 = require("./elements/constants.element");
 const externals_element_1 = require("./elements/externals.element");
 const log_1 = require("../engine/util/log");
 const queue_element_1 = require("./elements/queue.element");
+const cached_element_1 = require("./elements/cached.element");
 class CompilerModule {
-    constructor(compiler, name, path) {
+    constructor(compiler, name, path, subdir = []) {
         this.compiler = compiler;
         this.elements = [];
         this.lowName = name;
@@ -58,10 +59,16 @@ class CompilerModule {
         if (path && !fs.existsSync(path)) {
             throw error_1.CompilerError.DirectoryDoesntExists(path);
         }
-        this.module = new module_1.Module(name, { dirpath: path });
+        this.module = new module_1.Module(name, { dirpath: path }, subdir);
     }
     async buildElementNode(node) {
         log_1.Log.trace('compiler', 'module', `${this.lowName}::${(0, log_1.scopeTag)(node.type, node.name)} Compiling${node.isInline ? ' (inline)' : ''}`);
+        // Progressive (Cached)
+        if (node.progressive) {
+            const el = new cached_element_1.CachedElement(this.compiler, node);
+            this.elements.push(el);
+            return el;
+        }
         // Entities
         if (node.type === 'constants') {
             const el = new constants_element_1.ConstantsElement(this.compiler, this.lowName, 'constants', node.filepath, node.schema, node.dependencies.map(dep => dep.node), undefined, node.bridge);

package/lib/compiler/progressive.d.ts

@@ -0,0 +1,71 @@
+import { BuilderNode } from "../engine/dependency";
+import { AnySpace } from "../engine/space";
+import { BuilderType } from "../schema";
+import { Compiler } from './compiler';
+import { ObjTypeAsObj } from './elements/element';
+export type ProgressiveBuildCache = {
+    nesoidir: string;
+    hash: {
+        $: string;
+        space: string;
+        modules: {
+            [name: string]: {
+                $: string;
+                nodes: {
+                    [tag: string]: string;
+                };
+            };
+        };
+        files: {
+            [filepath: string]: string;
+        };
+    };
+    files: {
+        [filepath: string]: {
+            type: BuilderType[];
+            elements: string[];
+        };
+    };
+    modules: {
+        [name: string]: {
+            dependencies: {
+                modules: string[];
+            };
+        };
+    };
+    types: {
+        space: ObjTypeAsObj;
+        modules: {
+            [name: string]: ObjTypeAsObj;
+        };
+        elements: {
+            [tag: string]: string;
+        };
+    };
+};
+export declare class ProgressiveBuild {
+    static cache(compiler: Compiler, $?: {
+        init: boolean;
+    }): ProgressiveBuildCache | Promise<ProgressiveBuildCache>;
+    static treeshake(cache: ProgressiveBuildCache, filepath: string): Promise<BuilderNode[] | undefined>;
+    static empty(): ProgressiveBuildCache;
+    static init(compiler: Compiler): Promise<ProgressiveBuildCache>;
+    static save(space: AnySpace, cache: ProgressiveBuildCache, hash?: ProgressiveBuildCache['hash']): Promise<void>;
+    static hash(compiler: Compiler): Promise<{
+        $: string;
+        space: string;
+        modules: {
+            [name: string]: {
+                $: string;
+                nodes: {
+                    [tag: string]: string;
+                };
+            };
+        };
+        files: {
+            [filepath: string]: string;
+        };
+    }>;
+    private static nodes;
+    private static schemas;
+}

package/lib/compiler/progressive.js

@@ -0,0 +1,164 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProgressiveBuild = void 0;
+const fs_1 = __importStar(require("fs"));
+const dependency_1 = require("../engine/dependency");
+const space_1 = require("../engine/space");
+const hash_1 = require("../engine/util/hash");
+const path_1 = __importDefault(require("path"));
+class ProgressiveBuild {
+    static cache(compiler, $) {
+        const path = space_1.Space.path(compiler.space, '.nesoi', '.cache');
+        if (!(0, fs_1.existsSync)(path)) {
+            return this.init(compiler);
+        }
+        const file = fs_1.default.readFileSync(path);
+        return JSON.parse(file.toString());
+    }
+    static async treeshake(cache, filepath) {
+        const file = cache.files[filepath];
+        // Currently, progressive build of constants and externals is
+        // not supported, given that the schemas are merged, so checking
+        // the hash of a single file is not enough to ensure changes
+        if (!file.type.includes('constants') && !file.type.includes('externals')) {
+            const hash = await hash_1.Hash.file(filepath);
+            if (hash === cache.hash.files[filepath]) {
+                return ProgressiveBuild.nodes(cache, filepath);
+            }
+        }
+    }
+    static empty() {
+        const cache = {
+            nesoidir: '',
+            hash: {
+                $: '',
+                files: {},
+                modules: {},
+                space: ''
+            },
+            files: {},
+            modules: {},
+            types: {
+                space: {},
+                modules: {},
+                elements: {}
+            }
+        };
+        return cache;
+    }
+    static async init(compiler) {
+        const cache = {
+            nesoidir: space_1.Space.path(compiler.space, '.nesoi'),
+            hash: await ProgressiveBuild.hash(compiler),
+            files: {},
+            modules: {},
+            types: {
+                space: {},
+                modules: {},
+                elements: {}
+            }
+        };
+        return cache;
+    }
+    static async save(space, cache, hash) {
+        if (!fs_1.default.existsSync(cache.nesoidir)) {
+            fs_1.default.mkdirSync(cache.nesoidir, { recursive: true });
+        }
+        cache.hash = hash || cache.hash;
+        const cachePath = path_1.default.join(cache.nesoidir, '.cache');
+        const str = JSON.stringify(cache);
+        fs_1.default.writeFileSync(cachePath, str);
+    }
+    static async hash(compiler) {
+        const out = {
+            $: '',
+            files: {},
+            space: await hash_1.Hash.file(space_1.Space.path(compiler.space, 'nesoi.ts')),
+            modules: {}
+        };
+        // Calculate a hash for each module
+        const modules = compiler.tree.allNodesByModule();
+        for (const name in modules) {
+            out.modules[name] = {
+                $: '',
+                nodes: {}
+            };
+            const module = modules[name];
+            for (const node of module) {
+                if (Array.isArray(node.filepath)) {
+                    // Currently, progressive build of constants and externals is
+                    // not supported, so these are ignore.
+                    continue;
+                }
+                const hash = await hash_1.Hash.file(node.filepath);
+                out.files[node.filepath] = hash;
+                out.modules[name].nodes[node.tag] = hash;
+            }
+            out.modules[name].$ = hash_1.Hash.merge(out.modules[name].nodes);
+        }
+        out.$ = hash_1.Hash.merge({
+            __space: out.space,
+            ...out.modules
+        });
+        return out;
+    }
+    // treeshake
+    static async nodes(cache, filepath) {
+        const file = cache.files[filepath];
+        const schemas = await this.schemas(cache, file);
+        return schemas.map(schema => new dependency_1.BuilderNode({
+            module: schema.module,
+            type: schema.$t,
+            name: schema.name,
+            filepath,
+            dependencies: [],
+            builder: undefined,
+            progressive: { schema }
+        }));
+    }
+    static async schemas(cache, file) {
+        const schemas = [];
+        for (const schemaPath of file.elements) {
+            const schema = (await Promise.resolve(`${schemaPath}`).then(s => __importStar(require(s)))).default;
+            schemas.push(schema);
+        }
+        return schemas;
+    }
+}
+exports.ProgressiveBuild = ProgressiveBuild;

package/lib/compiler/stages/1_scan_stage.js

@@ -16,10 +16,13 @@ class ScanStage {
         this.compiler = compiler;
     }
     async run() {
+        const t0 = new Date().getTime();
         log_1.Log.info('compiler', 'stage.scan', 'Scanning module folders...');
-        space_1.Space.scan(this.compiler.space, (name, path) => {
-            this.compiler.modules[name] = new module_1.CompilerModule(this.compiler, name, path);
+        space_1.Space.scan(this.compiler.space, (name, path, subdir) => {
+            this.compiler.modules[name] = new module_1.CompilerModule(this.compiler, name, path, subdir);
         });
+        const t = new Date().getTime();
+        log_1.Log.debug('compiler', 'stage.scan', `[t: ${(t - t0) / 1000} ms]`);
         log_1.Log.debug('compiler', 'stage.scan', `Modules (${Object.keys(this.compiler.modules).length}): ${Object.keys(this.compiler.modules)}`);
     }
 }

package/lib/compiler/stages/2_treeshake_stage.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TreeshakeStage = void 0;
 const log_1 = require("../../engine/util/log");
+const progressive_1 = require("../progressive");
 /**
  * [Compiler Stage #2]
  * Treeshake each module to finds it's nodes, inline nodes and dependencies,
@@ -16,12 +17,17 @@ class TreeshakeStage {
     }
     async run() {
         log_1.Log.info('compiler', 'stage.treeshake', 'Treeshaking Nodes and Resolving Dependencies...');
+        const t0 = new Date().getTime();
         const modules = {};
         Object.entries(this.compiler.modules).forEach(([name, module]) => {
             modules[name] = module.module;
         });
         this.compiler.tree.modules = modules;
-        await this.compiler.tree.resolve();
+        const cache = await progressive_1.ProgressiveBuild.cache(this.compiler);
+        await this.compiler.tree.resolve(cache);
+        await progressive_1.ProgressiveBuild.save(this.compiler.space, cache);
+        const t = new Date().getTime();
+        log_1.Log.debug('compiler', 'stage.treeshake', `[t: ${(t - t0) / 1000} ms]`);
     }
 }
 exports.TreeshakeStage = TreeshakeStage;

package/lib/compiler/stages/3_extract_ts_stage.js

@@ -17,6 +17,7 @@ class ExtractTSStage {
     }
     run() {
         log_1.Log.info('compiler', 'stage.extract_ts', 'Extracting TypeScript code from builders...');
+        const t0 = new Date().getTime();
         const { tree } = this.compiler;
         const nodes = tree.allNodes();
         const extract = {};
@@ -27,6 +28,9 @@ class ExtractTSStage {
             machines: {}
         };
         nodes.forEach(node => {
+            if (node.progressive) {
+                return;
+            }
             if (node.isInline) {
                 return;
             }
@@ -46,6 +50,9 @@ class ExtractTSStage {
             Object.assign(organized.machines, nodeOrganized.machines);
         });
         nodes.forEach(node => {
+            if (node.progressive) {
+                return;
+            }
             const imports = node.isInline
                 ? extract[node.root.tag]?.imports
                 : extract[node.tag]?.imports;
@@ -68,6 +75,8 @@ class ExtractTSStage {
                 appDependencies: [] // TODO
             };
         });
+        const t = new Date().getTime();
+        log_1.Log.debug('compiler', 'stage.extract_ts', `[t: ${(t - t0) / 1000} ms]`);
         log_1.Log.trace('compiler', 'stage.extract_ts', 'Finished extracting TS code', organized);
     }
 }