greybel-interpreter 0.1.6 → 0.2.0

package/dist/expressions/path.js

@@ -96,47 +96,100 @@ var ExpressionSegment = /** @class */ (function () {
 exports.ExpressionSegment = ExpressionSegment;
 var PathExpression = /** @class */ (function (_super) {
     __extends(PathExpression, _super);
-    function PathExpression(ast, visit) {
+    function PathExpression(ast) {
         var _this = _super.call(this) || this;
         var me = _this;
-        var buildExpression = function (node) {
-            var _a;
-            var expression = new ExpressionSegment();
-            switch (node.type) {
-                case greyscript_core_1.ASTType.MemberExpression:
-                    var memberExpression = node;
-                    expression.append(buildExpression(memberExpression.base));
-                    expression.append(buildExpression(memberExpression.identifier));
-                    break;
-                case greyscript_core_1.ASTType.IndexExpression:
-                    var indexExpression = node;
-                    expression.append(buildExpression(indexExpression.base));
-                    if (((_a = indexExpression.index) === null || _a === void 0 ? void 0 : _a.type) === 'SliceExpression') {
-                        var sliceExpression = indexExpression.index;
-                        expression.append(new SliceSegment(visit(sliceExpression.left), visit(sliceExpression.right)));
-                    }
-                    else {
-                        expression.append(new IndexSegment(visit(indexExpression.index)));
-                    }
-                    break;
-                case greyscript_core_1.ASTType.Identifier:
-                    var identifier = node;
-                    expression.append(new PathSegment(identifier.name));
-                    break;
-                default:
-                    expression.append(visit(node));
-            }
-            return expression;
-        };
         me.ast = ast;
-        me.expr = buildExpression(ast);
+        me.expr = null;
         return _this;
     }
-    PathExpression.prototype.get = function (operationContext, parentExpr) {
+    PathExpression.prototype.prepare = function (visit) {
         return __awaiter(this, void 0, void 0, function () {
-            var me, evaluate, resultExpr, context, value_1, value, callable, _a;
+            var me, buildExpression, _a;
             return __generator(this, function (_b) {
                 switch (_b.label) {
+                    case 0:
+                        me = this;
+                        buildExpression = function (node) {
+                            var _a;
+                            return __awaiter(this, void 0, void 0, function () {
+                                var expression, _b, memberExpression, _c, _d, _e, _f, indexExpression, _g, _h, sliceExpression, _j, _k, _l, _m, _o, _p, _q, identifier, _r, _s;
+                                return __generator(this, function (_t) {
+                                    switch (_t.label) {
+                                        case 0:
+                                            expression = new ExpressionSegment();
+                                            _b = node.type;
+                                            switch (_b) {
+                                                case greyscript_core_1.ASTType.MemberExpression: return [3 /*break*/, 1];
+                                                case greyscript_core_1.ASTType.IndexExpression: return [3 /*break*/, 4];
+                                                case greyscript_core_1.ASTType.Identifier: return [3 /*break*/, 11];
+                                            }
+                                            return [3 /*break*/, 12];
+                                        case 1:
+                                            memberExpression = node;
+                                            _d = (_c = expression).append;
+                                            return [4 /*yield*/, buildExpression(memberExpression.base)];
+                                        case 2:
+                                            _d.apply(_c, [_t.sent()]);
+                                            _f = (_e = expression).append;
+                                            return [4 /*yield*/, buildExpression(memberExpression.identifier)];
+                                        case 3:
+                                            _f.apply(_e, [_t.sent()]);
+                                            return [3 /*break*/, 14];
+                                        case 4:
+                                            indexExpression = node;
+                                            _h = (_g = expression).append;
+                                            return [4 /*yield*/, buildExpression(indexExpression.base)];
+                                        case 5:
+                                            _h.apply(_g, [_t.sent()]);
+                                            if (!(((_a = indexExpression.index) === null || _a === void 0 ? void 0 : _a.type) === 'SliceExpression')) return [3 /*break*/, 8];
+                                            sliceExpression = indexExpression.index;
+                                            _k = (_j = expression).append;
+                                            _l = SliceSegment.bind;
+                                            return [4 /*yield*/, visit(sliceExpression.left)];
+                                        case 6:
+                                            _m = [void 0, _t.sent()];
+                                            return [4 /*yield*/, visit(sliceExpression.right)];
+                                        case 7:
+                                            _k.apply(_j, [new (_l.apply(SliceSegment, _m.concat([_t.sent()])))()]);
+                                            return [3 /*break*/, 10];
+                                        case 8:
+                                            _p = (_o = expression).append;
+                                            _q = IndexSegment.bind;
+                                            return [4 /*yield*/, visit(indexExpression.index)];
+                                        case 9:
+                                            _p.apply(_o, [new (_q.apply(IndexSegment, [void 0, _t.sent()]))()]);
+                                            _t.label = 10;
+                                        case 10: return [3 /*break*/, 14];
+                                        case 11:
+                                            identifier = node;
+                                            expression.append(new PathSegment(identifier.name));
+                                            return [3 /*break*/, 14];
+                                        case 12:
+                                            _s = (_r = expression).append;
+                                            return [4 /*yield*/, visit(node)];
+                                        case 13:
+                                            _s.apply(_r, [_t.sent()]);
+                                            _t.label = 14;
+                                        case 14: return [2 /*return*/, expression];
+                                    }
+                                });
+                            });
+                        };
+                        _a = me;
+                        return [4 /*yield*/, buildExpression(me.ast)];
+                    case 1:
+                        _a.expr = _b.sent();
+                        return [2 /*return*/, me];
+                }
+            });
+        });
+    };
+    PathExpression.prototype.get = function (operationContext, parentExpr) {
+        return __awaiter(this, void 0, void 0, function () {
+            var me, evaluate, resultExpr, context, value_1, _a, value, callable, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
                     case 0:
                         me = this;
                         evaluate = function (node) {
@@ -265,7 +318,7 @@ var PathExpression = /** @class */ (function (_super) {
                         operationContext.debugger.debug('PathExpression', 'get', 'expr', me.expr);
                         return [4 /*yield*/, evaluate(me.expr)];
                     case 1:
-                        resultExpr = _b.sent();
+                        resultExpr = _c.sent();
                         if (!!parentExpr) return [3 /*break*/, 14];
                         if (!resultExpr.handle) return [3 /*break*/, 8];
                         if (!(resultExpr.path.length === 0)) return [3 /*break*/, 2];
@@ -275,30 +328,31 @@ var PathExpression = /** @class */ (function (_super) {
                         context = resultExpr.handle;
                         return [4 /*yield*/, context.get(resultExpr.path)];
                     case 3:
-                        value_1 = _b.sent();
+                        value_1 = _c.sent();
                         if (!(value_1 instanceof operation_1.Operation)) return [3 /*break*/, 4];
                         return [2 /*return*/, value_1.run(operationContext)];
                     case 4:
                         if (!(value_1 instanceof Function)) return [3 /*break*/, 6];
+                        _a = typer_1.cast;
                         return [4 /*yield*/, value_1.call(context)];
-                    case 5: return [2 /*return*/, _b.sent()];
+                    case 5: return [2 /*return*/, _a.apply(void 0, [_c.sent()])];
                     case 6: return [2 /*return*/, value_1];
                     case 7: return [2 /*return*/, (0, typer_1.cast)(resultExpr.handle.callMethod(resultExpr.path))];
                     case 8: return [4 /*yield*/, operationContext.get(resultExpr.path)];
                     case 9:
-                        value = _b.sent();
+                        value = _c.sent();
                         if (!(value instanceof Function)) return [3 /*break*/, 12];
                         return [4 /*yield*/, operationContext.getCallable(resultExpr.path)];
                     case 10:
-                        callable = _b.sent();
-                        _a = typer_1.cast;
+                        callable = _c.sent();
+                        _b = typer_1.cast;
                         return [4 /*yield*/, callable.origin.call(callable.context)];
-                    case 11: return [2 /*return*/, _a.apply(void 0, [_b.sent()])];
+                    case 11: return [2 /*return*/, _b.apply(void 0, [_c.sent()])];
                     case 12:
                         if (value instanceof operation_1.Operation) {
                             return [2 /*return*/, value.run(operationContext)];
                         }
-                        _b.label = 13;
+                        _c.label = 13;
                     case 13: return [2 /*return*/, value];
                     case 14: return [2 /*return*/, resultExpr];
                 }

package/dist/interpreter.d.ts

@@ -10,7 +10,7 @@ export interface InterpreterOptions {
 }
 export default class Interpreter {
     target: string;
-    code: string;
+    code: string | null;
     api: Map<string, any>;
     params: any[];
     resourceHandler: ResourceHandler;

package/dist/interpreter.js

@@ -1,4 +1,40 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -20,7 +56,7 @@ var Interpreter = /** @class */ (function () {
         me.context = null;
         if (options.target) {
             me.target = options.target;
-            me.code = me.resourceHandler.get(options.target);
+            me.code = null;
         }
         else {
             me.target = 'unknown';
@@ -28,28 +64,49 @@ var Interpreter = /** @class */ (function () {
         }
     }
     Interpreter.prototype.digest = function () {
-        var me = this;
-        var parser = new greybel_core_1.Parser(me.code);
-        var chunk = parser.parseChunk();
-        var cps = new cps_1.default({
-            target: me.target,
-            resourceHandler: me.resourceHandler
-        });
-        var mainContext = new context_1.OperationContext({
-            isProtected: true,
-            debugger: me.debugger,
-            cps: cps
-        });
-        var topOperation = new top_1.default(null, {
-            body: cps.visit(chunk)
-        });
-        mainContext.extend(me.api);
-        mainContext.scope.refs.set('params', (0, typer_1.cast)(me.params));
-        me.context = mainContext;
-        return topOperation.run(mainContext)
-            .catch(function (err) {
-            console.error(err);
-            throw err;
+        return __awaiter(this, void 0, void 0, function () {
+            var me, code, _a, parser, chunk, cps, mainContext, topOperation, _b, _c;
+            var _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        me = this;
+                        _a = me.code;
+                        if (_a) return [3 /*break*/, 2];
+                        return [4 /*yield*/, me.resourceHandler.get(me.target)];
+                    case 1:
+                        _a = (_e.sent());
+                        _e.label = 2;
+                    case 2:
+                        code = _a;
+                        parser = new greybel_core_1.Parser(code);
+                        chunk = parser.parseChunk();
+                        cps = new cps_1.default({
+                            target: me.target,
+                            resourceHandler: me.resourceHandler
+                        });
+                        mainContext = new context_1.OperationContext({
+                            isProtected: true,
+                            debugger: me.debugger,
+                            cps: cps
+                        });
+                        _b = top_1.default.bind;
+                        _c = [void 0, null];
+                        _d = {};
+                        return [4 /*yield*/, cps.visit(chunk)];
+                    case 3:
+                        topOperation = new (_b.apply(top_1.default, _c.concat([(_d.body = _e.sent(),
+                                _d)])))();
+                        mainContext.extend(me.api);
+                        mainContext.scope.refs.set('params', (0, typer_1.cast)(me.params));
+                        me.context = mainContext;
+                        return [2 /*return*/, topOperation.run(mainContext)
+                                .catch(function (err) {
+                                console.error(err);
+                                throw err;
+                            })];
+                }
+            });
         });
     };
     Interpreter.prototype.exit = function () {

package/dist/resource.d.ts

@@ -1,8 +1,8 @@
 export interface ResourceHandler {
-    getTargetRelativeTo(source: string, target: string): string;
-    has(target: string): boolean;
-    get(target: string): string;
-    resolve(target: string): string;
+    getTargetRelativeTo(source: string, target: string): Promise<string>;
+    has(target: string): Promise<boolean>;
+    get(target: string): Promise<string>;
+    resolve(target: string): Promise<string>;
 }
 export declare class ResourceProvider {
     getHandler(): ResourceHandler;

package/dist/resource.js

@@ -11,16 +11,16 @@ var ResourceProvider = /** @class */ (function () {
             getTargetRelativeTo: function (source, target) {
                 var base = path.resolve(source, '..');
                 var result = path.resolve(base, target);
-                return fs.existsSync(result) ? result : result + '.src';
+                return Promise.resolve(fs.existsSync(result) ? result : result + '.src');
             },
             has: function (target) {
-                return fs.existsSync(target);
+                return Promise.resolve(fs.existsSync(target));
             },
             get: function (target) {
-                return fs.readFileSync(target, 'utf8');
+                return Promise.resolve(fs.readFileSync(target, 'utf8'));
             },
             resolve: function (target) {
-                return path.resolve(target);
+                return Promise.resolve(path.resolve(target));
             }
         };
     };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "greybel-interpreter",
-    "version": "0.1.6",
+    "version": "0.2.0",
     "description": "Interpreter",
     "main": "dist/index",
     "typings": "dist/index",