@bikky/compiler 0.0.7 → 0.0.9

package/Source/ASTHelper.js

@@ -1,344 +1,321 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Printer = exports.logError = exports.SourceFile = exports.ClassDeclaration = exports.AccessExpression = exports.CallExpression = exports.PropertyDeclaration = exports.VariableDeclaration = exports.NamedExpression = exports.StaticModifier = exports.StringLiteral = exports.Identifier = void 0;
-const ts = require("typescript");
-function Identifier(context, name) {
-    return context.factory.createIdentifier(name);
-}
-exports.Identifier = Identifier;
-function StringLiteral(context, name) {
-    return context.factory.createStringLiteral(name);
-}
-exports.StringLiteral = StringLiteral;
-function StaticModifier(context) {
-    return context.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Static)[0];
-}
-exports.StaticModifier = StaticModifier;
-class NamedExpression {
-    constructor(name) {
-        this.name = name;
-    }
-    getName() {
-        return this.name;
-    }
-    rename(name) {
-        this.name = name;
-        return this;
-    }
-}
-exports.NamedExpression = NamedExpression;
-class VariableDeclaration extends NamedExpression {
-    constructor() {
-        super(...arguments);
-        this.modifiers = [];
-    }
-    setValue(value) {
-        this.value = value;
-        return this;
-    }
-    addModifier(modifier) {
-        if (!this.modifiers) {
-            this.modifiers = [];
-        }
-        this.modifiers.push(modifier);
-        return this;
-    }
-    make(context) {
-        return context.factory.createVariableStatement(this.modifiers, context.factory.createVariableDeclarationList([context.factory.createVariableDeclaration(this.name, undefined, undefined, this.value)]));
-    }
-}
-exports.VariableDeclaration = VariableDeclaration;
-(function (VariableDeclaration) {
-    function from(variable) {
-        var result = new VariableDeclaration(variable.name);
-        result.value = variable.initializer;
-        result.modifiers = variable.modifiers ? Array.from(variable.modifiers) : undefined;
-        return result;
-    }
-    VariableDeclaration.from = from;
-})(VariableDeclaration = exports.VariableDeclaration || (exports.VariableDeclaration = {}));
-class PropertyDeclaration extends VariableDeclaration {
-    //Property declarations can support a few more name types than normal variables.
-    constructor(name) {
-        super(name);
-    }
-    make(context) {
-        return context.factory.createPropertyDeclaration([], this.modifiers, this.name, undefined, undefined, this.value);
-    }
-}
-exports.PropertyDeclaration = PropertyDeclaration;
-(function (PropertyDeclaration) {
-    function from(variable) {
-        var result = new PropertyDeclaration(variable.name);
-        result.value = variable.initializer;
-        result.modifiers = variable.modifiers ? Array.from(variable.modifiers) : undefined;
-        return result;
-    }
-    PropertyDeclaration.from = from;
-})(PropertyDeclaration = exports.PropertyDeclaration || (exports.PropertyDeclaration = {}));
-class CallExpression extends NamedExpression {
-    constructor() {
-        super(...arguments);
-        this.arguments = [];
-    }
-    addArgument(...arg) {
-        this.arguments.push(...arg);
-        return this;
-    }
-    make(context) {
-        return context.factory.createCallExpression(this.name, undefined, this.arguments);
-    }
-}
-exports.CallExpression = CallExpression;
-//this[super].function.call(this, arguments);
-class AccessExpression {
-    constructor(context) {
-        this.context = context;
-    }
-    this() {
-        if (!this.start) {
-            this.start = this.context.factory.createThis();
-        }
-        else {
-            throw new Error("This can only be the first expression in an access chain");
-        }
-        return this;
-    }
-    access(node) {
-        if (!this.start) {
-            this.start = node;
-        }
-        else {
-            if (!this.chain) {
-                if (this.start.kind === ts.SyntaxKind.ThisKeyword) {
-                    this.chain = this.context.factory.createElementAccessExpression(this.start, node);
-                }
-                else {
-                    this.chain = this.context.factory.createPropertyAccessExpression(this.start, node);
-                }
-            }
-            else {
-                this.chain = this.context.factory.createPropertyAccessExpression(this.chain, node);
-            }
-        }
-        return this;
-    }
-    make() {
-        return this.chain;
-    }
-}
-exports.AccessExpression = AccessExpression;
-class ClassDeclaration extends NamedExpression {
-    constructor() {
-        super(...arguments);
-        this.decorators = [];
-        this.members = [];
-    }
-    static from(oldClass) {
-        var Class = new ClassDeclaration(oldClass.name);
-        Class.original = oldClass;
-        if (oldClass.heritageClauses) {
-            for (var clause of oldClass.heritageClauses) {
-                if (clause.token == ts.SyntaxKind.ExtendsKeyword) {
-                    Class.extends = clause.types[0].expression;
-                }
-            }
-        }
-        Class.members = Array.from(oldClass.members);
-        if (oldClass.decorators) {
-            Class.decorators = Array.from(oldClass.decorators);
-        }
-        return Class;
-    }
-    addMemberAtStart(member) {
-        this.members.unshift(member);
-        return this;
-    }
-    addMember(member) {
-        this.members.push(member);
-        return this;
-    }
-    hasDecorator(identifier) {
-        var name = (typeof identifier === "string") ? identifier : identifier.text;
-        for (var i = 0; i < this.decorators.length; i++) {
-            var decorator = this.decorators[i];
-            if (ts.isIdentifier(decorator.expression) && decorator.expression.text == name) {
-                return true;
-            }
-            else if (ts.isCallExpression(decorator.expression) && decorator.expression.expression.getText() == name) {
-                return true;
-            }
-        }
-        return false;
-    }
-    removeDecorator(identifier) {
-        var name = (typeof identifier === "string") ? identifier : identifier.text;
-        for (var i = 0; i < this.decorators.length; i++) {
-            var decorator = this.decorators[i];
-            if (ts.isIdentifier(decorator.expression) && decorator.expression.text == name) {
-                this.decorators.splice(i, 1);
-                return this;
-            }
-            else if (ts.isCallExpression(decorator.expression) && decorator.expression.expression.getText() == name) {
-                this.decorators.splice(i, 1);
-                return this;
-            }
-        }
-        return this;
-    }
-    hasExtends() {
-        return !!this.extends;
-    }
-    getExtends() {
-        return this.extends;
-    }
-    setExtends(Extends) {
-        this.extends = Extends;
-        return this;
-    }
-    static eachContextualNode(Class, foo, context) {
-        var statement = (node) => {
-            if (ts.isBlock(node)) {
-                return blocks(node);
-            }
-            else if (ts.isArrowFunction(node)) {
-                return members(node);
-            }
-            else {
-                var result = foo(node);
-                if (!result) {
-                    return result;
-                }
-                if (Array.isArray(result)) {
-                    //TODO: Should probably do something smart here?
-                    return result;
-                }
-                return ts.visitEachChild(result, statement, context);
-            }
-        };
-        var blocks = (node) => {
-            if (ts.isBlock(node)) {
-                return ts.visitEachChild(node, statement, context);
-            }
-            return node;
-        };
-        var members = (node) => {
-            if (ts.isMethodDeclaration(node)) {
-                return ts.visitEachChild(node, blocks, context);
-            }
-            else {
-                return node;
-            }
-        };
-        return ts.visitEachChild(Class, members, context);
-    }
-    update(context) {
-        if (!this.original) {
-            throw new Error("Cannot update class that doesn't exist!");
-        }
-        var replaceNodeArrays = (nodes, visitor, test, start, count) => {
-            if (nodes == this.original.decorators) {
-                return context.factory.createNodeArray(this.decorators);
-            }
-            if (nodes == this.original.members) {
-                return context.factory.createNodeArray(this.members);
-            }
-            if (nodes) {
-                var changedArray = false;
-                var newArray = [];
-                for (var node of nodes) {
-                    var newNode = ts.visitNode(node, visitor, test);
-                    newArray.push(newNode);
-                    if (node != newNode) {
-                        changedArray = true;
-                    }
-                }
-                if (changedArray) {
-                    return context.factory.createNodeArray(newArray);
-                }
-            }
-            return nodes;
-        };
-        var replaceExports = (node) => {
-            if (node.kind == ts.SyntaxKind.HeritageClause && node.token == ts.SyntaxKind.ExtendsKeyword) {
-                //I hope this works...
-                var result = context.factory.createHeritageClause(ts.SyntaxKind.ExtendsKeyword, [ts.createExpressionWithTypeArguments(undefined, this.extends)]);
-                return result;
-            }
-            return node;
-        };
-        //first parameter is the class, second is the thing to edit individual nodes, third is the context
-        // last parameter is the thing to edit entire node arrays.
-        return ts.visitEachChild(this.original, replaceExports, context, replaceNodeArrays);
-    }
-}
-exports.ClassDeclaration = ClassDeclaration;
-class SourceFile {
-    constructor() {
-        this.statements = [];
-    }
-    static from(oldfile) {
-        var file = new SourceFile;
-        file.statements = Array.from(oldfile.statements);
-        file.original = oldfile;
-        return file;
-    }
-    replaceNode(oldNode, newNode) {
-        var index = this.statements.indexOf(oldNode);
-        if (index < 0) {
-            throw new Error("Tried to replace a node that doesn't exist in file");
-        }
-        this.statements[index] = newNode;
-        return this;
-    }
-    insertUnderImports(node) {
-        for (var i = 0; i < this.statements.length; i++) {
-            if (this.statements[i].kind !== ts.SyntaxKind.ImportDeclaration) {
-                this.statements.splice(i, 0, node);
-                break;
-            }
-        }
-        return this;
-    }
-    update(context) {
-        if (!this.original) {
-            throw new Error("Cannot update file that doesn't exist!");
-        }
-        var newSource = ts.getMutableClone(this.original);
-        //Cast to any because mutable clones use the same immutable typing as their original node.
-        newSource.statements = context.factory.createNodeArray(this.statements);
-        return newSource;
-    }
-}
-exports.SourceFile = SourceFile;
-function logError(node, error) {
-    if (!node || !node.getSourceFile()) {
-        console.error("Why are we here?");
-        return;
-    }
-    var source = ts.isSourceFile(node) ? node : node.getSourceFile();
-    var pos = source.getLineAndCharacterOfPosition(node.pos);
-    console.error(`${source.fileName}(${pos.line},${pos.character}):`, error);
-    // This can cause the compiler to stop, but we're not using it because the above will allow
-    // us to go to the right location in the file. And we probably want to return what we can if
-    // there's an error since that's how the rest of typescript works.
-    //ts.createThrow(ts.createStringLiteral("Compiler Error."));
-    return;
-}
-exports.logError = logError;
-var Printer;
-(function (Printer) {
-    var printer = ts.createPrinter();
-    function printNode(node, sourceFile) {
-        return printer.printNode(ts.EmitHint.Unspecified, node, sourceFile);
-    }
-    Printer.printNode = printNode;
-    function printNodeFirstLine(node, sourceFile) {
-        var code = printNode(node, node.getSourceFile());
-        //space matches tab.
-        code = code.replace(/^ *{? *\r\n?/, "");
-        return code.replace(/\r\n.*/gi, "");
-    }
-    Printer.printNodeFirstLine = printNodeFirstLine;
-})(Printer = exports.Printer || (exports.Printer = {}));
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Printer = exports.logError = exports.SourceFile = exports.ClassDeclaration = exports.AccessExpression = exports.PropertyDeclaration = exports.VariableDeclaration = exports.NamedExpression = exports.getNodeText = exports.setContext = void 0;
+const ts = require("typescript");
+let context;
+function setContext(newContext) {
+    context = newContext;
+}
+exports.setContext = setContext;
+function getNodeText(node, source) {
+    if (node.pos > 0 && node.end < source.end) {
+        return node.getText(source);
+    }
+    return "[text not found]";
+}
+exports.getNodeText = getNodeText;
+class NamedExpression {
+    constructor(name) {
+        this.name = name;
+    }
+    getName() {
+        return this.name;
+    }
+    rename(name) {
+        this.name = name;
+        return this;
+    }
+}
+exports.NamedExpression = NamedExpression;
+class VariableDeclaration extends NamedExpression {
+    constructor() {
+        super(...arguments);
+        this.modifiers = [];
+    }
+    setValue(value) {
+        this.value = value;
+        return this;
+    }
+    addModifier(modifier) {
+        if (!this.modifiers) {
+            this.modifiers = [];
+        }
+        this.modifiers.push(modifier);
+        return this;
+    }
+    make(context) {
+        return context.factory.createVariableStatement(this.modifiers, context.factory.createVariableDeclarationList([context.factory.createVariableDeclaration(this.name, undefined, undefined, this.value)]));
+    }
+}
+exports.VariableDeclaration = VariableDeclaration;
+(function (VariableDeclaration) {
+    function from(variable) {
+        var result = new VariableDeclaration(variable.name);
+        result.value = variable.initializer;
+        // result.modifiers = variable.modifiers ? Array.from(variable.modifiers) as ts.Modifier[] : undefined;
+        return result;
+    }
+    VariableDeclaration.from = from;
+})(VariableDeclaration || (exports.VariableDeclaration = VariableDeclaration = {}));
+class PropertyDeclaration extends VariableDeclaration {
+    //Property declarations can support a few more name types than normal variables.
+    constructor(name) {
+        super(name);
+    }
+    make(context) {
+        return context.factory.createPropertyDeclaration(this.modifiers, this.name, undefined, undefined, this.value);
+    }
+}
+exports.PropertyDeclaration = PropertyDeclaration;
+(function (PropertyDeclaration) {
+    function from(variable) {
+        var result = new PropertyDeclaration(variable.name);
+        result.value = variable.initializer;
+        // result.modifiers = variable.modifiers ? Array.from(variable.modifiers) as ts.Modifier[] : undefined;
+        return result;
+    }
+    PropertyDeclaration.from = from;
+})(PropertyDeclaration || (exports.PropertyDeclaration = PropertyDeclaration = {}));
+//this[super].function.call(this, arguments);
+class AccessExpression {
+    constructor(start) {
+        this.start = start;
+    }
+    access(node) {
+        if (!this.chain) {
+            if (this.start.kind === ts.SyntaxKind.ThisKeyword) {
+                this.chain = context.factory.createElementAccessExpression(this.start, node);
+            }
+            else {
+                this.chain = context.factory.createPropertyAccessExpression(this.start, node);
+            }
+        }
+        else {
+            this.chain = context.factory.createPropertyAccessExpression(this.chain, node);
+        }
+        return this;
+    }
+    make() {
+        return this.chain;
+    }
+}
+exports.AccessExpression = AccessExpression;
+class ClassDeclaration extends NamedExpression {
+    constructor() {
+        super(...arguments);
+        this.decorators = [];
+        this.members = [];
+    }
+    static from(oldClass) {
+        var Class = new ClassDeclaration(oldClass.name);
+        Class.original = oldClass;
+        if (oldClass.heritageClauses) {
+            for (var clause of oldClass.heritageClauses) {
+                if (clause.token == ts.SyntaxKind.ExtendsKeyword) {
+                    Class.extends = clause.types[0].expression;
+                }
+            }
+        }
+        Class.members = Array.from(oldClass.members);
+        Class.decorators = ClassDeclaration.getDecorators(oldClass);
+        return Class;
+    }
+    static getModifiers(node) {
+        var _a, _b;
+        return ([...((_b = (_a = node.modifiers) === null || _a === void 0 ? void 0 : _a.filter((m) => m.kind != ts.SyntaxKind.Decorator)) !== null && _b !== void 0 ? _b : [])]);
+    }
+    static getDecorators(node) {
+        var _a, _b;
+        return ([...((_b = (_a = node.modifiers) === null || _a === void 0 ? void 0 : _a.filter((m) => m.kind == ts.SyntaxKind.Decorator)) !== null && _b !== void 0 ? _b : [])]);
+    }
+    addMemberAtStart(member) {
+        this.members.unshift(member);
+        return this;
+    }
+    addMember(member) {
+        this.members.push(member);
+        return this;
+    }
+    hasDecorator(identifier) {
+        var name = (typeof identifier === "string") ? identifier : identifier.text;
+        for (var i = 0; i < this.decorators.length; i++) {
+            var decorator = this.decorators[i];
+            if (ts.isIdentifier(decorator.expression) && decorator.expression.text == name) {
+                return true;
+            }
+            else if (ts.isCallExpression(decorator.expression) && decorator.expression.expression.getText() == name) {
+                return true;
+            }
+        }
+        return false;
+    }
+    removeDecorator(identifier) {
+        var name = (typeof identifier === "string") ? identifier : identifier.text;
+        for (var i = 0; i < this.decorators.length; i++) {
+            var decorator = this.decorators[i];
+            if (ts.isIdentifier(decorator.expression) && decorator.expression.text == name) {
+                this.decorators.splice(i, 1);
+                return this;
+            }
+            else if (ts.isCallExpression(decorator.expression) && decorator.expression.expression.getText() == name) {
+                this.decorators.splice(i, 1);
+                return this;
+            }
+        }
+        return this;
+    }
+    hasExtends() {
+        return !!this.extends;
+    }
+    getExtends() {
+        return this.extends;
+    }
+    setExtends(Extends) {
+        this.extends = Extends;
+        return this;
+    }
+    static eachContextualNode(Class, foo, context) {
+        var statement = (node) => {
+            if (ts.isBlock(node)) {
+                return blocks(node);
+            }
+            else if (ts.isArrowFunction(node)) {
+                return members(node);
+            }
+            else {
+                var result = foo(node);
+                if (!result) {
+                    return result;
+                }
+                if (Array.isArray(result)) {
+                    //TODO: Should probably do something smart here?
+                    return result;
+                }
+                return ts.visitEachChild(result, statement, context);
+            }
+        };
+        var blocks = (node) => {
+            if (ts.isBlock(node)) {
+                return ts.visitEachChild(node, statement, context);
+            }
+            return node;
+        };
+        var members = (node) => {
+            if (ts.isMethodDeclaration(node)) {
+                return ts.visitEachChild(node, blocks, context);
+            }
+            else {
+                return node;
+            }
+        };
+        return ts.visitEachChild(Class, members, context);
+    }
+    update(context) {
+        if (!this.original) {
+            throw new Error("Cannot update class that doesn't exist!");
+        }
+        var replaceNodeArrays = (nodes, visitor, test, start, count) => {
+            if (nodes == this.original.members) {
+                return context.factory.createNodeArray([...this.decorators, ...ClassDeclaration.getModifiers(this.original)]);
+                // return context.factory.createNodeArray(this.decorators);
+            }
+            // if (nodes == this.original!.members) {
+            //     return context.factory.createNodeArray(this.members);
+            // }
+            if (nodes) {
+                var changedArray = false;
+                var newArray = [];
+                for (var node of nodes) {
+                    var newNode = ts.visitNode(node, visitor, test);
+                    newArray.push(newNode);
+                    if (node != newNode) {
+                        changedArray = true;
+                    }
+                }
+                if (changedArray) {
+                    return context.factory.createNodeArray(newArray);
+                }
+            }
+            return nodes;
+        };
+        var replaceExports = (node) => {
+            if (node.kind == ts.SyntaxKind.HeritageClause && node.token == ts.SyntaxKind.ExtendsKeyword) {
+                //I hope this works...
+                var result = context.factory.createHeritageClause(ts.SyntaxKind.ExtendsKeyword, [ts.factory.createExpressionWithTypeArguments(this.extends, undefined)]);
+                return result;
+            }
+            return node;
+        };
+        //first parameter is the class, second is the thing to edit individual nodes, third is the context
+        // last parameter is the thing to edit entire node arrays.
+        return ts.visitEachChild(this.original, replaceExports, context, replaceNodeArrays);
+    }
+}
+exports.ClassDeclaration = ClassDeclaration;
+class SourceFile {
+    constructor() {
+        this.statements = [];
+    }
+    static from(oldfile) {
+        var file = new SourceFile;
+        file.statements = Array.from(oldfile.statements);
+        file.original = oldfile;
+        return file;
+    }
+    replaceNode(oldNode, newNode) {
+        var index = this.statements.indexOf(oldNode);
+        if (index < 0) {
+            throw new Error("Tried to replace a node that doesn't exist in file");
+        }
+        this.statements[index] = newNode;
+        return this;
+    }
+    insertUnderImports(node) {
+        for (var i = 0; i < this.statements.length; i++) {
+            if (this.statements[i].kind !== ts.SyntaxKind.ImportDeclaration) {
+                this.statements.splice(i, 0, node);
+                break;
+            }
+        }
+        return this;
+    }
+    update(context) {
+        if (!this.original) {
+            throw new Error("Cannot update file that doesn't exist!");
+        }
+        return ts.factory.updateSourceFile(this.original, this.statements);
+        ;
+    }
+}
+exports.SourceFile = SourceFile;
+function logError(node, error) {
+    if (!node || !node.getSourceFile()) {
+        console.error("Why are we here?");
+        return;
+    }
+    var source = ts.isSourceFile(node) ? node : node.getSourceFile();
+    var pos = source.getLineAndCharacterOfPosition(node.pos);
+    console.error(`${source.fileName}(${pos.line},${pos.character}):`, error);
+    // This can cause the compiler to stop, but we're not using it because the above will allow
+    // us to go to the right location in the file. And we probably want to return what we can if
+    // there's an error since that's how the rest of typescript works.
+    //ts.createThrow(ts.createStringLiteral("Compiler Error."));
+    return;
+}
+exports.logError = logError;
+var Printer;
+(function (Printer) {
+    var printer = ts.createPrinter();
+    function printNode(node, sourceFile) {
+        return printer.printNode(ts.EmitHint.Unspecified, node, sourceFile);
+    }
+    Printer.printNode = printNode;
+    function printNodeFirstLine(node, sourceFile) {
+        var code = printNode(node, node.getSourceFile());
+        //space matches tab.
+        code = code.replace(/^ *{? *\r\n?/, "");
+        return code.replace(/\r\n.*/gi, "");
+    }
+    Printer.printNodeFirstLine = printNodeFirstLine;
+})(Printer || (exports.Printer = Printer = {}));
 //# sourceMappingURL=ASTHelper.js.map