greybel-interpreter 0.1.6 → 0.2.0

package/dist/custom-types/list.js

@@ -195,7 +195,7 @@ var CustomList = /** @class */ (function (_super) {
                         }
                     }
                     else if (path.length === 1 && CustomList.intrinsics.has(currentValue)) {
-                        return [2 /*return*/, CustomList.intrinsics.get(currentValue)];
+                        return [2 /*return*/, CustomList.intrinsics.get(currentValue).bind(null, me)];
                     }
                     else {
                         throw new Error("Cannot get path ".concat(path.join('.')));
@@ -228,7 +228,7 @@ var CustomList = /** @class */ (function (_super) {
                     }
                     else if (path.length === 1 && CustomList.intrinsics.has(current)) {
                         return [2 /*return*/, {
-                                origin: CustomList.intrinsics.get(current),
+                                origin: CustomList.intrinsics.get(current).bind(null, me),
                                 context: me
                             }];
                     }

package/dist/custom-types/map.js

@@ -180,7 +180,7 @@ var CustomMap = /** @class */ (function (_super) {
                         }
                     }
                     else if (path.length === 1 && CustomMap.intrinsics.has(currentValue)) {
-                        return [2 /*return*/, CustomMap.intrinsics.get(currentValue)];
+                        return [2 /*return*/, CustomMap.intrinsics.get(currentValue).bind(null, me)];
                     }
                     else {
                         throw new Error("Cannot get path ".concat(path.join('.')));
@@ -212,7 +212,7 @@ var CustomMap = /** @class */ (function (_super) {
                     }
                     else if (path.length === 1 && CustomMap.intrinsics.has(current)) {
                         return [2 /*return*/, {
-                                origin: CustomMap.intrinsics.get(current),
+                                origin: CustomMap.intrinsics.get(current).bind(null, me),
                                 context: me
                             }];
                     }

package/dist/custom-types/string.js

@@ -120,7 +120,7 @@ var CustomString = /** @class */ (function (_super) {
         return me.value.length === 0 ? null : me.value;
     };
     CustomString.prototype.toString = function () {
-        return "\"".concat(this.value.toString(), "\"");
+        return this.value;
     };
     CustomString.prototype.fork = function () {
         return new CustomString(this.value);

package/dist/expressions/assign.d.ts

@@ -7,6 +7,7 @@ export declare class ExpressionSegment {
     constructor(left: any, right: any);
 }
 export default class AssignExpression extends Expression {
-    constructor(ast: ASTAssignmentStatement, visit: Function);
+    constructor(ast: ASTAssignmentStatement);
+    prepare(visit: Function): Promise<AssignExpression>;
     get(operationContext: OperationContext, parentExpr: any): Promise<any>;
 }

package/dist/expressions/assign.js

@@ -67,16 +67,34 @@ var ExpressionSegment = /** @class */ (function () {
 exports.ExpressionSegment = ExpressionSegment;
 var AssignExpression = /** @class */ (function (_super) {
     __extends(AssignExpression, _super);
-    function AssignExpression(ast, visit) {
+    function AssignExpression(ast) {
         var _this = _super.call(this) || this;
         var me = _this;
-        var buildExpression = function (node) {
-            return new ExpressionSegment(visit(node.variable), visit(node.init));
-        };
         me.ast = ast;
-        me.expr = buildExpression(ast);
+        me.expr = null;
         return _this;
     }
+    AssignExpression.prototype.prepare = function (visit) {
+        return __awaiter(this, void 0, void 0, function () {
+            var me, node, _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        me = this;
+                        node = me.ast;
+                        _a = me;
+                        _b = ExpressionSegment.bind;
+                        return [4 /*yield*/, visit(node.variable)];
+                    case 1:
+                        _c = [void 0, _d.sent()];
+                        return [4 /*yield*/, visit(node.init)];
+                    case 2:
+                        _a.expr = new (_b.apply(ExpressionSegment, _c.concat([_d.sent()])))();
+                        return [2 /*return*/, me];
+                }
+            });
+        });
+    };
     AssignExpression.prototype.get = function (operationContext, parentExpr) {
         return __awaiter(this, void 0, void 0, function () {
             var me, evaluate;

package/dist/expressions/binary-negated-expression.d.ts

@@ -13,6 +13,7 @@ export declare class ExpressionSegment {
 }
 export default class BinaryNegatedExpression extends Expression {
     expr: ExpressionSegment;
-    constructor(ast: ASTUnaryExpression, visit: Function);
+    constructor(ast: ASTUnaryExpression);
+    prepare(visit: Function): Promise<BinaryNegatedExpression>;
     get(operationContext: OperationContext): any;
 }

package/dist/expressions/binary-negated-expression.js

@@ -75,16 +75,32 @@ var ExpressionSegment = /** @class */ (function () {
 exports.ExpressionSegment = ExpressionSegment;
 var BinaryNegatedExpression = /** @class */ (function (_super) {
     __extends(BinaryNegatedExpression, _super);
-    function BinaryNegatedExpression(ast, visit) {
+    function BinaryNegatedExpression(ast) {
         var _this = _super.call(this) || this;
         var me = _this;
-        var buildExpression = function (node) {
-            return new ExpressionSegment(node.operator, visit(node.argument));
-        };
         me.ast = ast;
-        me.expr = buildExpression(ast);
+        me.expr = null;
         return _this;
     }
+    BinaryNegatedExpression.prototype.prepare = function (visit) {
+        return __awaiter(this, void 0, void 0, function () {
+            var me, node, _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        me = this;
+                        node = me.ast;
+                        _a = me;
+                        _b = ExpressionSegment.bind;
+                        _c = [void 0, node.operator];
+                        return [4 /*yield*/, visit(node.argument)];
+                    case 1:
+                        _a.expr = new (_b.apply(ExpressionSegment, _c.concat([_d.sent()])))();
+                        return [2 /*return*/, me];
+                }
+            });
+        });
+    };
     BinaryNegatedExpression.prototype.get = function (operationContext) {
         var me = this;
         var evaluate = function (node) {

package/dist/expressions/call.d.ts

@@ -8,6 +8,7 @@ export declare class ExpressionSegment {
 }
 export default class CallExpression extends Expression {
     expr: ExpressionSegment;
-    constructor(ast: any, visit: Function);
+    constructor(ast: any);
+    prepare(visit: Function): Promise<CallExpression>;
     get(operationContext: OperationContext, parentExpr: any): Promise<any>;
 }

package/dist/expressions/call.js

@@ -105,66 +105,97 @@ var ExpressionSegment = /** @class */ (function () {
 exports.ExpressionSegment = ExpressionSegment;
 var CallExpression = /** @class */ (function (_super) {
     __extends(CallExpression, _super);
-    function CallExpression(ast, visit) {
+    function CallExpression(ast) {
         var _this = _super.call(this) || this;
         var me = _this;
-        var buildExpression = function (node) {
-            if (greyscript_core_1.ASTType.CallStatement === node.type) {
-                return buildExpression(node.expression);
-            }
-            return new ExpressionSegment(visit(node.base), node.arguments.map(function (item) { return visit(item); }));
-        };
         me.ast = ast;
-        me.expr = buildExpression(ast);
+        me.expr = null;
         return _this;
     }
+    CallExpression.prototype.prepare = function (visit) {
+        return __awaiter(this, void 0, void 0, function () {
+            var me, buildExpression, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        me = this;
+                        buildExpression = function (node) {
+                            return __awaiter(this, void 0, void 0, function () {
+                                var _a, _b;
+                                return __generator(this, function (_c) {
+                                    switch (_c.label) {
+                                        case 0:
+                                            if (greyscript_core_1.ASTType.CallStatement === node.type) {
+                                                return [2 /*return*/, buildExpression(node.expression)];
+                                            }
+                                            _a = ExpressionSegment.bind;
+                                            return [4 /*yield*/, visit(node.base)];
+                                        case 1:
+                                            _b = [void 0, _c.sent()];
+                                            return [4 /*yield*/, Promise.all(node.arguments.map(function (item) { return visit(item); }))];
+                                        case 2: return [2 /*return*/, new (_a.apply(ExpressionSegment, _b.concat([_c.sent()])))()];
+                                    }
+                                });
+                            });
+                        };
+                        _a = me;
+                        return [4 /*yield*/, buildExpression(me.ast)];
+                    case 1:
+                        _a.expr = _b.sent();
+                        return [2 /*return*/, me];
+                }
+            });
+        });
+    };
     CallExpression.prototype.get = function (operationContext, parentExpr) {
         var me = this;
         var opc = operationContext.fork(context_1.ContextType.CALL, context_1.ContextState.TEMPORARY);
         var evaluate = function (node) {
             return __awaiter(this, void 0, void 0, function () {
-                var args, pathExpr, callable_1, callable, _a;
-                var _b, _c, _d;
-                return __generator(this, function (_e) {
-                    switch (_e.label) {
+                var args, pathExpr, callable_1, _a, callable, _b;
+                var _c, _d, _e;
+                return __generator(this, function (_f) {
+                    switch (_f.label) {
                         case 0:
                             if (node instanceof expression_1.Expression) {
                                 return [2 /*return*/, node.get(opc)];
                             }
                             return [4 /*yield*/, node.resolveArgs(operationContext)];
                         case 1:
-                            args = _e.sent();
+                            args = _f.sent();
                             return [4 /*yield*/, node.path.get(opc, me.expr)];
                         case 2:
-                            pathExpr = _e.sent();
+                            pathExpr = _f.sent();
                             operationContext.debugger.debug('CallExpression', 'pathExpr', pathExpr);
-                            if (!pathExpr.handle) return [3 /*break*/, 5];
-                            if (!(0, typer_1.isCustomMap)(pathExpr.handle)) return [3 /*break*/, 4];
+                            if (!pathExpr.handle) return [3 /*break*/, 8];
+                            if (!(0, typer_1.isCustomMap)(pathExpr.handle)) return [3 /*break*/, 7];
                             return [4 /*yield*/, pathExpr.handle.getCallable(pathExpr.path)];
                         case 3:
-                            callable_1 = _e.sent();
-                            if (callable_1.origin instanceof operation_1.Operation) {
-                                opc.setMemory('args', args);
-                                return [2 /*return*/, callable_1.origin.run(opc)];
-                            }
-                            else if (callable_1.origin instanceof Function) {
-                                return [2 /*return*/, (_b = callable_1.origin).call.apply(_b, __spreadArray([pathExpr.handle], __read(args), false))];
-                            }
-                            operationContext.debugger.raise('Unexpected handle call', me, callable_1);
-                            _e.label = 4;
-                        case 4: return [2 /*return*/, (0, typer_1.cast)((_c = pathExpr.handle).callMethod.apply(_c, __spreadArray([pathExpr.path], __read(args), false)))];
-                        case 5: return [4 /*yield*/, opc.getCallable(pathExpr.path)];
+                            callable_1 = _f.sent();
+                            if (!(callable_1.origin instanceof operation_1.Operation)) return [3 /*break*/, 4];
+                            opc.setMemory('args', args);
+                            return [2 /*return*/, callable_1.origin.run(opc)];
+                        case 4:
+                            if (!(callable_1.origin instanceof Function)) return [3 /*break*/, 6];
+                            _a = typer_1.cast;
+                            return [4 /*yield*/, (_c = callable_1.origin).call.apply(_c, __spreadArray([pathExpr.handle], __read(args), false))];
+                        case 5: return [2 /*return*/, _a.apply(void 0, [_f.sent()])];
                         case 6:
-                            callable = _e.sent();
+                            operationContext.debugger.raise('Unexpected handle call', me, callable_1);
+                            _f.label = 7;
+                        case 7: return [2 /*return*/, (0, typer_1.cast)((_d = pathExpr.handle).callMethod.apply(_d, __spreadArray([pathExpr.path], __read(args), false)))];
+                        case 8: return [4 /*yield*/, opc.getCallable(pathExpr.path)];
+                        case 9:
+                            callable = _f.sent();
                             opc.setMemory('args', args);
-                            if (!(callable.origin instanceof operation_1.Operation)) return [3 /*break*/, 7];
+                            if (!(callable.origin instanceof operation_1.Operation)) return [3 /*break*/, 10];
                             return [2 /*return*/, callable.origin.run(opc)];
-                        case 7:
-                            if (!(callable.origin instanceof Function)) return [3 /*break*/, 9];
-                            _a = typer_1.cast;
-                            return [4 /*yield*/, (_d = callable.origin).call.apply(_d, __spreadArray([callable.context], __read(args), false))];
-                        case 8: return [2 /*return*/, _a.apply(void 0, [_e.sent()])];
-                        case 9: return [2 /*return*/, (0, typer_1.cast)(callable.origin)];
+                        case 10:
+                            if (!(callable.origin instanceof Function)) return [3 /*break*/, 12];
+                            _b = typer_1.cast;
+                            return [4 /*yield*/, (_e = callable.origin).call.apply(_e, __spreadArray([callable.context], __read(args), false))];
+                        case 11: return [2 /*return*/, _b.apply(void 0, [_f.sent()])];
+                        case 12: return [2 /*return*/, (0, typer_1.cast)(callable.origin)];
                     }
                 });
             });

package/dist/expressions/list.d.ts

@@ -8,6 +8,7 @@ export declare class ExpressionSegment {
 }
 export default class ListExpression extends Expression {
     expr: ExpressionSegment;
-    constructor(ast: ASTListConstructorExpression, visit: Function);
+    constructor(ast: ASTListConstructorExpression);
+    prepare(visit: Function): Promise<ListExpression>;
     get(operationContext: OperationContext, parentExpr: any): Promise<CustomList>;
 }

package/dist/expressions/list.js

@@ -67,18 +67,33 @@ var ExpressionSegment = /** @class */ (function () {
 exports.ExpressionSegment = ExpressionSegment;
 var ListExpression = /** @class */ (function (_super) {
     __extends(ListExpression, _super);
-    function ListExpression(ast, visit) {
+    function ListExpression(ast) {
         var _this = _super.call(this) || this;
         var me = _this;
-        var buildExpression = function (node) {
-            return new ExpressionSegment(node.fields.map(function (item) {
-                return visit(item.value);
-            }));
-        };
         me.ast = ast;
-        me.expr = buildExpression(ast);
+        me.expr = null;
         return _this;
     }
+    ListExpression.prototype.prepare = function (visit) {
+        return __awaiter(this, void 0, void 0, function () {
+            var me, node, _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        me = this;
+                        node = me.ast;
+                        _a = me;
+                        _b = ExpressionSegment.bind;
+                        return [4 /*yield*/, Promise.all(node.fields.map(function (item) {
+                                return visit(item.value);
+                            }))];
+                    case 1:
+                        _a.expr = new (_b.apply(ExpressionSegment, [void 0, _c.sent()]))();
+                        return [2 /*return*/, me];
+                }
+            });
+        });
+    };
     ListExpression.prototype.get = function (operationContext, parentExpr) {
         var me = this;
         var evaluate = function (node) {

package/dist/expressions/logical-and-binary.d.ts

@@ -17,6 +17,7 @@ export declare class ExpressionSegment {
 }
 export default class LogicalAndBinaryExpression extends Expression {
     expr: ExpressionSegment;
-    constructor(ast: ASTEvaluationExpression, visit: Function);
+    constructor(ast: ASTEvaluationExpression);
+    prepare(visit: Function): Promise<LogicalAndBinaryExpression>;
     get(operationContext: OperationContext): Promise<any>;
 }

package/dist/expressions/logical-and-binary.js

@@ -123,16 +123,36 @@ var ExpressionSegment = /** @class */ (function () {
 exports.ExpressionSegment = ExpressionSegment;
 var LogicalAndBinaryExpression = /** @class */ (function (_super) {
     __extends(LogicalAndBinaryExpression, _super);
-    function LogicalAndBinaryExpression(ast, visit) {
+    function LogicalAndBinaryExpression(ast) {
         var _this = _super.call(this) || this;
         var me = _this;
-        var buildExpression = function (node) {
-            return new ExpressionSegment(node.type, node.operator, visit(node.left), visit(node.right));
-        };
         me.ast = ast;
-        me.expr = buildExpression(ast);
+        me.expr = null;
         return _this;
     }
+    LogicalAndBinaryExpression.prototype.prepare = function (visit) {
+        return __awaiter(this, void 0, void 0, function () {
+            var me, node, _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        me = this;
+                        node = me.ast;
+                        _a = me;
+                        _b = ExpressionSegment.bind;
+                        _c = [void 0, node.type,
+                            node.operator];
+                        return [4 /*yield*/, visit(node.left)];
+                    case 1:
+                        _c = _c.concat([_d.sent()]);
+                        return [4 /*yield*/, visit(node.right)];
+                    case 2:
+                        _a.expr = new (_b.apply(ExpressionSegment, _c.concat([_d.sent()])))();
+                        return [2 /*return*/, me];
+                }
+            });
+        });
+    };
     LogicalAndBinaryExpression.prototype.get = function (operationContext) {
         var _this = this;
         var me = this;

package/dist/expressions/map.d.ts

@@ -13,6 +13,7 @@ export declare class ExpressionSegment {
 }
 export default class MapExpression extends Expression {
     expr: ExpressionSegment;
-    constructor(ast: ASTMapConstructorExpression, visit: Function);
+    constructor(ast: ASTMapConstructorExpression);
+    prepare(visit: Function): Promise<MapExpression>;
     get(operationContext: OperationContext, parentExpr: any): Promise<CustomMap>;
 }

package/dist/expressions/map.js

@@ -87,21 +87,46 @@ var ExpressionSegment = /** @class */ (function () {
 exports.ExpressionSegment = ExpressionSegment;
 var MapExpression = /** @class */ (function (_super) {
     __extends(MapExpression, _super);
-    function MapExpression(ast, visit) {
+    function MapExpression(ast) {
         var _this = _super.call(this) || this;
         var me = _this;
-        var buildExpression = function (node) {
-            return new ExpressionSegment(node.fields.map(function (item) {
-                return {
-                    key: visit(item.key),
-                    value: visit(item.value)
-                };
-            }));
-        };
         me.ast = ast;
-        me.expr = buildExpression(ast);
+        me.expr = null;
         return _this;
     }
+    MapExpression.prototype.prepare = function (visit) {
+        return __awaiter(this, void 0, void 0, function () {
+            var me, node, _a, _b;
+            var _this = this;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        me = this;
+                        node = me.ast;
+                        _a = me;
+                        _b = ExpressionSegment.bind;
+                        return [4 /*yield*/, Promise.all(node.fields.map(function (item) { return __awaiter(_this, void 0, void 0, function () {
+                                var _a;
+                                return __generator(this, function (_b) {
+                                    switch (_b.label) {
+                                        case 0:
+                                            _a = {};
+                                            return [4 /*yield*/, visit(item.key)];
+                                        case 1:
+                                            _a.key = _b.sent();
+                                            return [4 /*yield*/, visit(item.value)];
+                                        case 2: return [2 /*return*/, (_a.value = _b.sent(),
+                                                _a)];
+                                    }
+                                });
+                            }); }))];
+                    case 1:
+                        _a.expr = new (_b.apply(ExpressionSegment, [void 0, _c.sent()]))();
+                        return [2 /*return*/, me];
+                }
+            });
+        });
+    };
     MapExpression.prototype.get = function (operationContext, parentExpr) {
         var me = this;
         var evaluate = function (values) {

package/dist/expressions/path.d.ts

@@ -25,6 +25,7 @@ export declare class ExpressionSegment {
 }
 export default class PathExpression extends Expression {
     expr: ExpressionSegment;
-    constructor(ast: ASTBase, visit: Function);
+    constructor(ast: ASTBase);
+    prepare(visit: Function): Promise<PathExpression>;
     get(operationContext: OperationContext, parentExpr: any): Promise<any>;
 }