nesoi 3.0.0

package/lib/compiler/typescript/parser.js

@@ -0,0 +1,581 @@
+"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.Parser = exports.ParsedNode = void 0;
+const ts = __importStar(require("typescript"));
+const error_1 = require("./error");
+/**
+ * TODO: DEPRECATE THIS
+ */
+const DEBUG_LOG = false;
+class ParsedNode {
+    constructor(node, superkind, kind, value, type = 'unknown') {
+        this.superkind = superkind;
+        this.kind = kind;
+        this.value = value;
+        this.type = type;
+    }
+    withExpressionOperator(operator) {
+        this.expressionOperator = operator;
+        return this;
+    }
+    withArrayElement(element) {
+        this.arrayElement = element;
+        return this;
+    }
+    withArguments(args) {
+        this.arguments = args;
+        return this;
+    }
+    withMembers(members) {
+        this.members = members;
+        return this;
+    }
+    withReturn(node) {
+        this.return = node;
+        return this;
+    }
+    withChain(chain) {
+        this.chain = chain;
+        return this;
+    }
+    toString(d = 0) {
+        const pad0 = '  '.repeat(d);
+        const pad1 = '  '.repeat(d + 1);
+        if (this.kind === 'primitive')
+            return this.value;
+        if (this.kind === 'string')
+            return `'${this.value}'`;
+        if (this.kind === 'obj') {
+            return '{\n' +
+                Object.entries(this.members).map(([key, val]) => `${pad1}${key}: ${val.toString(d + 1)}`).join(',\n')
+                + `\n${pad0}}`;
+        }
+        if (this.kind === 'array') {
+            return '[\n' +
+                Object.values(this.members).map((val) => `${pad1}${val.toString(d + 1)}`).join(',\n')
+                + `\n${pad0}]`;
+        }
+        if (this.kind === 'fn') {
+            return `${this.value}(` +
+                Object.values(this.arguments).map((val) => `${val.toString(d)}`).join(', ')
+                + ') => {\n' +
+                `${pad1}${this.return.toString(d + 1)}`
+                + `\n${pad0}}`;
+        }
+        if (this.kind === 'identifier') {
+            return this.value;
+        }
+        if (this.kind === 'call') {
+            if (!this.chain) {
+                if (this.arguments) {
+                    return `${this.value}(` +
+                        Object.values(this.arguments).map((val) => `${val.toString(d)}`).join(',')
+                        + ')';
+                }
+                return `${this.value}()`;
+            }
+        }
+        if (this.kind === 'chain') {
+            return '[\n' +
+                this.chain.map(call => pad1 + call.toString(d + 1))
+                    .join(',\n')
+                + `\n${pad0}]`;
+        }
+        if (this.kind === 'expression') {
+            if (this.arguments.length === 1) {
+                return this.expressionOperator.value + this.arguments[0].toString();
+            }
+            else if (this.arguments.length === 2) {
+                return this.arguments[0].toString() + this.expressionOperator.value + this.arguments[1].toString();
+            }
+        }
+    }
+}
+exports.ParsedNode = ParsedNode;
+class Parser {
+    /* Value */
+    static parseNode(node, parseChain = true) {
+        const text = node?.getText();
+        if (!node) {
+            return undefined;
+        }
+        // Simple values
+        if (node.kind === ts.SyntaxKind.NullKeyword) {
+            if (DEBUG_LOG)
+                console.log('Parsing value node as null', { text });
+            return new ParsedNode(node, 'value', 'primitive', 'null', 'null');
+        }
+        if (node.kind === ts.SyntaxKind.UndefinedKeyword) {
+            if (DEBUG_LOG)
+                console.log('Parsing value node as undefined', { text });
+            return new ParsedNode(node, 'value', 'primitive', 'undefined', 'undefined');
+        }
+        if (node.kind === ts.SyntaxKind.TrueKeyword) {
+            if (DEBUG_LOG)
+                console.log('Parsing value node as true', { text });
+            return new ParsedNode(node, 'value', 'primitive', 'true', 'boolean');
+        }
+        if (node.kind === ts.SyntaxKind.FalseKeyword) {
+            if (DEBUG_LOG)
+                console.log('Parsing value node as false', { text });
+            return new ParsedNode(node, 'value', 'primitive', 'false', 'boolean');
+        }
+        if (ts.isNumericLiteral(node)) {
+            if (DEBUG_LOG)
+                console.log('Parsing value node as number', { text });
+            return new ParsedNode(node, 'value', 'primitive', node.text, 'number');
+        }
+        if (ts.isStringLiteral(node)) {
+            if (DEBUG_LOG)
+                console.log('Parsing value node as string', { text });
+            return new ParsedNode(node, 'value', 'string', node.text, 'string');
+        }
+        if (ts.isObjectLiteralExpression(node)) {
+            if (DEBUG_LOG)
+                console.log('Parsing value node as object', { text });
+            return new ParsedNode(node, 'value', 'obj', undefined)
+                .withMembers(this.parseObjectMembers(node));
+        }
+        if (ts.isArrayLiteralExpression(node)) {
+            if (DEBUG_LOG)
+                console.log('Parsing value node as array', { text });
+            return new ParsedNode(node, 'value', 'array', undefined)
+                .withMembers(this.parseArrayElements(node));
+        }
+        // Functions, Builders, Identifiers
+        if (ts.isFunctionExpression(node) || ts.isArrowFunction(node)) {
+            if (DEBUG_LOG)
+                console.log('Parsing value node as function', { text });
+            const name = this.parseFunctionName(node);
+            return new ParsedNode(node, 'value', 'fn', name)
+                .withArguments(this.parseFunctionParameters(node))
+                .withReturn(this.parseNode(node.body));
+        }
+        if (ts.isIdentifier(node)) {
+            if (DEBUG_LOG)
+                console.log('Parsing value node as identifier', { text });
+            const name = node.escapedText.toString();
+            return new ParsedNode(node, 'value', 'identifier', name);
+        }
+        if (ts.isParameter(node)) {
+            if (DEBUG_LOG)
+                console.log('Parsing value node as parameter', { text });
+            const name = this.parseNode(node.name);
+            return new ParsedNode(node, 'value', 'identifier', name);
+        }
+        if (ts.isPropertyAccessExpression(node)) {
+            if (DEBUG_LOG)
+                console.log('Parsing value node as property access expression', { text, parseChain });
+            return this.parseGetterCall(node, parseChain);
+        }
+        if (ts.isCallExpression(node)) {
+            if (DEBUG_LOG)
+                console.log('Parsing value node as function call', { text, parseChain });
+            return this.parseFunctionCall(node, parseChain);
+        }
+        if (ts.isBlock(node)) {
+            if (DEBUG_LOG)
+                console.log('Parsing value node as block output', { text });
+            return this.parseBlockReturn(node);
+        }
+        // Expressions
+        if (ts.isParenthesizedExpression(node)) {
+            if (DEBUG_LOG)
+                console.log('Parsing value node as parenthesized expression', { text });
+            return this.parseNode(node.expression);
+        }
+        if (ts.isAsExpression(node)) {
+            if (DEBUG_LOG)
+                console.log('Parsing value node as block output', { text });
+            return this.parseNode(node.expression);
+        }
+        if (ts.isPrefixUnaryExpression(node)) {
+            if (DEBUG_LOG)
+                console.log('Parsing value node as prefix unary expression', { text });
+            return this.parsePrefixUnaryExpression(node);
+        }
+        if (ts.isBinaryExpression(node)) {
+            if (DEBUG_LOG)
+                console.log('Parsing value node as binary expression', { text });
+            return this.parseBinaryExpression(node);
+        }
+        if (ts.isConditionalExpression(node)) {
+            if (DEBUG_LOG)
+                console.log('Parsing value node as binary expression', { text });
+            return this.parseConditionalExpression(node);
+        }
+        if (ts.isAwaitExpression(node)) {
+            if (DEBUG_LOG)
+                console.log('Parsing value node as binary expression', { text });
+            return this.parseAwaitExpression(node);
+        }
+        // Tokens
+        if (ts.isPlusToken(node)) {
+            if (DEBUG_LOG)
+                console.log('Parsing value node as plus token', { text });
+            return new ParsedNode(node, 'value', 'token', '+');
+        }
+        if (ts.isMinusToken(node)) {
+            if (DEBUG_LOG)
+                console.log('Parsing value node as minus token', { text });
+            return new ParsedNode(node, 'value', 'token', '-');
+        }
+        if (ts.isAsteriskToken(node)) {
+            if (DEBUG_LOG)
+                console.log('Parsing value node as asterisk token', { text });
+            return new ParsedNode(node, 'value', 'token', '*');
+        }
+        if (node.kind === ts.SyntaxKind.SlashToken) {
+            if (DEBUG_LOG)
+                console.log('Parsing value node as slash token', { text });
+            return new ParsedNode(node, 'value', 'token', '/');
+        }
+        if (node.kind === ts.SyntaxKind.EqualsEqualsToken) {
+            if (DEBUG_LOG)
+                console.log('Parsing value node as equals2 token', { text });
+            return new ParsedNode(node, 'value', 'token', '==');
+        }
+        if (node.kind === ts.SyntaxKind.EqualsEqualsEqualsToken) {
+            if (DEBUG_LOG)
+                console.log('Parsing value node as equals3 token', { text });
+            return new ParsedNode(node, 'value', 'token', '===');
+        }
+        if (node.kind === ts.SyntaxKind.ExclamationEqualsToken) {
+            if (DEBUG_LOG)
+                console.log('Parsing value node as not_equals2 token', { text });
+            return new ParsedNode(node, 'value', 'token', '!=');
+        }
+        if (node.kind === ts.SyntaxKind.ExclamationEqualsEqualsToken) {
+            if (DEBUG_LOG)
+                console.log('Parsing value node as not_equals3 token', { text });
+            return new ParsedNode(node, 'value', 'token', '!==');
+        }
+        if (node.kind === ts.SyntaxKind.BarBarToken) {
+            if (DEBUG_LOG)
+                console.log('Parsing value node as bar bar token', { text });
+            return new ParsedNode(node, 'value', 'token', '||');
+        }
+        if (node.kind === ts.SyntaxKind.QuestionQuestionToken) {
+            if (DEBUG_LOG)
+                console.log('Parsing value node as question question token', { text });
+            return new ParsedNode(node, 'value', 'token', '??');
+        }
+        console.error(node.getText());
+        throw error_1.ParserError.StrangeValueKind(node.kind);
+    }
+    static parseObjectMembers(node) {
+        if (DEBUG_LOG)
+            console.log('Parsing value node object members');
+        const properties = {};
+        for (const p in node.properties) {
+            const prop = node.properties[p];
+            if (typeof prop !== 'object') {
+                continue;
+            }
+            if (!ts.isPropertyAssignment(prop)) {
+                throw error_1.ParserError.ObjectPropertyIsNotAssignment();
+            }
+            const name = Parser.parseNode(prop.name).value;
+            properties[name] = Parser.parseNode(prop.initializer);
+        }
+        return properties;
+    }
+    static parseArrayElements(node) {
+        if (DEBUG_LOG)
+            console.log('Parsing value node array elements');
+        const elements = {};
+        let i = 0;
+        for (const p in node.elements) {
+            const prop = node.elements[p];
+            if (typeof prop !== 'object') {
+                continue;
+            }
+            elements[i] = Parser.parseNode(prop);
+            i++;
+        }
+        return elements;
+    }
+    static parseFunctionName(node) {
+        if (DEBUG_LOG)
+            console.log('Parsing value node function name');
+        if (ts.isArrowFunction(node)) {
+            return '$';
+        }
+        return node.name?.escapedText;
+    }
+    static parseFunctionParameters(node) {
+        if (DEBUG_LOG)
+            console.log('Parsing value node function parameters');
+        const parameters = [];
+        for (const p in node.parameters) {
+            const prop = node.parameters[p];
+            if (typeof prop !== 'object') {
+                continue;
+            }
+            parameters.push(Parser.parseNode(prop));
+        }
+        return parameters;
+    }
+    static parseBlockReturn(node) {
+        if (DEBUG_LOG)
+            console.log('Parsing value node block return');
+        for (const i in node.statements) {
+            const statement = node.statements[i];
+            if (ts.isReturnStatement(statement)) {
+                if (statement.expression) {
+                    return this.parseNode(statement.expression);
+                }
+                else {
+                    break;
+                }
+            }
+        }
+        return new ParsedNode(node, 'value', 'primitive', 'undefined');
+    }
+    static parseFunctionCall(node, parseChain) {
+        let name = '';
+        if (ts.isIdentifier(node.expression)) {
+            name = node.expression.escapedText.toString();
+        }
+        else if (ts.isPropertyAccessExpression(node.expression)) {
+            name = node.expression.name.escapedText.toString();
+        }
+        const parsed = new ParsedNode(node, 'value', parseChain ? 'chain' : 'call', name);
+        if (parseChain) {
+            parsed.withChain(this.parseCallChain(node));
+        }
+        else {
+            parsed.withArguments(this.parseCallArguments(node));
+        }
+        return parsed;
+    }
+    static parseGetterCall(node, parseChain) {
+        let name = '';
+        if (ts.isIdentifier(node.name)) {
+            name = node.name.escapedText.toString();
+        }
+        const parsed = new ParsedNode(node, 'value', parseChain ? 'chain' : 'call', name);
+        if (parseChain) {
+            parsed.withChain(this.parseCallChain(node));
+        }
+        return parsed;
+    }
+    static parseCallArguments(node) {
+        if (DEBUG_LOG)
+            console.log('Parsing value node function call arguments');
+        const args = [];
+        for (const i in node.arguments) {
+            const arg = node.arguments[i];
+            if (typeof arg !== 'object') {
+                continue;
+            }
+            args.push(this.parseNode(arg));
+        }
+        return args;
+    }
+    static parsePrefixUnaryExpression(node) {
+        if (DEBUG_LOG)
+            console.log('Parsing value node as prefix unary expression');
+        const operator = new ParsedNode(node, 'value', 'token', {
+            [ts.SyntaxKind.PlusPlusToken]: '++',
+            [ts.SyntaxKind.MinusMinusToken]: '--',
+            [ts.SyntaxKind.PlusToken]: '+',
+            [ts.SyntaxKind.MinusToken]: '-',
+            [ts.SyntaxKind.TildeToken]: '~',
+            [ts.SyntaxKind.ExclamationToken]: '!',
+        }[node.operator]);
+        const operand = this.parseNode(node.operand);
+        return new ParsedNode(node, 'value', 'expression', undefined, 'boolean')
+            .withExpressionOperator(operator)
+            .withArguments([operand]);
+    }
+    static parseAwaitExpression(node) {
+        if (DEBUG_LOG)
+            console.log('Parsing value node as binary expression');
+        const operator = new ParsedNode(node, 'value', 'token', 'await');
+        const expression = this.parseNode(node.expression);
+        return new ParsedNode(node, 'value', 'expression', undefined, `Promise<${expression.type}>`)
+            .withExpressionOperator(operator)
+            .withArguments([expression]);
+    }
+    static parseBinaryExpression(node) {
+        if (DEBUG_LOG)
+            console.log('Parsing value node as binary expression');
+        const left = this.parseNode(node.left);
+        const right = this.parseNode(node.right);
+        const token = this.parseNode(node.operatorToken);
+        return new ParsedNode(node, 'value', 'expression', undefined, left.type)
+            .withExpressionOperator(token)
+            .withArguments([left, right]);
+    }
+    static parseConditionalExpression(node) {
+        if (DEBUG_LOG)
+            console.log('Parsing value node as conditional expression');
+        const condition = this.parseNode(node.condition);
+        const left = this.parseNode(node.whenTrue);
+        const right = this.parseNode(node.whenFalse);
+        return new ParsedNode(node, 'value', 'expression', undefined, left.type + ' | ' + right.type)
+            .withExpressionOperator(condition)
+            .withArguments([left, right]);
+    }
+    static parseCallChain(node) {
+        if (DEBUG_LOG)
+            console.log('Parsing value node function call chain', node.getText());
+        const upNodes = [];
+        const downNodes = [];
+        let downCall = ts.isCallExpression(node)
+            ? (ts.isPropertyAccessExpression(node.expression) ? node.expression.expression : undefined) // function
+            : ((ts.isCallExpression(node.expression) || ts.isPropertyAccessExpression(node.expression))
+                ? node.expression
+                : undefined); // getter
+        while (downCall) {
+            if (DEBUG_LOG)
+                console.log('Parsing value down node', downCall.getText());
+            // function
+            if (ts.isCallExpression(downCall)) {
+                if (DEBUG_LOG)
+                    console.log('Parsing value down node as function');
+                downNodes.push(downCall);
+                if (!ts.isPropertyAccessExpression(downCall.expression)) {
+                    break;
+                }
+                downCall = downCall.expression.expression;
+            }
+            // getter
+            else if (ts.isPropertyAccessExpression(downCall)) {
+                if (DEBUG_LOG)
+                    console.log('Parsing value down node as getter');
+                downNodes.push(downCall);
+                downCall = downCall.expression;
+            }
+            else {
+                break;
+            }
+        }
+        let upCall = ts.isCallExpression(node)
+            ? (ts.isPropertyAccessExpression(node.parent) ? node.parent.parent : undefined) // function
+            : (ts.isPropertyAccessExpression(node.parent) ? node.parent : undefined); // getter
+        while (upCall) {
+            if (DEBUG_LOG)
+                console.log('Parsing value up node', upCall.getText());
+            // .something()
+            if (ts.isCallExpression(upCall)) {
+                if (DEBUG_LOG)
+                    console.log('Parsing value up node as function');
+                upNodes.push(upCall);
+                if (!ts.isPropertyAccessExpression(upCall.parent)) {
+                    break;
+                }
+                upCall = upCall.parent.parent;
+            }
+            // .something
+            else if (ts.isPropertyAccessExpression(upCall)) {
+                if (DEBUG_LOG)
+                    console.log('Parsing value up node as getter');
+                upNodes.push(upCall);
+                upCall = upCall.parent;
+            }
+            else {
+                break;
+            }
+        }
+        const chain = [
+            ...downNodes.reverse(),
+            node,
+            ...upNodes,
+        ];
+        return chain.map((call, i) => this.parseNode(call, false));
+    }
+    /* Type */
+    static parseType(node) {
+        if (!node) {
+            return undefined;
+        }
+        if (node.kind === ts.SyntaxKind.NullKeyword) {
+            return new ParsedNode(node, 'type', 'primitive', 'null');
+        }
+        if (node.kind === ts.SyntaxKind.UndefinedKeyword) {
+            return new ParsedNode(node, 'type', 'primitive', 'undefined');
+        }
+        if (node.kind === ts.SyntaxKind.NumberKeyword) {
+            return new ParsedNode(node, 'type', 'primitive', 'number');
+        }
+        if (node.kind === ts.SyntaxKind.StringKeyword) {
+            return new ParsedNode(node, 'type', 'primitive', 'string');
+        }
+        if (node.kind === ts.SyntaxKind.BooleanKeyword) {
+            return new ParsedNode(node, 'type', 'primitive', 'boolean');
+        }
+        if (ts.isInterfaceDeclaration(node)) {
+            const members = [...node.members];
+            return new ParsedNode(node, 'type', 'obj', undefined)
+                .withMembers(this.parseTypeMembers(members));
+        }
+        if (ts.isArrayTypeNode(node)) {
+            const element = this.parseType(node.elementType);
+            return new ParsedNode(node, 'type', 'array', undefined)
+                .withArrayElement(element);
+        }
+        if (ts.isTypeLiteralNode(node)) {
+            const members = [...node.members];
+            return new ParsedNode(node, 'type', 'obj', undefined)
+                .withMembers(this.parseTypeMembers(members));
+        }
+        if (ts.isTypeReferenceNode(node)) {
+            return new ParsedNode(node, 'type', 'identifier', this.parseNode(node.typeName)?.value);
+        }
+        console.error(node);
+        throw error_1.ParserError.StrangeTypeKind(node.kind);
+    }
+    static parseTypeMembers(nodes) {
+        const parsed = {};
+        for (const i in nodes) {
+            const node = nodes[i];
+            if (ts.isPropertySignature(node)) {
+                const key = this.parseNode(node.name).value;
+                if (!node.type) {
+                    throw new Error('Property signature without type');
+                }
+                const type = this.parseType(node);
+                parsed[key] = type;
+                continue;
+            }
+            throw new Error(`Strange Type Member kind ${ts.SyntaxKind[node.kind]}`);
+        }
+        return parsed;
+    }
+}
+exports.Parser = Parser;

package/lib/compiler/typescript/source.d.ts

@@ -0,0 +1,12 @@
+import * as ts from 'typescript';
+import { BuilderType } from "../../schema";
+export declare class MetaSource {
+    sourceFile: ts.SourceFile;
+    filename: string;
+    imports: ts.ImportDeclaration[];
+    interfaces: Record<string, ts.InterfaceDeclaration>;
+    newExpressions: ts.NewExpression[];
+    nesoiCallExpressions: Partial<Record<BuilderType, Record<string, ts.CallExpression>>>;
+    constructor(sourceFile: ts.SourceFile);
+    private parseFile;
+}

package/lib/compiler/typescript/source.js

@@ -0,0 +1,87 @@
+"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.MetaSource = void 0;
+const ts = __importStar(require("typescript"));
+const parser_1 = require("./parser");
+class MetaSource {
+    constructor(sourceFile) {
+        this.sourceFile = sourceFile;
+        this.imports = [];
+        this.interfaces = {};
+        this.newExpressions = [];
+        this.nesoiCallExpressions = {};
+        this.filename = this.sourceFile.fileName;
+        this.parseFile();
+    }
+    parseFile() {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const _this = this;
+        const transformerFactory = (context) => {
+            return (rootNode) => {
+                function visit(node) {
+                    node = ts.visitEachChild(node, visit, context);
+                    if (ts.isImportDeclaration(node)) {
+                        _this.imports.push(node);
+                    }
+                    else if (ts.isInterfaceDeclaration(node)) {
+                        const name = parser_1.Parser.parseNode(node).value;
+                        _this.interfaces[name] = node;
+                    }
+                    else if (ts.isNewExpression(node)) {
+                        _this.newExpressions.push(node);
+                    }
+                    // TODO: Make this less strict (use something other than escapedText == Nesoi')
+                    else if (ts.isCallExpression(node)
+                        && ts.isPropertyAccessExpression(node.expression)
+                        && ts.isIdentifier(node.expression.expression)
+                        && node.expression.expression.escapedText === 'Nesoi') {
+                        const builderType = parser_1.Parser.parseNode(node.expression).value;
+                        if (!(builderType in _this.nesoiCallExpressions)) {
+                            _this.nesoiCallExpressions[builderType] = {};
+                        }
+                        const globalName = parser_1.Parser.parseNode(node.arguments[0]).value;
+                        const [moduleName, lowName] = globalName.split(':');
+                        _this.nesoiCallExpressions[builderType][lowName] = node;
+                    }
+                    return node;
+                }
+                return ts.visitNode(rootNode, visit);
+            };
+        };
+        ts.transform(this.sourceFile, [transformerFactory]);
+    }
+}
+exports.MetaSource = MetaSource;

package/lib/compiler/typescript/transformers/app_inject.transformer.d.ts

@@ -0,0 +1,2 @@
+import * as ts from 'typescript';
+export declare function makeAppInjectTransformer(modules: string[]): ts.TransformerFactory<ts.SourceFile>;