xmlui 0.11.4 → 0.11.7

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

@@ -1,539 +0,0 @@
-"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.readCookie = readCookie;
-exports.capitalizeFirstLetter = capitalizeFirstLetter;
-exports.removeNullProperties = removeNullProperties;
-exports.humanFileSize = humanFileSize;
-exports.isLocale = isLocale;
-exports.filterKeysInObject = filterKeysInObject;
-exports.subStringsPresentInString = subStringsPresentInString;
-exports.ensureTrailingSlashForUrl = ensureTrailingSlashForUrl;
-exports.ensureLeadingSlashForUrl = ensureLeadingSlashForUrl;
-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.formatFileSizeInBytes = formatFileSizeInBytes;
-exports.getFileExtension = getFileExtension;
-exports.pluralize = pluralize;
-exports.toHashObject = toHashObject;
-exports.findByField = findByField;
-exports.distinct = distinct;
-exports.asyncThrottle = asyncThrottle;
-exports.debounce = debounce;
-const react_1 = require("react");
-const lodash_es_1 = require("lodash-es");
-const date_fns_1 = require("date-fns");
-/**
- * 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));
-}
-function readCookie(name) {
-    const nameEQ = name + "=";
-    const ca = document.cookie.split(";");
-    for (let i = 0; i < ca.length; i++) {
-        let c = ca[i];
-        while (c.charAt(0) === " ")
-            c = c.substring(1, c.length);
-        if (c.indexOf(nameEQ) === 0)
-            return c.substring(nameEQ.length, c.length);
-    }
-    return null;
-}
-/**
- * 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]);
-        }
-    }
-}
-// from here: https://github.com/bluesky-social/social-app/blob/587c0c625752964d8ce64faf1d329dce3c834a5c/src/lib/hooks/useNonReactiveCallback.ts
-// This should be used sparingly. It erases reactivity, i.e. when the inputs
-// change, the function itself will remain the same. This means that if you
-// use this at a higher level of your tree, and then some state you read in it
-// changes, there is no mechanism for anything below in the tree to "react"
-// to this change (e.g. by knowing to call your function again).
-//
-// Also, you should avoid calling the returned function during rendering
-// since the values captured by it are going to lag behind.
-const useEvent = (callback) => {
-    const callbackRef = (0, react_1.useRef)(callback);
-    (0, react_1.useInsertionEffect)(() => {
-        callbackRef.current = callback;
-    }, [callback]);
-    return (0, react_1.useCallback)((...args) => {
-        const latestFn = callbackRef.current;
-        return latestFn === null || latestFn === void 0 ? void 0 : latestFn(...args);
-    }, [callbackRef]);
-};
-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 ensureLeadingSlashForUrl(url) {
-    if (!url) {
-        return undefined;
-    }
-    if (url.startsWith("/")) {
-        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://")) {
-        return url;
-    }
-    if (typeof window === "undefined") {
-        return url;
-    }
-    // @ts-ignore
-    const prefix = window.__PUBLIC_PATH || "";
-    if (!prefix) {
-        return url;
-    }
-    const prefixWithoutTrailingSlash = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
-    const urlWithoutLeadingSlash = url.startsWith("/") ? url.slice(1) : url;
-    return `${prefixWithoutTrailingSlash}/${urlWithoutLeadingSlash}`;
-}
-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 (typeof a === "string" || typeof b === "string") {
-        return a === 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 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}`;
-}
-function toHashObject(arr, keyProp, valueProp) {
-    return (arr !== null && arr !== void 0 ? arr : []).reduce((acc, item) => {
-        acc[item[keyProp]] = item[valueProp];
-        return acc;
-    }, {});
-}
-function findByField(arr, field, value) {
-    return (arr !== null && arr !== void 0 ? arr : []).find((item) => item[field || ""] === value);
-}
-function distinct(arr) {
-    if (!Array.isArray(arr) || !arr || !arr.length) {
-        return [];
-    }
-    return Array.from(new Set(arr));
-}
-// 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) => {
-        void func(...args)
-            .then(resolve)
-            .catch(reject);
-    }, wait, options);
-    return (...args) => new Promise((resolve, reject) => {
-        throttled(resolve, reject, args);
-    });
-}
-/**
- * Registry to store debounced function timers and their captured arguments by key
- */
-const debounceRegistry = new Map();
-/**
- * Creates a debounced function that delays invoking the provided function until after
- * the specified delay in milliseconds has elapsed since the last time it was invoked.
- *
- * When called from XMLUI markup, it automatically generates a stable key based on the
- * call site to ensure proper debouncing across multiple invocations.
- *
- * @param delayMs The number of milliseconds to delay execution
- * @param func The function to debounce
- * @param args Optional arguments to pass to the function when it executes
- * @returns void (executes the function after the delay)
- *
- * @example
- * // In XMLUI markup with value capture:
- * <TextBox onDidChange="e => debounce(500, () => console.log('value:', e), e)" />
- *
- * @example
- * // In XMLUI markup with inline function:
- * <TextBox onDidChange="e => debounce(500, (val) => console.log('value:', val), e)" />
- */
-function debounce(delayMs, func, ...args) {
-    // Generate a unique key for this debounce call based on the function source
-    // This ensures that the same event handler in markup reuses the same timer
-    const key = func.toString();
-    // Clear existing timeout for this key
-    const existing = debounceRegistry.get(key);
-    if (existing !== undefined) {
-        clearTimeout(existing.timeoutId);
-    }
-    // Set new timeout with captured arguments
-    const timeoutId = setTimeout(() => {
-        const entry = debounceRegistry.get(key);
-        if (entry) {
-            func(...entry.args);
-            debounceRegistry.delete(key);
-        }
-    }, delayMs);
-    debounceRegistry.set(key, { timeoutId, args });
-}

package/dist/scripts/src/components-core/utils/request-params.js

@@ -1,70 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertRequestParamPart = convertRequestParamPart;
-// Testable helper function to convert request parameters
-function convertRequestParamPart(part, paramTypes) {
-    if (!paramTypes)
-        return part;
-    const result = Object.assign({}, part);
-    Object.keys(part).forEach((key) => {
-        if (!(key in paramTypes))
-            return;
-        const partValue = part[key];
-        const partValueType = typeof partValue;
-        switch (paramTypes[key]) {
-            // --- Parameter to integer
-            case "integer":
-                switch (partValueType) {
-                    case "number":
-                        result[key] = Math.round(partValue);
-                        break;
-                    case "string":
-                        result[key] = parseInt(partValue, 10);
-                        break;
-                    case "boolean":
-                        result[key] = partValue ? 1 : 0;
-                        break;
-                }
-                break;
-            // --- Parameter to float
-            case "float":
-            case "real":
-            case "double":
-                switch (partValueType) {
-                    case "number":
-                        result[key] = partValue;
-                        break;
-                    case "string":
-                        result[key] = parseFloat(partValue);
-                        break;
-                    case "boolean":
-                        result[key] = partValue ? 1 : 0;
-                        break;
-                }
-                break;
-            // --- Parameter to boolean
-            case "boolean":
-                switch (partValueType) {
-                    case "string":
-                        switch (partValue.toLowerCase()) {
-                            case "true":
-                            case "yes":
-                            case "on":
-                                result[key] = true;
-                                break;
-                            case "false":
-                            case "no":
-                            case "off":
-                                result[key] = false;
-                                break;
-                        }
-                        break;
-                    case "number":
-                        result[key] = !!partValue;
-                        break;
-                }
-                break;
-        }
-    });
-    return result;
-}