xmlui 0.7.14 → 0.7.16

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

@@ -0,0 +1,129 @@
+"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("@components-core/utils/misc");
+const statementUtils_1 = require("@components-core/utils/statementUtils");
+const Errors_1 = __importDefault(require("@components-core/interception/Errors"));
+const date_functions_1 = require("@components-core/appContext/date-functions");
+const misc_utils_1 = require("@components-core/appContext/misc-utils");
+const date_utils_1 = require("@components-core/utils/date-utils");
+// 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] //TODO really ugly, temporary solution
+             });
+            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;

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

@@ -0,0 +1,205 @@
+"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.IndexedDb = void 0;
+const dexie_1 = __importDefault(require("dexie"));
+const ReadonlyCollection_1 = require("@components-core/interception/ReadonlyCollection");
+class IndexedDb {
+    constructor(tables, initialData = {}, config) {
+        this.tables = tables;
+        this.initialData = initialData;
+        this.config = config;
+        // private repository: Record<string, Array<any>>;
+        // private maxIdsByCollections: Record<string, number> = {};
+        this.db = null;
+        this.getItems = (resourceId) => this.getDb().table(resourceId).toArray();
+        this.findItems = (resourceId, predicate) => __awaiter(this, void 0, void 0, function* () {
+            const ret = yield this.getItems(resourceId);
+            const results = yield Promise.all(ret.map(predicate));
+            return ret.filter((_v, index) => results[index]);
+        });
+        this.getItem = (resourceId, predicate) => __awaiter(this, void 0, void 0, function* () {
+            const ret = yield this.getItems(resourceId);
+            const results = yield Promise.all(ret.map(predicate));
+            return ret.find((_v, index) => results[index]);
+        });
+        this.getItemById = (resourceId, id) => __awaiter(this, void 0, void 0, function* () {
+            return yield this.getItem(resourceId, (item) => __awaiter(this, void 0, void 0, function* () {
+                return item.id + "" === id + "";
+            }));
+        });
+        this.deleteItems = (resourceId, predicate) => __awaiter(this, void 0, void 0, function* () {
+            // this.repository[resourceId] = this.repository[resourceId]?.filter((item) => !predicate(item));
+        });
+        this.insertItem = (resourceId, item) => __awaiter(this, void 0, void 0, function* () {
+            const id = yield this.getDb().table(resourceId).add(item);
+            return this.getItemById(resourceId, id);
+        });
+        this.updateItem = (resourceId, item) => __awaiter(this, void 0, void 0, function* () {
+            yield this.getDb().table(resourceId).update(item.id, item);
+            return yield this.getItemById(resourceId, item.id);
+        });
+    }
+    getDb() {
+        if (this.db === null) {
+            throw new Error("Db is not initialized yet");
+        }
+        return this.db;
+    }
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const resolvedInitialData = typeof this.initialData === "function" ? yield this.initialData() : this.initialData;
+            const schema = {};
+            const tableNames = new Set();
+            if (this.tables) {
+                this.tables.forEach((tableDescriptor) => {
+                    const schemaArray = [];
+                    if (tableDescriptor.pk.length === 1) {
+                        schemaArray.push(tableDescriptor.pk[0]);
+                    }
+                    else {
+                        schemaArray.push(`[${tableDescriptor.pk.join("+")}]`); //indexeddb compound index looks like this: [field+anotherfield]
+                    }
+                    if (tableDescriptor.indexes) {
+                        schemaArray.push(...tableDescriptor.indexes);
+                    }
+                    schema[tableDescriptor.name] = schemaArray.join(", ");
+                    tableNames.add(tableDescriptor.name);
+                });
+            }
+            else {
+                Object.entries(resolvedInitialData).forEach(([key]) => {
+                    schema[key] = "++id";
+                    tableNames.add(key);
+                });
+            }
+            const targetVersion = ((_a = this.config) === null || _a === void 0 ? void 0 : _a.version) !== undefined && typeof ((_b = this.config) === null || _b === void 0 ? void 0 : _b.version) === "number" ? (_c = this.config) === null || _c === void 0 ? void 0 : _c.version : 1;
+            const shouldInitializeData = yield this.dropDbOnVersionChange(targetVersion);
+            this.db = this.createDbInstance();
+            this.db.version(targetVersion).stores(schema);
+            if (shouldInitializeData) {
+                yield Promise.all(Object.entries(resolvedInitialData).map((_a) => __awaiter(this, [_a], void 0, function* ([key, value]) {
+                    try {
+                        yield this.getDb().table(key).bulkAdd(value);
+                    }
+                    catch (ignored) {
+                        console.error(ignored);
+                    }
+                })));
+            }
+            tableNames.forEach((key) => {
+                this[`$${key}`] = createTableWrapper(this.getDb().table(key));
+            });
+        });
+    }
+    createDbInstance() {
+        var _a, _b;
+        return new dexie_1.default((_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.database) !== null && _b !== void 0 ? _b : "defaultIndexDb");
+    }
+    dropDbOnVersionChange(targetVersion) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tempDb = this.createDbInstance();
+            if (!(yield dexie_1.default.exists(tempDb.name))) {
+                return true;
+            }
+            yield tempDb.open();
+            if (tempDb.verno !== targetVersion) {
+                yield tempDb.delete();
+                return true;
+            }
+            else {
+                tempDb.close();
+                return false;
+            }
+        });
+    }
+    // --- This method signifies that a section of operations is executed in a transaction
+    transaction(actions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.db)
+                return;
+            const tables = this.db.tables;
+            yield this.db.transaction("rw", tables, actions);
+        });
+    }
+}
+exports.IndexedDb = IndexedDb;
+// Wraps an indexDb Table into an object that provides helpful methods
+function createTableWrapper(table) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // --- Function to retrieve the current table data
+        const getDataFn = () => table.db.table(table.name);
+        // --- Helper method to filter the table data
+        const filteredData = (predicate) => __awaiter(this, void 0, void 0, function* () {
+            const dataSnapshot = yield table.toArray();
+            const results = yield Promise.all(dataSnapshot.map(predicate !== null && predicate !== void 0 ? predicate : (() => __awaiter(this, void 0, void 0, function* () { return true; }))));
+            return dataSnapshot.filter((_v, index) => results[index]);
+        });
+        return {
+            native: getDataFn,
+            insert: (item) => __awaiter(this, void 0, void 0, function* () {
+                const id = yield table.add(item);
+                return getDataFn().get(id);
+            }),
+            update: (item) => __awaiter(this, void 0, void 0, function* () {
+                yield table.update(item.id, item);
+                return getDataFn().get(item.id);
+            }),
+            save: (item) => __awaiter(this, void 0, void 0, function* () {
+                const key = yield table.put(item);
+                return table.get(key);
+            }),
+            deleteById: (id) => __awaiter(this, void 0, void 0, function* () {
+                yield table.delete(id);
+            }),
+            byId: (id) => __awaiter(this, void 0, void 0, function* () {
+                if (id === undefined || id === null) {
+                    return null;
+                }
+                let safeId = id;
+                if (table.schema.primKey.src === "++id") {
+                    //it's an auto incremented id, must be a number
+                    safeId = Number(id);
+                }
+                return table.get(safeId);
+            }),
+            toArray: () => __awaiter(this, void 0, void 0, function* () { return yield table.toArray(); }),
+            single: (predicate) => __awaiter(this, void 0, void 0, function* () { return yield new ReadonlyCollection_1.ReadOnlyCollection(yield table.toArray()).single(predicate); }),
+            singleOrDefault: (predicate, defValue) => __awaiter(this, void 0, void 0, function* () {
+                return yield new ReadonlyCollection_1.ReadOnlyCollection(yield table.toArray()).singleOrDefault(predicate, defValue);
+            }),
+            where: (predicate) => __awaiter(this, void 0, void 0, function* () { return new ReadonlyCollection_1.ReadOnlyCollection(yield filteredData(predicate)); }),
+            whereAsArray: (predicate) => __awaiter(this, void 0, void 0, function* () { return yield filteredData(predicate); }),
+            orderBy: (...mappers) => __awaiter(this, void 0, void 0, function* () { return yield new ReadonlyCollection_1.ReadOnlyCollection(yield table.toArray()).orderBy(...mappers); }),
+            orderByAsArray: (...mappers) => __awaiter(this, void 0, void 0, function* () { return yield new ReadonlyCollection_1.ReadOnlyCollection(yield table.toArray()).orderByAsArray(...mappers); }),
+            groupBy: (groupKey) => __awaiter(this, void 0, void 0, function* () { return yield new ReadonlyCollection_1.ReadOnlyCollection(yield table.toArray()).groupBy(groupKey); }),
+            groupByAsArray: (groupKey) => __awaiter(this, void 0, void 0, function* () { return yield new ReadonlyCollection_1.ReadOnlyCollection(yield table.toArray()).groupByAsArray(groupKey); }),
+            distinct: (distinctValue) => __awaiter(this, void 0, void 0, function* () { return yield new ReadonlyCollection_1.ReadOnlyCollection(yield table.toArray()).distinct(distinctValue); }),
+            distinctAsArray: (distinctValue) => __awaiter(this, void 0, void 0, function* () { return yield new ReadonlyCollection_1.ReadOnlyCollection(yield table.toArray()).distinctAsArray(distinctValue); }),
+            maxValue: (...args_1) => __awaiter(this, [...args_1], void 0, function* (fieldName = "id", predicate) {
+                return yield new ReadonlyCollection_1.ReadOnlyCollection(yield table.toArray()).maxValue(fieldName, predicate);
+            }),
+            skip: (count) => __awaiter(this, void 0, void 0, function* () {
+                return yield new ReadonlyCollection_1.ReadOnlyCollection(yield table.toArray()).skip(count);
+            }),
+            take: (count) => __awaiter(this, void 0, void 0, function* () {
+                return yield new ReadonlyCollection_1.ReadOnlyCollection(yield table.toArray()).take(count);
+            }),
+            skipTake: (skip, take) => __awaiter(this, void 0, void 0, function* () {
+                return yield new ReadonlyCollection_1.ReadOnlyCollection(yield table.toArray()).skipTake(skip, take);
+            }),
+        };
+    });
+}

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

@@ -0,0 +1,145 @@
+"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.ReadOnlyCollection = void 0;
+const misc_1 = require("@components-core/utils/misc");
+class ReadOnlyCollection {
+    constructor(items) {
+        this.list = [];
+        for (const item of items) {
+            this.list.push(item);
+        }
+    }
+    get length() {
+        return this.list.length;
+    }
+    toArray() {
+        return this.list.slice(0);
+    }
+    at(index) {
+        if (index < 0 || index > this.list.length - 1) {
+            throw new Error(`Index (${index}) is out of range [0..${Math.max(this.list.length - 1, 0)}]`);
+        }
+        return this.list[index];
+    }
+    all() {
+        return new ReadOnlyCollection(this.list);
+    }
+    single(predicate) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const filtered = yield this.where(predicate);
+            if (filtered.length === 0) {
+                throw new Error("No items found with the specified predicate");
+            }
+            else if (filtered.length > 1) {
+                throw new Error("Multiple items found with the specified predicate");
+            }
+            return filtered.at(0);
+        });
+    }
+    singleOrDefault(predicate, defValue) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const filtered = yield this.where(predicate);
+            if (filtered.length === 0) {
+                return defValue;
+            }
+            else if (filtered.length > 1) {
+                throw new Error("Multiple items found with the specified predicate");
+            }
+            return filtered.at(0);
+        });
+    }
+    where(predicate) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new ReadOnlyCollection(yield this.whereAsArray(predicate));
+        });
+    }
+    whereAsArray(predicate) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const results = yield Promise.all(this.list.map(predicate !== null && predicate !== void 0 ? predicate : (() => __awaiter(this, void 0, void 0, function* () { return true; }))));
+            return this.list.filter((_v, index) => results[index]);
+        });
+    }
+    orderBy(...mappers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new ReadOnlyCollection(yield (0, misc_1.orderBy)(this.list, ...mappers));
+        });
+    }
+    orderByAsArray(...mappers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, misc_1.orderBy)(this.list, ...mappers);
+        });
+    }
+    groupBy(groupKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new ReadOnlyCollection(yield this.groupByAsArray(groupKey));
+        });
+    }
+    groupByAsArray(groupKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const grouped = new Map();
+            for (const item of this.list) {
+                const key = yield groupKey(item);
+                const matchingList = grouped.get(key);
+                if (matchingList === undefined) {
+                    grouped.set(key, [item]);
+                }
+                else {
+                    matchingList.push(item);
+                }
+            }
+            const groupedItems = [];
+            for (const [key, items] of grouped.entries()) {
+                groupedItems.push({ key, items });
+            }
+            return groupedItems;
+        });
+    }
+    distinct(distinctValue) {
+        return __awaiter(this, void 0, void 0, function* () {
+            distinctValue !== null && distinctValue !== void 0 ? distinctValue : (distinctValue = (x) => __awaiter(this, void 0, void 0, function* () { return x; }));
+            const values = new Set();
+            for (const item of this.list) {
+                values.add(yield distinctValue(item));
+            }
+            return new ReadOnlyCollection(values.values());
+        });
+    }
+    distinctAsArray(distinctValue) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.distinct(distinctValue)).toArray();
+        });
+    }
+    maxValue() {
+        return __awaiter(this, arguments, void 0, function* (fieldName = "id", predicate) {
+            let values = predicate ? (yield new ReadOnlyCollection(this.list)
+                .where(predicate)).toArray() : this.list;
+            values = yield (0, misc_1.orderBy)(values, (item) => item[fieldName], true);
+            return values.length === 0 ? undefined : values[0][fieldName];
+        });
+    }
+    skip(count) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new ReadOnlyCollection(this.list.slice(count));
+        });
+    }
+    take(count) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new ReadOnlyCollection(this.list.slice(0, count));
+        });
+    }
+    skipTake(skip, take) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new ReadOnlyCollection(this.list.slice(skip, take + skip));
+        });
+    }
+}
+exports.ReadOnlyCollection = ReadOnlyCollection;

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

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