xmlui 0.9.21 → 0.9.25

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,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.miscellaneousUtils = void 0;
+const lodash_es_1 = require("lodash-es");
+const misc_1 = require("../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,
+    distinct: misc_1.distinct
+};

package/dist/scripts/src/components-core/interception/ApiInterceptor.js

@@ -0,0 +1,199 @@
+"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.ApiInterceptor = exports.AuthService = void 0;
+const msw_1 = require("msw");
+const lodash_es_1 = require("lodash-es");
+const Backend_1 = require("../interception/Backend");
+const IndexedDb_1 = require("../interception/IndexedDb");
+const request_params_1 = require("../utils/request-params");
+const Errors_1 = require("../interception/Errors");
+const EngineError_1 = require("../EngineError");
+const InMemoryDb_1 = require("../interception/InMemoryDb");
+function mergeHeaders(...sources) {
+    const result = {};
+    for (const source of sources) {
+        if (!(0, lodash_es_1.isObject)(source)) {
+            throw new TypeError("All arguments must be of type object");
+        }
+        const headers = new Headers(source);
+        for (const [key, value] of headers.entries()) {
+            if (value === undefined || value === "undefined") {
+                delete result[key];
+            }
+            else {
+                result[key] = value;
+            }
+        }
+    }
+    return new Headers(result);
+}
+// Represents the authentication service used within an API interceptor
+class AuthService {
+    constructor(auth) {
+        const cachedLoggedInUser = JSON.parse(sessionStorage.getItem("session-logged-in-user"));
+        this.loggedInUser = cachedLoggedInUser || (auth === null || auth === void 0 ? void 0 : auth.defaultLoggedInUser);
+    }
+    login(newLoggedInUser) {
+        this.loggedInUser = newLoggedInUser;
+        sessionStorage.setItem("session-logged-in-user", JSON.stringify(newLoggedInUser));
+    }
+    logout() {
+        this.loggedInUser = null;
+        sessionStorage.removeItem("session-logged-in-user");
+    }
+    getCookieToken() {
+        return sessionStorage.getItem("session-anonymous-token");
+    }
+    setCookieToken(token) {
+        sessionStorage.setItem("session-anonymous-token", token);
+    }
+    getLoggedInUser() {
+        return this.loggedInUser;
+    }
+}
+exports.AuthService = AuthService;
+function initDb(apiDef) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        switch (apiDef.type) {
+            case "in-memory":
+                return new InMemoryDb_1.InMemoryDb((_a = apiDef.schemaDescriptor) === null || _a === void 0 ? void 0 : _a.tables, apiDef.initialData, apiDef.config);
+            default:
+                const indexedDb = new IndexedDb_1.IndexedDb((_b = apiDef.schemaDescriptor) === null || _b === void 0 ? void 0 : _b.tables, apiDef.initialData, apiDef.config);
+                yield indexedDb.initialize();
+                return indexedDb;
+        }
+    });
+}
+// An API interceptor implementation
+class ApiInterceptor {
+    constructor(apiDef) {
+        this.apiDef = apiDef;
+        this.backend = null;
+    }
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // --- Transfer the handlers of API operations to the backend implementation
+            const backendOperations = {};
+            Object.entries(this.apiDef.operations || {}).forEach(([key, value]) => {
+                backendOperations[key] = value.handler;
+            });
+            const db = yield initDb(this.apiDef);
+            const authService = new AuthService(this.apiDef.auth);
+            const definition = {
+                operations: backendOperations,
+                initialize: this.apiDef.initialize,
+                helpers: this.apiDef.helpers,
+            };
+            this.backend = new Backend_1.Backend(definition, db, authService);
+        });
+    }
+    getOperations() {
+        return this.apiDef.operations || {};
+    }
+    getApiUrl() {
+        return this.apiDef.apiUrl || "";
+    }
+    // Use the "msw" package to execute the interceptor operation
+    executeOperation(operationId, req, cookies, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if (this.backend === null) {
+                throw new Error("Interceptor not initialized");
+            }
+            const operation = (_a = this.apiDef.operations) === null || _a === void 0 ? void 0 : _a[operationId];
+            if (!operation) {
+                throw new Error(`Unknown API interceptor operation: ${operationId}`);
+            }
+            let reqBody;
+            try {
+                if (operation.requestShape === "formData") {
+                    const formData = yield req.formData();
+                    const obj = {};
+                    for (const key of formData.keys()) {
+                        const all = formData.getAll(key);
+                        if (all.length === 1) {
+                            obj[key] = all[0];
+                        }
+                        else {
+                            obj[key] = all;
+                        }
+                    }
+                    reqBody = obj;
+                }
+                else if (operation.requestShape === "blob") {
+                    reqBody = yield req.blob();
+                }
+                else {
+                    reqBody = yield req.json();
+                }
+            }
+            catch (e) { }
+            // --- Map path parameters
+            const mappedParams = this.convertRequestParams({
+                pathParams: params,
+                queryParams: Object.fromEntries(new URL(req.url).searchParams),
+                requestBody: reqBody,
+                cookies: cookies,
+                requestHeaders: Object.fromEntries(req.headers.entries()) || {},
+            }, operation);
+            //artificial delay for http requests
+            yield (0, msw_1.delay)();
+            const cookieService = new Backend_1.CookieService();
+            const headerService = new Backend_1.HeaderService();
+            try {
+                const ret = yield this.backend.executeOperation(operationId, mappedParams, cookieService, headerService);
+                const emptyBody = ret === undefined || ret === null;
+                const successStatusCode = (_b = operation.successStatusCode) !== null && _b !== void 0 ? _b : (emptyBody ? Errors_1.HttpStatusCode.NoContent : Errors_1.HttpStatusCode.Ok);
+                const headers = mergeHeaders(cookieService.getCookieHeader(), headerService.getHeaders());
+                if (ret instanceof File) {
+                    headers.append("Content-type", ret.type);
+                    headers.append("Content-Length", ret.size + "");
+                    headers.append("Content-Disposition", `attachment; filename="${ret.name}"; filename*=utf-8''${ret.name}`);
+                    return msw_1.HttpResponse.arrayBuffer(yield ret.arrayBuffer(), {
+                        headers: headers,
+                        status: successStatusCode,
+                    });
+                }
+                if (emptyBody) {
+                    return new msw_1.HttpResponse(null, {
+                        headers: headers,
+                        status: successStatusCode,
+                    });
+                }
+                console.log(operationId, ret);
+                return msw_1.HttpResponse.json(ret, {
+                    headers: headers,
+                    status: successStatusCode,
+                });
+            }
+            catch (e) {
+                console.error(e);
+                if (e instanceof EngineError_1.ThrowStatementError && e.errorObject instanceof Errors_1.HttpError) {
+                    return msw_1.HttpResponse.json(e.errorObject.details, {
+                        headers: cookieService.getCookieHeader(),
+                        status: e.errorObject.status,
+                    });
+                }
+                return msw_1.HttpResponse.json({ message: e === null || e === void 0 ? void 0 : e.message }, {
+                    headers: cookieService.getCookieHeader(),
+                    status: Errors_1.HttpStatusCode.InternalServerError,
+                });
+            }
+        });
+    }
+    // Ensures that type path and query params are converted according to the operation definition
+    convertRequestParams(params, operation) {
+        return Object.assign(Object.assign({}, params), { pathParams: (0, request_params_1.convertRequestParamPart)(params.pathParams, operation.pathParamTypes), queryParams: (0, request_params_1.convertRequestParamPart)(params.queryParams, operation.queryParamTypes) });
+    }
+}
+exports.ApiInterceptor = ApiInterceptor;

package/dist/scripts/src/components-core/interception/ApiInterceptorProvider.js

@@ -0,0 +1,94 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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.ApiInterceptorProvider = ApiInterceptorProvider;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const misc_1 = require("../utils/misc");
+const useApiInterceptorContext_1 = require("./useApiInterceptorContext");
+// This React component injects the API interceptor into the application's context
+function ApiInterceptorProvider({ interceptor, children, apiWorker, useHashBasedRouting, }) {
+    const [initialized, setInitialized] = (0, react_1.useState)(!interceptor);
+    // --- Whenever the interceptor changes, update the provider accordingly
+    (0, react_1.useEffect)(() => {
+        if (interceptor) {
+            setInitialized(false);
+            // --- We use "msw" to manage the API interception
+            let interceptorWorker;
+            (() => __awaiter(this, void 0, void 0, function* () {
+                // --- Create the worker on the fly
+                if (process.env.VITE_MOCK_ENABLED) {
+                    const { createApiInterceptorWorker } = yield Promise.resolve().then(() => __importStar(require("./apiInterceptorWorker")));
+                    if (interceptor) {
+                        interceptorWorker = yield createApiInterceptorWorker(interceptor, apiWorker);
+                        // if the apiWorker comes from the outside, we don't handle the lifecycle here
+                        if (!apiWorker) {
+                            const workerFileLocation = (0, misc_1.normalizePath)(process.env.VITE_MOCK_WORKER_LOCATION || "mockServiceWorker.js");
+                            yield interceptorWorker.start({
+                                onUnhandledRequest: "bypass",
+                                quiet: true,
+                                serviceWorker: {
+                                    url: workerFileLocation,
+                                },
+                            });
+                        }
+                    }
+                }
+                setInitialized(true);
+            }))();
+            return () => {
+                // if the apiWorker comes from the outside, we don't handle the lifecycle here
+                if (!apiWorker) {
+                    interceptorWorker === null || interceptorWorker === void 0 ? void 0 : interceptorWorker.stop();
+                }
+            };
+        }
+    }, [apiWorker, interceptor, useHashBasedRouting]);
+    const contextValue = (0, react_1.useMemo)(() => {
+        return {
+            isMocked: (url) => interceptor !== undefined && !!process.env.VITE_MOCK_ENABLED,
+        };
+    }, [interceptor]);
+    return ((0, jsx_runtime_1.jsx)(useApiInterceptorContext_1.ApiInterceptorContext.Provider, { value: contextValue, children: initialized ? children || null : null }));
+}

package/dist/scripts/src/components-core/interception/Backend.js

@@ -0,0 +1,128 @@
+"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.Backend = exports.HeaderService = exports.CookieService = exports.defaultBackendEnvironment = void 0;
+const lodash_es_1 = require("lodash-es");
+const misc_1 = require("../utils/misc");
+const statementUtils_1 = require("../utils/statementUtils");
+const date_functions_1 = require("../appContext/date-functions");
+const misc_utils_1 = require("../appContext/misc-utils");
+const date_utils_1 = require("../utils/date-utils");
+const Errors_1 = __importDefault(require("../interception/Errors"));
+// Use this backend environment as the default
+exports.defaultBackendEnvironment = {
+    getDate: (date) => (date ? new Date(date) : new Date()),
+};
+const mapValuesDeep = (obj, cb) => {
+    if ((0, lodash_es_1.isArray)(obj)) {
+        return obj.map((innerObj) => mapValuesDeep(innerObj, cb));
+    }
+    else if ((0, lodash_es_1.isObject)(obj)) {
+        return (0, lodash_es_1.mapValues)(obj, (val) => mapValuesDeep(val, cb));
+    }
+    else {
+        return cb(obj);
+    }
+};
+class CookieService {
+    constructor() {
+        this.cookies = {};
+    }
+    setCookie(key, value) {
+        this.cookies[key] = value;
+    }
+    getCookieHeader() {
+        const cookieArrays = [];
+        Object.entries(this.cookies).forEach(([key, value]) => {
+            if (Array.isArray(value)) {
+                value.forEach((val) => cookieArrays.push(["Set-Cookie", `${key}=${val}`]));
+            }
+            else {
+                cookieArrays.push(["Set-Cookie", `${key}=${value}`]);
+            }
+        });
+        return new Headers(cookieArrays);
+    }
+}
+exports.CookieService = CookieService;
+class HeaderService {
+    constructor() {
+        this.headers = {};
+    }
+    setHeader(key, value) {
+        this.headers[key] = value;
+    }
+    getHeaders() {
+        const headersArray = [];
+        Object.entries(this.headers).forEach(([key, value]) => {
+            headersArray.push([key, value]);
+        });
+        return new Headers(headersArray);
+    }
+}
+exports.HeaderService = HeaderService;
+class Backend {
+    constructor(definition, db, authService) {
+        this.definition = definition;
+        this.db = db;
+        this.authService = authService;
+        this.apiStateHash = {};
+        this.resolvedHelpers = mapValuesDeep(definition.helpers, (helper) => {
+            if (typeof helper === "string") {
+                return (...params) => this.runFn(helper, ...params);
+            }
+            return helper;
+        });
+        if (definition.initialize) {
+            this.runFn(definition.initialize);
+        }
+    }
+    executeOperation(operationId, requestParams, cookieService, headerService) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const handler = (_a = this.definition.operations) === null || _a === void 0 ? void 0 : _a[operationId];
+            if (!handler) {
+                throw new Error(`Unknown backend operation: ${operationId}`);
+            }
+            return yield this.runFn(handler, requestParams, cookieService, headerService);
+        });
+    }
+    runFn(src, ...args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g;
+            let localContext = Object.assign(Object.assign({}, this.resolvedHelpers), { $db: this.db, $state: this.apiStateHash, $authService: this.authService, $env: exports.defaultBackendEnvironment, $loggedInUser: this.authService.getLoggedInUser(), $pathParams: (_a = args[0]) === null || _a === void 0 ? void 0 : _a.pathParams, $queryParams: (_b = args[0]) === null || _b === void 0 ? void 0 : _b.queryParams, $requestBody: (_c = args[0]) === null || _c === void 0 ? void 0 : _c.requestBody, $cookies: (_d = args[0]) === null || _d === void 0 ? void 0 : _d.cookies, $requestHeaders: (_e = args[0]) === null || _e === void 0 ? void 0 : _e.requestHeaders, $cookieService: args[1], $headerService: args[2] });
+            const evalContext = createEvalContext({
+                localContext: localContext,
+                eventArgs: args,
+                appContext: Object.assign(Object.assign(Object.assign({}, date_functions_1.dateFunctions), misc_utils_1.miscellaneousUtils), { delay: misc_1.delay,
+                    Errors: Errors_1.default, createFile: (...args) => new File(args[0], args[1], args[2]), getDate: date_utils_1.getDate }),
+            });
+            yield (0, statementUtils_1.runEventHandlerCode)(src, evalContext);
+            return ((_g = (_f = evalContext.mainThread) === null || _f === void 0 ? void 0 : _f.blocks) === null || _g === void 0 ? void 0 : _g.length)
+                ? evalContext.mainThread.blocks[evalContext.mainThread.blocks.length - 1].returnValue
+                : undefined;
+        });
+    }
+}
+exports.Backend = Backend;
+function createEvalContext(parts) {
+    return Object.assign({
+        mainThread: {
+            childThreads: [],
+            blocks: [{ vars: {} }],
+            loops: [],
+            breakLabelValue: -1,
+        },
+    }, parts);
+}

package/dist/scripts/src/components-core/interception/Errors.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConflictError = exports.UnauthorizedError = exports.NotFoundError = exports.HttpError = exports.HttpStatusCode = void 0;
+//stolen from axios
+var HttpStatusCode;
+(function (HttpStatusCode) {
+    HttpStatusCode[HttpStatusCode["Continue"] = 100] = "Continue";
+    HttpStatusCode[HttpStatusCode["SwitchingProtocols"] = 101] = "SwitchingProtocols";
+    HttpStatusCode[HttpStatusCode["Processing"] = 102] = "Processing";
+    HttpStatusCode[HttpStatusCode["EarlyHints"] = 103] = "EarlyHints";
+    HttpStatusCode[HttpStatusCode["Ok"] = 200] = "Ok";
+    HttpStatusCode[HttpStatusCode["Created"] = 201] = "Created";
+    HttpStatusCode[HttpStatusCode["Accepted"] = 202] = "Accepted";
+    HttpStatusCode[HttpStatusCode["NonAuthoritativeInformation"] = 203] = "NonAuthoritativeInformation";
+    HttpStatusCode[HttpStatusCode["NoContent"] = 204] = "NoContent";
+    HttpStatusCode[HttpStatusCode["ResetContent"] = 205] = "ResetContent";
+    HttpStatusCode[HttpStatusCode["PartialContent"] = 206] = "PartialContent";
+    HttpStatusCode[HttpStatusCode["MultiStatus"] = 207] = "MultiStatus";
+    HttpStatusCode[HttpStatusCode["AlreadyReported"] = 208] = "AlreadyReported";
+    HttpStatusCode[HttpStatusCode["ImUsed"] = 226] = "ImUsed";
+    HttpStatusCode[HttpStatusCode["MultipleChoices"] = 300] = "MultipleChoices";
+    HttpStatusCode[HttpStatusCode["MovedPermanently"] = 301] = "MovedPermanently";
+    HttpStatusCode[HttpStatusCode["Found"] = 302] = "Found";
+    HttpStatusCode[HttpStatusCode["SeeOther"] = 303] = "SeeOther";
+    HttpStatusCode[HttpStatusCode["NotModified"] = 304] = "NotModified";
+    HttpStatusCode[HttpStatusCode["UseProxy"] = 305] = "UseProxy";
+    HttpStatusCode[HttpStatusCode["Unused"] = 306] = "Unused";
+    HttpStatusCode[HttpStatusCode["TemporaryRedirect"] = 307] = "TemporaryRedirect";
+    HttpStatusCode[HttpStatusCode["PermanentRedirect"] = 308] = "PermanentRedirect";
+    HttpStatusCode[HttpStatusCode["BadRequest"] = 400] = "BadRequest";
+    HttpStatusCode[HttpStatusCode["Unauthorized"] = 401] = "Unauthorized";
+    HttpStatusCode[HttpStatusCode["PaymentRequired"] = 402] = "PaymentRequired";
+    HttpStatusCode[HttpStatusCode["Forbidden"] = 403] = "Forbidden";
+    HttpStatusCode[HttpStatusCode["NotFound"] = 404] = "NotFound";
+    HttpStatusCode[HttpStatusCode["MethodNotAllowed"] = 405] = "MethodNotAllowed";
+    HttpStatusCode[HttpStatusCode["NotAcceptable"] = 406] = "NotAcceptable";
+    HttpStatusCode[HttpStatusCode["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired";
+    HttpStatusCode[HttpStatusCode["RequestTimeout"] = 408] = "RequestTimeout";
+    HttpStatusCode[HttpStatusCode["Conflict"] = 409] = "Conflict";
+    HttpStatusCode[HttpStatusCode["Gone"] = 410] = "Gone";
+    HttpStatusCode[HttpStatusCode["LengthRequired"] = 411] = "LengthRequired";
+    HttpStatusCode[HttpStatusCode["PreconditionFailed"] = 412] = "PreconditionFailed";
+    HttpStatusCode[HttpStatusCode["PayloadTooLarge"] = 413] = "PayloadTooLarge";
+    HttpStatusCode[HttpStatusCode["UriTooLong"] = 414] = "UriTooLong";
+    HttpStatusCode[HttpStatusCode["UnsupportedMediaType"] = 415] = "UnsupportedMediaType";
+    HttpStatusCode[HttpStatusCode["RangeNotSatisfiable"] = 416] = "RangeNotSatisfiable";
+    HttpStatusCode[HttpStatusCode["ExpectationFailed"] = 417] = "ExpectationFailed";
+    HttpStatusCode[HttpStatusCode["ImATeapot"] = 418] = "ImATeapot";
+    HttpStatusCode[HttpStatusCode["MisdirectedRequest"] = 421] = "MisdirectedRequest";
+    HttpStatusCode[HttpStatusCode["UnprocessableEntity"] = 422] = "UnprocessableEntity";
+    HttpStatusCode[HttpStatusCode["Locked"] = 423] = "Locked";
+    HttpStatusCode[HttpStatusCode["FailedDependency"] = 424] = "FailedDependency";
+    HttpStatusCode[HttpStatusCode["TooEarly"] = 425] = "TooEarly";
+    HttpStatusCode[HttpStatusCode["UpgradeRequired"] = 426] = "UpgradeRequired";
+    HttpStatusCode[HttpStatusCode["PreconditionRequired"] = 428] = "PreconditionRequired";
+    HttpStatusCode[HttpStatusCode["TooManyRequests"] = 429] = "TooManyRequests";
+    HttpStatusCode[HttpStatusCode["RequestHeaderFieldsTooLarge"] = 431] = "RequestHeaderFieldsTooLarge";
+    HttpStatusCode[HttpStatusCode["UnavailableForLegalReasons"] = 451] = "UnavailableForLegalReasons";
+    HttpStatusCode[HttpStatusCode["InternalServerError"] = 500] = "InternalServerError";
+    HttpStatusCode[HttpStatusCode["NotImplemented"] = 501] = "NotImplemented";
+    HttpStatusCode[HttpStatusCode["BadGateway"] = 502] = "BadGateway";
+    HttpStatusCode[HttpStatusCode["ServiceUnavailable"] = 503] = "ServiceUnavailable";
+    HttpStatusCode[HttpStatusCode["GatewayTimeout"] = 504] = "GatewayTimeout";
+    HttpStatusCode[HttpStatusCode["HttpVersionNotSupported"] = 505] = "HttpVersionNotSupported";
+    HttpStatusCode[HttpStatusCode["VariantAlsoNegotiates"] = 506] = "VariantAlsoNegotiates";
+    HttpStatusCode[HttpStatusCode["InsufficientStorage"] = 507] = "InsufficientStorage";
+    HttpStatusCode[HttpStatusCode["LoopDetected"] = 508] = "LoopDetected";
+    HttpStatusCode[HttpStatusCode["NotExtended"] = 510] = "NotExtended";
+    HttpStatusCode[HttpStatusCode["NetworkAuthenticationRequired"] = 511] = "NetworkAuthenticationRequired";
+})(HttpStatusCode || (exports.HttpStatusCode = HttpStatusCode = {}));
+class HttpError extends Error {
+    constructor(status, details) {
+        super((details === null || details === void 0 ? void 0 : details.message) || "Not found");
+        this.details = details;
+        this.status = status;
+        Object.setPrototypeOf(this, HttpError.prototype);
+    }
+}
+exports.HttpError = HttpError;
+class NotFoundError extends HttpError {
+    constructor(details) {
+        super(HttpStatusCode.NotFound, details);
+        Object.setPrototypeOf(this, NotFoundError.prototype);
+    }
+}
+exports.NotFoundError = NotFoundError;
+class UnauthorizedError extends HttpError {
+    constructor(details) {
+        super(HttpStatusCode.Unauthorized, details);
+        Object.setPrototypeOf(this, UnauthorizedError.prototype);
+    }
+}
+exports.UnauthorizedError = UnauthorizedError;
+class ConflictError extends HttpError {
+    constructor(details) {
+        super(HttpStatusCode.Conflict, details);
+        Object.setPrototypeOf(this, ConflictError.prototype);
+    }
+}
+exports.ConflictError = ConflictError;
+function convertErrorDetails(messageOrDetails) {
+    let details;
+    if (messageOrDetails) {
+        if (typeof messageOrDetails === "string") {
+            details = {
+                message: messageOrDetails,
+            };
+        }
+        else {
+            details = messageOrDetails;
+        }
+    }
+    return details;
+}
+const Errors = {
+    NotFound404: (messageOrDetails) => {
+        return new NotFoundError(convertErrorDetails(messageOrDetails));
+    },
+    Unauthorized401: (messageOrDetails) => {
+        return new UnauthorizedError(convertErrorDetails(messageOrDetails));
+    },
+    HttpError: (errorCode, messageOrDetails) => {
+        return new HttpError(errorCode, convertErrorDetails(messageOrDetails));
+    },
+    Conflict409: (messageOrDetails) => {
+        return new ConflictError(convertErrorDetails(messageOrDetails));
+    }
+};
+exports.default = Errors;

package/dist/scripts/src/components-core/interception/InMemoryDb.js

@@ -0,0 +1,41 @@
+"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.InMemoryDb = void 0;
+class InMemoryDb {
+    constructor(tables, initialData = {}, config) {
+        this.tables = tables;
+        this.initialData = initialData;
+        this.config = config;
+    }
+    getItems(collectionName) {
+        throw new Error("Method not implemented.");
+    }
+    getItem(collectionName, predicate) {
+        throw new Error("Method not implemented.");
+    }
+    getItemById(collectionName, id) {
+        throw new Error("Method not implemented.");
+    }
+    deleteItems(collectionName, predicate) {
+        throw new Error("Method not implemented.");
+    }
+    insertItem(collectionName, item) {
+        throw new Error("Method not implemented.");
+    }
+    updateItem(collectionName, item) {
+        throw new Error("Method not implemented.");
+    }
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+}
+exports.InMemoryDb = InMemoryDb;