xmlui 0.4.0

package/dist/scripts/src/components-core/script-runner/ParameterParser.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseParameterString = parseParameterString;
+const Parser_1 = require("../../parsers/scripting/Parser");
+/**
+ * This function parses a parameter string and splits them into string literal and binding expression sections
+ * @param source String to parse
+ * @returns Parameter string sections
+ */
+function parseParameterString(source) {
+    const result = [];
+    if (source === undefined || source === null)
+        return result;
+    let phase = ParsePhase.StringLiteral;
+    let section = "";
+    let escape = "";
+    for (let i = 0; i < source.length; i++) {
+        const ch = source[i];
+        switch (phase) {
+            case ParsePhase.StringLiteral:
+                if (ch === "\\") {
+                    phase = ParsePhase.Escape;
+                    escape = "\\";
+                }
+                else if (ch === "{") {
+                    // --- A new expression starts, close the previous string literal
+                    if (section !== "") {
+                        result.push({
+                            type: "literal",
+                            value: section
+                        });
+                    }
+                    // --- Start a new section
+                    section = "";
+                    phase = ParsePhase.ExprStart;
+                }
+                else {
+                    section += ch;
+                }
+                break;
+            case ParsePhase.Escape:
+                if (ch === "\\") {
+                    // --- Go on with escape
+                    escape += ch;
+                    break;
+                }
+                if (ch === "{") {
+                    // --- End escape as a literal section without the first "\" escape character
+                    section += escape.substring(1) + ch;
+                }
+                else {
+                    // --- End escape as a literal section with the full sequence
+                    section += escape + ch;
+                }
+                phase = ParsePhase.StringLiteral;
+                break;
+            case ParsePhase.ExprStart:
+                const exprSource = source.substring(i);
+                const parser = new Parser_1.Parser(source.substring(i));
+                let expr = null;
+                try {
+                    expr = parser.parseExpr();
+                }
+                catch (err) {
+                    throw new Error(`Cannot parse expression: '${exprSource}': ${err}`);
+                }
+                const tail = parser.getTail();
+                if (!tail || tail.trim().length < 1 || tail.trim()[0] !== "}") {
+                    // --- Unclosed expression, back to its beginning
+                    throw new Error(`Unclosed expression: '${exprSource}'`);
+                }
+                else {
+                    // --- Successfully parsed expression
+                    result.push({
+                        type: "expression",
+                        value: expr
+                    });
+                    // --- Skip the parsed part of the expression, and start a new literal section
+                    i = source.length - tail.length;
+                    section = "";
+                }
+                phase = ParsePhase.StringLiteral;
+                break;
+        }
+    }
+    // --- Process  the last segment
+    switch (phase) {
+        case ParsePhase.StringLiteral:
+            if (section !== "") {
+                result.push({
+                    type: "literal",
+                    value: section
+                });
+            }
+            break;
+        case ParsePhase.Escape:
+            result.push({
+                type: "literal",
+                value: section + escape
+            });
+            break;
+        case ParsePhase.ExprStart:
+            result.push({
+                type: "literal",
+                value: section + "{"
+            });
+            break;
+    }
+    // --- Done.
+    return result;
+}
+var ParsePhase;
+(function (ParsePhase) {
+    ParsePhase[ParsePhase["StringLiteral"] = 0] = "StringLiteral";
+    ParsePhase[ParsePhase["Escape"] = 1] = "Escape";
+    ParsePhase[ParsePhase["ExprStart"] = 2] = "ExprStart";
+})(ParsePhase || (ParsePhase = {}));

package/dist/scripts/src/components-core/script-runner/TryScope.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/scripts/src/components-core/script-runner/asyncProxy.js

@@ -0,0 +1,96 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAsyncProxy = getAsyncProxy;
+/**
+ * Gets a proxy function for one that does not support async operations
+ * @param fn Function to replace with a proxy
+ * @param origArgs Original function arguments
+ * @param context Function context ("this" of the function invocation)
+ * @return The proxy, if found; otherwise the original function
+ */
+function getAsyncProxy(fn, origArgs, context) {
+    const proxyFn = asyncProxies.get(fn);
+    if (!proxyFn)
+        return fn;
+    origArgs.unshift(context);
+    return proxyFn;
+}
+// Async implementations for JavaScript functions that do not support async arguments
+const asyncProxies = new Map();
+asyncProxies.set(Array.prototype.filter, asyncFilter);
+asyncProxies.set(Array.prototype.forEach, asyncForEach);
+asyncProxies.set(Array.prototype.map, asyncMap);
+asyncProxies.set(Array.prototype.every, asyncEvery);
+asyncProxies.set(Array.prototype.findIndex, asyncFindIndex);
+asyncProxies.set(Array.prototype.find, asyncFind);
+asyncProxies.set(Array.prototype.flatMap, asyncFlatMap);
+asyncProxies.set(Array.prototype.some, asyncSome);
+// The async implementation of Array.prototype.some
+function asyncSome(arr, predicate) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const results = yield Promise.all(arr.map(predicate));
+        return arr.some((_v, index) => results[index]);
+    });
+}
+// The async implementation of Array.prototype.filter
+function asyncFilter(arr, predicate) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const results = yield Promise.all(arr.map(predicate));
+        return arr.filter((_v, index) => results[index]);
+    });
+}
+// The async implementation of Array.prototype.forEach
+function asyncForEach(arr, predicate) {
+    return __awaiter(this, void 0, void 0, function* () {
+        for (let i = 0; i < arr.length; i++) {
+            yield predicate(arr[i], i, arr);
+        }
+    });
+}
+// The async implementation of Array.prototype.map
+function asyncMap(arr, predicate) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const result = [];
+        for (let i = 0; i < arr.length; i++) {
+            result.push(yield predicate(arr[i], i, arr));
+        }
+        return result;
+    });
+}
+// The async implementation of Array.prototype.asyncEvery
+function asyncEvery(arr, callback) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const results = yield Promise.all(arr.map(callback));
+        return results.every((_v, index) => results[index]);
+    });
+}
+// The async implementation of Array.prototype.asyncFind
+function asyncFind(arr, predicate) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const results = yield Promise.all(arr.map(predicate));
+        return arr.find((_v, index) => results[index]);
+    });
+}
+// The async implementation of Array.prototype.asyncFindIndex
+function asyncFindIndex(arr, predicate) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const results = yield Promise.all(arr.map(predicate));
+        return arr.findIndex((_v, index) => results[index]);
+    });
+}
+// The async implementation of Array.prototype.asyncFlatMap
+function asyncFlatMap(arr, predicate) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const results = yield Promise.all(arr.map(predicate));
+        return arr.flatMap((_v, index) => results[index]);
+    });
+}

package/dist/scripts/src/components-core/script-runner/bannedFunctions.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBannedFunction = isBannedFunction;
+/**
+ * Checks if the specified function object is banned from running.
+ * @param func Function to check
+ * @return Information about the banned state, including a helper text
+ */
+function isBannedFunction(func) {
+    if (func === undefined) {
+        return { banned: false };
+    }
+    const bannedInfo = bannedFunctions.find(f => f.func === func);
+    return bannedInfo
+        ? { banned: true, func: bannedInfo.func, help: bannedInfo.help }
+        : { banned: false };
+}
+/**
+ * List of global functions we do not allow to call
+ */
+const bannedFunctions = [
+    { func: globalThis.cancelAnimationFrame },
+    { func: globalThis.cancelIdleCallback },
+    { func: globalThis.clearInterval },
+    { func: globalThis.clearImmediate },
+    { func: globalThis.clearTimeout },
+    { func: globalThis.eval },
+    { func: globalThis.queueMicrotask },
+    { func: globalThis.requestAnimationFrame },
+    { func: globalThis.requestIdleCallback },
+    { func: globalThis.setImmediate },
+    { func: globalThis.setInterval },
+    { func: globalThis.setTimeout, help: "Use 'delay'" },
+];

package/dist/scripts/src/components-core/script-runner/custom-operations-registry.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customOperationsRegistry = void 0;
+/**
+ * Represents a registry for custom operations
+ */
+class CustomOperationsRegistry {
+    constructor() {
+        // --- Stores the register objects by their type ID
+        this._registry = new Map();
+    }
+    /**
+     * Registers the specified calculator
+     * @param key Custom data object type
+     * @param calculator Calculator instance
+     */
+    register(key, calculator) {
+        this._registry.set(key, calculator);
+    }
+    /**
+     * Gets the operation object for the specified type
+     * @param key Type key
+     * @return Operations object, if found; otherwise, undefined
+     */
+    getOperationsObjectByKey(key) {
+        return this._registry.get(key);
+    }
+    /**
+     * Gets all registered custom operations
+     */
+    getAllOperations() {
+        return new Map(this._registry);
+    }
+}
+// --- Register supported types
+const internalRegistry = new CustomOperationsRegistry();
+/**
+ * The singleton instance of our registry
+ */
+exports.customOperationsRegistry = internalRegistry;

package/dist/scripts/src/components-core/script-runner/custom-ui-data.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OverflowInCalculationError = exports.UnexpectedTypeError = void 0;
+exports.isCustomUiData = isCustomUiData;
+/**
+ * Type guard function for the CustomUiData type
+ * @param data Object to guard
+ */
+function isCustomUiData(data) {
+    return data._custom_data_type_ !== undefined;
+}
+/**
+ * Base class for all custom UI data related errors
+ */
+class CustomUiDataError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, CustomUiDataError.prototype);
+    }
+}
+/**
+ * This error is raised when an operation gets an unexpected type
+ */
+class UnexpectedTypeError extends CustomUiDataError {
+    constructor(expectedType, detail) {
+        super(`You must use ${expectedType} with the operation${detail ? " (" + detail + ")" : ""}`);
+        Object.setPrototypeOf(this, UnexpectedTypeError.prototype);
+    }
+}
+exports.UnexpectedTypeError = UnexpectedTypeError;
+/**
+ * This error is raised when an operation gets an unexpected type
+ */
+class OverflowInCalculationError extends CustomUiDataError {
+    constructor(number) {
+        super(`The decimal ${number} is too large to be saved`);
+        Object.setPrototypeOf(this, OverflowInCalculationError.prototype);
+    }
+}
+exports.OverflowInCalculationError = OverflowInCalculationError;