xmlui 0.4.0

package/dist/scripts/src/components-core/utils/misc.js

@@ -0,0 +1,460 @@
+"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.isPrimitive = exports.pickFromObject = exports.shallowCompare = exports.MIME_TYPES = exports.useEvent = exports.asyncWait = void 0;
+exports.partition = partition;
+exports.generatedId = generatedId;
+exports.randomUUID = randomUUID;
+exports.capitalizeFirstLetter = capitalizeFirstLetter;
+exports.removeNullProperties = removeNullProperties;
+exports.humanFileSize = humanFileSize;
+exports.isLocale = isLocale;
+exports.filterKeysInObject = filterKeysInObject;
+exports.subStringsPresentInString = subStringsPresentInString;
+exports.ensureTrailingSlashForUrl = ensureTrailingSlashForUrl;
+exports.humanReadableDateTimeTillNow = humanReadableDateTimeTillNow;
+exports.checkFileType = checkFileType;
+exports.delay = delay;
+exports.normalizePath = normalizePath;
+exports.isComponentDefChildren = isComponentDefChildren;
+exports.orderBy = orderBy;
+exports.shallowEqualArrays = shallowEqualArrays;
+exports.shallowEqualObjects = shallowEqualObjects;
+exports.groupChildrenByType = groupChildrenByType;
+exports.getChildrenByType = getChildrenByType;
+exports.formatFileSizeInBytes = formatFileSizeInBytes;
+exports.getFileExtension = getFileExtension;
+exports.pluralize = pluralize;
+exports.asyncThrottle = asyncThrottle;
+const react_1 = require("react");
+const lodash_es_1 = require("lodash-es");
+const date_fns_1 = require("date-fns");
+const EngineError_1 = require("@components-core/EngineError");
+/**
+ * Slice a single array into two based on a discriminator function.
+ * @param array Input array
+ * @param discriminator Does the separation of data
+ * @returns An array containing the two disjunct arrays
+ */
+function partition(array, discriminator) {
+    return array.reduce(([pass, fail], elem) => {
+        return discriminator(elem) ? [[...pass, elem], fail] : [pass, [...fail, elem]];
+    }, [[], []]);
+}
+/**
+ * The value used last time for ID generation
+ */
+let lastIdValue = 1;
+/**
+ * We use a generated value for all components that do not have an explicitly set ID.
+ */
+function generatedId() {
+    return `$qid_${lastIdValue++}`;
+}
+function randomUUID() {
+    if (crypto === null || crypto === void 0 ? void 0 : crypto.randomUUID) {
+        return crypto === null || crypto === void 0 ? void 0 : crypto.randomUUID();
+    }
+    // @ts-ignore
+    return ([1e7] + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, (c) => (c ^ (crypto.getRandomValues(new Uint8Array(1))[0] & (15 >> (c / 4)))).toString(16));
+}
+/**
+ * Wait for a set duration asynchronously.
+ * @param ms Time in ms to wait before continuing execution
+ * @returns An empty promise
+ */
+const asyncWait = (ms) => new Promise((res) => setTimeout(res, ms));
+exports.asyncWait = asyncWait;
+/**
+ * Capitalizes the first letter of a string.
+ * @param str Input string to capitalize
+ */
+function capitalizeFirstLetter(str) {
+    return str[0].toUpperCase() + str.substring(1);
+}
+/**
+ * Removes "null" properties from the specified object
+ * @param obj Object to remove nulls from
+ */
+function removeNullProperties(obj) {
+    if (typeof obj !== "object")
+        return;
+    for (const key in obj) {
+        if (obj[key] === null || obj[key] === undefined) {
+            delete obj[key];
+        }
+        else {
+            removeNullProperties(obj[key]);
+        }
+    }
+}
+//changed to useInsertionEffect, (from useLayoutEffect): https://stackoverflow.com/a/76514983
+// as for now, it's going to be called 'useEffectEvent'
+// more here: https://react.dev/reference/react/experimental_useEffectEvent
+const useEvent = (callback) => {
+    const callbackRef = (0, react_1.useRef)(callback);
+    (0, react_1.useInsertionEffect)(() => {
+        callbackRef.current = callback;
+    }, [callback]);
+    return (0, react_1.useCallback)((...args) => {
+        return callbackRef.current(...args);
+    }, []);
+};
+exports.useEvent = useEvent;
+/**
+ * Format bytes as human-readable text.
+ *
+ * @param bytes Number of bytes.
+ * @param si True to use metric (SI) units, aka powers of 1000. False to use
+ *           binary (IEC), aka powers of 1024.
+ * @param dp Number of decimal places to display.
+ *
+ * @return Formatted string.
+ */
+function humanFileSize(bytes, si = false, dp = 1) {
+    const thresh = si ? 1000 : 1024;
+    if (Math.abs(bytes) < thresh) {
+        return bytes + " B";
+    }
+    const units = si
+        ? ["kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"]
+        : ["KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB"];
+    let u = -1;
+    const r = Math.pow(10, dp);
+    do {
+        bytes /= thresh;
+        ++u;
+    } while (Math.round(Math.abs(bytes) * r) / r >= thresh && u < units.length - 1);
+    return bytes.toFixed(dp) + " " + units[u];
+}
+/**
+ * Returns whether a string is a locale ID according to specific ISO standards.
+ * See link for details:
+ * https://stackoverflow.com/questions/8758340/is-there-a-regex-to-test-if-a-string-is-for-a-locale
+ * @param value to test
+ * @returns whether the given value is a locale ID
+ */
+function isLocale(value) {
+    return /^[A-Za-z]{2,4}([_-][A-Za-z]{4})?([_-]([A-Za-z]{2}|[0-9]{3}))?$/.test(value);
+}
+/**
+ * Get certain keys from an object. This function preserves the original order of elements.
+ * @param object The target object
+ * @param keys a list of possible keys to find among the object keys
+ * @returns List of keys that are in the object, if no relevant keys found return an empty list
+ */
+function filterKeysInObject(object, keys) {
+    let objKeys = [];
+    if (keys && keys.length > 0) {
+        const relevantKeys = Object.keys(object).filter((key) => keys.find((fkey) => fkey === key));
+        objKeys = relevantKeys.length > 0 ? relevantKeys : objKeys;
+    }
+    return objKeys;
+}
+function subStringsPresentInString(original, toCheck) {
+    return toCheck.some((item) => original.includes(item));
+}
+function ensureTrailingSlashForUrl(url) {
+    if (!url) {
+        return undefined;
+    }
+    if (url.endsWith("/")) {
+        return url;
+    }
+    return `${url}/`;
+}
+function humanReadableDateTimeTillNow(dateTime, nowLabel, time) {
+    // WARNING: does not handle locales, consider doing Date arithmetic instead of parsing human-readable date time
+    const dateTimeStr = (0, date_fns_1.formatDistanceToNow)(new Date(dateTime), {
+        includeSeconds: true /* TODO: , locale  */,
+    });
+    const _nowLabel = nowLabel || dateTimeStr;
+    return time && dateTimeStr.includes(time) ? _nowLabel : dateTimeStr;
+}
+function checkFileType(fileName, mimeType) {
+    var _a;
+    const ext = (fileName === null || fileName === void 0 ? void 0 : fileName.includes(".")) ? (_a = fileName === null || fileName === void 0 ? void 0 : fileName.split(".").pop()) === null || _a === void 0 ? void 0 : _a.toLowerCase() : undefined;
+    if (!mimeType)
+        return ext;
+    const type = exports.MIME_TYPES.get(mimeType.split(";")[0] || "");
+    if (!ext && type)
+        return type;
+    // This last check may be unnecessary
+    return ext === type ? ext : undefined;
+}
+exports.MIME_TYPES = new Map([
+    ["text/html", "html"], // htm shtml
+    ["text/css", "css"],
+    ["text/xml", "xml"],
+    ["image/gif", "gif"],
+    ["image/jpeg", "jpg"], // jpeg
+    ["application/x-javascript", "js"],
+    ["application/atom+xml", "atom"],
+    ["application/rss+xml", "rss"],
+    ["text/mathml", "mml"],
+    ["text/plain", "txt"],
+    ["text/vnd.sun.j2me.app-descriptor", "jad"],
+    ["text/vnd.wap.wml", "wml"],
+    ["text/x-component", "htc"],
+    ["image/png", "png"],
+    ["image/tiff", "tif"], // tiff
+    ["image/vnd.wap.wbmp", "wbmp"],
+    ["image/x-icon", "ico"],
+    ["image/x-jng", "jng"],
+    ["image/x-ms-bmp", "bmp"],
+    ["image/svg+xml", "svg"],
+    ["image/webp", "webp"],
+    ["application/java-archive", "jar"], // war ear
+    ["application/mac-binhex40", "hqx"],
+    ["application/msword", "doc"],
+    ["application/pdf", "pdf"],
+    ["application/postscript", "ps"], // eps ai
+    ["application/rtf", "rtf"],
+    ["application/vnd.ms-excel", "xls"],
+    ["application/vnd.ms-powerpoint", "ppt"],
+    ["application/vnd.wap.wmlc", "wmlc"],
+    ["application/vnd.google-earth.kml+xml", "kml"],
+    ["application/vnd.google-earth.kmz", "kmz"],
+    ["application/x-7z-compressed", "7z"],
+    ["application/x-cocoa", "cco"],
+    ["application/x-java-archive-diff", "jardiff"],
+    ["application/x-java-jnlp-file", "jnlp"],
+    ["application/x-makeself", "run"],
+    ["application/x-perl", "pl"], // pm
+    ["application/x-pilot", "prc"], // pdb
+    ["application/x-rar-compressed", "rar"],
+    ["application/x-redhat-package-manager", "rpm"],
+    ["application/x-sea", "sea"],
+    ["application/x-shockwave-flash", "swf"],
+    ["application/x-stuffit", "sit"],
+    ["application/x-tcl", "tcl"], // tk
+    ["application/x-x509-ca-cert", "pem"], // der crt
+    ["application/x-xpinstall", "xpi"],
+    ["application/xhtml+xml", "xhtml"],
+    ["application/zip", "zip"],
+    ["application/octet-stream", "exe"], // bin dll
+    /*
+              application/octet-stream              "deb",
+              application/octet-stream              "dmg",
+              application/octet-stream              "eot",
+              application/octet-stream              "iso", // img
+              application/octet-stream              "msi", // msp msm
+              */
+    ["audio/midi", "mid"], // midi kar
+    ["audio/mpeg", "mp3"],
+    ["audio/ogg", "ogg"],
+    ["audio/x-realaudio", "ra"],
+    ["video/3gpp", "3gpp"], // 3gp
+    ["video/mpeg", "mpeg"], // mpg
+    ["video/quicktime", "mov"],
+    ["video/x-flv", "flv"],
+    ["video/x-mng", "mng"],
+    ["video/x-ms-asf", "asf"], // asx
+    ["video/x-ms-wmv", "wmv"],
+    ["video/x-msvideo", "avi"],
+    ["video/mp4", "mp4"], // m4v
+]);
+function delay(timeInMs, callback) {
+    return new Promise((resolve) => setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+        yield (callback === null || callback === void 0 ? void 0 : callback());
+        resolve === null || resolve === void 0 ? void 0 : resolve();
+    }), timeInMs));
+}
+function normalizePath(url) {
+    if (!url) {
+        return undefined;
+    }
+    if (url.startsWith("http://") || url.startsWith("https://") || url.startsWith("/")) {
+        return url;
+    }
+    if (typeof window === 'undefined') {
+        return url;
+    }
+    // @ts-ignore
+    const prefix = ensureTrailingSlashForUrl(window.__PUBLIC_PATH) || "";
+    return `${prefix}${url}`;
+}
+function isComponentDefChildren(children) {
+    return typeof children !== "string";
+}
+function orderBy(array, ...mappers) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!mappers.length)
+            return array;
+        // --- Create sort segment information
+        let count = 0;
+        const segments = [];
+        while (count < mappers.length) {
+            const mapper = mappers[count];
+            let segmentInfo;
+            if (typeof mapper === "string") {
+                segmentInfo = {
+                    mapperFn: (item) => item[mapper],
+                };
+            }
+            else if (typeof mapper === "function") {
+                segmentInfo = {
+                    mapperFn: (item) => mapper(item),
+                };
+            }
+            else {
+                // --- Skip invalid sort parameter
+                count++;
+                continue;
+            }
+            // --- Check if next mapper is a sort order specification
+            count++;
+            if (count < mappers.length && typeof mappers[count] === "boolean") {
+                segmentInfo.desc = true;
+                count++;
+            }
+            // --- Add the new segment
+            segments.push(segmentInfo);
+        }
+        // --- Create maps
+        const mappedValues = [];
+        for (const segment of segments) {
+            const mappedValue = new Map();
+            for (let i = 0; i < array.length; i++) {
+                mappedValue.set(array[i], yield segment.mapperFn(array[i]));
+            }
+            mappedValues.push(mappedValue);
+        }
+        return array.sort((a, b) => {
+            for (let i = 0; i < segments.length; i++) {
+                const segment = segments[i];
+                const fieldA = mappedValues[i].get(a);
+                const fieldB = mappedValues[i].get(b);
+                if (fieldA === fieldB)
+                    continue;
+                return fieldA < fieldB ? (segment.desc ? 1 : -1) : segment.desc ? -1 : 1;
+            }
+            return 0;
+        });
+    });
+}
+const shallowCompare = (obj1, obj2) => {
+    return shallowEqual(obj1, obj2);
+};
+exports.shallowCompare = shallowCompare;
+function shallowEqual(a, b) {
+    const aIsArr = Array.isArray(a);
+    const bIsArr = Array.isArray(b);
+    if (aIsArr !== bIsArr) {
+        return false;
+    }
+    if (aIsArr && bIsArr) {
+        return shallowEqualArrays(a, b);
+    }
+    return shallowEqualObjects(a, b);
+}
+function shallowEqualArrays(arrA, arrB) {
+    if (arrA === arrB) {
+        return true;
+    }
+    if (!arrA || !arrB) {
+        return false;
+    }
+    const len = arrA.length;
+    if (arrB.length !== len) {
+        return false;
+    }
+    for (let i = 0; i < len; i++) {
+        if (arrA[i] !== arrB[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+function shallowEqualObjects(objA, objB) {
+    if (objA === objB) {
+        return true;
+    }
+    if (!objA || !objB) {
+        return false;
+    }
+    const aKeys = Reflect.ownKeys(objA);
+    const bKeys = Reflect.ownKeys(objB);
+    const len = aKeys.length;
+    if (bKeys.length !== len) {
+        return false;
+    }
+    for (let i = 0; i < len; i++) {
+        const key = aKeys[i];
+        if (objA[key] !== objB[key] || !Object.prototype.hasOwnProperty.call(objB, key)) {
+            return false;
+        }
+    }
+    return true;
+}
+const pickFromObject = (object, paths) => {
+    const ret = {};
+    paths.forEach((path) => {
+        if ((0, lodash_es_1.get)(object, path) !== undefined) {
+            ret[path] = (0, lodash_es_1.get)(object, path);
+        }
+    });
+    return ret;
+};
+exports.pickFromObject = pickFromObject;
+const isPrimitive = (val) => Object(val) !== val;
+exports.isPrimitive = isPrimitive;
+function groupChildrenByType(node) {
+    var _a;
+    if (!isComponentDefChildren(node.children)) {
+        throw new EngineError_1.NotAComponentDefError();
+    }
+    const ret = {};
+    (_a = node.children) === null || _a === void 0 ? void 0 : _a.forEach((child) => {
+        if (!ret[child.type]) {
+            ret[child.type] = [];
+        }
+        ret[child.type].push(child);
+    });
+    return ret;
+}
+function getChildrenByType(node, type) {
+    const grouped = groupChildrenByType(node);
+    return (grouped[type] || []);
+}
+function formatFileSizeInBytes(size) {
+    if (!size)
+        return "-";
+    return humanFileSize(size);
+}
+function getFileExtension(fileName, mimeType) {
+    return checkFileType(fileName, mimeType);
+}
+function pluralize(number, singular, plural) {
+    if (number === 1) {
+        return `${number} ${singular}`;
+    }
+    return `${number} ${plural}`;
+}
+// from here: https://github.com/lodash/lodash/issues/4815
+/**
+ * Throttles an async function in a way that can be awaited.
+ * By default throttle doesn't return a promise for async functions unless it's invoking them immediately. See CUR-4769 for details.
+ * @param func async function to throttle calls for.
+ * @param wait same function as lodash.throttle's wait parameter.
+ *             Call this function at most this often.
+ * @returns a promise which will be resolved/ rejected only if the function is executed, with the result of the underlying call.
+ */
+function asyncThrottle(func, wait, options) {
+    const throttled = (0, lodash_es_1.throttle)((resolve, reject, args) => {
+        func(...args)
+            .then(resolve)
+            .catch(reject);
+    }, wait, options);
+    return (...args) => new Promise((resolve, reject) => {
+        throttled(resolve, reject, args);
+    });
+}

package/dist/scripts/src/components-core/utils/statementUtils.js

@@ -0,0 +1,205 @@
+"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.parseHandlerCode = parseHandlerCode;
+exports.prepareHandlerStatements = prepareHandlerStatements;
+exports.runEventHandlerCode = runEventHandlerCode;
+const Parser_1 = require("../../parsers/scripting/Parser");
+const process_statement_async_1 = require("../script-runner/process-statement-async");
+const reportEngineError_1 = require("../reportEngineError");
+const EngineError_1 = require("../EngineError");
+/**
+ * Parse the specified source code as event handler code
+ * @param source Event handler source code
+ */
+function parseHandlerCode(source) {
+    // --- Parse the event code
+    const wParser = new Parser_1.Parser(source);
+    let parsedStatements = null;
+    try {
+        // --- Invoke the parser
+        parsedStatements = wParser.parseStatements();
+    }
+    catch (err) {
+        // --- Parsing error with explicit error code
+        if (wParser.errors.length > 0) {
+            const err = wParser.errors[0];
+            (0, reportEngineError_1.reportEngineError)(new EngineError_1.ScriptParseError(`${err.code}(${err.line}, ${err.column}): ${wParser.errors[0].text}`, source, err.position));
+        }
+        else {
+            throw err;
+        }
+    }
+    // --- Check for the completeness of source code parsing
+    if (!wParser.isEof) {
+        const tail = wParser.getTail();
+        (0, reportEngineError_1.reportEngineError)(new EngineError_1.ScriptParseError(`Invalid tail found`, source, source.length - tail.length + 1));
+    }
+    // --- Done
+    return parsedStatements;
+}
+/**
+ * Optionally transform statements in an event handler to an arrow expression statement
+ * @param statements Statements to transform
+ * @param evalContext Optional event arguments
+ */
+function prepareHandlerStatements(statements, evalContext) {
+    var _a;
+    const stmtLength = (_a = statements === null || statements === void 0 ? void 0 : statements.length) !== null && _a !== void 0 ? _a : 0;
+    if (stmtLength === 0) {
+        // -- Use a no-op arrow function
+        return [
+            {
+                type: "ArrowS",
+                expression: {
+                    type: "ArrowE",
+                    args: [],
+                    statement: {
+                        type: "EmptyS",
+                    },
+                },
+            },
+        ];
+    }
+    if (stmtLength === 1) {
+        const stmt = statements[0];
+        if (evalContext && stmt.type === "ExprS" && stmt.expression.type === "IdE") {
+            // --- A single identifier, it is supposed to be an arrow function
+            // --- Create formal arguments
+            const formalArgs = evalContext.eventArgs
+                ? evalContext.eventArgs.map((_, idx) => ({
+                    type: "IdE",
+                    name: `__arg@@#__${idx}__`,
+                }))
+                : [];
+            // --- Add formal argument with current values
+            if (evalContext.eventArgs) {
+                evalContext.eventArgs.forEach((val, idx) => {
+                    evalContext.localContext[`__arg@@#__${idx}__`] = val;
+                });
+            }
+            // --- Create the arrow expression
+            const arrowExpr = {
+                type: "ArrowE",
+                args: formalArgs,
+                statement: {
+                    type: "ExprS",
+                    expression: {
+                        type: "InvokeE",
+                        object: stmt.expression,
+                        arguments: [...formalArgs],
+                    },
+                },
+            };
+            // --- Use this arrow expression
+            return [
+                {
+                    type: "ArrowS",
+                    expression: arrowExpr,
+                },
+            ];
+        }
+        if (stmt.type === "ExprS" && stmt.expression.type === "ArrowE") {
+            // --- A single arrow expression
+            return [
+                {
+                    type: "ArrowS",
+                    expression: stmt.expression,
+                },
+            ];
+        }
+        if (stmt.type === "ExprS" && stmt.expression.type !== "ArrowE") {
+            // --- A single arrow expression
+            return [
+                {
+                    type: "ArrowS",
+                    expression: {
+                        type: "ArrowE",
+                        args: [],
+                        statement: statements[0],
+                    },
+                },
+            ];
+        }
+        if (stmt.type === "RetS") {
+            // --- A single arrow expression with a return
+            return [
+                {
+                    type: "ArrowS",
+                    expression: {
+                        type: "ArrowE",
+                        args: [],
+                        statement: {
+                            type: "BlockS",
+                            statements: [stmt],
+                        },
+                    },
+                },
+            ];
+        }
+        if (stmt.type === "BlockS") {
+            // --- A single block statement?
+            if (stmt.statements[0].type === "ExprS" && stmt.statements[0].expression.type === "ArrowE") {
+                // --- A single block statement with a single arrow expression?
+                return [
+                    {
+                        type: "ArrowS",
+                        expression: stmt.statements[0].expression,
+                    },
+                ];
+            }
+            else {
+                // --- Consider as a body of a no-arg arrow function
+                return [
+                    {
+                        type: "ArrowS",
+                        expression: {
+                            type: "ArrowE",
+                            args: [],
+                            statement: statements[0],
+                        },
+                    },
+                ];
+            }
+        }
+    }
+    if (stmtLength > 1) {
+        // --- Use the statements as the body of a no-arg arrow function
+        return [
+            {
+                type: "ArrowS",
+                expression: {
+                    type: "ArrowE",
+                    args: [],
+                    statement: {
+                        type: "BlockS",
+                        statements,
+                    },
+                },
+            },
+        ];
+    }
+    // --- Nothing to transform
+    return statements;
+}
+/**
+ * Runs the specified event handler code
+ * @param source Event handler source code
+ * @param evalContext Evaluation context to use
+ * @param thread Logical thread to use
+ * @param onStatementCompleted Callback for statement completion
+ */
+function runEventHandlerCode(source, evalContext, thread, onStatementCompleted) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const statements = prepareHandlerStatements(parseHandlerCode(source));
+        return yield (0, process_statement_async_1.processStatementQueueAsync)(statements, evalContext, thread, onStatementCompleted);
+    });
+}