xmlui 0.4.0

package/dist/scripts/src/parsers/scripting/ParserError.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorMessages = exports.ParserError = void 0;
+// The common root class of all parser error objects
+class ParserError extends Error {
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        // --- Set the prototype explicitly.
+        Object.setPrototypeOf(this, ParserError.prototype);
+    }
+}
+exports.ParserError = ParserError;
+// The error messages of error codes
+exports.errorMessages = {
+    W001: "An expression expected",
+    W002: "Unexpected token: {0}",
+    W003: "An identifier expected",
+    W004: "'}' expected",
+    W005: "']' expected",
+    W006: "')' expected",
+    W007: "Invalid object property name type",
+    W008: "':' expected",
+    W009: "'=' expected",
+    W010: "Invalid argument list",
+    W011: "For loop variable must be initialized",
+    W012: "'{' expected",
+    W013: "'catch' or 'finally' expected",
+    W014: "'(' or expected",
+    W015: "'case' or 'default' expected",
+    W016: "'default' case can be used only once within a switch statement",
+    W017: "Invalid sequence expression",
+    W018: "Invalid object literal",
+    W019: "Identifier '{0}' is already imported",
+    W020: "Function '{0}' is already defined in the module",
+    W021: "'{0}' is already exported from the module",
+    W022: "Cannot find module '{0}'",
+    W023: "Module '{0}' does not export '{1}'",
+    W024: "'function' or 'const' expected",
+    W025: "'from' expected",
+    W026: "A string literal expected",
+    W027: "Variables can be declared only in the top level module",
+    W028: "Invalid statement used in a module: '{0}'",
+    W029: "An imported module can contain only exported functions",
+    W030: "Nested declarations cannot be exported",
+};

package/dist/scripts/src/parsers/scripting/TokenTrait.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tokenTraits = void 0;
+const Token_1 = require("../../abstractions/scripting/Token");
+// Individual traits of tokens
+exports.tokenTraits = {
+    [Token_1.TokenType.Eof]: {},
+    [Token_1.TokenType.Ws]: {},
+    [Token_1.TokenType.BlockComment]: {},
+    [Token_1.TokenType.EolComment]: {},
+    [Token_1.TokenType.Unknown]: {},
+    [Token_1.TokenType.LParent]: { expressionStart: true },
+    [Token_1.TokenType.RParent]: {},
+    [Token_1.TokenType.Identifier]: { expressionStart: true, keywordLike: true, isPropLiteral: true },
+    [Token_1.TokenType.Exponent]: {},
+    [Token_1.TokenType.Divide]: {},
+    [Token_1.TokenType.Multiply]: {},
+    [Token_1.TokenType.Remainder]: {},
+    [Token_1.TokenType.Plus]: { expressionStart: true, canBeUnary: true },
+    [Token_1.TokenType.Minus]: { expressionStart: true, canBeUnary: true },
+    [Token_1.TokenType.BitwiseXor]: {},
+    [Token_1.TokenType.BitwiseOr]: {},
+    [Token_1.TokenType.LogicalOr]: {},
+    [Token_1.TokenType.BitwiseAnd]: {},
+    [Token_1.TokenType.LogicalAnd]: {},
+    [Token_1.TokenType.Assignment]: { isAssignment: true },
+    [Token_1.TokenType.AddAssignment]: { isAssignment: true },
+    [Token_1.TokenType.SubtractAssignment]: { isAssignment: true },
+    [Token_1.TokenType.ExponentAssignment]: { isAssignment: true },
+    [Token_1.TokenType.MultiplyAssignment]: { isAssignment: true },
+    [Token_1.TokenType.DivideAssignment]: { isAssignment: true },
+    [Token_1.TokenType.RemainderAssignment]: { isAssignment: true },
+    [Token_1.TokenType.ShiftLeftAssignment]: { isAssignment: true },
+    [Token_1.TokenType.ShiftRightAssignment]: { isAssignment: true },
+    [Token_1.TokenType.SignedShiftRightAssignment]: { isAssignment: true },
+    [Token_1.TokenType.BitwiseAndAssignment]: { isAssignment: true },
+    [Token_1.TokenType.BitwiseXorAssignment]: { isAssignment: true },
+    [Token_1.TokenType.BitwiseOrAssignment]: { isAssignment: true },
+    [Token_1.TokenType.LogicalAndAssignment]: { isAssignment: true },
+    [Token_1.TokenType.LogicalOrAssignment]: { isAssignment: true },
+    [Token_1.TokenType.NullCoalesceAssignment]: { isAssignment: true },
+    [Token_1.TokenType.Semicolon]: {},
+    [Token_1.TokenType.Comma]: {},
+    [Token_1.TokenType.Colon]: {},
+    [Token_1.TokenType.LSquare]: { expressionStart: true },
+    [Token_1.TokenType.RSquare]: {},
+    [Token_1.TokenType.QuestionMark]: {},
+    [Token_1.TokenType.NullCoalesce]: {},
+    [Token_1.TokenType.OptionalChaining]: {},
+    [Token_1.TokenType.BinaryNot]: { expressionStart: true, canBeUnary: true },
+    [Token_1.TokenType.LBrace]: { expressionStart: true },
+    [Token_1.TokenType.RBrace]: {},
+    [Token_1.TokenType.Equal]: {},
+    [Token_1.TokenType.StrictEqual]: {},
+    [Token_1.TokenType.LogicalNot]: { expressionStart: true, canBeUnary: true },
+    [Token_1.TokenType.NotEqual]: {},
+    [Token_1.TokenType.StrictNotEqual]: {},
+    [Token_1.TokenType.LessThan]: {},
+    [Token_1.TokenType.LessThanOrEqual]: {},
+    [Token_1.TokenType.ShiftLeft]: {},
+    [Token_1.TokenType.GreaterThan]: {},
+    [Token_1.TokenType.GreaterThanOrEqual]: {},
+    [Token_1.TokenType.ShiftRight]: {},
+    [Token_1.TokenType.SignedShiftRight]: {},
+    [Token_1.TokenType.Dot]: {},
+    [Token_1.TokenType.Spread]: { expressionStart: true, isPropLiteral: true },
+    [Token_1.TokenType.Global]: { expressionStart: true },
+    [Token_1.TokenType.DecimalLiteral]: { expressionStart: true, isPropLiteral: true },
+    [Token_1.TokenType.HexadecimalLiteral]: { expressionStart: true, isPropLiteral: true },
+    [Token_1.TokenType.BinaryLiteral]: { expressionStart: true, isPropLiteral: true },
+    [Token_1.TokenType.RealLiteral]: { expressionStart: true, isPropLiteral: true },
+    [Token_1.TokenType.StringLiteral]: { expressionStart: true, isPropLiteral: true },
+    [Token_1.TokenType.IncOp]: { expressionStart: true },
+    [Token_1.TokenType.DecOp]: { expressionStart: true },
+    [Token_1.TokenType.Infinity]: { expressionStart: true, keywordLike: true },
+    [Token_1.TokenType.NaN]: { expressionStart: true, keywordLike: true },
+    [Token_1.TokenType.True]: { expressionStart: true, keywordLike: true, isPropLiteral: true },
+    [Token_1.TokenType.False]: { expressionStart: true, keywordLike: true, isPropLiteral: true },
+    [Token_1.TokenType.Typeof]: { expressionStart: true, canBeUnary: true, keywordLike: true },
+    [Token_1.TokenType.Null]: { expressionStart: true, keywordLike: true },
+    [Token_1.TokenType.Undefined]: { expressionStart: true, keywordLike: true },
+    [Token_1.TokenType.In]: { keywordLike: true },
+    [Token_1.TokenType.Let]: { keywordLike: true },
+    [Token_1.TokenType.Const]: { keywordLike: true },
+    [Token_1.TokenType.Var]: { keywordLike: true },
+    [Token_1.TokenType.If]: { keywordLike: true },
+    [Token_1.TokenType.Else]: { keywordLike: true },
+    [Token_1.TokenType.Arrow]: { keywordLike: true },
+    [Token_1.TokenType.Return]: { keywordLike: true },
+    [Token_1.TokenType.Break]: { keywordLike: true },
+    [Token_1.TokenType.Continue]: { keywordLike: true },
+    [Token_1.TokenType.Do]: { keywordLike: true },
+    [Token_1.TokenType.While]: { keywordLike: true },
+    [Token_1.TokenType.For]: { keywordLike: true },
+    [Token_1.TokenType.Of]: { keywordLike: true },
+    [Token_1.TokenType.Throw]: { keywordLike: true },
+    [Token_1.TokenType.Try]: { keywordLike: true },
+    [Token_1.TokenType.Catch]: { keywordLike: true },
+    [Token_1.TokenType.Finally]: { keywordLike: true },
+    [Token_1.TokenType.Switch]: { keywordLike: true },
+    [Token_1.TokenType.Case]: { keywordLike: true },
+    [Token_1.TokenType.Default]: { keywordLike: true },
+    [Token_1.TokenType.Delete]: { expressionStart: true, canBeUnary: true, keywordLike: true },
+    [Token_1.TokenType.Function]: { keywordLike: true },
+    [Token_1.TokenType.Export]: { keywordLike: true },
+    [Token_1.TokenType.Import]: { keywordLike: true },
+    [Token_1.TokenType.As]: { keywordLike: true },
+    [Token_1.TokenType.From]: { keywordLike: true },
+};

package/dist/scripts/src/parsers/scripting/code-behind-collect.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PARSED_MARK_PROP = void 0;
+exports.collectCodeBehindFromSource = collectCodeBehindFromSource;
+exports.removeCodeBehindTokensFromTree = removeCodeBehindTokensFromTree;
+const tree_visitor_1 = require("./tree-visitor");
+const modules_1 = require("../../components-core/script-runner/modules");
+const eval_tree_common_1 = require("../../components-core/script-runner/eval-tree-common");
+exports.PARSED_MARK_PROP = "__PARSED__";
+// --- Collect module statements from a parsed module
+function collectCodeBehindFromSource(moduleName, source, moduleResolver, evalContext) {
+    const result = {
+        vars: {},
+        moduleErrors: {},
+        functions: {},
+    };
+    // --- Parse the module (recursively, including imported modules) in restrictive mode
+    const parsedModule = (0, modules_1.parseScriptModule)(moduleName, source, moduleResolver, true);
+    if ((0, modules_1.isModuleErrors)(parsedModule)) {
+        return Object.assign(Object.assign({}, result), { moduleErrors: parsedModule });
+    }
+    // --- Collect imported functions
+    if (parsedModule.imports) {
+        Object.keys(parsedModule.imports).forEach((key) => {
+            const obj = parsedModule.imports[key];
+            if (obj.type === "FuncD") {
+                addFunctionDeclaration(obj);
+            }
+        });
+    }
+    // --- Collect statements from the module
+    parsedModule.statements.forEach((stmt) => {
+        switch (stmt.type) {
+            case "VarS":
+                stmt.declarations.forEach((decl) => {
+                    if (decl.id in result.vars) {
+                        throw new Error(`Duplicated var declaration: '${decl.id}'`);
+                    }
+                    result.vars[decl.id] = {
+                        [exports.PARSED_MARK_PROP]: true,
+                        source: decl.expression.source,
+                        tree: decl.expression,
+                    };
+                });
+                break;
+            case "FuncD":
+                addFunctionDeclaration(stmt);
+                break;
+            case "ImportD":
+                // --- Do nothing
+                break;
+            default:
+                throw new Error(`'${stmt.type}' is not allowed in a code-behind module.`);
+        }
+    });
+    return result;
+    // --- Collect function declaration data
+    function addFunctionDeclaration(stmt) {
+        var _a, _b;
+        if (stmt.name in result.functions) {
+            throw new Error(`Duplicated function declaration: '${stmt.name}'`);
+        }
+        const funcSource = stmt.args.length === 1
+            ? `${stmt.args[0].source} => ${stmt.statement.source}`
+            : `(${stmt.args.map((a) => a.source).join(", ")}) => ${stmt.statement.source}`;
+        const arrow = {
+            type: "ArrowE",
+            args: stmt.args.slice(),
+            statement: stmt.statement,
+            closureContext: (0, eval_tree_common_1.obtainClosures)(evalContext.mainThread),
+        };
+        // --- Remove the circular reference from the function to its closure context
+        const functionSelf = (_b = (_a = arrow.closureContext[0]) === null || _a === void 0 ? void 0 : _a.vars) === null || _b === void 0 ? void 0 : _b[stmt.name];
+        if (functionSelf === null || functionSelf === void 0 ? void 0 : functionSelf.closureContext) {
+            delete functionSelf.closureContext;
+        }
+        result.functions[stmt.name] = {
+            [exports.PARSED_MARK_PROP]: true,
+            source: funcSource,
+            tree: arrow,
+        };
+    }
+}
+// --- Remove all code-behind tokens from the tree
+function removeCodeBehindTokensFromTree(declarations) {
+    if (!declarations)
+        return;
+    const state = {
+        data: null,
+        cancel: false,
+        skipChildren: false,
+    };
+    Object.keys(declarations.vars).forEach((key) => {
+        removeTokens(declarations.vars[key]);
+    });
+    Object.keys(declarations.functions).forEach((key) => {
+        removeTokens(declarations.functions[key]);
+    });
+    function removeTokens(declaration) {
+        const nodeVisitor = (before, visited, state) => {
+            if (before) {
+                if (visited) {
+                    delete visited.startPosition;
+                    delete visited.endPosition;
+                    delete visited.startLine;
+                    delete visited.endLine;
+                    delete visited.startColumn;
+                    delete visited.endColumn;
+                    delete visited.startToken;
+                    delete visited.endToken;
+                    // delete visited.source;
+                }
+            }
+            return state;
+        };
+        (0, tree_visitor_1.visitNode)(declaration.tree, state, nodeVisitor, nodeVisitor);
+    }
+}