xmlui 0.4.0

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

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const jsx_runtime_1 = require("react/jsx-runtime");
+const UnknownComponent_module_scss_1 = __importDefault(require("./UnknownComponent.module.scss"));
+/**
+ * This React component renders an error message telling that a particular component type is not registered.
+ * @param message Message to display
+ */
+function UnknownComponent({ message }) {
+    return ((0, jsx_runtime_1.jsx)("div", { className: UnknownComponent_module_scss_1.default.errorOverlay, children: (0, jsx_runtime_1.jsxs)("span", { className: UnknownComponent_module_scss_1.default.title, children: ["Unknown component: ", message] }) }));
+}
+exports.default = UnknownComponent;

package/dist/scripts/src/components-core/abstractions/ComponentRenderer.js

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

package/dist/scripts/src/components-core/abstractions/LoaderRenderer.js

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

package/dist/scripts/src/components-core/abstractions/containers.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerActionKind = void 0;
+/**
+ * This enumeration defines the available actions on a view container. We use these actions in the redux-style state
+ * management of the component rendering engine.
+ */
+var ContainerActionKind;
+(function (ContainerActionKind) {
+    ContainerActionKind["LOADER_LOADED"] = "ContainerActionKind:LOADER_LOADED";
+    ContainerActionKind["LOADER_IN_PROGRESS_CHANGED"] = "ContainerActionKind:LOADER_IN_PROGRESS_CHANGED";
+    ContainerActionKind["LOADER_ERROR"] = "ContainerActionKind:LOADER_ERROR";
+    ContainerActionKind["EVENT_HANDLER_STARTED"] = "ContainerActionKind:EVENT_HANDLER_STARTED";
+    ContainerActionKind["EVENT_HANDLER_COMPLETED"] = "ContainerActionKind:EVENT_HANDLER_COMPLETED";
+    ContainerActionKind["EVENT_HANDLER_ERROR"] = "ContainerActionKind:EVENT_HANDLER_ERROR";
+    ContainerActionKind["COMPONENT_STATE_CHANGED"] = "ContainerActionKind:COMPONENT_STATE_CHANGED";
+    ContainerActionKind["STATE_PART_CHANGED"] = "ContainerActionKind:STATE_PART_CHANGED";
+})(ContainerActionKind || (exports.ContainerActionKind = ContainerActionKind = {}));

package/dist/scripts/src/components-core/abstractions/treeAbstractions.js

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

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

@@ -0,0 +1,276 @@
+"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.apiAction = void 0;
+const react_hot_toast_1 = __importDefault(require("react-hot-toast"));
+const RestApiProxy_1 = __importDefault(require("@components-core/RestApiProxy"));
+const actionUtils_1 = require("@components-core/utils/actionUtils");
+const extractParam_1 = require("@components-core/utils/extractParam");
+const immer_1 = require("immer");
+const misc_1 = require("@components-core/utils/misc");
+const actions_1 = require("./actions");
+function findQueryKeysToUpdate(updates, queryClient) {
+    const queryKeysToUpdate = [];
+    if (updates) {
+        let updatesArray;
+        if (Array.isArray(updates)) {
+            updatesArray = updates;
+        }
+        else {
+            updatesArray = [updates];
+        }
+        updatesArray.forEach((queryUrl) => {
+            queryClient
+                .getQueryCache()
+                .getAll()
+                .forEach((query) => {
+                if (query.queryKey[0] === queryUrl) {
+                    queryKeysToUpdate.push(query.queryKey);
+                }
+            });
+        });
+    }
+    return queryKeysToUpdate;
+}
+function prepareOptimisticValue(value, clientTxId) {
+    return Object.assign(Object.assign({}, value), { id: value.id || clientTxId, _optimisticValue: true, _initiatorClientTxId: clientTxId });
+}
+function prepareOptimisticValuesForQueries(queryKeys, queryClient, clientTxId, stateContext, resolvedOptimisticValue, optimisticValueGetter) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const ret = new Map();
+        yield Promise.all(queryKeys.map((queryKey) => __awaiter(this, void 0, void 0, function* () {
+            if (resolvedOptimisticValue) {
+                ret.set(queryKey, prepareOptimisticValue(resolvedOptimisticValue, clientTxId));
+                return;
+            }
+            if (!optimisticValueGetter) {
+                return;
+            }
+            const currentData = queryClient.getQueryData(queryKey);
+            const flatData = (currentData === null || currentData === void 0 ? void 0 : currentData.pages) ? currentData.pages.flatMap((page) => page.result) : currentData;
+            const optimisticValue = yield optimisticValueGetter(flatData, stateContext["$eventArgs"]);
+            if (optimisticValue) {
+                ret.set(queryKey, prepareOptimisticValue(optimisticValue, clientTxId));
+            }
+        })));
+        return ret;
+    });
+}
+function doOptimisticUpdate(optimisticValuesByQueryKeys, queryClient) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!optimisticValuesByQueryKeys.size) {
+            return;
+        }
+        for (const entry of optimisticValuesByQueryKeys.entries()) {
+            const [key, optimisticValue] = entry;
+            yield queryClient.cancelQueries({ queryKey: key });
+            const oldData = queryClient.getQueryData(key);
+            const draft = (0, immer_1.createDraft)(oldData);
+            if (draft.pages) {
+                let updated = false;
+                draft.pages.forEach((page) => {
+                    var _a;
+                    (_a = page.result) === null || _a === void 0 ? void 0 : _a.forEach((item) => {
+                        if (item.id === optimisticValue.id) {
+                            Object.assign(item, optimisticValue);
+                            updated = true;
+                        }
+                    });
+                });
+                if (!updated) {
+                    draft.pages[draft.pages.length - 1].result.push(optimisticValue);
+                }
+            }
+            else {
+                let updated = false;
+                draft.forEach((item) => {
+                    if (item.id === optimisticValue.id) {
+                        Object.assign(item, optimisticValue);
+                        updated = true;
+                    }
+                });
+                if (!updated) {
+                    draft.push(optimisticValue);
+                }
+            }
+            const newData = (0, immer_1.finishDraft)(draft);
+            queryClient.setQueryData(key, newData);
+            // console.log("optimistic added", { finalOptimisticValue, newData });
+        }
+    });
+}
+function updateQueriesWithResult(queryKeysToUpdate, optimisticValuesByQueryKeys, clientTxId, queryClient, result) {
+    if (!queryKeysToUpdate.length) {
+        return;
+    }
+    queryKeysToUpdate.forEach((key) => {
+        const oldData = queryClient.getQueryData(key);
+        const draft = (0, immer_1.createDraft)(oldData);
+        const optimisticValue = optimisticValuesByQueryKeys.get(key);
+        if (draft.pages) {
+            //pageable loader
+            if (optimisticValue) {
+                draft.pages[draft.pages.length - 1].result = draft.pages[draft.pages.length - 1].result.map((item) => item.id === optimisticValue.id && item._initiatorClientTxId === clientTxId ? result : item);
+            }
+            else {
+                let updated = false;
+                draft.pages.forEach((page) => {
+                    var _a;
+                    (_a = page.result) === null || _a === void 0 ? void 0 : _a.forEach((item) => {
+                        if (item.id === result.id) {
+                            Object.assign(item, result);
+                            updated = true;
+                        }
+                    });
+                });
+                if (!updated) {
+                    draft.pages[draft.pages.length - 1].result.push(result);
+                }
+            }
+        }
+        else {
+            if (optimisticValue) {
+                draft.forEach((item, index) => {
+                    if (item.id === optimisticValue.id && item._initiatorClientTxId === clientTxId) {
+                        draft[index] = result;
+                    }
+                });
+            }
+            else {
+                let updated = false;
+                draft.forEach((item, index) => {
+                    if (item.id === result.id) {
+                        draft[index] = result;
+                        updated = true;
+                    }
+                });
+                if (!updated) {
+                    draft.push(result);
+                }
+            }
+        }
+        const newData = (0, immer_1.finishDraft)(draft);
+        queryClient.setQueryData(key, newData);
+    });
+}
+function updateQueriesWithOptimisticValue(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ stateContext, updates, appContext, queryClient, clientTxId, optimisticValue, lookupAction, getOptimisticValue, uid, }) {
+        const queryKeysToUpdate = findQueryKeysToUpdate((0, extractParam_1.extractParam)(stateContext, updates, appContext), queryClient);
+        const optimisticValuesByQueryKeys = yield prepareOptimisticValuesForQueries(queryKeysToUpdate, queryClient, clientTxId, stateContext, (0, extractParam_1.extractParam)(stateContext, optimisticValue, appContext), lookupAction(getOptimisticValue, uid));
+        yield doOptimisticUpdate(optimisticValuesByQueryKeys, queryClient);
+        return { queryKeysToUpdate, optimisticValuesByQueryKeys };
+    });
+}
+function callApi(_a, _b) {
+    return __awaiter(this, arguments, void 0, function* ({ state, appContext, lookupAction, uid: containerUid }, { confirmTitle, confirmMessage, confirmButtonLabel, params = {}, beforeRequest, onSuccess, onError, invalidates, updates, optimisticValue, payloadType, when, getOptimisticValue, inProgressNotificationMessage, completedNotificationMessage, errorNotificationMessage, uid: actionUid, onProgress, 
+    //operation
+    headers, url, queryParams, rawBody, method, body, }, { resolveBindingExpressions } = {}) {
+        const uid = Symbol(actionUid);
+        const stateContext = Object.assign(Object.assign({}, params), state);
+        if (!(0, extractParam_1.shouldKeep)(when, stateContext, appContext)) {
+            return;
+        }
+        if (confirmTitle || confirmMessage || confirmButtonLabel) {
+            const title = (0, extractParam_1.extractParam)(stateContext, confirmTitle, appContext);
+            const message = (0, extractParam_1.extractParam)(stateContext, confirmMessage, appContext);
+            const buttonLabel = (0, extractParam_1.extractParam)(stateContext, confirmButtonLabel, appContext);
+            const dialogCheck = yield appContext.confirm(title !== null && title !== void 0 ? title : "Confirm Operation", message !== null && message !== void 0 ? message : "Are you sure you want to perform this operation?", buttonLabel !== null && buttonLabel !== void 0 ? buttonLabel : "Yes");
+            if (!dialogCheck)
+                return;
+        }
+        const resolvedInvalidates = (0, extractParam_1.extractParam)(stateContext, invalidates, appContext);
+        const clientTxId = (0, misc_1.randomUUID)();
+        const beforeRequestFn = lookupAction(beforeRequest, uid);
+        yield (beforeRequestFn === null || beforeRequestFn === void 0 ? void 0 : beforeRequestFn());
+        const { queryKeysToUpdate, optimisticValuesByQueryKeys } = yield updateQueriesWithOptimisticValue({
+            stateContext,
+            updates,
+            appContext,
+            queryClient: appContext.queryClient,
+            clientTxId,
+            optimisticValue,
+            lookupAction,
+            getOptimisticValue,
+            uid,
+        });
+        const inProgressMessage = (0, extractParam_1.extractParam)(stateContext, inProgressNotificationMessage, appContext);
+        let loadingToastId;
+        if (inProgressMessage) {
+            loadingToastId = react_hot_toast_1.default.loading(inProgressMessage);
+        }
+        try {
+            const operation = {
+                headers,
+                url,
+                queryParams,
+                rawBody,
+                method,
+                body,
+                payloadType
+            };
+            const _onProgress = lookupAction(onProgress, uid, {
+                eventName: "progress"
+            });
+            const result = yield new RestApiProxy_1.default(appContext).execute({
+                operation,
+                params: stateContext,
+                transactionId: clientTxId,
+                resolveBindingExpressions,
+                onProgress: _onProgress
+            });
+            const onSuccessFn = lookupAction(onSuccess, uid, {
+                eventName: "success",
+            });
+            yield (onSuccessFn === null || onSuccessFn === void 0 ? void 0 : onSuccessFn(result, stateContext["$eventArgs"]));
+            updateQueriesWithResult(queryKeysToUpdate, optimisticValuesByQueryKeys, clientTxId, appContext.queryClient, result);
+            if (resolvedInvalidates || !updates) {
+                yield (0, actionUtils_1.invalidateQueries)(resolvedInvalidates, appContext, state);
+            }
+            const completedMessage = (0, extractParam_1.extractParam)(Object.assign(Object.assign({}, stateContext), { $result: result }), completedNotificationMessage, appContext);
+            if (completedMessage) {
+                react_hot_toast_1.default.success(completedMessage, {
+                    id: loadingToastId,
+                });
+            }
+            else if (loadingToastId) {
+                react_hot_toast_1.default.dismiss(loadingToastId);
+            }
+            return result;
+        }
+        catch (e) {
+            if (optimisticValuesByQueryKeys.size) {
+                yield appContext.queryClient.invalidateQueries();
+            }
+            const onErrorFn = lookupAction(onError, uid, {
+                eventName: "error"
+            });
+            const result = yield (onErrorFn === null || onErrorFn === void 0 ? void 0 : onErrorFn(e, stateContext["$eventArgs"]));
+            const errorMessage = (0, extractParam_1.extractParam)(Object.assign(Object.assign({}, stateContext), { $error: e }), errorNotificationMessage, appContext);
+            if (errorMessage) {
+                react_hot_toast_1.default.error(errorMessage, {
+                    id: loadingToastId
+                });
+            }
+            else {
+                if (loadingToastId) {
+                    react_hot_toast_1.default.dismiss(loadingToastId);
+                }
+                if (result !== false) { //stop the error propagation, if the error handler returns false
+                    throw e;
+                }
+            }
+        }
+    });
+}
+exports.apiAction = (0, actions_1.createAction)("callApi", callApi);

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

@@ -0,0 +1,80 @@
+"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.downloadAction = void 0;
+const actions_1 = require("./actions");
+const RestApiProxy_1 = __importDefault(require("@components-core/RestApiProxy"));
+function download(_a, _b) {
+    return __awaiter(this, arguments, void 0, function* ({ state, appContext }, { params, url, queryParams, method, rawBody, body, fileName, headers, }, { resolveBindingExpressions } = {}) {
+        var _c;
+        const context = Object.assign(Object.assign({}, params), state);
+        const operation = {
+            url,
+            queryParams,
+            method,
+            rawBody,
+            body,
+            fileName,
+            headers,
+        };
+        const api = new RestApiProxy_1.default(appContext);
+        const _url = api.resolveUrl({ operation, params: context, resolveBindingExpressions });
+        if ((operation.method && operation.method.toLowerCase() !== "get") ||
+            Object.keys(((_c = appContext.globals) === null || _c === void 0 ? void 0 : _c.headers) || {}).length !== 0 || //if we have any headers for the api, we can't use the iframe trick
+            appContext.apiInterceptorContext.isMocked(_url) //if we mock this url, the mock can't work in an iframe, so we must fall back to download it with the restApiProxy
+        ) {
+            const file = yield api.execute({
+                operation,
+                params: context,
+                parseOptions: {
+                    asFile: true,
+                },
+                resolveBindingExpressions,
+            });
+            downloadWithAnchor(file);
+        }
+        else {
+            downloadInIframe(_url);
+        }
+    });
+}
+//we use a hidden iframe trick here,
+// we set the iframe source as the download url, this way the browser will ask to download the file, and show a progress bar
+// (we could use an anchor tag with a download attribute, but in this case we can't show progress )
+// we can use it if we don't have to add extra headers to the request in order to download a file (pre-signed urls, or public urls)
+function downloadInIframe(fileUrl) {
+    const iframe = document.createElement("iframe");
+    iframe.style.display = "none";
+    iframe.hidden = true;
+    iframe.name = fileUrl;
+    iframe.id = `download-iframe_${fileUrl}`;
+    iframe.src = fileUrl;
+    document.body.appendChild(iframe);
+    setTimeout(() => {
+        iframe.remove();
+    }, 20000);
+}
+// we can use it if we do have to add extra headers to the request in order to download a file (urls require authentication)
+function downloadWithAnchor(file) {
+    const url = window.URL.createObjectURL(file);
+    const a = document.createElement("a");
+    a.style.display = "none";
+    a.href = url;
+    // the filename you want
+    a.download = file.name;
+    document.body.appendChild(a);
+    a.click();
+    window.URL.revokeObjectURL(url);
+}
+exports.downloadAction = (0, actions_1.createAction)("download", download);

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({ appContext, 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/UploadAction.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["$eventArgs"]));
+            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/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/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 = {
+    formatFileSizeInBytes: misc_1.formatFileSizeInBytes,
+    getFileExtension: misc_1.getFileExtension,
+    capitalize: lodash_es_1.capitalize,
+    pluralize: misc_1.pluralize,
+    defaultTo: lodash_es_1.defaultTo
+};

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;