@websolutespa/bom-core 2.0.1-next.0 → 2.0.1

package/dist/index.mjs

@@ -0,0 +1,1807 @@
+// src/utils/arrayShuffle.ts
+function arrayShuffle(items) {
+  return items.map((item) => ({ item, order: Math.random() })).sort((a, b) => a.order - b.order).map(({ item }) => item);
+}
+
+// src/utils/typeGuards.ts
+function isNumber(item) {
+  return typeof item === "number";
+}
+function isString(item) {
+  return typeof item === "string";
+}
+function isValidString(item) {
+  return typeof item === "string" && item.length > 0;
+}
+function isArray(item) {
+  return Array.isArray(item);
+}
+function isNonEmptyArray(item) {
+  return Array.isArray(item) && item.length > 0;
+}
+function isObject(item) {
+  return item != null && typeof item === "object" && !isArray(item);
+}
+function isPromise(result) {
+  return isObject(result) && typeof result.then === "function";
+}
+function isNotNullString(item) {
+  return typeof item === "string" && Boolean(item);
+}
+function isEquatable(item) {
+  return typeof item === "number" || isNotNullString(item);
+}
+function isEntity(item) {
+  return isObject(item) && isEquatable(item.id);
+}
+function isComponent(item) {
+  return isObject(item) && (isValidString(item.blockType) || isValidString(item.schema));
+}
+function hasComponents(item) {
+  return isObject(item) && "components" in item && Array.isArray(item.components) && item.components.length > 0;
+}
+function isUnresolvedRelation(item) {
+  return isObject(item) && isNotNullString(item.relationTo) && (isEquatable(item.value) || isArray(item.value));
+}
+function isRelation(item) {
+  return isObject(item) && isNotNullString(item.relationTo) && isEntity(item.value);
+}
+function isUnresolvedCategory(category) {
+  return category ? typeof category === "string" : false;
+}
+function isUndecoratedCategory(category) {
+  return isObject(category) && !category.href;
+}
+function isUndecoratedMenuItem(item) {
+  return isObject(item) && (item.type === "category" && isEquatable(item.category) || item.type === "page" && isEquatable(item.page.value));
+}
+function isUndecoratedMenuCategory(item) {
+  return isObject(item) && item.type === "category" && isNotNullString(item.category) && item.id === void 0 && item.href === void 0;
+}
+function isUndecoratedMenuPage(item) {
+  return isObject(item) && item.type === "page" && isObject(item.page) && isNotNullString(item.page.relationTo) && isEquatable(item.page.value);
+}
+function isUndecoratedNav(item) {
+  return isUndecoratedMenuPage(item);
+}
+
+// src/utils/asEquatable.ts
+function asEquatable(value) {
+  const id = isEntity(value) ? value.id : value;
+  if (typeof id === "string") {
+    if (String(parseInt(id)) === id) {
+      return Number(id);
+    }
+  }
+  return id;
+}
+function asEquatableString(value) {
+  const id = isEntity(value) ? value.id : value;
+  if (typeof id !== "undefined") {
+    return String(id);
+  }
+  return id;
+}
+function asEquatableNumber(value) {
+  const id = isEntity(value) ? value.id : value;
+  if (typeof id === "string") {
+    if (String(parseInt(id)) === id) {
+      return Number(id);
+    } else {
+      return void 0;
+    }
+  }
+  return id;
+}
+
+// src/utils/asSortedOptions.ts
+function asSortedOptions(items) {
+  items.sort((a, b) => {
+    const nameA = a.name.toLowerCase();
+    const nameB = b.name.toLowerCase();
+    return nameA < nameB ? -1 : nameA > nameB ? 1 : 0;
+  });
+  return items;
+}
+
+// src/utils/babelCase.ts
+function unknownCaseToPascalCase(unknownCase) {
+  const pascalCase = unknownCase.replace(
+    /(^[a-zA-Z])|(\W|_)+(\w?)([a-z0-9]*)?/g,
+    (m, g1, g2, g3, g4) => (g1 ? g1.toUpperCase() : "") + (g3 ? g3.toUpperCase() : "") + (g4 ? g4.toLowerCase() : "")
+  );
+  return pascalCase;
+}
+function pascalCaseToCamelCase(pascalCase) {
+  const camelCase = pascalCase.charAt(0).toLowerCase() + pascalCase.slice(1);
+  return camelCase;
+}
+function pascalCaseToCharCase(pascalCase, char = "-") {
+  const charCase = pascalCase.replace(
+    /([A-Z]+)/g,
+    (m, g1, index) => (index > 0 ? char : "") + m
+  ).toLowerCase();
+  return charCase;
+}
+function pascalCaseToKebabCase(pascalCase) {
+  const kebabCase = pascalCaseToCharCase(pascalCase, "-");
+  return kebabCase;
+}
+function pascalCaseToSnakeCase(pascalCase) {
+  const kebabCase = pascalCaseToCharCase(pascalCase, "_");
+  return kebabCase;
+}
+function toPascalCase(unknownCase) {
+  const pascalCase = unknownCaseToPascalCase(unknownCase);
+  return pascalCase;
+}
+function toCamelCase(unknownCase) {
+  const pascalCase = unknownCaseToPascalCase(unknownCase);
+  const camelCase = pascalCaseToCamelCase(pascalCase);
+  return camelCase;
+}
+function toCharCase(unknownCase, char = "-") {
+  const pascalCase = unknownCaseToPascalCase(unknownCase);
+  const charCase = pascalCaseToCharCase(pascalCase, char);
+  return charCase;
+}
+function toKebabCase(unknownCase) {
+  const kebabCase = toCharCase(unknownCase, "-");
+  return kebabCase;
+}
+function toSnakeCase(unknownCase) {
+  const snakeCase = toCharCase(unknownCase, "_");
+  return snakeCase;
+}
+
+// src/utils/cloneItem.ts
+function cloneItem(item) {
+  if (isArray(item)) {
+    item = item.map((x) => cloneItem(x));
+  } else if (isObject(item)) {
+    item = { ...item };
+    const object = item;
+    Object.keys(object).forEach((key) => {
+      object[key] = cloneItem(object[key]);
+    });
+  }
+  return item;
+}
+
+// src/utils/collectFeatureTypes.ts
+async function collectFeatureTypes(items, ...keys) {
+  const featureTypes = [];
+  if (keys.length > 0) {
+    items.forEach((item) => {
+      keys.forEach((key) => {
+        const value = item[key] || [];
+        const values = Array.isArray(value) ? value : [value];
+        values.forEach((value2) => {
+          let featureType = featureTypes.find((x) => x.id === key);
+          if (!featureType) {
+            featureType = {
+              id: key,
+              schema: "featureType",
+              title: key,
+              mode: "or",
+              features: []
+            };
+            featureTypes.push(featureType);
+          }
+          const features = featureType.features;
+          const option = isObject(value2) ? {
+            ...value2,
+            title: value2.title || value2.name || value2.label || "Untitled"
+          } : {
+            id: value2,
+            title: String(value2)
+          };
+          if (option.id && option.title && features && !features.find((x) => x.id === option.id)) {
+            features.push(option);
+          }
+        });
+      });
+    });
+  }
+  featureTypes.forEach((featureType) => {
+    featureType.features.sort((a, b) => {
+      const textA = a.title.toUpperCase();
+      const textB = b.title.toUpperCase();
+      return textA < textB ? -1 : textA > textB ? 1 : 0;
+    });
+  });
+  return featureTypes;
+}
+async function collectFeatureTypes__(items, ...keys) {
+  const featureTypes = [];
+  if (keys.length > 0) {
+    items.forEach((item) => {
+      keys.forEach((key) => {
+        const value = item[key];
+        if (value) {
+          let featureType = featureTypes.find((x) => x.id === key);
+          if (!featureType) {
+            featureType = {
+              id: key,
+              schema: "featureType",
+              title: key,
+              mode: "or",
+              features: []
+            };
+            featureTypes.push(featureType);
+          }
+          const features = featureType.features;
+          if (features && !features.find((x) => x.id === value)) {
+            features.push({
+              id: value,
+              title: String(value)
+            });
+          }
+        }
+      });
+    });
+  }
+  return featureTypes;
+}
+
+// src/utils/collectOptions.ts
+async function collectOptions(items, ...keys) {
+  const optionsGroup = {};
+  if (keys.length > 0) {
+    items.forEach((item) => {
+      keys.forEach((key) => {
+        const value = item[key];
+        if (value) {
+          let options = optionsGroup[key];
+          if (!options) {
+            options = [];
+            optionsGroup[key] = options;
+          }
+          if (!options.find((x) => x.id === value)) {
+            options.push({
+              id: value,
+              name: String(value)
+            });
+          }
+        }
+      });
+    });
+  }
+  return optionsGroup;
+}
+
+// src/utils/uuid.ts
+function uuidv4() {
+  return "10000000-1000-4000-8000-100000000000".replace(
+    /[018]/g,
+    (c) => (+c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> +c / 4).toString(16)
+  );
+}
+
+// src/utils/components.ts
+function isComponentOfType(item, ...blockTypes) {
+  return isComponent(item) && blockTypes.includes(item.blockType || item.schema || "");
+}
+function pickComponent(items, ...blockTypes) {
+  return items?.filter((x) => isComponentOfType(x, ...blockTypes));
+}
+function excludeComponent(items, ...blockTypes) {
+  return items?.filter((x) => !isComponentOfType(x, ...blockTypes));
+}
+function pickHero(items, blockTypes = ["hero"]) {
+  const heroComponents = pickComponent(items, ...blockTypes);
+  const otherComponents = excludeComponent(items, ...blockTypes);
+  return [heroComponents, otherComponents];
+}
+function prependHero(items, hero, blockType = "hero") {
+  const components = items || [];
+  const heroIndex = components.findIndex((x) => isComponentOfType(x, blockType));
+  if (heroIndex === -1) {
+    const component = typeof hero === "string" ? {
+      id: uuidv4(),
+      blockType: hero
+    } : hero;
+    components.unshift(component);
+  }
+  return components;
+}
+function groupComponents(items, blockTypes, blockType) {
+  const components = [];
+  let previousGroup;
+  let previousItem;
+  (items || []).forEach((item) => {
+    if (blockTypes.includes(item.blockType || item.schema || "unkown_type")) {
+      if (previousItem) {
+        if (previousGroup) {
+          previousGroup.components.push(item);
+        } else {
+          previousGroup = {
+            id: uuidv4(),
+            blockType,
+            components: [previousItem, item]
+          };
+        }
+      }
+      previousItem = item;
+    } else {
+      if (previousGroup) {
+        components.push(previousGroup);
+      } else if (previousItem) {
+        components.push(previousItem);
+      }
+      previousGroup = void 0;
+      previousItem = void 0;
+      components.push(item);
+    }
+  });
+  return components;
+}
+
+// src/utils/deepMerge.ts
+function deepMerge(target, source) {
+  const output = { ...target };
+  if (isObject(target) && isObject(source)) {
+    Object.entries(source).forEach(([k, v]) => {
+      if (isArray(v)) {
+        output[k] = v.map((x) => deepMerge(x, x));
+      } else if (isObject(v)) {
+        const targetValue = k in target ? target[k] : void 0;
+        output[k] = isObject(targetValue) ? deepMerge(targetValue, v) : deepMerge(v, v);
+      } else {
+        output[k] = v;
+      }
+    });
+  }
+  return output;
+}
+
+// src/types/image.ts
+var ImageStrategy = /* @__PURE__ */ ((ImageStrategy2) => {
+  ImageStrategy2["None"] = "none";
+  ImageStrategy2["Next"] = "next";
+  ImageStrategy2["Mixer"] = "mixer";
+  ImageStrategy2["Oven"] = "oven";
+  ImageStrategy2["Token"] = "token";
+  ImageStrategy2["Custom"] = "custom";
+  return ImageStrategy2;
+})(ImageStrategy || {});
+
+// src/types/media.ts
+function resolveMediaType(media) {
+  if (typeof media.type === "string" && media.type.length > 0) {
+    return media.type;
+  }
+  if (typeof media.mimeType === "string" && media.mimeType.length > 0) {
+    const mime = media.mimeType.split("/");
+    return mime[0] === "application" ? mime[1] : mime[0];
+  }
+  return "unknown";
+}
+function isMediaImage(media) {
+  const type = resolveMediaType(media);
+  if (type === "image") {
+    media.type = type;
+    return true;
+  }
+  return false;
+}
+function isMediaVideo(media) {
+  const type = resolveMediaType(media);
+  if (type === "video") {
+    media.type = type;
+    return true;
+  }
+  return false;
+}
+function isMediaJson(media) {
+  const type = resolveMediaType(media);
+  if (type === "json") {
+    media.type = type;
+    return true;
+  }
+  return false;
+}
+function isMediaPdf(media) {
+  const type = resolveMediaType(media);
+  if (type === "pdf") {
+    media.type = type;
+    return true;
+  }
+  return false;
+}
+function isMedia(item) {
+  return isObject(item) && ("mimeType" in item || "type" in item) && (isValidString(item.url) || isValidString(item.src));
+}
+
+// src/types/menu.ts
+function isMenuHref(item) {
+  return ["category", "link", "page", "route"].includes(item.type);
+}
+function isMenuCategory(item) {
+  return item.type === "category";
+}
+function isMenuGroup(item) {
+  return item.type === "group";
+}
+function isMenuLink(item) {
+  return item.type === "link";
+}
+function isMenuPage(item) {
+  return item.type === "page";
+}
+function isMenuRoute(item) {
+  return item.type === "route";
+}
+var MenuCategoryStrategy = /* @__PURE__ */ ((MenuCategoryStrategy2) => {
+  MenuCategoryStrategy2["Default"] = "default";
+  MenuCategoryStrategy2["ExcludeHidden"] = "exclude-hidden";
+  return MenuCategoryStrategy2;
+})(MenuCategoryStrategy || {});
+
+// src/types/querable.ts
+function toFindParams(idOrParams) {
+  if (typeof idOrParams === "number" || typeof idOrParams === "string") {
+    return { where: { id: idOrParams } };
+  } else {
+    return idOrParams;
+  }
+}
+
+// src/types/redirect.ts
+var RedirectReason = /* @__PURE__ */ ((RedirectReason2) => {
+  RedirectReason2["MovedPermanently"] = "301";
+  RedirectReason2["Found"] = "302";
+  RedirectReason2["TemporaryRedirect"] = "307";
+  RedirectReason2["PermanentRedirect"] = "308";
+  RedirectReason2["Gone"] = "410";
+  return RedirectReason2;
+})(RedirectReason || {});
+
+// src/utils/eachValue.ts
+function eachValue(item, callback) {
+  if (isArray(item)) {
+    item.forEach((value) => {
+      callback(value);
+      eachValue(value, callback);
+    });
+  } else if (isObject(item)) {
+    Object.values(item).forEach((value) => {
+      callback(value);
+      eachValue(value, callback);
+    });
+  } else {
+    callback(item);
+  }
+}
+
+// src/utils/eachMedia.ts
+function eachMedia(item, callback) {
+  eachValue(item, (value) => {
+    if (isMedia(value)) {
+      callback(value);
+    }
+  });
+}
+
+// src/utils/enumToList.ts
+function enumToList(enumeration, separatorRegex = /_/g) {
+  const array = Object.keys(enumeration);
+  return array.filter((key) => isNaN(Number(key))).filter((key) => typeof enumeration[key] === "number" || typeof enumeration[key] === "string").map((key) => ({
+    key: String(key).replace(separatorRegex, " "),
+    value: enumeration[key]
+  }));
+}
+
+// src/utils/index.ts
+function getIsDevelopment() {
+  return process && (!process.env.NODE_ENV || process.env.NODE_ENV === "development");
+}
+function getIsProduction() {
+  return process && process.env && String(process.env.PRODUCTION) === "true";
+}
+var isDevelopment = getIsDevelopment();
+var isProduction = getIsProduction();
+var isStage = !isProduction && !isDevelopment;
+var isBrowser = typeof window !== "undefined";
+function getEnv() {
+  const env = {};
+  const keys = Object.keys(process.env).sort();
+  keys.forEach((key) => {
+    env[key] = process.env[key];
+  });
+  return env;
+}
+function withSchema(component, schema) {
+  return Object.assign(component, schema);
+}
+function asServerProps(props) {
+  return JSON.parse(JSON.stringify(props));
+}
+async function awaitAll(array, callback) {
+  const promises = array.map(callback);
+  return await Promise.all(promises);
+}
+function merge(target, source) {
+  if (source === null) {
+    return source;
+  }
+  if (!target) {
+    if (source && typeof source === "object") {
+      return Object.assign({}, source);
+    } else {
+      return source;
+    }
+  }
+  if (source && typeof source === "object") {
+    Object.keys(source).forEach((key) => {
+      const value = source[key];
+      if (typeof value === "object" && !Array.isArray(value)) {
+        target[key] = merge(target[key], value);
+      } else {
+        target[key] = value;
+      }
+    });
+  }
+  return target;
+}
+
+// src/base64/base64.ts
+function base64ToString(text) {
+  return isBrowser ? window.atob(text) : Buffer.from(text, "base64").toString();
+}
+function stringToBase64(text) {
+  return isBrowser ? window.btoa(text) : Buffer.from(text).toString("base64");
+}
+
+// src/category/category.ts
+var ROOT_CATEGORY = process.env.ROOT_CATEGORY || "";
+function getRootCategory(categories) {
+  const rootCategory = ROOT_CATEGORY && categories.find((x) => x.id == ROOT_CATEGORY);
+  if (rootCategory) {
+    return rootCategory;
+  } else {
+    return categories.find((x) => x.category == null);
+  }
+}
+function getParentCategory(categories, item) {
+  const parentCategoryId = asCategoryId(item.category);
+  const parentCategory = parentCategoryId ? categories.find((x) => x.id === parentCategoryId) : void 0;
+  return parentCategory;
+}
+function getParentCategoriesById(categories, id) {
+  const routeCategories = [];
+  const segments = [];
+  let parentId = id;
+  while (parentId != null) {
+    const parentCategory = categories.find((c) => c.id === parentId);
+    if (parentCategory) {
+      const segment = { ...parentCategory };
+      segments.unshift(segment);
+      routeCategories.push(parentId);
+      parentId = asCategoryId(parentCategory.category);
+      if (parentId) {
+        if (routeCategories.includes(parentId)) {
+          console.log("ICategory.getParentCategoriesById", "circular reference found", parentId);
+          parentId = void 0;
+        }
+      }
+    } else {
+      parentId = void 0;
+    }
+  }
+  return segments;
+}
+function getCategorySegments(categories, item) {
+  const parentCategoryId = asCategoryId(item.category);
+  const segments = getParentCategoriesById(categories, parentCategoryId);
+  return segments;
+}
+function getCategorySegmentsByCategory(categories, item) {
+  const parentCategoryId = asCategoryId(item.category);
+  const segments = parentCategoryId ? getParentCategoriesById(categories, parentCategoryId) : [];
+  segments.push(item);
+  return segments;
+}
+function asCategoryId(value) {
+  return isEntity(value) ? String(value.id) : value ? String(value) : void 0;
+}
+function findCategoryInCategories(categories, item) {
+  const categoryId = asCategoryId(item);
+  return categoryId ? categories.find((x) => x.id === categoryId) : void 0;
+}
+function findChildCategories(categories, item) {
+  const categoryId = asCategoryId(item);
+  return categoryId ? categories.filter((x) => asCategoryId(x.category) === categoryId) : [];
+}
+
+// src/classNames/classNames.ts
+function isClassNameCollection(value) {
+  return typeof value === "object" && !Array.isArray(value);
+}
+function classNameCollectionToString(className) {
+  const keys = Object.keys(className);
+  const total = keys.length;
+  let classNames = "";
+  for (let i = 0; i < total; i++) {
+    const key = keys[i];
+    const value = className[keys[i]];
+    if (!value) {
+      continue;
+    }
+    classNames = classNames ? `${classNames} ${String(key)}` : String(key);
+  }
+  return classNames;
+}
+function getClassNames(...props) {
+  const total = props.length;
+  let classNames = "";
+  if (total === 0) {
+    return classNames;
+  }
+  for (let i = 0; i < total; i++) {
+    const value = props[i];
+    if (!value) {
+      continue;
+    }
+    if (isClassNameCollection(value)) {
+      classNames += ` ${classNameCollectionToString(value)}`;
+    } else {
+      classNames += ` ${String(value).trim()}`;
+    }
+  }
+  return classNames.trim();
+}
+
+// src/collection/collection.ts
+import pluralize from "pluralize";
+function getCollectionDescription(text) {
+  text = toValidCollectionName(text);
+  const displayName = toDisplayName(text);
+  const pluralName = toPluralName(text);
+  const pluralDisplayName = toDisplayName(pluralName);
+  const singularName = text;
+  const title = toTitleCase(text);
+  return {
+    displayName,
+    pluralName,
+    pluralDisplayName,
+    singularName,
+    title
+  };
+}
+function camelToSnakeCase(text) {
+  return text.replace(/[A-Z]/g, (letter, index) => {
+    return index > 0 ? `_${letter.toLowerCase()}` : letter.toLowerCase();
+  });
+}
+function isValidCollectionDescription(description) {
+  return description.singularName !== description.pluralName;
+}
+function isReservedCollectionDescription(description) {
+  return [
+    "category",
+    "label",
+    "locale",
+    "market",
+    "menu",
+    "redirect",
+    "route",
+    "template"
+  ].includes(description.singularName);
+}
+function toDisplayName(text) {
+  return toTitleCase(text).replace(/\s/g, "");
+}
+function toPluralName(text) {
+  const plural = pluralize.plural(text);
+  return plural === text ? `${plural}es` : plural;
+}
+function toTitleCase(text) {
+  return text.replace(/^[-_]*(.)/, (_, c) => c.toUpperCase()).replace(/[-_]+(.)/g, (_, c) => " " + c.toUpperCase());
+}
+function toValidCollectionName(text) {
+  text = text.trim().replace(/\W/g, "_").replace(/^[_]*(.)/, (_, c) => c);
+  text = camelToSnakeCase(text);
+  text = text.replace(/__/g, "_");
+  return text.toLowerCase();
+}
+
+// src/consoleWarn/consoleWarn.ts
+var warningStack = {};
+function consoleWarn(message, component) {
+  if (typeof console === "undefined") {
+    return;
+  }
+  const tag = component ? ` [${component}]` : " ";
+  const log = `[DesignSystem]${tag}: ${message}`;
+  if (warningStack[log]) {
+    return;
+  }
+  warningStack[log] = true;
+  if (process.env.NODE_ENV !== "production") {
+    return console.error(log);
+  }
+  console.warn(log);
+}
+
+// src/entity/entity.ts
+function asEntityId(value) {
+  return isEntity(value) ? value.id : value;
+}
+
+// src/http/http.service.ts
+var defaultOptions = {
+  // method: 'POST', // *GET, POST, PUT, DELETE, etc.
+  // mode: 'cors', // no-cors, *cors, same-origin
+  // cache: 'no-cache', // *default, no-cache, reload, force-cache, only-if-cached
+  // credentials: 'same-origin', // include, *same-origin, omit
+  headers: {
+    "Content-Type": "application/json"
+    // 'Content-Type': 'application/x-www-form-urlencoded',
+  }
+  // redirect: 'follow', // manual, *follow, error
+  // referrerPolicy: 'no-referrer', // no-referrer, *no-referrer-when-downgrade, origin, origin-when-cross-origin, same-origin, strict-origin, strict-origin-when-cross-origin, unsafe-url
+  // body: JSON.stringify(data) // body data type must match 'Content-Type' header
+};
+async function httpFetch(url, options = {}, serviceOptions) {
+  try {
+    const httpOptions = merge({ ...defaultOptions }, options);
+    const httpResponse = await fetch(url, httpOptions);
+    if (!httpResponse.ok) {
+      throw httpResponse;
+    }
+    const response = await httpResponse.json();
+    return response;
+  } catch (error) {
+    if (typeof error === "object" && error.status) {
+      console.log("httpFetch.error", options.method, url, error.status, error.statusText);
+    } else {
+      console.log("httpFetch.error", options.method, url, error);
+    }
+    throw error;
+  }
+}
+async function httpGet(url, options = {}) {
+  return await httpFetch(url, { ...options, method: "GET" });
+}
+async function httpPost(url, payload, options = {}) {
+  return await httpFetch(url, { ...options, method: "POST", body: JSON.stringify(payload) });
+}
+async function httpPut(url, payload, options = {}) {
+  return await httpFetch(url, { ...options, method: "PUT", body: JSON.stringify(payload) });
+}
+async function httpPatch(url, payload, options = {}) {
+  return await httpFetch(url, { ...options, method: "PATCH", body: JSON.stringify(payload) });
+}
+async function httpDelete(url, options = {}) {
+  return await httpFetch(url, { ...options, method: "DELETE" });
+}
+
+// src/image/image.ts
+function getSecret() {
+  return process.env.IMAGE_SECRET || "IMAGE_SECRET";
+}
+function textToArrayBuffer_(text) {
+  const encoder = new TextEncoder();
+  const arrayBuffer = encoder.encode(text);
+  return arrayBuffer;
+}
+function arrayBufferToText_(arrayBuffer) {
+  const encoder = new TextDecoder("utf-8");
+  const text = encoder.decode(arrayBuffer);
+  return text;
+}
+function xor_(text, secret) {
+  const s = textToArrayBuffer_(secret);
+  const t = textToArrayBuffer_(text);
+  const m = t.map((a, i) => {
+    const b = s[i % s.length];
+    return a ^ b;
+  });
+  return arrayBufferToText_(m);
+}
+function encrypt_(text, secret) {
+  const encrypted = xor_(text, secret);
+  const base64 = stringToBase64(encrypted);
+  return base64;
+}
+function decrypt_(base64, secret) {
+  const text = base64ToString(base64);
+  const decrypted = xor_(text, secret);
+  return decrypted;
+}
+function encryptImageToken(imageResize) {
+  const text = JSON.stringify(imageResize);
+  const token = encrypt_(text, getSecret());
+  return token;
+}
+function decryptImageResize(token) {
+  const text = decrypt_(token, getSecret());
+  const data = JSON.parse(text);
+  return data;
+}
+
+// src/json/json.service.ts
+var JsonService = class {
+  constructor(items) {
+    this.items = items;
+  }
+  async getItems() {
+    return this.items;
+  }
+  async findGlobal(params = {}) {
+    const items = await this.getItems();
+    if (items.length > 0) {
+      return await this.decorateOne_(items[0], params);
+    } else {
+      console.log("JsonService.findGlobal.notfound", params);
+      return void 0;
+    }
+  }
+  async findOne(id, params = {}) {
+    let items = await this.getItems();
+    params.where = params.where || {};
+    params.where.id = params.where.id || { equals: id };
+    items = this.whereItems_(items, params.where);
+    if (items.length > 0) {
+      return await this.decorateOne_(items[0], params);
+    } else {
+      console.log("JsonService.findOne.notfound", id, params);
+      return void 0;
+    }
+  }
+  async findMany(params = {}) {
+    params.pagination = false;
+    let items = await this.getItems();
+    if (params.where) {
+      items = this.whereItems_(items, params.where, params.limit);
+    }
+    if (params.sort) {
+      items = this.sortCollection_(items, params.sort);
+    }
+    if (params.limit && !params.where) {
+      items = this.limitCollection_(items, params.limit);
+    }
+    return await this.decorateMany_(items, params);
+  }
+  async findPaged(params = {}) {
+    params.pagination = true;
+    let items = await this.getItems();
+    if (params.where) {
+      items = this.whereItems_(items, params.where);
+    }
+    if (params.sort) {
+      items = this.sortCollection_(items, params.sort);
+    }
+    const pagination = this.paginatedItems_(items, params.page, params.limit);
+    pagination.docs = await this.decorateMany_(pagination.docs, params);
+    return pagination;
+  }
+  async create(payload) {
+    const items = await this.getItems();
+    const item = { ...payload, id: this.newUUID_() };
+    this.items = [...items, item];
+    return item;
+  }
+  async updateOne(id, payload, params = {}) {
+    let items = await this.getItems();
+    params.where = params.where || {};
+    params.where.id = params.where.id || { equals: id };
+    const whereItems = this.whereItems_(items, params.where);
+    if (whereItems.length > 0) {
+      const index = items.indexOf(whereItems[0]);
+      const item = { ...items[index], payload };
+      items = [...items];
+      items[index] = item;
+      this.items = items;
+      return await this.decorateOne_(item, params);
+    }
+    throw "not found";
+  }
+  async updateMany(payload, params = {}) {
+    params.pagination = false;
+    let items = await this.getItems();
+    let filteredItems = items;
+    if (params.where) {
+      filteredItems = this.whereItems_(filteredItems, params.where, params.limit);
+    }
+    if (params.sort) {
+      filteredItems = this.sortCollection_(filteredItems, params.sort);
+    }
+    if (params.limit && !params.where) {
+      filteredItems = this.limitCollection_(filteredItems, params.limit);
+    }
+    items = [...items];
+    filteredItems = filteredItems.map((x) => {
+      const index = items.indexOf(x);
+      const item = { ...items[index], payload };
+      items[index] = item;
+      return item;
+    });
+    this.items = items;
+    return await this.decorateMany_(filteredItems, params);
+  }
+  async deleteOne(id, params = {}) {
+    let items = await this.getItems();
+    params.where = params.where || {};
+    params.where.id = params.where.id || { equals: id };
+    const whereItems = this.whereItems_(items, params.where);
+    if (whereItems.length > 0) {
+      const index = items.indexOf(whereItems[0]);
+      if (index !== -1) {
+        const item = items[index];
+        items = [...items];
+        items.splice(index, 1);
+        this.items = items;
+        return await this.decorateOne_(item, params);
+      }
+      return void 0;
+    }
+    return void 0;
+  }
+  async deleteMany(params = {}) {
+    params.pagination = false;
+    let items = await this.getItems();
+    let filteredItems = items;
+    if (params.where) {
+      filteredItems = this.whereItems_(filteredItems, params.where, params.limit);
+    }
+    if (params.sort) {
+      filteredItems = this.sortCollection_(filteredItems, params.sort);
+    }
+    if (params.limit && !params.where) {
+      filteredItems = this.limitCollection_(filteredItems, params.limit);
+    }
+    items = [...items];
+    this.items = items.filter((x) => filteredItems.indexOf(x) === -1);
+    return await this.decorateMany_(filteredItems, params);
+  }
+  // !!! old
+  async update(payload) {
+    let items = await this.getItems();
+    const index = items.reduce((p, c, i) => {
+      return c.id === payload.id ? i : p;
+    }, -1);
+    if (index !== -1) {
+      const item = { ...items[index], payload };
+      items = [...items];
+      items[index] = item;
+      this.items = items;
+      return item;
+    }
+    throw "not found";
+  }
+  async delete(id) {
+    let items = await this.getItems();
+    const index = items.reduce((p, c, i) => {
+      return c.id === id ? i : p;
+    }, -1);
+    if (index !== -1) {
+      const item = items[index];
+      items = [...items];
+      items.splice(index, 1);
+      this.items = items;
+      return item;
+    }
+    return void 0;
+  }
+  async decorateOne_(item, params = {}) {
+    return item;
+  }
+  async decorateMany_(items, params = {}) {
+    return items;
+  }
+  newUUID_() {
+    return (/* @__PURE__ */ new Date()).getTime();
+  }
+  // where
+  equalsClause_(value, equals) {
+    if (typeof equals !== "undefined") {
+      return value === equals;
+    }
+    return true;
+  }
+  notEqualsClause_(value, not_equals) {
+    if (typeof not_equals !== "undefined") {
+      return value != not_equals;
+    }
+    return true;
+  }
+  existsClause_(value, exists) {
+    if (typeof exists === "boolean") {
+      return value != null === exists;
+    }
+    return true;
+  }
+  greaterThanClause_(value, greater_than) {
+    if (typeof greater_than === "number") {
+      return typeof value === "number" && value > greater_than;
+    }
+    return true;
+  }
+  greaterThanEqualClause_(value, greater_than_equal) {
+    if (typeof greater_than_equal === "number") {
+      return typeof value === "number" && value >= greater_than_equal;
+    }
+    return true;
+  }
+  lessThanClause_(value, less_than) {
+    if (typeof less_than === "number") {
+      return typeof value === "number" && value < less_than;
+    }
+    return true;
+  }
+  lessThanEqualClause_(value, less_than_equal) {
+    if (typeof less_than_equal === "number") {
+      return typeof value === "number" && value <= less_than_equal;
+    }
+    return true;
+  }
+  likeClause_(value, query) {
+    if (typeof query === "string") {
+      return String(value).toLowerCase().indexOf(query.toLowerCase()) !== -1;
+    }
+    return true;
+  }
+  containsClause_(value, contains) {
+    if (typeof contains !== "undefined") {
+      contains = String(contains).toLowerCase();
+      if (Array.isArray(value)) {
+        return value.reduce((p, c) => p || String(c).toLowerCase() === contains, false);
+      } else if (typeof value === "string") {
+        return value.toLowerCase().includes(contains);
+      } else {
+        return false;
+      }
+    }
+    return true;
+  }
+  inClause_(value, values) {
+    if (Array.isArray(values) && values.length > 0) {
+      return values.indexOf(value) !== -1;
+    }
+    return true;
+  }
+  notInClause_(value, values) {
+    if (Array.isArray(values) && values.length > 0) {
+      return values.indexOf(value) === -1;
+    }
+    return true;
+  }
+  allClause_(value, values) {
+    if (Array.isArray(values) && values.length > 0) {
+      return Array.isArray(value) ? values.reduce((p, c) => p && value.includes(c), true) : false;
+    }
+    return true;
+  }
+  nearClause_(value, near) {
+    if (Array.isArray(near) && near.reduce((p, c) => p && typeof c === "number", true)) {
+      if (!Array.isArray(value)) {
+        return false;
+      }
+      const itemLongitude = value[0];
+      if (typeof itemLongitude !== "number") {
+        return false;
+      }
+      const itemLatitude = value[1];
+      if (typeof itemLatitude !== "number") {
+        return false;
+      }
+      const [longitude, latitude, maxDistance, minDistance] = near;
+      const distance = calculateDistanceInMeters_(itemLongitude, itemLatitude, longitude, latitude);
+      if (typeof maxDistance === "number" && typeof minDistance === "number") {
+        return distance <= maxDistance && distance >= minDistance;
+      } else if (typeof maxDistance === "number") {
+        return distance <= maxDistance;
+      } else if (typeof minDistance === "number") {
+        return distance >= minDistance;
+      }
+    }
+    return true;
+  }
+  whereItem_(item, where) {
+    let has = true;
+    if (typeof where === "object") {
+      Object.entries(where).forEach(([k, v]) => {
+        switch (k) {
+          case "and":
+            if (Array.isArray(v)) {
+              has = v.reduce((p, c) => {
+                return p && this.whereItem_(item, c);
+              }, has);
+            }
+            break;
+          case "or":
+            if (Array.isArray(v)) {
+              has = has && v.reduce((p, c) => {
+                return p || this.whereItem_(item, c);
+              }, false);
+            }
+            break;
+          default:
+            if (Array.isArray(v)) {
+            } else if (typeof v === "object") {
+              const value = getValue(item, k);
+              has = has && this.equalsClause_(value, v.equals);
+              has = has && this.notEqualsClause_(value, v.not_equals);
+              has = has && this.existsClause_(value, v.exists);
+              has = has && this.greaterThanClause_(value, v.greater_than);
+              has = has && this.greaterThanEqualClause_(value, v.greater_than_equal);
+              has = has && this.lessThanClause_(value, v.less_than);
+              has = has && this.lessThanEqualClause_(value, v.less_than_equal);
+              has = has && this.likeClause_(value, v.like);
+              has = has && this.containsClause_(value, v.contains);
+              has = has && this.inClause_(value, v.in);
+              has = has && this.notInClause_(value, v.not_in);
+              has = has && this.allClause_(value, v.all);
+              has = has && this.nearClause_(value, v.near);
+            }
+        }
+      });
+    }
+    return has;
+  }
+  /**
+  equals	The value must be exactly equal.
+  not_equals	The query will return all documents where the value is not equal.
+  exists	Only return documents where the value either exists (true) or does not exist (false).
+  greater_than	For numeric or date-based fields.
+  greater_than_equal	For numeric or date-based fields.
+  less_than	For numeric or date-based fields.
+  less_than_equal	For numeric or date-based fields.
+  like	Case-insensitive string must be present. If string of words, all words must be present, in any order.
+  contains	Must contain the value entered, case-insensitive.
+  in	The value must be found within the provided comma-delimited list of values.
+  not_in	The value must NOT be within the provided comma-delimited list of values.
+  all	The value must contain all values provided in the comma-delimited list.
+  near	For distance related to a point field comma separated as <longitude>, <latitude>, <maxDistance in meters (nullable)>, <minDistance in meters (nullable)>.
+  */
+  whereItems_(items, where, limit = -1) {
+    if (typeof where === "object") {
+      const whereItems = [];
+      for (const item of items) {
+        if (limit > -1 && whereItems.length >= limit) {
+          return whereItems;
+        }
+        if (this.whereItem_(item, where)) {
+          whereItems.push(item);
+        }
+      }
+      return whereItems;
+    }
+    return items;
+  }
+  // ^ where
+  // sort
+  sortCollection_(items, sort) {
+    if (sort) {
+      const reverse = sort.indexOf("-") === 0 ? -1 : 1;
+      const key = sort.replace(/^-/, "");
+      items = [...items];
+      items.sort((a, b) => {
+        const aValue = a[key];
+        const bValue = b[key];
+        if (typeof aValue === "number" && typeof bValue === "number") {
+          return (aValue - bValue) * reverse;
+        }
+        const aStringValue = String(aValue);
+        const bStringValue = String(bValue);
+        return aStringValue.localeCompare(bStringValue) * reverse;
+      });
+    }
+    return items;
+  }
+  // ^ sort
+  // limit
+  limitCollection_(items, limit) {
+    if (limit) {
+      items = items.slice(0, Math.min(limit, items.length));
+    }
+    return items;
+  }
+  // ^ limit
+  // pagination
+  paginatedItems_(items, page = 1, limit = 10) {
+    const totalDocs = items.length;
+    const totalPages = Math.ceil(items.length / limit);
+    const hasNextPage = page < totalPages;
+    const hasPrevPage = page > 1;
+    const index = page - 1;
+    const from = index * limit;
+    const to = Math.min(page * limit, totalDocs);
+    const docs = items.slice(from, to);
+    const pagination = {
+      totalDocs,
+      totalPages,
+      page,
+      limit,
+      hasNextPage,
+      hasPrevPage,
+      nextPage: hasNextPage ? page + 1 : null,
+      prevPage: hasPrevPage ? page - 1 : null,
+      pagingCounter: from + 1
+    };
+    return {
+      docs,
+      ...pagination
+    };
+  }
+  // ^ sort
+};
+function getValue(item, key) {
+  const keys = key.split(".");
+  const value = keys.reduce((p, c) => {
+    if (isObject(p)) {
+      const v = p[c];
+      if (isUnresolvedRelation(v)) {
+        return v.value;
+      }
+      return v;
+    } else {
+      return void 0;
+    }
+  }, item);
+  return value;
+}
+function calculateDistanceInMeters_(lon1, lat1, lon2, lat2) {
+  const R = 6371;
+  const dLat = deg2rad_(lat2 - lat1);
+  const dLon = deg2rad_(lon2 - lon1);
+  const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) + Math.cos(deg2rad_(lat1)) * Math.cos(deg2rad_(lat2)) * Math.sin(dLon / 2) * Math.sin(dLon / 2);
+  const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+  const distance = R * c * 1e3;
+  return distance;
+}
+function deg2rad_(deg) {
+  return deg * (Math.PI / 180);
+}
+
+// src/locale/locale.ts
+function getDefaultLocale() {
+  let defaultLocale2 = "en";
+  if (typeof process !== "undefined" && process.env.DEFAULT_LOCALE) {
+    defaultLocale2 = process.env.DEFAULT_LOCALE;
+  }
+  return defaultLocale2;
+}
+var defaultLocale = getDefaultLocale();
+
+// src/localized/localized.ts
+var DEFAULT_LOCALE = defaultLocale;
+function isLocalizedString(value) {
+  let isLocalizedString2 = false;
+  if (value && !Array.isArray(value) && typeof value === "object") {
+    const matchKeys = Object.keys(value).reduce((p, c) => p && /^(\w{2})(-\w{2})?$/.test(c), true);
+    const matchValues = Object.values(value).reduce((p, c) => p && (typeof c === "string" || !c), true);
+    isLocalizedString2 = Boolean(matchKeys && matchValues);
+  }
+  return isLocalizedString2;
+}
+function localizedToString(json, locale, defaultLocale2 = DEFAULT_LOCALE) {
+  const localizedString = json[locale] || json[defaultLocale2] || Object.values(json)[0];
+  return localizedString;
+}
+function localize(value, locale, defaultLocale2 = DEFAULT_LOCALE) {
+  return isLocalizedString(value) ? localizedToString(value, locale, defaultLocale2) : value;
+}
+function localizeValue(value, locale, defaultLocale2 = DEFAULT_LOCALE) {
+  if (value) {
+    if (isLocalizedString(value)) {
+      return localizedToString(value, locale, defaultLocale2);
+    } else {
+      return localizeItem(value, locale, defaultLocale2);
+    }
+  }
+}
+function localizeItem(item, locale, defaultLocale2 = DEFAULT_LOCALE) {
+  if (isArray(item)) {
+    item = item.map((x) => localizeValue(x, locale, defaultLocale2));
+  } else if (isObject(item)) {
+    item = { ...item };
+    const object = item;
+    Object.keys(object).forEach((key) => {
+      object[key] = localizeValue(object[key], locale, defaultLocale2);
+    });
+  }
+  return item;
+}
+
+// src/logger/logger.ts
+var LoggerLevel = /* @__PURE__ */ ((LoggerLevel2) => {
+  LoggerLevel2[LoggerLevel2["NONE"] = 0] = "NONE";
+  LoggerLevel2[LoggerLevel2["ERROR"] = 1] = "ERROR";
+  LoggerLevel2[LoggerLevel2["WARN"] = 2] = "WARN";
+  LoggerLevel2[LoggerLevel2["INFO"] = 3] = "INFO";
+  LoggerLevel2[LoggerLevel2["LOG"] = 4] = "LOG";
+  LoggerLevel2[LoggerLevel2["ALL"] = 5] = "ALL";
+  return LoggerLevel2;
+})(LoggerLevel || {});
+var Logger = class {
+  static setLevel(level) {
+    this.level_ = level;
+  }
+  static getLevel() {
+    if (isDevelopment) {
+      return this.level_;
+    } else {
+      return 1 /* ERROR */;
+    }
+  }
+  static error(...args) {
+    if (this.getLevel() >= 1 /* ERROR */) {
+      console.error(...args);
+    }
+  }
+  static warn(...args) {
+    if (this.getLevel() >= 2 /* WARN */) {
+      console.warn(...args);
+    }
+  }
+  static info(...args) {
+    if (this.getLevel() >= 3 /* INFO */) {
+      console.info(...args);
+    }
+  }
+  static log(...args) {
+    if (this.getLevel() >= 4 /* LOG */) {
+      console.log(...args);
+    }
+  }
+};
+Logger.level_ = 5 /* ALL */;
+
+// src/market/market.ts
+function getDefaultMarket() {
+  let defaultMarket2 = "ww";
+  if (typeof process !== "undefined" && process.env.DEFAULT_MARKET) {
+    defaultMarket2 = process.env.DEFAULT_MARKET;
+  }
+  return defaultMarket2;
+}
+var defaultMarket = getDefaultMarket();
+
+// src/password/password.ts
+function getPasswordStrategy() {
+  const passwordStrategy2 = typeof process !== "undefined" && process.env.NEXT_PUBLIC_PASSWORD_STRATEGY ? process.env.NEXT_PUBLIC_PASSWORD_STRATEGY : "^(?=.*[0-9])(?=.*[A-Z])(?=.*[a-z])[a-zA-Z0-9._\\-\\W]{8,}$";
+  return passwordStrategy2;
+}
+var passwordStrategy = getPasswordStrategy();
+
+// src/qs/qs.ts
+function qsSerializeKey(key, parentKey = "") {
+  return parentKey ? `${parentKey}[${key}]` : String(key);
+}
+function qsSerializeParam(key, value, serializedParams = [], parentKey = "") {
+  if (value != null) {
+    if (typeof value === "object") {
+      serializedParams = qsSerializeParams(value, serializedParams, qsSerializeKey(key, parentKey));
+    } else {
+      serializedParams.push({
+        key: qsSerializeKey(key, parentKey),
+        value
+      });
+    }
+  }
+  return serializedParams;
+}
+function qsSerializeParams(params, serializedParams = [], parentKey = "") {
+  if (Array.isArray(params)) {
+    params.forEach((value, key) => {
+      serializedParams = qsSerializeParam(key, value, serializedParams, parentKey);
+    });
+  } else {
+    Object.entries(params).forEach(([key, value]) => {
+      serializedParams = qsSerializeParam(key, value, serializedParams, parentKey);
+    });
+  }
+  return serializedParams;
+}
+function qsSerialize(queryParams = {}) {
+  const params = qsSerializeParams(queryParams);
+  if (params.length) {
+    return params.map((x) => `${x.key}=${x.value}`).join("&");
+  }
+  return "";
+}
+function qsSerializeRaw(queryParams = {}) {
+  const params = qsSerializeParams(queryParams);
+  if (params.length) {
+    return params.map((x) => `${x.key}=${x.value}`).join("&");
+  }
+  return "";
+}
+function qsDeserializeValue(value) {
+  if (String(parseInt(value)) === value) {
+    return Number(value);
+  } else if (String(value) === "true") {
+    return true;
+  } else if (String(value) === "false") {
+    return false;
+  }
+  return value;
+}
+function qsDeserializeKey(value) {
+  if (String(parseInt(value)) === value) {
+    return Number(value);
+  }
+  return value;
+}
+function qsDeserializeKeys(key) {
+  const keys = key.replace(/[\]]/g, "").split("[").map((x) => qsDeserializeKey(x));
+  return keys;
+}
+function getNextKeyItem(key) {
+  if (typeof key === "number") {
+    return [];
+  } else {
+    return {};
+  }
+}
+function qsDeserializeParam(key, value, deserializedParams = {}) {
+  const keys = qsDeserializeKeys(key);
+  let target = deserializedParams;
+  while (keys.length) {
+    const key2 = keys.shift();
+    if (keys.length === 0) {
+      target[key2] = qsDeserializeValue(value);
+    } else {
+      const next = target[key2] ? target[key2] : target[key2] = getNextKeyItem(keys[0]);
+      target = next;
+    }
+  }
+  return deserializedParams;
+}
+function qsDeserializeParams(params, deserializedParams = {}) {
+  params.forEach((x) => qsDeserializeParam(x[0], x[1], deserializedParams));
+  return deserializedParams;
+}
+function qsDeserialize(query = "", deserializedParams = {}) {
+  if (query.indexOf("?") === 0) {
+    query = query.substring(1);
+  }
+  if (query !== "") {
+    const params = query.split("&").map((x) => x.split("="));
+    if (params.length) {
+      return qsDeserializeParams(params, deserializedParams);
+    }
+  }
+  return deserializedParams;
+}
+function qsDeserializeRaw(query = "", deserializedParams = {}) {
+  if (query.indexOf("?") === 0) {
+    query = query.substring(1);
+  }
+  if (query !== "") {
+    const params = query.split("&").map((x) => x.split("="));
+    if (params.length) {
+      return qsDeserializeParams(params, deserializedParams);
+    }
+  }
+  return deserializedParams;
+}
+
+// src/request/request.ts
+function isHeaders(headers) {
+  return typeof headers === "object" && "get" in headers ? typeof headers.get === "function" : false;
+}
+function isIncomingHttpHeaders(headers) {
+  return typeof headers === "object" && !("get" in headers);
+}
+function getHost(headers) {
+  if (isIncomingHttpHeaders(headers)) {
+    return headers["x-forwarded-host"] || headers.forwarded || headers.host || null;
+  } else if (isHeaders(headers)) {
+    return headers.get("X-Forwarded-Host") || headers.get("Forwarded") || headers.get("Host") || null;
+  } else {
+    return null;
+  }
+}
+function getProto(headers) {
+  if (isIncomingHttpHeaders(headers)) {
+    return headers["x-forwarded-proto"] || "https";
+  } else if (isHeaders(headers)) {
+    return headers.get("X-Forwarded-Proto") || "https";
+  } else {
+    return "https";
+  }
+}
+function getOrigin(headers) {
+  if (process.env.NEXT_PUBLIC_URL) {
+    return process.env.NEXT_PUBLIC_URL;
+  } else {
+    const host = getHost(headers);
+    if (host) {
+      return host.indexOf("localhost") !== -1 ? "http://" + host : getProto(headers) + "://" + host;
+    } else {
+      return "";
+    }
+  }
+}
+
+// src/route/route.ts
+var RouteStrategy = /* @__PURE__ */ ((RouteStrategy2) => {
+  RouteStrategy2["Auto"] = "auto";
+  RouteStrategy2["Default"] = "default";
+  RouteStrategy2["Manual"] = "manual";
+  return RouteStrategy2;
+})(RouteStrategy || {});
+var ROUTE_STRATEGY = process.env.ROUTE_STRATEGY || "manual" /* Manual */;
+function collectRoutes(store, categories, markets, locales, medias) {
+  const routes = [];
+  if (locales.length > 0 && markets.length > 0) {
+    const rootCategory = getRootCategory(categories);
+    eachCategorized(store, (item, key) => {
+      const segments = getCategorySegments(categories, item);
+      const visibleSegments = segments.filter((x) => Boolean(x.isHidden) === false);
+      const visibleCategory = visibleSegments.length > 0 ? visibleSegments[visibleSegments.length - 1] : rootCategory;
+      if (visibleCategory) {
+        const slugs = visibleSegments.map((x) => ({ slug: x.slug }));
+        if (Boolean(item.isDefault) === false) {
+          slugs.push({ slug: item.slug });
+        }
+        const isRootCategory = rootCategory && item.category === rootCategory.id && item.isDefault;
+        eachMarketLocale(markets, locales, (market, locale, markets2, locales2) => {
+          if (hasMarket(item, market)) {
+            const title = localize(item.title, locale.id);
+            const id = getRouteHref(slugs, market, locale, markets2, locales2);
+            const {
+              _status,
+              category,
+              isDefault,
+              media,
+              order,
+              template,
+              updatedAt,
+              useSplat
+            } = item;
+            const route = {
+              _status,
+              category,
+              // id: isDefaultRootCategory ? '/' : id,
+              id,
+              locale: locale.id,
+              market: market.id,
+              media,
+              page: item.id,
+              resolvedCategory: visibleCategory.id,
+              schema: key,
+              template,
+              title,
+              updatedAt
+            };
+            if (isDefault) {
+              route.isDefault = true;
+            }
+            if (isRootCategory) {
+              route.isRoot = true;
+            }
+            const noindex = (item.meta?.robots || "").includes("noindex");
+            if (noindex) {
+              route.noindex = true;
+            }
+            if (order != null) {
+              route.order = order;
+            }
+            if (useSplat) {
+              route.useSplat = true;
+            }
+            const mediaId = typeof item.media === "string" ? item.media : void 0;
+            if (Array.isArray(medias) && mediaId) {
+              const media2 = item.media && medias.find((x) => x.id === mediaId);
+              if (media2) {
+                route.media = media2;
+              }
+            }
+            routes.push(route);
+          }
+        });
+      }
+    });
+  }
+  return routes;
+}
+function eachMarketLocale(markets, locales, callback) {
+  locales = locales.filter((x) => x.isActive !== false);
+  markets = markets.filter((x) => x.isActive !== false);
+  markets.forEach((market) => {
+    const marketLocales = market.languages && market.languages.length > 0 ? market.languages.map((idOrEntity) => locales.find((x) => x.id === asEntityId(idOrEntity))).filter((x) => x !== void 0) : locales;
+    marketLocales.forEach((locale) => {
+      callback(market, locale, markets, locales);
+    });
+  });
+}
+function eachCategorized(store, callback) {
+  const keys = Object.keys(store);
+  for (const key of keys) {
+    const items = store[key];
+    for (const item of items) {
+      callback(item, key);
+    }
+  }
+}
+function findRouteOfCategory(routes, categoryId, market, locale) {
+  const findRoute = market && locale ? (route2) => route2.isDefault && route2.resolvedCategory === categoryId && route2.market === market && route2.locale === locale : (route2) => route2.isDefault && route2.resolvedCategory === categoryId;
+  const route = routes.find(findRoute);
+  return route;
+}
+function findRoutesOfCategory(routes, categoryId, isDefault = true) {
+  const filteredRoutes = routes.filter(
+    (route) => route.resolvedCategory === categoryId && Boolean(route.isDefault) === isDefault
+  );
+  return filteredRoutes;
+}
+function getRouteHref(segments, market, locale, markets, locales) {
+  const href = segments.reduce((p, c, i) => {
+    let slug = localize(c.slug || "", locale.id);
+    slug = `${p}/${slug}`;
+    return slug === "/" ? "" : slug;
+  }, "");
+  const prefixes = [];
+  switch (ROUTE_STRATEGY) {
+    case "auto" /* Auto */:
+      if (locales.length > 1 || markets.length > 1) {
+        prefixes.push(locale.id);
+      }
+      if (markets.length > 1) {
+        prefixes.push(market.id);
+      }
+      break;
+    case "default" /* Default */:
+      if (locale.isDefault !== true) {
+        prefixes.push(locale.id);
+      }
+      if (market.isDefault !== true) {
+        prefixes.push(market.id);
+      }
+      break;
+    case "manual" /* Manual */:
+      if (locale.isHidden !== true) {
+        prefixes.push(locale.id);
+      }
+      if (market.isHidden !== true) {
+        prefixes.push(market.id);
+      }
+      break;
+  }
+  const prefix = prefixes.length ? `/${prefixes.join("-")}` : "";
+  return `${prefix}${href}`;
+}
+function hasMarket(item, market) {
+  return !item.markets || item.markets.length === 0 || item.markets.includes(market.id);
+}
+export {
+  ImageStrategy,
+  JsonService,
+  Logger,
+  LoggerLevel,
+  MenuCategoryStrategy,
+  RedirectReason,
+  RouteStrategy,
+  arrayShuffle,
+  asCategoryId,
+  asEntityId,
+  asEquatable,
+  asEquatableNumber,
+  asEquatableString,
+  asServerProps,
+  asSortedOptions,
+  awaitAll,
+  base64ToString,
+  camelToSnakeCase,
+  cloneItem,
+  collectFeatureTypes,
+  collectFeatureTypes__,
+  collectOptions,
+  collectRoutes,
+  consoleWarn,
+  decryptImageResize,
+  deepMerge,
+  defaultLocale,
+  defaultMarket,
+  eachCategorized,
+  eachMarketLocale,
+  eachMedia,
+  eachValue,
+  encryptImageToken,
+  enumToList,
+  excludeComponent,
+  findCategoryInCategories,
+  findChildCategories,
+  findRouteOfCategory,
+  findRoutesOfCategory,
+  getCategorySegments,
+  getCategorySegmentsByCategory,
+  getClassNames,
+  getCollectionDescription,
+  getEnv,
+  getHost,
+  getIsDevelopment,
+  getIsProduction,
+  getOrigin,
+  getParentCategoriesById,
+  getParentCategory,
+  getProto,
+  getRootCategory,
+  getRouteHref,
+  groupComponents,
+  hasComponents,
+  hasMarket,
+  httpDelete,
+  httpFetch,
+  httpGet,
+  httpPatch,
+  httpPost,
+  httpPut,
+  isArray,
+  isBrowser,
+  isComponent,
+  isComponentOfType,
+  isDevelopment,
+  isEntity,
+  isEquatable,
+  isHeaders,
+  isIncomingHttpHeaders,
+  isLocalizedString,
+  isMedia,
+  isMediaImage,
+  isMediaJson,
+  isMediaPdf,
+  isMediaVideo,
+  isMenuCategory,
+  isMenuGroup,
+  isMenuHref,
+  isMenuLink,
+  isMenuPage,
+  isMenuRoute,
+  isNonEmptyArray,
+  isNotNullString,
+  isNumber,
+  isObject,
+  isProduction,
+  isPromise,
+  isRelation,
+  isReservedCollectionDescription,
+  isStage,
+  isString,
+  isUndecoratedCategory,
+  isUndecoratedMenuCategory,
+  isUndecoratedMenuItem,
+  isUndecoratedMenuPage,
+  isUndecoratedNav,
+  isUnresolvedCategory,
+  isUnresolvedRelation,
+  isValidCollectionDescription,
+  isValidString,
+  localize,
+  localizeItem,
+  localizeValue,
+  localizedToString,
+  merge,
+  pascalCaseToCamelCase,
+  pascalCaseToCharCase,
+  pascalCaseToKebabCase,
+  pascalCaseToSnakeCase,
+  passwordStrategy,
+  pickComponent,
+  pickHero,
+  prependHero,
+  qsDeserialize,
+  qsDeserializeRaw,
+  qsSerialize,
+  qsSerializeRaw,
+  resolveMediaType,
+  stringToBase64,
+  toCamelCase,
+  toCharCase,
+  toDisplayName,
+  toFindParams,
+  toKebabCase,
+  toPascalCase,
+  toPluralName,
+  toSnakeCase,
+  toTitleCase,
+  toValidCollectionName,
+  unknownCaseToPascalCase,
+  uuidv4,
+  withSchema
+};