xmlui 0.7.13 → 0.7.15

package/dist/scripts/src/components-core/action/FileUploadAction.js

@@ -0,0 +1,88 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadAction = void 0;
+const actions_1 = require("./actions");
+const RestApiProxy_1 = __importDefault(require("@components-core/RestApiProxy"));
+const extractParam_1 = require("@components-core/utils/extractParam");
+const actionUtils_1 = require("@components-core/utils/actionUtils");
+function uploadFile(_a, _b) {
+    return __awaiter(this, arguments, void 0, function* ({ appContext, state, lookupAction, uid }, { params, invalidates, onError, queryParams, asForm, file, headers, url, method, formParams, rawBody, body, chunkSizeInBytes, onProgress, }, { resolveBindingExpressions } = {}) {
+        const stateContext = Object.assign(Object.assign({}, params), state);
+        const api = new RestApiProxy_1.default(appContext);
+        const operation = {
+            file,
+            body,
+            asForm,
+            formParams,
+            rawBody,
+            method,
+            url,
+            queryParams,
+            headers,
+        };
+        let result = null;
+        try {
+            const _chunkSizeInBytes = (0, extractParam_1.extractParam)(stateContext, chunkSizeInBytes, appContext);
+            const _onProgress = (0, extractParam_1.extractParam)(stateContext, onProgress, appContext);
+            if (_chunkSizeInBytes !== undefined) {
+                const _file = (0, extractParam_1.extractParam)(stateContext, file, appContext);
+                const numberOfChunks = Math.ceil(_file.size / _chunkSizeInBytes);
+                for (let i = 0; i < numberOfChunks; i++) {
+                    const start = i * _chunkSizeInBytes;
+                    const chunkEnd = Math.min(start + _chunkSizeInBytes, _file.size);
+                    const chunk = _file.slice(start, chunkEnd);
+                    result = yield api.upload({
+                        operation,
+                        chunk: {
+                            blob: chunk,
+                            chunkStart: start,
+                            chunkEnd: chunkEnd,
+                        },
+                        params: stateContext,
+                        onUploadProgress: (progressEvent) => {
+                            const overallTotal = _file.size;
+                            const overallLoaded = start + progressEvent.loaded;
+                            const overallProgressEvent = {
+                                total: overallTotal,
+                                loaded: overallLoaded,
+                                progress: overallLoaded / overallTotal,
+                            };
+                            _onProgress === null || _onProgress === void 0 ? void 0 : _onProgress(overallProgressEvent);
+                        },
+                        resolveBindingExpressions,
+                    });
+                }
+            }
+            else {
+                result = yield api.upload({
+                    operation,
+                    params: stateContext,
+                    onUploadProgress: _onProgress,
+                    resolveBindingExpressions,
+                });
+            }
+        }
+        catch (e) {
+            const onErrorFn = lookupAction(onError, uid);
+            const result = yield (onErrorFn === null || onErrorFn === void 0 ? void 0 : onErrorFn(e, stateContext["$param"]));
+            if (result !== false) {
+                throw e;
+            }
+        }
+        (0, actionUtils_1.invalidateQueries)(invalidates, appContext, state);
+        return result;
+    });
+}
+exports.uploadAction = (0, actions_1.createAction)("upload", uploadFile);

package/dist/scripts/src/components-core/action/NavigateAction.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.navigateAction = void 0;
+const actions_1 = require("./actions");
+const component_utils_1 = require("@components/component-utils");
+function navigate({ navigate, location }, pathname, queryParams) {
+    // https://stackoverflow.com/questions/37385570/how-to-know-if-react-router-can-go-back-to-display-back-button-in-react-app
+    if (pathname === -1 && location.key === "default") {
+        navigate(".");
+        return;
+    }
+    const to = queryParams
+        ? (0, component_utils_1.createUrlWithQueryParams)({
+            pathname,
+            queryParams,
+        })
+        : pathname;
+    navigate(to);
+}
+exports.navigateAction = (0, actions_1.createAction)("navigate", navigate);

package/dist/scripts/src/components-core/action/TimedAction.js

@@ -0,0 +1,21 @@
+"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.timedAction = void 0;
+const misc_1 = require("@components-core/utils/misc");
+const actions_1 = require("./actions");
+function delay(_executionContext, timeoutInMs, callback) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield (0, misc_1.delay)(timeoutInMs);
+        yield (callback === null || callback === void 0 ? void 0 : callback());
+    });
+}
+exports.timedAction = (0, actions_1.createAction)("delay", delay);

package/dist/scripts/src/components-core/action/actions.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAction = createAction;
+/**
+ * Creates an action renderer definition object that can be registered in the action registry.
+ * @param actionName The name of the action
+ * @param actionFn The function that executes the action
+ * @returns An action renderer definition object
+ */
+function createAction(actionName, actionFn) {
+    return {
+        actionName,
+        actionFn,
+    };
+}

package/dist/scripts/src/components-core/appContext/date-functions.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dateFunctions = void 0;
+const date_utils_1 = require("../utils/date-utils");
+exports.dateFunctions = {
+    isoDateString: date_utils_1.isoDateString,
+    formatDate: date_utils_1.formatDate,
+    formatDateTime: date_utils_1.formatDateTime,
+    formatTime: date_utils_1.formatTime,
+    formatTimeWithoutSeconds: date_utils_1.formatTimeWithoutSeconds,
+    formatDateWithoutYear: date_utils_1.formatDateWithoutYear,
+    getDate: date_utils_1.getDate,
+    getDateUntilNow: date_utils_1.getDateUntilNow,
+    smartFormatDateTime: date_utils_1.smartFormatDateTime,
+    smartFormatDate: date_utils_1.smartFormatDate,
+    isToday: date_utils_1.isDateToday,
+    isYesterday: date_utils_1.isDateYesterday,
+    isTomorrow: date_utils_1.isDateTomorrow
+};

package/dist/scripts/src/components-core/appContext/math-function.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mathFunctions = void 0;
+/**
+ * This function calculates the average of the specified values and returns it.
+ * @param values Values to calculate the average
+ * @param decimals Number of decimal places to round the result
+ */
+function avg(values, decimals) {
+    if (values.length === 0) {
+        return 0;
+    }
+    const sumValues = sum(values);
+    const result = sumValues / values.length;
+    return decimals ? Number(result.toFixed(decimals)) : result;
+}
+/**
+ * This function calculates the sum of the specified values and returns it.
+ * @param values Values to calculate the sum
+ */
+function sum(values) {
+    return values.reduce((acc, val) => acc + val, 0);
+}
+exports.mathFunctions = {
+    avg,
+    sum
+};

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.miscellaneousUtils = void 0;
+const lodash_es_1 = require("lodash-es");
+const misc_1 = require("@components-core/utils/misc");
+exports.miscellaneousUtils = {
+    capitalize: lodash_es_1.capitalize,
+    pluralize: misc_1.pluralize,
+    defaultTo: lodash_es_1.defaultTo,
+    toHashObject: misc_1.toHashObject,
+    findByField: misc_1.findByField,
+};

package/dist/scripts/src/components-core/component-hooks.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useContentAlignment = useContentAlignment;
+const react_1 = require("react");
+const Stack_module_scss_1 = __importDefault(require("@components/Stack/Stack.module.scss"));
+const misc_1 = require("@components-core/utils/misc");
+// This react hooks prepares CSS style values according to the CSS flex semantics to combine orientation,
+// horizontal, and vertical alignments.
+function useContentAlignment(orientation, horizontal, vertical) {
+    return (0, react_1.useMemo)(() => {
+        // --- Use CSS flex semantics to combine the orientation with alignment to prepare the CSS properties
+        return orientation === "horizontal"
+            ? {
+                horizontal: horizontal && Stack_module_scss_1.default[`justifyItems${(0, misc_1.capitalizeFirstLetter)(horizontal)}`],
+                vertical: vertical && Stack_module_scss_1.default[`alignItems${(0, misc_1.capitalizeFirstLetter)(vertical)}`],
+            }
+            : {
+                horizontal: horizontal && Stack_module_scss_1.default[`alignItems${(0, misc_1.capitalizeFirstLetter)(horizontal)}`],
+                vertical: vertical && Stack_module_scss_1.default[`justifyItems${(0, misc_1.capitalizeFirstLetter)(vertical)}`],
+            };
+    }, [orientation, horizontal, vertical]);
+}

package/dist/scripts/src/components-core/constants.js

@@ -0,0 +1,18 @@
+"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.asyncNoop = exports.noop = exports.EMPTY_OBJECT = exports.EMPTY_ARRAY = void 0;
+exports.EMPTY_ARRAY = Object.freeze([]);
+exports.EMPTY_OBJECT = Object.freeze({});
+const noop = (...args) => ({});
+exports.noop = noop;
+const asyncNoop = (...args) => __awaiter(void 0, void 0, void 0, function* () { });
+exports.asyncNoop = asyncNoop;