xmlui 0.10.8 → 0.10.11

package/dist/lib/initMock-CV-9AUzP.mjs

@@ -0,0 +1,843 @@
+import { delay as delay$1, HttpResponse, matchRequestUrl } from "msw";
+import { isArray, isObject, mapValues } from "lodash-es";
+import { r as runEventHandlerCode, g as getDate, d as delay, m as miscellaneousUtils, a as dateFunctions, o as orderBy, T as ThrowStatementError } from "./index-BuIblMfO.mjs";
+import Dexie from "dexie";
+var HttpStatusCode = /* @__PURE__ */ ((HttpStatusCode2) => {
+  HttpStatusCode2[HttpStatusCode2["Continue"] = 100] = "Continue";
+  HttpStatusCode2[HttpStatusCode2["SwitchingProtocols"] = 101] = "SwitchingProtocols";
+  HttpStatusCode2[HttpStatusCode2["Processing"] = 102] = "Processing";
+  HttpStatusCode2[HttpStatusCode2["EarlyHints"] = 103] = "EarlyHints";
+  HttpStatusCode2[HttpStatusCode2["Ok"] = 200] = "Ok";
+  HttpStatusCode2[HttpStatusCode2["Created"] = 201] = "Created";
+  HttpStatusCode2[HttpStatusCode2["Accepted"] = 202] = "Accepted";
+  HttpStatusCode2[HttpStatusCode2["NonAuthoritativeInformation"] = 203] = "NonAuthoritativeInformation";
+  HttpStatusCode2[HttpStatusCode2["NoContent"] = 204] = "NoContent";
+  HttpStatusCode2[HttpStatusCode2["ResetContent"] = 205] = "ResetContent";
+  HttpStatusCode2[HttpStatusCode2["PartialContent"] = 206] = "PartialContent";
+  HttpStatusCode2[HttpStatusCode2["MultiStatus"] = 207] = "MultiStatus";
+  HttpStatusCode2[HttpStatusCode2["AlreadyReported"] = 208] = "AlreadyReported";
+  HttpStatusCode2[HttpStatusCode2["ImUsed"] = 226] = "ImUsed";
+  HttpStatusCode2[HttpStatusCode2["MultipleChoices"] = 300] = "MultipleChoices";
+  HttpStatusCode2[HttpStatusCode2["MovedPermanently"] = 301] = "MovedPermanently";
+  HttpStatusCode2[HttpStatusCode2["Found"] = 302] = "Found";
+  HttpStatusCode2[HttpStatusCode2["SeeOther"] = 303] = "SeeOther";
+  HttpStatusCode2[HttpStatusCode2["NotModified"] = 304] = "NotModified";
+  HttpStatusCode2[HttpStatusCode2["UseProxy"] = 305] = "UseProxy";
+  HttpStatusCode2[HttpStatusCode2["Unused"] = 306] = "Unused";
+  HttpStatusCode2[HttpStatusCode2["TemporaryRedirect"] = 307] = "TemporaryRedirect";
+  HttpStatusCode2[HttpStatusCode2["PermanentRedirect"] = 308] = "PermanentRedirect";
+  HttpStatusCode2[HttpStatusCode2["BadRequest"] = 400] = "BadRequest";
+  HttpStatusCode2[HttpStatusCode2["Unauthorized"] = 401] = "Unauthorized";
+  HttpStatusCode2[HttpStatusCode2["PaymentRequired"] = 402] = "PaymentRequired";
+  HttpStatusCode2[HttpStatusCode2["Forbidden"] = 403] = "Forbidden";
+  HttpStatusCode2[HttpStatusCode2["NotFound"] = 404] = "NotFound";
+  HttpStatusCode2[HttpStatusCode2["MethodNotAllowed"] = 405] = "MethodNotAllowed";
+  HttpStatusCode2[HttpStatusCode2["NotAcceptable"] = 406] = "NotAcceptable";
+  HttpStatusCode2[HttpStatusCode2["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired";
+  HttpStatusCode2[HttpStatusCode2["RequestTimeout"] = 408] = "RequestTimeout";
+  HttpStatusCode2[HttpStatusCode2["Conflict"] = 409] = "Conflict";
+  HttpStatusCode2[HttpStatusCode2["Gone"] = 410] = "Gone";
+  HttpStatusCode2[HttpStatusCode2["LengthRequired"] = 411] = "LengthRequired";
+  HttpStatusCode2[HttpStatusCode2["PreconditionFailed"] = 412] = "PreconditionFailed";
+  HttpStatusCode2[HttpStatusCode2["PayloadTooLarge"] = 413] = "PayloadTooLarge";
+  HttpStatusCode2[HttpStatusCode2["UriTooLong"] = 414] = "UriTooLong";
+  HttpStatusCode2[HttpStatusCode2["UnsupportedMediaType"] = 415] = "UnsupportedMediaType";
+  HttpStatusCode2[HttpStatusCode2["RangeNotSatisfiable"] = 416] = "RangeNotSatisfiable";
+  HttpStatusCode2[HttpStatusCode2["ExpectationFailed"] = 417] = "ExpectationFailed";
+  HttpStatusCode2[HttpStatusCode2["ImATeapot"] = 418] = "ImATeapot";
+  HttpStatusCode2[HttpStatusCode2["MisdirectedRequest"] = 421] = "MisdirectedRequest";
+  HttpStatusCode2[HttpStatusCode2["UnprocessableEntity"] = 422] = "UnprocessableEntity";
+  HttpStatusCode2[HttpStatusCode2["Locked"] = 423] = "Locked";
+  HttpStatusCode2[HttpStatusCode2["FailedDependency"] = 424] = "FailedDependency";
+  HttpStatusCode2[HttpStatusCode2["TooEarly"] = 425] = "TooEarly";
+  HttpStatusCode2[HttpStatusCode2["UpgradeRequired"] = 426] = "UpgradeRequired";
+  HttpStatusCode2[HttpStatusCode2["PreconditionRequired"] = 428] = "PreconditionRequired";
+  HttpStatusCode2[HttpStatusCode2["TooManyRequests"] = 429] = "TooManyRequests";
+  HttpStatusCode2[HttpStatusCode2["RequestHeaderFieldsTooLarge"] = 431] = "RequestHeaderFieldsTooLarge";
+  HttpStatusCode2[HttpStatusCode2["UnavailableForLegalReasons"] = 451] = "UnavailableForLegalReasons";
+  HttpStatusCode2[HttpStatusCode2["InternalServerError"] = 500] = "InternalServerError";
+  HttpStatusCode2[HttpStatusCode2["NotImplemented"] = 501] = "NotImplemented";
+  HttpStatusCode2[HttpStatusCode2["BadGateway"] = 502] = "BadGateway";
+  HttpStatusCode2[HttpStatusCode2["ServiceUnavailable"] = 503] = "ServiceUnavailable";
+  HttpStatusCode2[HttpStatusCode2["GatewayTimeout"] = 504] = "GatewayTimeout";
+  HttpStatusCode2[HttpStatusCode2["HttpVersionNotSupported"] = 505] = "HttpVersionNotSupported";
+  HttpStatusCode2[HttpStatusCode2["VariantAlsoNegotiates"] = 506] = "VariantAlsoNegotiates";
+  HttpStatusCode2[HttpStatusCode2["InsufficientStorage"] = 507] = "InsufficientStorage";
+  HttpStatusCode2[HttpStatusCode2["LoopDetected"] = 508] = "LoopDetected";
+  HttpStatusCode2[HttpStatusCode2["NotExtended"] = 510] = "NotExtended";
+  HttpStatusCode2[HttpStatusCode2["NetworkAuthenticationRequired"] = 511] = "NetworkAuthenticationRequired";
+  return HttpStatusCode2;
+})(HttpStatusCode || {});
+class HttpError extends Error {
+  constructor(status, details) {
+    super((details == null ? void 0 : details.message) || "Not found");
+    this.details = details;
+    this.status = status;
+    Object.setPrototypeOf(this, HttpError.prototype);
+  }
+}
+class NotFoundError extends HttpError {
+  constructor(details) {
+    super(404, details);
+    Object.setPrototypeOf(this, NotFoundError.prototype);
+  }
+}
+class UnauthorizedError extends HttpError {
+  constructor(details) {
+    super(401, details);
+    Object.setPrototypeOf(this, UnauthorizedError.prototype);
+  }
+}
+class ConflictError extends HttpError {
+  constructor(details) {
+    super(409, details);
+    Object.setPrototypeOf(this, ConflictError.prototype);
+  }
+}
+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));
+  }
+};
+const defaultBackendEnvironment = {
+  getDate: (date) => date ? new Date(date) : /* @__PURE__ */ new Date()
+};
+const mapValuesDeep = (obj, cb) => {
+  if (isArray(obj)) {
+    return obj.map((innerObj) => mapValuesDeep(innerObj, cb));
+  } else if (isObject(obj)) {
+    return 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);
+  }
+}
+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);
+  }
+}
+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);
+    }
+  }
+  async executeOperation(operationId, requestParams, cookieService, headerService) {
+    var _a;
+    const handler = (_a = this.definition.operations) == null ? void 0 : _a[operationId];
+    if (!handler) {
+      throw new Error(`Unknown backend operation: ${operationId}`);
+    }
+    return await this.runFn(handler, requestParams, cookieService, headerService);
+  }
+  async runFn(src, ...args) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    let localContext = {
+      ...this.resolvedHelpers,
+      $db: this.db,
+      $state: this.apiStateHash,
+      $authService: this.authService,
+      $env: defaultBackendEnvironment,
+      $loggedInUser: this.authService.getLoggedInUser(),
+      $pathParams: (_a = args[0]) == null ? void 0 : _a.pathParams,
+      $queryParams: (_b = args[0]) == null ? void 0 : _b.queryParams,
+      $requestBody: (_c = args[0]) == null ? void 0 : _c.requestBody,
+      $cookies: (_d = args[0]) == null ? void 0 : _d.cookies,
+      $requestHeaders: (_e = args[0]) == null ? void 0 : _e.requestHeaders,
+      $cookieService: args[1],
+      //TODO really ugly, temporary solution
+      $headerService: args[2]
+      //TODO really ugly, temporary solution
+    };
+    const evalContext = createEvalContext({
+      localContext,
+      eventArgs: args,
+      appContext: {
+        ...dateFunctions,
+        ...miscellaneousUtils,
+        delay,
+        Errors,
+        createFile: (...args2) => {
+          return new File(args2[0], args2[1], args2[2]);
+        },
+        appendBlob: (blob1, blob2) => {
+          if (blob1 && blob2) {
+            return new Blob([blob1, blob2], { type: blob1.type || blob2.type });
+          }
+          if (blob1) {
+            return blob1;
+          }
+          if (blob2) {
+            return blob2;
+          }
+          return null;
+        },
+        getDate
+      }
+    });
+    await runEventHandlerCode(src, evalContext);
+    return ((_g = (_f = evalContext.mainThread) == null ? void 0 : _f.blocks) == null ? void 0 : _g.length) ? evalContext.mainThread.blocks[evalContext.mainThread.blocks.length - 1].returnValue : void 0;
+  }
+}
+function createEvalContext(parts) {
+  return {
+    ...{
+      mainThread: {
+        childThreads: [],
+        blocks: [{ vars: {} }],
+        loops: [],
+        breakLabelValue: -1
+      }
+    },
+    ...parts
+  };
+}
+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);
+  }
+  async single(predicate) {
+    const filtered = await 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);
+  }
+  async singleOrDefault(predicate, defValue) {
+    const filtered = await 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);
+  }
+  async where(predicate) {
+    return new ReadOnlyCollection(await this.whereAsArray(predicate));
+  }
+  async whereAsArray(predicate) {
+    const results = await Promise.all(this.list.map(predicate ?? (async () => true)));
+    return this.list.filter((_v, index) => results[index]);
+  }
+  async orderBy(...mappers) {
+    return new ReadOnlyCollection(await orderBy(this.list, ...mappers));
+  }
+  async orderByAsArray(...mappers) {
+    return await orderBy(this.list, ...mappers);
+  }
+  async groupBy(groupKey) {
+    return new ReadOnlyCollection(await this.groupByAsArray(groupKey));
+  }
+  async groupByAsArray(groupKey) {
+    const grouped = /* @__PURE__ */ new Map();
+    for (const item of this.list) {
+      const key = await groupKey(item);
+      const matchingList = grouped.get(key);
+      if (matchingList === void 0) {
+        grouped.set(key, [item]);
+      } else {
+        matchingList.push(item);
+      }
+    }
+    const groupedItems = [];
+    for (const [key, items] of grouped.entries()) {
+      groupedItems.push({ key, items });
+    }
+    return groupedItems;
+  }
+  async distinct(distinctValue) {
+    distinctValue ?? (distinctValue = async (x) => x);
+    const values = /* @__PURE__ */ new Set();
+    for (const item of this.list) {
+      values.add(await distinctValue(item));
+    }
+    return new ReadOnlyCollection(values.values());
+  }
+  async distinctAsArray(distinctValue) {
+    return (await this.distinct(distinctValue)).toArray();
+  }
+  async maxValue(fieldName = "id", predicate) {
+    let values = predicate ? (await new ReadOnlyCollection(this.list).where(predicate)).toArray() : this.list;
+    values = await orderBy(values, (item) => item[fieldName], true);
+    return values.length === 0 ? void 0 : values[0][fieldName];
+  }
+  async skip(count) {
+    return new ReadOnlyCollection(this.list.slice(count));
+  }
+  async take(count) {
+    return new ReadOnlyCollection(this.list.slice(0, count));
+  }
+  async skipTake(skip, take) {
+    return new ReadOnlyCollection(this.list.slice(skip, take + skip));
+  }
+}
+class IndexedDb {
+  constructor(tables, initialData = {}, config) {
+    this.tables = tables;
+    this.initialData = initialData;
+    this.config = config;
+    this.db = null;
+    this.getItems = (resourceId) => this.getDb().table(resourceId).toArray();
+    this.findItems = async (resourceId, predicate) => {
+      const ret = await this.getItems(resourceId);
+      const results = await Promise.all(ret.map(predicate));
+      return ret.filter((_v, index) => results[index]);
+    };
+    this.getItem = async (resourceId, predicate) => {
+      const ret = await this.getItems(resourceId);
+      const results = await Promise.all(ret.map(predicate));
+      return ret.find((_v, index) => results[index]);
+    };
+    this.getItemById = async (resourceId, id) => {
+      return await this.getItem(resourceId, async (item) => {
+        return item.id + "" === id + "";
+      });
+    };
+    this.deleteItems = async (resourceId, predicate) => {
+    };
+    this.insertItem = async (resourceId, item) => {
+      const id = await this.getDb().table(resourceId).add(item);
+      return this.getItemById(resourceId, id);
+    };
+    this.updateItem = async (resourceId, item) => {
+      await this.getDb().table(resourceId).update(item.id, item);
+      return await this.getItemById(resourceId, item.id);
+    };
+  }
+  getDb() {
+    if (this.db === null) {
+      throw new Error("Db is not initialized yet");
+    }
+    return this.db;
+  }
+  async initialize() {
+    var _a, _b, _c;
+    const resolvedInitialData = typeof this.initialData === "function" ? await this.initialData() : this.initialData;
+    const schema = {};
+    const tableNames = /* @__PURE__ */ 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("+")}]`);
+        }
+        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 ? void 0 : _a.version) !== void 0 && typeof ((_b = this.config) == null ? void 0 : _b.version) === "number" ? (_c = this.config) == null ? void 0 : _c.version : 1;
+    const shouldInitializeData = await this.dropDbOnVersionChange(targetVersion);
+    this.db = this.createDbInstance();
+    this.db.version(targetVersion).stores(schema);
+    if (shouldInitializeData) {
+      await Promise.all(
+        Object.entries(resolvedInitialData).map(async ([key, value]) => {
+          try {
+            await this.getDb().table(key).bulkAdd(value);
+          } catch (ignored) {
+            console.error(ignored);
+          }
+        })
+      );
+    }
+    tableNames.forEach((key) => {
+      this[`$${key}`] = createTableWrapper(this.getDb().table(key));
+    });
+  }
+  createDbInstance() {
+    var _a;
+    return new Dexie(((_a = this.config) == null ? void 0 : _a.database) ?? "defaultIndexDb");
+  }
+  async dropDbOnVersionChange(targetVersion) {
+    const tempDb = this.createDbInstance();
+    if (!await Dexie.exists(tempDb.name)) {
+      return true;
+    }
+    await tempDb.open();
+    if (tempDb.verno !== targetVersion) {
+      await tempDb.delete();
+      return true;
+    } else {
+      tempDb.close();
+      return false;
+    }
+  }
+  // --- This method signifies that a section of operations is executed in a transaction
+  async transaction(actions) {
+    if (!this.db) return;
+    const tables = this.db.tables;
+    await this.db.transaction("rw", tables, actions);
+  }
+}
+async function createTableWrapper(table) {
+  const getDataFn = () => table.db.table(table.name);
+  const filteredData = async (predicate) => {
+    const dataSnapshot = await table.toArray();
+    const results = await Promise.all(dataSnapshot.map(predicate ?? (async () => true)));
+    return dataSnapshot.filter((_v, index) => results[index]);
+  };
+  return {
+    native: getDataFn,
+    insert: async (item) => {
+      const id = await table.add(item);
+      return getDataFn().get(id);
+    },
+    update: async (item) => {
+      await table.update(item.id, item);
+      return getDataFn().get(item.id);
+    },
+    save: async (item) => {
+      const key = await table.put(item);
+      return table.get(key);
+    },
+    deleteById: async (id) => {
+      await table.delete(id);
+    },
+    byId: async (id) => {
+      if (id === void 0 || id === null) {
+        return null;
+      }
+      let safeId = id;
+      if (table.schema.primKey.src === "++id") {
+        safeId = Number(id);
+      }
+      return table.get(safeId);
+    },
+    toArray: async () => await table.toArray(),
+    single: async (predicate) => await new ReadOnlyCollection(await table.toArray()).single(predicate),
+    singleOrDefault: async (predicate, defValue) => {
+      return await new ReadOnlyCollection(await table.toArray()).singleOrDefault(
+        predicate,
+        defValue
+      );
+    },
+    where: async (predicate) => new ReadOnlyCollection(await filteredData(predicate)),
+    whereAsArray: async (predicate) => await filteredData(predicate),
+    orderBy: async (...mappers) => await new ReadOnlyCollection(await table.toArray()).orderBy(...mappers),
+    orderByAsArray: async (...mappers) => await new ReadOnlyCollection(await table.toArray()).orderByAsArray(...mappers),
+    groupBy: async (groupKey) => await new ReadOnlyCollection(await table.toArray()).groupBy(groupKey),
+    groupByAsArray: async (groupKey) => await new ReadOnlyCollection(await table.toArray()).groupByAsArray(groupKey),
+    distinct: async (distinctValue) => await new ReadOnlyCollection(await table.toArray()).distinct(distinctValue),
+    distinctAsArray: async (distinctValue) => await new ReadOnlyCollection(await table.toArray()).distinctAsArray(distinctValue),
+    maxValue: async (fieldName = "id", predicate) => {
+      return await new ReadOnlyCollection(await table.toArray()).maxValue(fieldName, predicate);
+    },
+    skip: async (count) => {
+      return await new ReadOnlyCollection(await table.toArray()).skip(count);
+    },
+    take: async (count) => {
+      return await new ReadOnlyCollection(await table.toArray()).take(count);
+    },
+    skipTake: async (skip, take) => {
+      return await new ReadOnlyCollection(await table.toArray()).skipTake(skip, take);
+    }
+  };
+}
+function convertRequestParamPart(part, paramTypes) {
+  if (!paramTypes) return part;
+  const result = { ...part };
+  Object.keys(part).forEach((key) => {
+    if (!(key in paramTypes)) return;
+    const partValue = part[key];
+    const partValueType = typeof partValue;
+    switch (paramTypes[key]) {
+      case "integer":
+        switch (partValueType) {
+          case "number":
+            result[key] = Math.round(partValue);
+            break;
+          case "string":
+            result[key] = parseInt(partValue, 10);
+            break;
+          case "boolean":
+            result[key] = partValue ? 1 : 0;
+            break;
+        }
+        break;
+      case "float":
+      case "real":
+      case "double":
+        switch (partValueType) {
+          case "number":
+            result[key] = partValue;
+            break;
+          case "string":
+            result[key] = parseFloat(partValue);
+            break;
+          case "boolean":
+            result[key] = partValue ? 1 : 0;
+            break;
+        }
+        break;
+      case "boolean":
+        switch (partValueType) {
+          case "string":
+            switch (partValue.toLowerCase()) {
+              case "true":
+              case "yes":
+              case "on":
+                result[key] = true;
+                break;
+              case "false":
+              case "no":
+              case "off":
+                result[key] = false;
+                break;
+            }
+            break;
+          case "number":
+            result[key] = !!partValue;
+            break;
+        }
+        break;
+    }
+  });
+  return result;
+}
+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.");
+  }
+  async initialize() {
+  }
+}
+function mergeHeaders(...sources) {
+  const result = {};
+  for (const source of sources) {
+    if (!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 === void 0 || value === "undefined") {
+        delete result[key];
+      } else {
+        result[key] = value;
+      }
+    }
+  }
+  return new Headers(result);
+}
+class AuthService {
+  constructor(auth) {
+    const cachedLoggedInUser = JSON.parse(sessionStorage.getItem("session-logged-in-user"));
+    this.loggedInUser = cachedLoggedInUser || (auth == null ? 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;
+  }
+}
+async function initDb(apiDef) {
+  var _a, _b;
+  switch (apiDef.type) {
+    case "in-memory":
+      return new InMemoryDb((_a = apiDef.schemaDescriptor) == null ? void 0 : _a.tables, apiDef.initialData, apiDef.config);
+    default:
+      const indexedDb = new IndexedDb(
+        (_b = apiDef.schemaDescriptor) == null ? void 0 : _b.tables,
+        apiDef.initialData,
+        apiDef.config
+      );
+      await indexedDb.initialize();
+      return indexedDb;
+  }
+}
+class ApiInterceptor {
+  // public id = crypto.randomUUID();
+  constructor(apiDef) {
+    this.apiDef = apiDef;
+    this.backend = null;
+  }
+  async initialize() {
+    const backendOperations = {};
+    Object.entries(this.apiDef.operations || {}).forEach(([key, value]) => {
+      backendOperations[key] = value.handler;
+    });
+    const db = await 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(definition, db, authService);
+  }
+  getOperations() {
+    return this.apiDef.operations || {};
+  }
+  getApiUrl() {
+    return this.apiDef.apiUrl || "";
+  }
+  // Use the "msw" package to execute the interceptor operation
+  async executeOperation(operationId, req, cookies, params) {
+    var _a;
+    if (this.backend === null) {
+      throw new Error("Interceptor not initialized");
+    }
+    const operation = (_a = this.apiDef.operations) == null ? void 0 : _a[operationId];
+    if (!operation) {
+      throw new Error(`Unknown API interceptor operation: ${operationId}`);
+    }
+    let reqBody;
+    try {
+      if (operation.requestShape === "formData") {
+        const formData = await 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 = await req.blob();
+      } else {
+        reqBody = await req.json();
+      }
+    } catch (e) {
+    }
+    const mappedParams = this.convertRequestParams(
+      {
+        pathParams: params,
+        queryParams: Object.fromEntries(new URL(req.url).searchParams),
+        requestBody: reqBody,
+        cookies,
+        requestHeaders: Object.fromEntries(req.headers.entries()) || {}
+      },
+      operation
+    );
+    if (this.apiDef.artificialDelay === void 0) {
+      await delay$1("real");
+    } else if (this.apiDef.artificialDelay !== 0) {
+      await delay$1(this.apiDef.artificialDelay);
+    }
+    const cookieService = new CookieService();
+    const headerService = new HeaderService();
+    try {
+      const ret = await this.backend.executeOperation(
+        operationId,
+        mappedParams,
+        cookieService,
+        headerService
+      );
+      const emptyBody = ret === void 0 || ret === null;
+      const successStatusCode = operation.successStatusCode ?? (emptyBody ? HttpStatusCode.NoContent : 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 + "");
+        const encodedFilename = encodeURIComponent(ret.name);
+        headers.append(
+          "Content-Disposition",
+          `attachment; filename*=UTF-8''${encodedFilename}`
+        );
+        return HttpResponse.arrayBuffer(await ret.arrayBuffer(), {
+          headers,
+          status: successStatusCode
+        });
+      }
+      if (emptyBody) {
+        return new HttpResponse(null, {
+          headers,
+          status: successStatusCode
+        });
+      }
+      return HttpResponse.json(ret, {
+        headers,
+        status: successStatusCode
+      });
+    } catch (e) {
+      console.error(e);
+      if (e instanceof ThrowStatementError && e.errorObject instanceof HttpError) {
+        return HttpResponse.json(e.errorObject.details, {
+          headers: cookieService.getCookieHeader(),
+          status: e.errorObject.status
+        });
+      }
+      return HttpResponse.json(
+        { message: e == null ? void 0 : e.message },
+        {
+          headers: cookieService.getCookieHeader(),
+          status: HttpStatusCode.InternalServerError
+        }
+      );
+    }
+  }
+  // Ensures that type path and query params are converted according to the operation definition
+  convertRequestParams(params, operation) {
+    return {
+      ...params,
+      pathParams: convertRequestParamPart(params.pathParams, operation.pathParamTypes),
+      queryParams: convertRequestParamPart(params.queryParams, operation.queryParamTypes)
+    };
+  }
+  hasMockForRequest(url, options) {
+    return this.getMockForRequest(url, options) !== void 0;
+  }
+  getMockForRequest(url, options) {
+    return Object.entries(this.getOperations()).find(([operationId, operationDef]) => {
+      if (matchRequestUrl(new URL(url, window.location.href), `${this.getApiUrl()}${operationDef.url}`, `${window.location.href}`).matches && (options.method || "get").toLowerCase() === operationDef.method.toLowerCase()) {
+        return true;
+      }
+      return false;
+    });
+  }
+  async executeMockedFetch(url, options) {
+    const mockForRequest = this.getMockForRequest(url, options);
+    if (!mockForRequest) {
+      throw new Error(`No mock found for request: ${url} with options: ${JSON.stringify(options)}`);
+    }
+    const [operationId, operationDef] = mockForRequest;
+    const match = matchRequestUrl(new URL(url, window.location.href), `${this.getApiUrl()}${operationDef.url}`, `${window.location.href}`);
+    return this.executeOperation(operationId, new Request(url, options), getCookiesAsObject(), match.params);
+  }
+}
+function getCookiesAsObject() {
+  const cookieString = document.cookie;
+  if (cookieString === "") {
+    return {};
+  }
+  const cookiePairs = cookieString.split("; ");
+  const cookieObject = cookiePairs.reduce((acc, currentPair) => {
+    const [key, value] = currentPair.split("=");
+    acc[decodeURIComponent(key)] = decodeURIComponent(value);
+    return acc;
+  }, {});
+  return cookieObject;
+}
+const initMock = async (apiInterceptorDefinition) => {
+  const apiInstance = new ApiInterceptor(apiInterceptorDefinition);
+  await apiInstance.initialize();
+  return apiInstance;
+};
+export {
+  initMock
+};