xmlui 0.11.3 → 0.11.6

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

@@ -1,186 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isoDateString = isoDateString;
-exports.formatDate = formatDate;
-exports.formatDateTime = formatDateTime;
-exports.formatTime = formatTime;
-exports.formatTimeWithoutSeconds = formatTimeWithoutSeconds;
-exports.formatDateWithoutYear = formatDateWithoutYear;
-exports.getDate = getDate;
-exports.getDateUntilNow = getDateUntilNow;
-exports.smartFormatDateTime = smartFormatDateTime;
-exports.smartFormatDate = smartFormatDate;
-exports.isDateToday = isDateToday;
-exports.isDateYesterday = isDateYesterday;
-exports.isDateTomorrow = isDateTomorrow;
-exports.formatHumanElapsedTime = formatHumanElapsedTime;
-const date_fns_1 = require("date-fns");
-const misc_1 = require("../utils/misc");
-function isoDateString(date) {
-    return (!date ? new Date() : new Date(date)).toJSON();
-}
-function formatDate(date, formatString) {
-    if (formatString) {
-        return (0, date_fns_1.format)(new Date(date), formatString);
-    }
-    return new Date(date).toLocaleDateString();
-}
-function formatDateTime(date, formatString) {
-    if (formatString) {
-        return (0, date_fns_1.format)(new Date(date), formatString);
-    }
-    return new Date(date).toLocaleString();
-}
-function formatTime(date, formatString) {
-    if (formatString) {
-        return (0, date_fns_1.format)(new Date(date), formatString);
-    }
-    return new Date(date).toLocaleTimeString();
-}
-function formatTimeWithoutSeconds(date) {
-    return (0, date_fns_1.format)(new Date(date), "H:m");
-}
-function formatDateWithoutYear(date) {
-    return new Date(date).toLocaleDateString([], {
-        month: "numeric",
-        day: "2-digit"
-    });
-}
-function getDate(date) {
-    return date ? new Date(date) : new Date();
-}
-function getDateUntilNow(date, nowLabel, time) {
-    return date ? (0, misc_1.humanReadableDateTimeTillNow)(date, nowLabel, time) : "-";
-}
-function smartFormatDateTime(date) {
-    if (!date) {
-        return "-";
-    }
-    if ((0, date_fns_1.isToday)(new Date(date))) {
-        return new Date(date).toLocaleTimeString();
-    }
-    if ((0, date_fns_1.isThisWeek)(new Date(date))) {
-        return `${(0, date_fns_1.formatRelative)(new Date(date), new Date())}`;
-    }
-    return new Date(date).toLocaleString();
-}
-function smartFormatDate(date) {
-    if (!date) {
-        return "-";
-    }
-    //TODO we could use formatRelative when they implement this: https://github.com/date-fns/date-fns/issues/1218
-    if ((0, date_fns_1.isToday)(new Date(date))) {
-        return "Today";
-    }
-    if ((0, date_fns_1.isYesterday)(new Date(date))) {
-        return "Yesterday";
-    }
-    return new Date(date).toLocaleDateString();
-}
-function isDateToday(date) {
-    return (0, date_fns_1.isToday)(new Date(date));
-}
-function isDateYesterday(date) {
-    return (0, date_fns_1.isYesterday)(new Date(date));
-}
-function isDateTomorrow(date) {
-    return (0, date_fns_1.isTomorrow)(new Date(date));
-}
-/**
- * Formats a date into a human-readable elapsed time string.
- * Returns strings like "now", "12 seconds ago", "3 hours ago", "today", "yesterday", "3 weeks ago", etc.
- *
- * @param date The date to format
- * @param shortFormat When true, uses abbreviated time units (e.g. "s" instead of "seconds")
- * @returns A human-readable elapsed time string
- */
-function formatHumanElapsedTime(date, shortFormat = false) {
-    const now = new Date();
-    const inputDate = new Date(date);
-    // Calculate time difference in milliseconds
-    const diffMs = now.getTime() - inputDate.getTime();
-    // Handle future dates
-    if (diffMs < 0) {
-        return formatDate(date);
-    }
-    // Convert to seconds, minutes, hours, days, weeks
-    const diffSeconds = Math.floor(diffMs / 1000);
-    const diffMinutes = Math.floor(diffSeconds / 60);
-    const diffHours = Math.floor(diffMinutes / 60);
-    const diffDays = Math.floor(diffHours / 24);
-    const diffWeeks = Math.floor(diffDays / 7);
-    const diffMonths = Math.floor(diffDays / 30);
-    const diffYears = Math.floor(diffDays / 365);
-    // Define unit formats based on shortFormat parameter
-    const units = {
-        second: {
-            singular: shortFormat ? 's' : 'second',
-            plural: shortFormat ? 's' : 'seconds'
-        },
-        minute: {
-            singular: shortFormat ? 'min' : 'minute',
-            plural: shortFormat ? 'min' : 'minutes'
-        },
-        hour: {
-            singular: shortFormat ? 'hr' : 'hour',
-            plural: shortFormat ? 'hrs' : 'hours'
-        },
-        day: {
-            singular: shortFormat ? 'd' : 'day',
-            plural: shortFormat ? 'd' : 'days'
-        },
-        week: {
-            singular: shortFormat ? 'wk' : 'week',
-            plural: shortFormat ? 'wks' : 'weeks'
-        },
-        month: {
-            singular: shortFormat ? 'mo' : 'month',
-            plural: shortFormat ? 'mos' : 'months'
-        },
-        year: {
-            singular: shortFormat ? 'y' : 'year',
-            plural: shortFormat ? 'yrs' : 'years'
-        }
-    };
-    // Just now (within 10 seconds)
-    if (diffSeconds < 10) {
-        return "now";
-    }
-    // Seconds ago (up to 1 minute)
-    if (diffSeconds < 60) {
-        const unit = diffSeconds === 1 ? units.second.singular : units.second.plural;
-        return `${diffSeconds} ${unit} ago`;
-    }
-    // Minutes ago (up to 1 hour)
-    if (diffMinutes < 60) {
-        const unit = diffMinutes === 1 ? units.minute.singular : units.minute.plural;
-        return `${diffMinutes} ${unit} ago`;
-    }
-    // Hours ago (up to today)
-    if ((0, date_fns_1.isToday)(inputDate)) {
-        const unit = diffHours === 1 ? units.hour.singular : units.hour.plural;
-        return `${diffHours} ${unit} ago`;
-    }
-    // Yesterday
-    if ((0, date_fns_1.isYesterday)(inputDate)) {
-        return "yesterday";
-    }
-    // Days ago (up to 1 week)
-    if (diffDays < 7) {
-        const unit = diffDays === 1 ? units.day.singular : units.day.plural;
-        return `${diffDays} ${unit} ago`;
-    }
-    // Weeks ago (up to 4 weeks / 1 month)
-    if (diffWeeks < 4) {
-        const unit = diffWeeks === 1 ? units.week.singular : units.week.plural;
-        return `${diffWeeks} ${unit} ago`;
-    }
-    // Months ago (up to 12 months / 1 year)
-    if (diffMonths < 12) {
-        const unit = diffMonths === 1 ? units.month.singular : units.month.plural;
-        return `${diffMonths} ${unit} ago`;
-    }
-    // Years ago
-    const unit = diffYears === 1 ? units.year.singular : units.year.plural;
-    return `${diffYears} ${unit} ago`;
-}

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

@@ -1,281 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PropsTrasform = void 0;
-exports.extractParam = extractParam;
-exports.withStableObjectReference = withStableObjectReference;
-exports.shouldKeep = shouldKeep;
-exports.resolveAndCleanProps = resolveAndCleanProps;
-exports.removeStylesFromProps = removeStylesFromProps;
-const react_1 = __importDefault(require("react"));
-const lodash_es_1 = require("lodash-es");
-const ParameterParser_1 = require("../script-runner/ParameterParser");
-const eval_tree_sync_1 = require("../script-runner/eval-tree-sync");
-const LruCache_1 = require("../utils/LruCache");
-const descriptorHelper_1 = require("../descriptorHelper");
-const valueExtractor_1 = require("../rendering/valueExtractor");
-/**
- * Extract the value of the specified parameter from the given view container state
- * @param state The state of the view container
- * @param param Parameter to extract
- * @param appContext Application context to use
- * @param strict Strict evaluation?
- * @param extractContext
- * @returns
- */
-function extractParam(state, param, appContext = undefined, strict = false, // --- In this case we only allow string binding expression
-extractContext = { didResolve: false }) {
-    if (typeof param === "string") {
-        const paramSegments = (0, ParameterParser_1.parseParameterString)(param);
-        if (paramSegments.length === 0) {
-            // --- The param is an empty string, retrieve it
-            return param;
-        }
-        // --- Cut the first segment, if it is whitespace-only
-        if (paramSegments[0].type === "literal" && paramSegments[0].value.trim() === "") {
-            paramSegments.shift();
-        }
-        if (paramSegments.length === 0) {
-            // --- The param is an empty string, retrieve it
-            return param;
-        }
-        // --- Cut the last segment, if it is whitespace-only
-        const lastSegment = paramSegments[paramSegments.length - 1];
-        if (lastSegment.type === "literal" && lastSegment.value.trim() === "") {
-            paramSegments.pop();
-        }
-        if (paramSegments.length === 0) {
-            // --- The param is an empty string, retrieve it
-            return param;
-        }
-        if (paramSegments.length === 1) {
-            // --- We have a single string literal or expression
-            if (paramSegments[0].type === "literal") {
-                // --- No expression to evaluate
-                return paramSegments[0].value;
-            }
-            else {
-                // --- We have a single expression to evaluate
-                extractContext.didResolve = true;
-                return (0, eval_tree_sync_1.evalBinding)(paramSegments[0].value, {
-                    localContext: state,
-                    appContext,
-                    options: {
-                        defaultToOptionalMemberAccess: true,
-                    },
-                });
-            }
-        }
-        // --- At this point, we have multiple segments. Evaluate all expressions and convert them to strings
-        let result = "";
-        paramSegments.forEach((ps) => {
-            if (ps.type === "literal") {
-                result += ps.value;
-            }
-            else {
-                extractContext.didResolve = true;
-                const exprValue = (0, eval_tree_sync_1.evalBinding)(ps.value, {
-                    localContext: state,
-                    appContext,
-                    options: {
-                        defaultToOptionalMemberAccess: true,
-                    },
-                });
-                if (exprValue === null || exprValue === void 0 ? void 0 : exprValue.toString) {
-                    result += exprValue.toString();
-                }
-            }
-        });
-        return result;
-    }
-    if (strict) {
-        // --- As we allow only string parameters as binding expressions, we return with the provided
-        // --- *not string* parameter without transforming it
-        return param;
-    }
-    // --- Resolve each array item
-    if (Array.isArray(param)) {
-        const arrayExtractContext = { didResolve: false };
-        let resolvedChildren = param.map((childParam) => extractParam(state, childParam, appContext, false, arrayExtractContext));
-        if (arrayExtractContext.didResolve) {
-            extractContext.didResolve = true;
-            return resolvedChildren;
-        }
-        return param;
-    }
-    // --- Resolve each object property
-    if ((0, lodash_es_1.isPlainObject)(param)) {
-        const objectExtractContext = { didResolve: false };
-        const substitutedObject = {};
-        Object.entries(param).forEach(([key, value]) => {
-            substitutedObject[key] = extractParam(state, value, appContext, false, objectExtractContext);
-        });
-        if (objectExtractContext.didResolve) {
-            extractContext.didResolve = true;
-            return substitutedObject;
-        }
-        return param;
-    }
-    // --- The param itself is the extracted value
-    return param;
-}
-// --- Store stable object references for extracted parameter values
-const extractedObjectCache = new LruCache_1.LRUCache(1024 * 10);
-/**
- * Get a stable object reference from an LRU cache
- * @param object Object to get the stable reference for
- *
- * We are doing this to prevent creating new objects with new references when the data hasn't changed this way we
- * can use these as dependencies for useEffect
- */
-function withStableObjectReference(object) {
-    if (typeof object === "function") {
-        return object;
-    }
-    if (react_1.default.isValidElement(object) || (Array.isArray(object) && react_1.default.isValidElement(object[0]))) {
-        //here could be some gnarly circular object references, JSON.stringify would blow up
-        return object;
-    }
-    if (object === null || object === void 0 ? void 0 : object._ARROW_EXPR_) {
-        //here could be some gnarly circular object references, JSON.stringify would blow up
-        return object;
-    }
-    try {
-        const stringObject = JSON.stringify(object);
-        const cachedObject = extractedObjectCache.get(stringObject);
-        if (cachedObject) {
-            return cachedObject;
-        }
-        extractedObjectCache.set(stringObject, object);
-    }
-    catch (e) {
-        console.log(object);
-        console.warn("couldn't cache result", e);
-    }
-    return object;
-}
-function shouldKeep(when, componentState, appContext) {
-    if (when === undefined) {
-        return true;
-    }
-    return (0, valueExtractor_1.asOptionalBoolean)(extractParam(componentState, when, appContext, true));
-}
-/**
- * Resolves props that can either be regular properties or URL resources.
- * It also removes layoutCss props from regular properties.
- * @param props Component (rest) props
- * @param extractValue Value extractor function
- * @param layoutCss Component styles
- * @param resourceExtraction URL resource extractor function and array that specifies which props are URL resources
- * @returns properties that are resolved and cleaned of CSS styles
- */
-function resolveAndCleanProps(props, extractValue, resourceExtraction) {
-    const { extractResourceUrl, resourceProps } = resourceExtraction !== null && resourceExtraction !== void 0 ? resourceExtraction : {};
-    const cleanedProps = removeStylesFromProps(props);
-    const resultProps = {};
-    const result = Object.keys(cleanedProps).reduce((acc, propName) => {
-        if (resourceProps && extractResourceUrl && resourceProps.includes(propName)) {
-            acc[propName] = extractResourceUrl(cleanedProps[propName]);
-        }
-        else {
-            acc[propName] = extractValue(cleanedProps[propName]);
-        }
-        return acc;
-    }, resultProps);
-    // --- Remove aliased CSS properties
-    delete resultProps.canShrink;
-    delete resultProps.radiusTopLeft;
-    delete resultProps.radiusTopRight;
-    delete resultProps.radiusBottomLeft;
-    delete resultProps.radiusBottomRight;
-    // --- Delete pseudo CSS properties
-    delete resultProps.paddingHorizontal;
-    delete resultProps.paddingVertical;
-    delete resultProps.marginHorizontal;
-    delete resultProps.marginVertical;
-    delete resultProps.borderHorizontal;
-    delete resultProps.borderVertical;
-    return result;
-}
-/**
- * Removes unnecessary style related properties so only layoutCss contains them.
- * @param nodeProps properties to clean
- * @returns only component-specific properties
- */
-function removeStylesFromProps(nodeProps) {
-    if (nodeProps.hasOwnProperty("style")) {
-        delete nodeProps["style"];
-    }
-    if (nodeProps.hasOwnProperty("class")) {
-        delete nodeProps["class"];
-    }
-    const filterKeys = descriptorHelper_1.layoutOptionKeys;
-    return Object.fromEntries(Object.entries(nodeProps).filter(([key]) => !filterKeys.includes(key)));
-}
-/**
- * Extracts props that can either be regular properties or URL resources.
- * It also removes layoutCss props from regular properties fed into it.
- * @param extractValue Value extractor function
- * @param extractResourceUrl URL resource extractor function that specifies which props are URL resources
- * @param layoutCss Component styles
- * @param props Component props
- * @returns properties that are resolved and cleaned of CSS styles
- */
-class PropsTrasform {
-    constructor(extractValue, extractResourceUrl, props) {
-        this.usedKeys = [];
-        this.extractValue = extractValue;
-        this.extractResourceUrl = extractResourceUrl;
-        this.nodeProps = removeStylesFromProps(props);
-    }
-    mapValues(keys, fn) {
-        this.usedKeys = Array.from(new Set(this.usedKeys.concat(keys)));
-        return Object.fromEntries(keys.map((key) => [key, fn(this.nodeProps[key])]));
-    }
-    asValue(...key) {
-        return this.mapValues(key, this.extractValue);
-    }
-    asUrlResource(...key) {
-        return this.mapValues(key, this.extractResourceUrl);
-    }
-    asBoolean(...key) {
-        return this.mapValues(key, this.extractValue.asBoolean);
-    }
-    asOptionalBoolean(...key) {
-        return this.mapValues(key, this.extractValue.asOptionalBoolean);
-    }
-    asString(...key) {
-        return this.mapValues(key, this.extractValue.asString);
-    }
-    asOptionalString(...key) {
-        return this.mapValues(key, this.extractValue.asOptionalString);
-    }
-    asOptionalStringArray(...key) {
-        return this.mapValues(key, this.extractValue.asOptionalString);
-    }
-    asDisplayText(...key) {
-        return this.mapValues(key, this.extractValue.asDisplayText);
-    }
-    asNumber(...key) {
-        return this.mapValues(key, this.extractValue.asNumber);
-    }
-    asOptionalNumber(...key) {
-        return this.mapValues(key, this.extractValue.asOptionalNumber);
-    }
-    asSize(...key) {
-        return this.mapValues(key, this.extractValue.asSize);
-    }
-    /**
-     * Resolves props which have not been used yet.
-     * If all keys have been referenced before this function is called, an empty object is returned.
-     *
-     * @returns props that have not been used yet
-     */
-    asRest() {
-        const filteredKeys = Object.keys(this.nodeProps).filter((propKey) => !this.usedKeys.includes(propKey));
-        return this.mapValues(filteredKeys, this.extractValue);
-    }
-}
-exports.PropsTrasform = PropsTrasform;