xmlui 0.8.6 → 0.9.1

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

@@ -0,0 +1,47 @@
+"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' expected",
+    W025: "'from' expected",
+    W026: "A string literal expected",
+    W027: "Cannot declare var ('{0}') in an imported module",
+    W028: "Invalid statement used in a module.",
+    W029: "An imported module can contain only exported functions",
+    W030: "Nested declarations cannot be exported",
+    W031: "An identifier in a declaration cannot start with '$'"
+};

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

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

package/dist/scripts/src/parsers/scripting-exp/TokenType.js

@@ -105,8 +105,6 @@ var TokenType;
     TokenType[TokenType["Default"] = 93] = "Default";
     TokenType[TokenType["Delete"] = 94] = "Delete";
     TokenType[TokenType["Function"] = 95] = "Function";
-    TokenType[TokenType["Export"] = 96] = "Export";
-    TokenType[TokenType["Import"] = 97] = "Import";
-    TokenType[TokenType["As"] = 98] = "As";
-    TokenType[TokenType["From"] = 99] = "From";
+    TokenType[TokenType["As"] = 96] = "As";
+    TokenType[TokenType["From"] = 97] = "From";
 })(TokenType || (exports.TokenType = TokenType = {}));

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

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PARSED_MARK_PROP = void 0;
+exports.collectCodeBehindFromSource = collectCodeBehindFromSource;
+exports.removeCodeBehindTokensFromTree = removeCodeBehindTokensFromTree;
+const ScriptingSourceTreeExp_1 = require("../../abstractions/scripting/ScriptingSourceTreeExp");
+const tree_visitor_1 = require("./tree-visitor");
+const modules_1 = require("./modules");
+exports.PARSED_MARK_PROP = "__PARSED__";
+// --- Collect module statements from a parsed module
+function collectCodeBehindFromSource(moduleName, source) {
+    const result = {
+        vars: {},
+        moduleErrors: {},
+        functions: {},
+    };
+    const collectedFunctions = {};
+    // --- Parse the module (recursively, including imported modules) in restrictive mode
+    const parsedModule = (0, modules_1.parseScriptModule)(moduleName, source);
+    if ((0, modules_1.isModuleErrors)(parsedModule)) {
+        return Object.assign(Object.assign({}, result), { moduleErrors: parsedModule });
+    }
+    // --- Collect statements from the module
+    parsedModule.statements.forEach((stmt) => {
+        switch (stmt.type) {
+            case ScriptingSourceTreeExp_1.T_VAR_STATEMENT:
+                stmt.decls.forEach((decl) => {
+                    if (decl.id.name in result.vars) {
+                        throw new Error(`Duplicated var declaration: '${decl.id.name}'`);
+                    }
+                    result.vars[decl.id.name] = {
+                        [exports.PARSED_MARK_PROP]: true,
+                        tree: decl.expr,
+                    };
+                });
+                break;
+            case ScriptingSourceTreeExp_1.T_FUNCTION_DECLARATION:
+                addFunctionDeclaration(stmt);
+                break;
+            default:
+                throw new Error(`'${stmt.type}' is not allowed in a code-behind module.`);
+        }
+    });
+    return result;
+    // --- Collect function declaration data
+    function addFunctionDeclaration(stmt) {
+        if ((collectedFunctions === null || collectedFunctions === void 0 ? void 0 : collectedFunctions[stmt.id.name]) !== undefined) {
+            return;
+        }
+        if (stmt.id.name in result.functions) {
+            throw new Error(`Duplicated function declaration: '${stmt.id.name}'`);
+        }
+        const arrow = {
+            type: ScriptingSourceTreeExp_1.T_ARROW_EXPRESSION,
+            args: stmt.args.slice(),
+            statement: stmt.stmt,
+            // closureContext: obtainClosures({
+            //   childThreads: [],
+            //   blocks: [{ vars: {} }],
+            //   loops: [],
+            //   breakLabelValue: -1,
+            // }),
+        };
+        collectedFunctions[stmt.id.name] = {
+            [exports.PARSED_MARK_PROP]: true,
+            tree: arrow,
+        };
+        result.functions[stmt.id.name] = {
+            [exports.PARSED_MARK_PROP]: true,
+            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.startToken;
+                    delete visited.endToken;
+                }
+            }
+            return state;
+        };
+        (0, tree_visitor_1.visitNode)(declaration.tree, state, nodeVisitor, nodeVisitor);
+    }
+}

package/dist/scripts/src/parsers/scripting-exp/modules.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isModuleErrors = isModuleErrors;
+exports.parseScriptModule = parseScriptModule;
+const ScriptingSourceTreeExp_1 = require("../../abstractions/scripting/ScriptingSourceTreeExp");
+const Parser_1 = require("./Parser");
+const ParserError_1 = require("./ParserError");
+const TokenType_1 = require("./TokenType");
+/**
+ * Checks if the result is a module error
+ * @param result Result to check
+ * @returns True if the result is a module error
+ */
+function isModuleErrors(result) {
+    return result.type !== "ScriptModule";
+}
+/**
+ * Parses a script module
+ * @param moduleName Name of the module
+ * @param source Source code to parse
+ * @param moduleResolver A function that resolves a module path to the text of the module
+ * @returns The parsed and resolved module
+ */
+function parseScriptModule(moduleName, source) {
+    // --- Keep track of parsed modules to avoid circular references
+    const parsedModules = new Map();
+    const moduleErrors = {};
+    const parsedModule = doParseModule(moduleName, source);
+    return !parsedModule || Object.keys(moduleErrors).length > 0 ? moduleErrors : parsedModule;
+    // --- Do the parsing, allow recursion
+    function doParseModule(moduleName, source) {
+        var _a;
+        // --- Do not parse the same module twice
+        if (parsedModules.has(moduleName)) {
+            return parsedModules.get(moduleName);
+        }
+        // --- Parse the source code
+        const parser = new Parser_1.Parser(source);
+        let statements = [];
+        try {
+            statements = parser.parseStatements();
+        }
+        catch (error) {
+            moduleErrors[moduleName] = parser.errors;
+            return null;
+        }
+        // --- Check for unparsed tail
+        const lastToken = parser.current;
+        if (lastToken.type !== TokenType_1.TokenType.Eof) {
+            (_a = moduleErrors[moduleName]) !== null && _a !== void 0 ? _a : (moduleErrors[moduleName] = []);
+            moduleErrors[moduleName].push({
+                code: "W002",
+                text: ParserError_1.errorMessages["W002"].replace(/\{(\d+)}/g, () => lastToken.text),
+                position: lastToken.startLine,
+                line: lastToken.startLine,
+                column: lastToken.startColumn,
+            });
+            return null;
+        }
+        const errors = [];
+        // --- Collect functions
+        const functions = {};
+        statements
+            .filter((stmt) => stmt.type === ScriptingSourceTreeExp_1.T_FUNCTION_DECLARATION)
+            .forEach((stmt) => {
+            const func = stmt;
+            if (functions[func.id.name]) {
+                addErrorMessage("W020", stmt, func.id.name);
+                return;
+            }
+            functions[func.id.name] = func;
+        });
+        // --- Successful module parsing
+        const parsedModule = {
+            type: "ScriptModule",
+            name: moduleName,
+            exports,
+            functions,
+            statements: statements,
+            sources: new Map(),
+            executed: false,
+        };
+        // --- Sign this module as parsed
+        parsedModules.set(moduleName, parsedModule);
+        // --- Catch errors
+        if (errors.length > 0) {
+            moduleErrors[moduleName] = errors;
+            return null;
+        }
+        // --- Done.
+        return parsedModule;
+        function addErrorMessage(code, stmt, ...args) {
+            var _a, _b, _c;
+            let errorText = ParserError_1.errorMessages[code];
+            if (args) {
+                args.forEach((o, idx) => (errorText = errorText.replaceAll(`{${idx}}`, args[idx].toString())));
+            }
+            errors.push({
+                code,
+                text: ParserError_1.errorMessages[code].replace(/\{(\d+)}/g, (_, index) => args[index]),
+                position: (_a = stmt.startToken) === null || _a === void 0 ? void 0 : _a.startPosition,
+                line: (_b = stmt.startToken) === null || _b === void 0 ? void 0 : _b.startLine,
+                column: (_c = stmt.startToken) === null || _c === void 0 ? void 0 : _c.startColumn,
+            });
+        }
+    }
+}