nesoi 3.0.0

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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceElement = void 0;
+const element_1 = require("./element");
+const name_helpers_1 = require("../helpers/name_helpers");
+const dependency_1 = require("../../engine/dependency");
+const dump_helpers_1 = require("../helpers/dump_helpers");
+class ResourceElement extends element_1.Element {
+    prepare() {
+        this.schema['#authn'] = element_1.Element.Any;
+        this.schema['#input'] = this.schema.input.length ? element_1.Element.Any : element_1.Element.Never;
+        this.schema['#output'] = element_1.Element.Never;
+        this.schema['#bucket'] = element_1.Element.Any;
+        this.schema['#input.view'] = this.schema.jobs.view ? element_1.Element.Any : element_1.Element.Never;
+        this.schema['#input.query'] = this.schema.jobs.query ? element_1.Element.Any : element_1.Element.Never;
+        this.schema['#input.create'] = this.schema.jobs.create ? element_1.Element.Any : element_1.Element.Never;
+        this.schema['#input.update'] = this.schema.jobs.update ? element_1.Element.Any : element_1.Element.Never;
+        this.schema['#input.delete'] = this.schema.jobs.delete ? element_1.Element.Any : element_1.Element.Never;
+    }
+    buildType() {
+        const bucketName = dependency_1.$Dependency.typeName(this.schema.bucket, this.module);
+        const input = {};
+        if (this.schema.jobs.view) {
+            const msg = this.compiler.tree.getSchema(this.schema.jobs.view);
+            const msgName = name_helpers_1.NameHelpers.names({ $t: 'message', name: msg.name });
+            input.view = msgName.type;
+        }
+        if (this.schema.jobs.query) {
+            const msg = this.compiler.tree.getSchema(this.schema.jobs.query);
+            const msgName = name_helpers_1.NameHelpers.names({ $t: 'message', name: msg.name });
+            input.query = msgName.type;
+        }
+        if (this.schema.jobs.create) {
+            const msg = this.compiler.tree.getSchema(this.schema.jobs.create);
+            const msgName = name_helpers_1.NameHelpers.names({ $t: 'message', name: msg.name });
+            input.create = msgName.type;
+        }
+        if (this.schema.jobs.update) {
+            const msg = this.compiler.tree.getSchema(this.schema.jobs.update);
+            const msgName = name_helpers_1.NameHelpers.names({ $t: 'message', name: msg.name });
+            input.update = msgName.type;
+        }
+        if (this.schema.jobs.delete) {
+            const msg = this.compiler.tree.getSchema(this.schema.jobs.delete);
+            const msgName = name_helpers_1.NameHelpers.names({ $t: 'message', name: msg.name });
+            input.delete = msgName.type;
+        }
+        const allInputs = Object.values(input);
+        return dump_helpers_1.DumpHelpers.dumpValueToType(this.schema, {
+            '#authn': () => element_1.Element.makeAuthnType(this.schema.authn),
+            '#input': () => allInputs.length ? allInputs.join(' | ') : 'never',
+            '#output': () => 'never',
+            '#bucket': () => bucketName,
+            '#input.view': () => input.view ?? 'never',
+            '#input.query': () => input.query ?? 'never',
+            '#input.create': () => input.create ?? 'never',
+            '#input.update': () => input.update ?? 'never',
+            '#input.delete': () => input.delete ?? 'never'
+        });
+    }
+    buildCreate() {
+    }
+}
+exports.ResourceElement = ResourceElement;

package/lib/compiler/error.d.ts

@@ -0,0 +1,21 @@
+export declare class CompilerError extends Error {
+    constructor(message: string);
+    static DirectoryDoesntExists(dir: string): CompilerError;
+    static FileDoesntExist(path: string): CompilerError;
+    static NoModulesFolder(): CompilerError;
+    static UnmetModuleDependency(from: string, name: string): CompilerError;
+    static UnmetDependency(from: string, name: string): CompilerError;
+    static CircularDependency(): CompilerError;
+}
+export declare class HelperError extends Error {
+    constructor(message: string);
+    static ArrayElementIsNotString(kind: string): void;
+    static NotAStringOrArray(kind: string): void;
+    static StringIsUndefined(): void;
+    static NotAString(kind: string): void;
+}
+export declare class TypegenError extends Error {
+    constructor(message: string);
+    static BuildMethodNotCalled(context: string): CompilerError;
+    static Resource_BucketRequired(context: string): CompilerError;
+}

package/lib/compiler/error.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypegenError = exports.HelperError = exports.CompilerError = void 0;
+class CompilerError extends Error {
+    constructor(message) {
+        super(message);
+    }
+    static DirectoryDoesntExists(dir) {
+        return new CompilerError(`Directory doesn't exists: ${dir}.`);
+    }
+    static FileDoesntExist(path) {
+        return new CompilerError(`File doesn't exist: ${path}`);
+    }
+    static NoModulesFolder() {
+        return new CompilerError('No modules folder found on project root.');
+    }
+    static UnmetModuleDependency(from, name) {
+        return new CompilerError(`Unment module dependency '${name}' while building '${from}'.`);
+    }
+    static UnmetDependency(from, name) {
+        return new CompilerError(`Unment dependency '${name}' while building '${from}'.`);
+    }
+    static CircularDependency() {
+        return new CompilerError('Circular dependency found while building.');
+    }
+}
+exports.CompilerError = CompilerError;
+class HelperError extends Error {
+    constructor(message) {
+        super(message);
+    }
+    static ArrayElementIsNotString(kind) {
+        throw new CompilerError(`Array element is not a string (${kind})`);
+    }
+    static NotAStringOrArray(kind) {
+        throw new CompilerError(`Not a string or array (${kind})`);
+    }
+    static StringIsUndefined() {
+        throw new CompilerError('String is undefined');
+    }
+    static NotAString(kind) {
+        throw new CompilerError(`Not a string (${kind})`);
+    }
+}
+exports.HelperError = HelperError;
+class TypegenError extends Error {
+    constructor(message) {
+        super(message);
+    }
+    static BuildMethodNotCalled(context) {
+        return new CompilerError(`Build method not called on ${context}.`);
+    }
+    static Resource_BucketRequired(context) {
+        return new CompilerError(`Resource ${context} should specify a bucket.`);
+    }
+}
+exports.TypegenError = TypegenError;

package/lib/compiler/helpers/dump_helpers.d.ts

@@ -0,0 +1,11 @@
+import { TypeAsObj } from '../elements/element';
+type TransformTypes = {
+    [x: string]: TransformTypes | ((v?: any) => TypeAsObj);
+};
+export declare class DumpHelpers {
+    static dumpType(type: TypeAsObj, d?: number): string;
+    static dumpSchema(val: any, d?: number): string;
+    private static dumpFunction;
+    static dumpValueToType(value: any, transform?: TransformTypes, d?: number): TypeAsObj;
+}
+export {};

package/lib/compiler/helpers/dump_helpers.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DumpHelpers = void 0;
+class DumpHelpers {
+    static dumpType(type, d = 0) {
+        const pad0 = '    '.repeat(d);
+        const pad1 = '    '.repeat(d + 1);
+        let str = '';
+        if (typeof type === 'undefined') {
+            str = 'never';
+        }
+        else if (typeof type === 'string') {
+            str = type;
+        }
+        else if (typeof type === 'number') {
+            str = type;
+        }
+        else if (Array.isArray(type)) {
+            if (type.length) {
+                str = '(' + type.map(t => this.dumpType(t)).join(' | ') + ')';
+            }
+            else {
+                str = 'never';
+            }
+        }
+        else {
+            str = '{\n' +
+                Object.entries(type)
+                    .filter(([key]) => key !== '__array' && key !== '__optional')
+                    .map(([key, value]) => {
+                    let k = key;
+                    // If key is not a special [],
+                    if (!(k.startsWith('[') && k.endsWith(']'))
+                        && !(k.startsWith('`') && k.endsWith('`'))) {
+                        // Put single quotes around non-alphanumeric keys
+                        k = /[^\w]/.exec(key) ? `'${key}'` : key;
+                    }
+                    // Put ? on possibly undefined keys
+                    if (typeof value === 'string' && value.includes('| undefined') && !k.startsWith('\'#')) {
+                        k += '?';
+                        value = value.replace('| undefined', '');
+                    }
+                    else if (typeof value === 'object' && value.__optional) {
+                        k += '?';
+                        delete value.__optional;
+                    }
+                    else if (value === 'undefined') {
+                        k += '?';
+                    }
+                    // Dump element type
+                    const t = this.dumpType(value, d + 1);
+                    return `${pad1}${k}: ${t}`;
+                }).join(',\n')
+                + `\n${pad0}}`;
+        }
+        if (typeof type === 'object') {
+            if (type.__array) {
+                str += '[]';
+            }
+            if (type.__optional) {
+                str += ' | undefined';
+            }
+        }
+        return str;
+    }
+    static dumpSchema(val, d = 0) {
+        const pad0 = '    '.repeat(d);
+        const pad1 = '    '.repeat(d + 1);
+        if (typeof val === 'undefined') {
+            return 'undefined';
+        }
+        if (typeof val === 'number') {
+            return val.toString();
+        }
+        if (typeof val === 'boolean') {
+            return val.toString();
+        }
+        if (typeof val === 'string') {
+            return `'${val}'`;
+        }
+        if (typeof val === 'symbol') {
+            return val.description || 'undefined';
+        }
+        else if (Array.isArray(val)) {
+            return '[\n' +
+                val.map(child => {
+                    return `${pad1}${this.dumpSchema(child, d + 1)}`;
+                }).join(',\n')
+                + `\n${pad0}]`;
+        }
+        else if (typeof val === 'object') {
+            if ('__fn' in val) {
+                return val.__fn;
+            }
+            return '{\n' +
+                Object.entries(val).map(([key, child]) => {
+                    const _key = key.match(/\W/) ? `'${key}'` : key;
+                    return `${pad1}${_key}: ${this.dumpSchema(child, d + 1)}`;
+                }).join(',\n')
+                + `\n${pad0}}`;
+        }
+        else if (typeof val === 'function') {
+            return this.dumpFunction(val, pad0);
+        }
+        return val;
+    }
+    static dumpFunction(fn, padding = '') {
+        // Functions should have been replaced by { __fn: ... } by the Compiler,
+        // if any is missed, this flag causes a typescript error when compiling.
+        return `/* TS BRIDGE ERROR: function not properly extracted from source. Function: ${fn.toString()} */`;
+    }
+    static dumpValueToType(value, transform = {}, d = 2) {
+        if (value === undefined) {
+            return 'undefined';
+        }
+        if (typeof value == 'boolean') {
+            return value.toString();
+        }
+        if (typeof value === 'string') {
+            return `'${value}'`;
+        }
+        if (typeof value === 'function') {
+            return 'any // TODO: TypesScript API';
+        }
+        if (typeof value === 'object') {
+            if ('__fn' in value) {
+                return value.__fn_type || 'any /* WARN: non-compiled function */';
+            }
+            if (Array.isArray(value)) {
+                if (value.length === 0) {
+                    return 'never[]';
+                }
+                return '[' + value.map((v) => DumpHelpers.dumpType(this.dumpValueToType(v, transform, d + 1), d)).join(', ') + ']';
+            }
+            else {
+                const obj = {};
+                // Type-only keys (#something)
+                Object.entries(transform).forEach(([key, trf]) => {
+                    if (key.startsWith('#') && typeof trf === 'function') {
+                        obj[key] = trf();
+                    }
+                });
+                Object.entries(value).forEach(([key, value]) => {
+                    if (typeof transform[key] === 'function') {
+                        obj[key] = transform[key](value);
+                    }
+                    else {
+                        obj[key] = this.dumpValueToType(value, transform[key], d + 1);
+                    }
+                });
+                return obj;
+            }
+        }
+        return value;
+    }
+}
+exports.DumpHelpers = DumpHelpers;

package/lib/compiler/helpers/name_helpers.d.ts

@@ -0,0 +1,20 @@
+import { BuilderType } from "../../schema";
+export type ParsedType = string | ({
+    [x: string]: ParsedType;
+} & {
+    __array?: boolean;
+    __optional?: boolean;
+});
+export declare class NameHelpers {
+    static nameLowToHigh(low: string): string;
+    static nameHighToLow(high: string): string;
+    static unabbrevName(name: string, context: string): string;
+    static names(schema: {
+        $t: BuilderType;
+        name: string;
+    }): {
+        low: string;
+        high: string;
+        type: string;
+    };
+}

package/lib/compiler/helpers/name_helpers.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NameHelpers = void 0;
+class NameHelpers {
+    static nameLowToHigh(low) {
+        const words = low.split(/[\W_]/).filter(c => c);
+        return words.map(word => word[0].toUpperCase() + word.slice(1)).join('');
+    }
+    static nameHighToLow(high) {
+        return high.replace(/([a-zA-Z])(?=[A-Z])/g, '$1_').toLowerCase();
+    }
+    static unabbrevName(name, context) {
+        if (name === '@') {
+            return context;
+        }
+        const abbrev = name.match(/@\.(.*)/);
+        if (abbrev) {
+            return `${context}${abbrev[1].length ? ('.' + abbrev[1]) : abbrev[1]}`;
+        }
+        return name;
+    }
+    static names(schema) {
+        const lowName = schema.name;
+        const highName = this.nameLowToHigh(lowName);
+        const suffix = {
+            'constants': 'Constants',
+            'externals': 'Externals',
+            'bucket': 'Bucket',
+            'message': 'Message',
+            'job': 'Job',
+            'resource': 'Resource',
+            'machine': 'Machine',
+            'controller': 'Controller',
+            'queue': 'Queue'
+        }[schema.$t];
+        const typeName = highName + suffix;
+        return {
+            low: lowName,
+            high: highName,
+            type: typeName
+        };
+    }
+}
+exports.NameHelpers = NameHelpers;

package/lib/compiler/index.d.ts

@@ -0,0 +1,2 @@
+export { Compiler } from './compiler';
+export { MonolythCompiler } from './apps/monolyth/monolyth_compiler';

package/lib/compiler/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MonolythCompiler = exports.Compiler = void 0;
+var compiler_1 = require("./compiler");
+Object.defineProperty(exports, "Compiler", { enumerable: true, get: function () { return compiler_1.Compiler; } });
+var monolyth_compiler_1 = require("./apps/monolyth/monolyth_compiler");
+Object.defineProperty(exports, "MonolythCompiler", { enumerable: true, get: function () { return monolyth_compiler_1.MonolythCompiler; } });

package/lib/compiler/module.d.ts

@@ -0,0 +1,24 @@
+import { Compiler } from './compiler';
+import { Module } from "../engine/module";
+import { MessageElement } from './elements/message.element';
+import { BucketElement } from './elements/bucket.element';
+import { JobElement } from './elements/job.element';
+import { ResourceElement } from './elements/resource.element';
+import { MachineElement } from './elements/machine.element';
+import { ControllerElement } from './elements/controller.element';
+import { ConstantsElement } from './elements/constants.element';
+import { ExternalsElement } from './elements/externals.element';
+import { ResolvedBuilderNode } from "../engine/dependency";
+import { $Module } from "../schema";
+import { QueueElement } from './elements/queue.element';
+import { Element } from './elements/element';
+export declare class CompilerModule {
+    compiler: Compiler;
+    lowName: string;
+    highName: string;
+    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>;
+}

package/lib/compiler/module.js

@@ -0,0 +1,122 @@
+"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.CompilerModule = void 0;
+const fs = __importStar(require("fs"));
+const error_1 = require("./error");
+const module_1 = require("../engine/module");
+const name_helpers_1 = require("./helpers/name_helpers");
+const message_element_1 = require("./elements/message.element");
+const bucket_element_1 = require("./elements/bucket.element");
+const job_element_1 = require("./elements/job.element");
+const resource_element_1 = require("./elements/resource.element");
+const machine_element_1 = require("./elements/machine.element");
+const controller_element_1 = require("./elements/controller.element");
+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");
+class CompilerModule {
+    constructor(compiler, name, path) {
+        this.compiler = compiler;
+        this.elements = [];
+        this.lowName = name;
+        this.highName = name_helpers_1.NameHelpers.nameLowToHigh(this.lowName);
+        this.typeName = this.highName + 'Module';
+        if (path && !fs.existsSync(path)) {
+            throw error_1.CompilerError.DirectoryDoesntExists(path);
+        }
+        this.module = new module_1.Module(name, { path });
+    }
+    async buildElementNode(node) {
+        log_1.Log.trace('compiler', 'module', `${this.lowName}::${(0, log_1.scopeTag)(node.type, node.name)} Compiling${node.isInline ? ' (inline)' : ''}`);
+        // 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);
+            this.elements.push(el);
+            return el;
+        }
+        if (node.type === 'externals') {
+            const el = new externals_element_1.ExternalsElement(this.compiler, this.lowName, 'externals', node.filepath, node.schema, node.dependencies.map(dep => dep.node), undefined, node.bridge);
+            this.elements.push(el);
+            return el;
+        }
+        if (node.type === 'message') {
+            const schema = node.schema;
+            const el = new message_element_1.MessageElement(this.compiler, this.lowName, 'message', [node.filepath], schema, node.dependencies.map(dep => dep.node), node.root, node.bridge);
+            this.elements.push(el);
+            return el;
+        }
+        if (node.type === 'bucket') {
+            const schema = node.schema;
+            const el = new bucket_element_1.BucketElement(this.compiler, this.lowName, 'bucket', [node.filepath], schema, node.dependencies.map(dep => dep.node), undefined, node.bridge);
+            this.elements.push(el);
+            return el;
+        }
+        // Blocks
+        if (node.type === 'job') {
+            const schema = node.schema;
+            const el = new job_element_1.JobElement(this.compiler, this.lowName, 'job', [node.filepath], schema, node.dependencies.map(dep => dep.node), node.root, node.bridge);
+            this.elements.push(el);
+            return el;
+        }
+        if (node.type === 'resource') {
+            const schema = node.schema;
+            const el = new resource_element_1.ResourceElement(this.compiler, this.lowName, 'resource', [node.filepath], schema, node.dependencies.map(dep => dep.node), undefined, node.bridge);
+            this.elements.push(el);
+            return el;
+        }
+        if (node.type === 'machine') {
+            const schema = node.schema;
+            const el = new machine_element_1.MachineElement(this.compiler, this.lowName, 'machine', [node.filepath], schema, node.dependencies.map(dep => dep.node), undefined, node.bridge);
+            this.elements.push(el);
+            return el;
+        }
+        // Edge
+        if (node.type === 'controller') {
+            const schema = node.schema;
+            const el = new controller_element_1.ControllerElement(this.compiler, this.lowName, 'controller', [node.filepath], schema, node.dependencies.map(dep => dep.node), undefined, node.bridge);
+            this.elements.push(el);
+            return el;
+        }
+        if (node.type === 'queue') {
+            const schema = node.schema;
+            const el = new queue_element_1.QueueElement(this.compiler, this.lowName, 'queue', [node.filepath], schema, node.dependencies.map(dep => dep.node), undefined, node.bridge);
+            this.elements.push(el);
+            return el;
+        }
+    }
+}
+exports.CompilerModule = CompilerModule;

package/lib/compiler/stages/1_scan_stage.d.ts

@@ -0,0 +1,10 @@
+import { Compiler } from '../compiler';
+/**
+ * [Compiler Stage #1]
+ * Scan the space path looking for modules in the /modules folder.
+ */
+export declare class ScanStage {
+    compiler: Compiler;
+    constructor(compiler: Compiler);
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScanStage = void 0;
+const space_1 = require("../../engine/space");
+const module_1 = require("../module");
+const log_1 = require("../../engine/util/log");
+/**
+ * [Compiler Stage #1]
+ * Scan the space path looking for modules in the /modules folder.
+ */
+class ScanStage {
+    constructor(compiler) {
+        this.compiler = compiler;
+    }
+    async run() {
+        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);
+        });
+        log_1.Log.debug('compiler', 'stage.scan', `Modules (${Object.keys(this.compiler.modules).length}): ${Object.keys(this.compiler.modules)}`);
+    }
+}
+exports.ScanStage = ScanStage;

package/lib/compiler/stages/2_treeshake_stage.d.ts

@@ -0,0 +1,11 @@
+import { Compiler } from '../compiler';
+/**
+ * [Compiler Stage #2]
+ * Treeshake each module to finds it's nodes, inline nodes and dependencies,
+ * then resolve a graph of such dependencies.
+ */
+export declare class TreeshakeStage {
+    compiler: Compiler;
+    constructor(compiler: Compiler);
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TreeshakeStage = void 0;
+const log_1 = require("../../engine/util/log");
+/**
+ * [Compiler Stage #2]
+ * Treeshake each module to finds it's nodes, inline nodes and dependencies,
+ * then resolve a graph of such dependencies.
+ */
+class TreeshakeStage {
+    constructor(compiler) {
+        this.compiler = compiler;
+    }
+    async run() {
+        log_1.Log.info('compiler', 'stage.treeshake', 'Treeshaking Nodes and Resolving Dependencies...');
+        const modules = {};
+        Object.entries(this.compiler.modules).forEach(([name, module]) => {
+            modules[name] = module.module;
+        });
+        this.compiler.tree.modules = modules;
+        await this.compiler.tree.resolve();
+    }
+}
+exports.TreeshakeStage = TreeshakeStage;

package/lib/compiler/stages/3_extract_ts_stage.d.ts

@@ -0,0 +1,10 @@
+import { Compiler } from '../compiler';
+/**
+ * [Compiler Stage #3]
+ * Extract TypeScript sources (methods and imports) from builders
+ */
+export declare class ExtractTSStage {
+    compiler: Compiler;
+    constructor(compiler: Compiler);
+    run(): void;
+}