@mattisvensson/strapi-plugin-webatlas 0.1.0

package/dist/server/index.mjs

@@ -0,0 +1,1862 @@
+function transformToUrl(input) {
+  const specialCharMap = {
+    "ü": "ue",
+    "ä": "ae",
+    "ö": "oe"
+  };
+  if (!input || typeof input !== "string") return "";
+  input = input.toLowerCase();
+  input = input.replace(/\/+/g, "/");
+  input = input.startsWith("/") ? input.slice(1) : input;
+  input = input.endsWith("/") ? input.slice(0, -1) : input;
+  for (const char in specialCharMap) {
+    const regex = new RegExp(char, "g");
+    input = input.replace(regex, specialCharMap[char]);
+  }
+  input = input.trim();
+  input = input.replace(/\s+/g, "-");
+  input = input.replace(/[^A-Za-z0-9$\-_.+!*'()/]/g, "");
+  input = input.replace(/-+/g, "-");
+  return input;
+}
+const version = "0.1.0";
+const keywords = [];
+const type = "commonjs";
+const exports = {
+  "./package.json": "./package.json",
+  "./strapi-admin": {
+    types: "./dist/admin/src/index.d.ts",
+    source: "./admin/src/index.tsx",
+    "import": "./dist/admin/index.mjs",
+    require: "./dist/admin/index.js",
+    "default": "./dist/admin/index.js"
+  },
+  "./strapi-server": {
+    types: "./dist/server/src/index.d.ts",
+    source: "./server/src/index.ts",
+    "import": "./dist/server/index.mjs",
+    require: "./dist/server/index.js",
+    "default": "./dist/server/index.js"
+  }
+};
+const files = [
+  "dist"
+];
+const scripts = {
+  build: "strapi-plugin build && yalc push --publish",
+  watch: "strapi-plugin watch",
+  "watch:link": "strapi-plugin watch:link",
+  verify: "strapi-plugin verify",
+  "test:ts:front": "tsc -p admin/tsconfig.json",
+  "test:ts:back": "tsc -p server/tsconfig.json",
+  "test:jest": "ENV_PATH=./playground/.env  jest --verbose --runInBand --forceExit",
+  "test:cypress": "cypress run",
+  "test:cypress:open": "cypress open",
+  "playground:install": "yarn playground:yalc-add-link && cd playground && yarn install",
+  "playground:yalc-add": "cd playground && yalc add strapi-plugin-boilerplate",
+  "playground:yalc-add-link": "cd playground && yalc add --link strapi-plugin-boilerplate",
+  "playground:build": "cd playground && yarn build",
+  "playground:develop": "cd playground && yarn develop",
+  "playground:start": "cd playground && yarn start"
+};
+const dependencies = {
+  "@dnd-kit/core": "^6.3.1",
+  "@dnd-kit/sortable": "^10.0.0",
+  "@dnd-kit/utilities": "^3.2.2",
+  "@strapi/design-system": "^2.0.0-rc.14",
+  "@strapi/icons": "^2.0.0-rc.14",
+  "react-intl": "^7.1.0"
+};
+const devDependencies = {
+  "@strapi/sdk-plugin": "^5.0.0",
+  "@strapi/strapi": "^5.0.0",
+  "@strapi/typescript-utils": "^5.0.0",
+  "@types/react": "^19.0.0",
+  "@types/react-dom": "^19.0.0",
+  cypress: "^13.9.0",
+  "cypress-terminal-report": "^6.0.2",
+  jest: "^29.7.0",
+  prettier: "^3.4.2",
+  react: "^19.0.0",
+  "react-router-dom": "^6.0.0",
+  supertest: "^7.0.0",
+  typescript: "^5.7.2"
+};
+const peerDependencies = {
+  "@strapi/strapi": "^5.0.0",
+  react: "^17.0.0 || ^18.0.0",
+  "react-dom": "^17.0.0 || ^18.0.0",
+  "react-router-dom": "^6.0.0",
+  "styled-components": "^6.0.0"
+};
+const description = "A strapi plugin to manage URL routes and navigations.";
+const strapi$1 = {
+  name: "webatlas",
+  displayName: "Webatlas",
+  description: "A strapi plugin to manage URL routes and navigations.",
+  kind: "plugin"
+};
+const name = "@mattisvensson/strapi-plugin-webatlas";
+const license = "MIT";
+const repository = {
+  type: "git",
+  url: "git+ssh://git@github.com:mattisvensson/strapi-plugin-webatlas.git"
+};
+const bugs = {
+  url: "https://github.com/mattisvensson/strapi-plugin-webatlas/issues"
+};
+const homepage = "https://github.com/mattisvensson/strapi-plugin-webatlas#readme";
+const author = {
+  name: "Matti Svensson",
+  email: "mattisvensson@web.de",
+  url: "https://mattisvensson.com"
+};
+const maintainers = [
+  {
+    name: "Matti Svensson",
+    email: "mattisvensson@web.de",
+    url: "https://mattisvensson.com"
+  }
+];
+const packageManager = "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e";
+const pluginPkg = {
+  version,
+  keywords,
+  type,
+  exports,
+  files,
+  scripts,
+  dependencies,
+  devDependencies,
+  peerDependencies,
+  description,
+  strapi: strapi$1,
+  name,
+  license,
+  repository,
+  bugs,
+  homepage,
+  author,
+  maintainers,
+  packageManager
+};
+const PLUGIN_NAME = pluginPkg.strapi.displayName;
+const waNavigation = `plugin::${PLUGIN_NAME}.navigation`;
+const waNavItem = `plugin::${PLUGIN_NAME}.navitem`;
+const waRoute = `plugin::${PLUGIN_NAME}.route`;
+function getAdminService() {
+  return strapi.plugin(PLUGIN_NAME)?.service("admin");
+}
+function getClientService() {
+  return strapi.plugin(PLUGIN_NAME)?.service("client");
+}
+async function checkPathExists(path, targetRoutePath) {
+  const entities = await strapi.documents(waRoute).findMany({
+    filters: {
+      $or: [
+        {
+          fullPath: path
+        },
+        {
+          slug: path
+        },
+        {
+          uidPath: path
+        }
+      ]
+    }
+  });
+  if (targetRoutePath && entities && entities[0]?.fullPath === targetRoutePath)
+    return false;
+  return entities?.length > 0;
+}
+async function duplicateCheck(initialPath, targetRouteDocumentId) {
+  try {
+    let uniquePath = initialPath;
+    let targetRoutePath = null;
+    let counter = 1;
+    if (targetRouteDocumentId) {
+      const route2 = await strapi.documents(waRoute).findOne({
+        documentId: targetRouteDocumentId
+      });
+      if (route2) targetRoutePath = route2.fullPath;
+    }
+    let exists = await checkPathExists(uniquePath, targetRoutePath);
+    while (exists) {
+      uniquePath = `${initialPath}-${counter}`;
+      exists = await checkPathExists(uniquePath);
+      counter++;
+    }
+    return uniquePath;
+  } catch (e) {
+    console.log(e);
+  }
+}
+const bootstrap = async ({ strapi: strapi2 }) => {
+  if (!strapi2.store) {
+    throw new Error("strapi.store is undefined");
+  }
+  const pluginStore = strapi2.store({ type: "plugin", name: "webatlas" });
+  const config2 = await pluginStore.get({
+    key: "config"
+  });
+  if (!config2?.selectedContentTypes) return;
+  strapi2.db?.lifecycles.subscribe({
+    models: [waNavItem],
+    async beforeDelete(event) {
+      const id = event.params.where["id"];
+      if (!id) return;
+      try {
+        const navItem = await strapi2.db?.query(waNavItem).findOne({
+          where: {
+            id
+          },
+          populate: ["route"]
+        });
+        event.state = navItem.route.id && !navItem.route.internal ? { id: navItem.route.id } : null;
+      } catch (err) {
+        console.log(err);
+      }
+    },
+    async afterDelete(event) {
+      const { id } = event.state;
+      if (!id) return;
+      try {
+        await strapi2.db?.query(waRoute).delete({
+          where: {
+            id
+          }
+        });
+      } catch (err) {
+        console.log(err);
+      }
+    }
+  });
+  strapi2.db?.lifecycles.subscribe({
+    models: config2.selectedContentTypes.map((type2) => type2.uid),
+    async beforeCreate() {
+      const validContentTypes = config2.selectedContentTypes.filter((type2) => strapi2.contentTypes[type2.uid]);
+      await pluginStore.set({ key: "config", value: { selectedContentTypes: validContentTypes } });
+    },
+    async afterCreate(event) {
+      const ctSettings = config2.selectedContentTypes.find((type2) => type2.uid === event.model.uid);
+      const {
+        webatlas_path,
+        webatlas_override
+      } = event.params.data;
+      if (!webatlas_path) return;
+      const title = ctSettings?.default ? event.params.data[ctSettings.default] : "";
+      const path = await duplicateCheck(transformToUrl(webatlas_path));
+      await strapi2.documents(waRoute).create({
+        data: {
+          relatedContentType: event.model.uid,
+          relatedId: event.result.id,
+          relatedDocumentId: event.result.documentId,
+          slug: path,
+          fullPath: path,
+          uidPath: `${event.model.singularName}/${event.result.id}`,
+          documentIdPath: event.result.documentId,
+          isOverride: webatlas_override || false,
+          title
+        }
+      });
+    },
+    async afterUpdate(event) {
+      const ctSettings = config2.selectedContentTypes.find((type2) => type2.uid === event.model.uid);
+      const {
+        webatlas_path,
+        webatlas_override,
+        documentId
+      } = event.params.data;
+      if (!webatlas_path) return;
+      const relatedRoute = await strapi2.db?.query(waRoute).findOne({
+        where: {
+          relatedDocumentId: documentId
+        }
+      });
+      const title = ctSettings?.default ? event.params.data[ctSettings.default] : "";
+      const path = await duplicateCheck(transformToUrl(webatlas_path));
+      const routeData = {
+        title,
+        fullPath: path,
+        slug: path,
+        isOverride: webatlas_override || false
+      };
+      if (!relatedRoute) {
+        await strapi2.documents(waRoute).create({
+          data: {
+            relatedContentType: event.model.uid,
+            relatedId: event.result.id,
+            relatedDocumentId: event.result.documentId,
+            uidPath: `${event.model.singularName}/${event.result.id}`,
+            documentIdPath: event.result.documentId,
+            ...routeData
+          }
+        });
+      } else {
+        await strapi2.documents(waRoute).update({
+          documentId: relatedRoute.documentId,
+          data: {
+            ...routeData
+          }
+        });
+      }
+    },
+    async afterDelete(event) {
+      try {
+        await findAndDeleteNavItem(event.result.id, event.model.uid);
+      } catch (err) {
+        console.log(err);
+      }
+    },
+    async afterDeleteMany(event) {
+      const deletedArr = event.params.where["$and"];
+      deletedArr.map((item) => {
+        const ids = item.id["$in"];
+        ids.map(async (id) => {
+          await findAndDeleteNavItem(id, event.model.uid);
+        });
+      });
+    }
+  });
+};
+async function findAndDeleteNavItem(relatedId, relatedContentType) {
+  if (!relatedId || !relatedContentType) return;
+  try {
+    const route2 = await strapi.db?.query(waRoute).findOne({
+      where: {
+        relatedId,
+        relatedContentType
+      }
+    });
+    if (!route2?.documentId) return;
+    const navItem = await strapi.db?.query(waNavItem).findOne({
+      where: {
+        route: {
+          documentId: route2.documentId
+        }
+      }
+    });
+    await strapi.documents(waRoute).delete({ documentId: route2.documentId });
+    if (navItem?.documentId) await strapi.documents(waNavItem).delete({ documentId: navItem.documentId });
+  } catch (err) {
+    console.log(err);
+  }
+}
+const destroy = ({ strapi: strapi2 }) => {
+};
+var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+var freeGlobal$1 = typeof commonjsGlobal == "object" && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
+var _freeGlobal = freeGlobal$1;
+var freeGlobal = _freeGlobal;
+var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+var root$3 = freeGlobal || freeSelf || Function("return this")();
+var _root = root$3;
+var root$2 = _root;
+var Symbol$4 = root$2.Symbol;
+var _Symbol = Symbol$4;
+var Symbol$3 = _Symbol;
+var objectProto$5 = Object.prototype;
+var hasOwnProperty$4 = objectProto$5.hasOwnProperty;
+var nativeObjectToString$1 = objectProto$5.toString;
+var symToStringTag$1 = Symbol$3 ? Symbol$3.toStringTag : void 0;
+function getRawTag$1(value) {
+  var isOwn = hasOwnProperty$4.call(value, symToStringTag$1), tag = value[symToStringTag$1];
+  try {
+    value[symToStringTag$1] = void 0;
+    var unmasked = true;
+  } catch (e) {
+  }
+  var result = nativeObjectToString$1.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag$1] = tag;
+    } else {
+      delete value[symToStringTag$1];
+    }
+  }
+  return result;
+}
+var _getRawTag = getRawTag$1;
+var objectProto$4 = Object.prototype;
+var nativeObjectToString = objectProto$4.toString;
+function objectToString$1(value) {
+  return nativeObjectToString.call(value);
+}
+var _objectToString = objectToString$1;
+var Symbol$2 = _Symbol, getRawTag = _getRawTag, objectToString = _objectToString;
+var nullTag = "[object Null]", undefinedTag = "[object Undefined]";
+var symToStringTag = Symbol$2 ? Symbol$2.toStringTag : void 0;
+function baseGetTag$2(value) {
+  if (value == null) {
+    return value === void 0 ? undefinedTag : nullTag;
+  }
+  return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+}
+var _baseGetTag = baseGetTag$2;
+function isObject$3(value) {
+  var type2 = typeof value;
+  return value != null && (type2 == "object" || type2 == "function");
+}
+var isObject_1 = isObject$3;
+var baseGetTag$1 = _baseGetTag, isObject$2 = isObject_1;
+var asyncTag = "[object AsyncFunction]", funcTag = "[object Function]", genTag = "[object GeneratorFunction]", proxyTag = "[object Proxy]";
+function isFunction$1(value) {
+  if (!isObject$2(value)) {
+    return false;
+  }
+  var tag = baseGetTag$1(value);
+  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+}
+var isFunction_1 = isFunction$1;
+var root$1 = _root;
+var coreJsData$1 = root$1["__core-js_shared__"];
+var _coreJsData = coreJsData$1;
+var coreJsData = _coreJsData;
+var maskSrcKey = function() {
+  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
+  return uid ? "Symbol(src)_1." + uid : "";
+}();
+function isMasked$1(func) {
+  return !!maskSrcKey && maskSrcKey in func;
+}
+var _isMasked = isMasked$1;
+var funcProto$1 = Function.prototype;
+var funcToString$1 = funcProto$1.toString;
+function toSource$1(func) {
+  if (func != null) {
+    try {
+      return funcToString$1.call(func);
+    } catch (e) {
+    }
+    try {
+      return func + "";
+    } catch (e) {
+    }
+  }
+  return "";
+}
+var _toSource = toSource$1;
+var isFunction = isFunction_1, isMasked = _isMasked, isObject$1 = isObject_1, toSource = _toSource;
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+var funcProto = Function.prototype, objectProto$3 = Object.prototype;
+var funcToString = funcProto.toString;
+var hasOwnProperty$3 = objectProto$3.hasOwnProperty;
+var reIsNative = RegExp(
+  "^" + funcToString.call(hasOwnProperty$3).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+);
+function baseIsNative$1(value) {
+  if (!isObject$1(value) || isMasked(value)) {
+    return false;
+  }
+  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
+  return pattern.test(toSource(value));
+}
+var _baseIsNative = baseIsNative$1;
+function getValue$1(object, key) {
+  return object == null ? void 0 : object[key];
+}
+var _getValue = getValue$1;
+var baseIsNative = _baseIsNative, getValue = _getValue;
+function getNative$3(object, key) {
+  var value = getValue(object, key);
+  return baseIsNative(value) ? value : void 0;
+}
+var _getNative = getNative$3;
+var getNative$2 = _getNative;
+var defineProperty$1 = function() {
+  try {
+    var func = getNative$2(Object, "defineProperty");
+    func({}, "", {});
+    return func;
+  } catch (e) {
+  }
+}();
+var _defineProperty = defineProperty$1;
+var defineProperty = _defineProperty;
+function baseAssignValue$1(object, key, value) {
+  if (key == "__proto__" && defineProperty) {
+    defineProperty(object, key, {
+      "configurable": true,
+      "enumerable": true,
+      "value": value,
+      "writable": true
+    });
+  } else {
+    object[key] = value;
+  }
+}
+var _baseAssignValue = baseAssignValue$1;
+function eq$2(value, other) {
+  return value === other || value !== value && other !== other;
+}
+var eq_1 = eq$2;
+var baseAssignValue = _baseAssignValue, eq$1 = eq_1;
+var objectProto$2 = Object.prototype;
+var hasOwnProperty$2 = objectProto$2.hasOwnProperty;
+function assignValue$1(object, key, value) {
+  var objValue = object[key];
+  if (!(hasOwnProperty$2.call(object, key) && eq$1(objValue, value)) || value === void 0 && !(key in object)) {
+    baseAssignValue(object, key, value);
+  }
+}
+var _assignValue = assignValue$1;
+var isArray$3 = Array.isArray;
+var isArray_1 = isArray$3;
+function isObjectLike$1(value) {
+  return value != null && typeof value == "object";
+}
+var isObjectLike_1 = isObjectLike$1;
+var baseGetTag = _baseGetTag, isObjectLike = isObjectLike_1;
+var symbolTag = "[object Symbol]";
+function isSymbol$3(value) {
+  return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag;
+}
+var isSymbol_1 = isSymbol$3;
+var isArray$2 = isArray_1, isSymbol$2 = isSymbol_1;
+var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, reIsPlainProp = /^\w*$/;
+function isKey$1(value, object) {
+  if (isArray$2(value)) {
+    return false;
+  }
+  var type2 = typeof value;
+  if (type2 == "number" || type2 == "symbol" || type2 == "boolean" || value == null || isSymbol$2(value)) {
+    return true;
+  }
+  return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object(object);
+}
+var _isKey = isKey$1;
+var getNative$1 = _getNative;
+var nativeCreate$4 = getNative$1(Object, "create");
+var _nativeCreate = nativeCreate$4;
+var nativeCreate$3 = _nativeCreate;
+function hashClear$1() {
+  this.__data__ = nativeCreate$3 ? nativeCreate$3(null) : {};
+  this.size = 0;
+}
+var _hashClear = hashClear$1;
+function hashDelete$1(key) {
+  var result = this.has(key) && delete this.__data__[key];
+  this.size -= result ? 1 : 0;
+  return result;
+}
+var _hashDelete = hashDelete$1;
+var nativeCreate$2 = _nativeCreate;
+var HASH_UNDEFINED$1 = "__lodash_hash_undefined__";
+var objectProto$1 = Object.prototype;
+var hasOwnProperty$1 = objectProto$1.hasOwnProperty;
+function hashGet$1(key) {
+  var data = this.__data__;
+  if (nativeCreate$2) {
+    var result = data[key];
+    return result === HASH_UNDEFINED$1 ? void 0 : result;
+  }
+  return hasOwnProperty$1.call(data, key) ? data[key] : void 0;
+}
+var _hashGet = hashGet$1;
+var nativeCreate$1 = _nativeCreate;
+var objectProto = Object.prototype;
+var hasOwnProperty = objectProto.hasOwnProperty;
+function hashHas$1(key) {
+  var data = this.__data__;
+  return nativeCreate$1 ? data[key] !== void 0 : hasOwnProperty.call(data, key);
+}
+var _hashHas = hashHas$1;
+var nativeCreate = _nativeCreate;
+var HASH_UNDEFINED = "__lodash_hash_undefined__";
+function hashSet$1(key, value) {
+  var data = this.__data__;
+  this.size += this.has(key) ? 0 : 1;
+  data[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED : value;
+  return this;
+}
+var _hashSet = hashSet$1;
+var hashClear = _hashClear, hashDelete = _hashDelete, hashGet = _hashGet, hashHas = _hashHas, hashSet = _hashSet;
+function Hash$1(entries) {
+  var index2 = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index2 < length) {
+    var entry = entries[index2];
+    this.set(entry[0], entry[1]);
+  }
+}
+Hash$1.prototype.clear = hashClear;
+Hash$1.prototype["delete"] = hashDelete;
+Hash$1.prototype.get = hashGet;
+Hash$1.prototype.has = hashHas;
+Hash$1.prototype.set = hashSet;
+var _Hash = Hash$1;
+function listCacheClear$1() {
+  this.__data__ = [];
+  this.size = 0;
+}
+var _listCacheClear = listCacheClear$1;
+var eq = eq_1;
+function assocIndexOf$4(array, key) {
+  var length = array.length;
+  while (length--) {
+    if (eq(array[length][0], key)) {
+      return length;
+    }
+  }
+  return -1;
+}
+var _assocIndexOf = assocIndexOf$4;
+var assocIndexOf$3 = _assocIndexOf;
+var arrayProto = Array.prototype;
+var splice = arrayProto.splice;
+function listCacheDelete$1(key) {
+  var data = this.__data__, index2 = assocIndexOf$3(data, key);
+  if (index2 < 0) {
+    return false;
+  }
+  var lastIndex = data.length - 1;
+  if (index2 == lastIndex) {
+    data.pop();
+  } else {
+    splice.call(data, index2, 1);
+  }
+  --this.size;
+  return true;
+}
+var _listCacheDelete = listCacheDelete$1;
+var assocIndexOf$2 = _assocIndexOf;
+function listCacheGet$1(key) {
+  var data = this.__data__, index2 = assocIndexOf$2(data, key);
+  return index2 < 0 ? void 0 : data[index2][1];
+}
+var _listCacheGet = listCacheGet$1;
+var assocIndexOf$1 = _assocIndexOf;
+function listCacheHas$1(key) {
+  return assocIndexOf$1(this.__data__, key) > -1;
+}
+var _listCacheHas = listCacheHas$1;
+var assocIndexOf = _assocIndexOf;
+function listCacheSet$1(key, value) {
+  var data = this.__data__, index2 = assocIndexOf(data, key);
+  if (index2 < 0) {
+    ++this.size;
+    data.push([key, value]);
+  } else {
+    data[index2][1] = value;
+  }
+  return this;
+}
+var _listCacheSet = listCacheSet$1;
+var listCacheClear = _listCacheClear, listCacheDelete = _listCacheDelete, listCacheGet = _listCacheGet, listCacheHas = _listCacheHas, listCacheSet = _listCacheSet;
+function ListCache$1(entries) {
+  var index2 = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index2 < length) {
+    var entry = entries[index2];
+    this.set(entry[0], entry[1]);
+  }
+}
+ListCache$1.prototype.clear = listCacheClear;
+ListCache$1.prototype["delete"] = listCacheDelete;
+ListCache$1.prototype.get = listCacheGet;
+ListCache$1.prototype.has = listCacheHas;
+ListCache$1.prototype.set = listCacheSet;
+var _ListCache = ListCache$1;
+var getNative = _getNative, root = _root;
+var Map$2 = getNative(root, "Map");
+var _Map = Map$2;
+var Hash = _Hash, ListCache = _ListCache, Map$1 = _Map;
+function mapCacheClear$1() {
+  this.size = 0;
+  this.__data__ = {
+    "hash": new Hash(),
+    "map": new (Map$1 || ListCache)(),
+    "string": new Hash()
+  };
+}
+var _mapCacheClear = mapCacheClear$1;
+function isKeyable$1(value) {
+  var type2 = typeof value;
+  return type2 == "string" || type2 == "number" || type2 == "symbol" || type2 == "boolean" ? value !== "__proto__" : value === null;
+}
+var _isKeyable = isKeyable$1;
+var isKeyable = _isKeyable;
+function getMapData$4(map, key) {
+  var data = map.__data__;
+  return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+}
+var _getMapData = getMapData$4;
+var getMapData$3 = _getMapData;
+function mapCacheDelete$1(key) {
+  var result = getMapData$3(this, key)["delete"](key);
+  this.size -= result ? 1 : 0;
+  return result;
+}
+var _mapCacheDelete = mapCacheDelete$1;
+var getMapData$2 = _getMapData;
+function mapCacheGet$1(key) {
+  return getMapData$2(this, key).get(key);
+}
+var _mapCacheGet = mapCacheGet$1;
+var getMapData$1 = _getMapData;
+function mapCacheHas$1(key) {
+  return getMapData$1(this, key).has(key);
+}
+var _mapCacheHas = mapCacheHas$1;
+var getMapData = _getMapData;
+function mapCacheSet$1(key, value) {
+  var data = getMapData(this, key), size = data.size;
+  data.set(key, value);
+  this.size += data.size == size ? 0 : 1;
+  return this;
+}
+var _mapCacheSet = mapCacheSet$1;
+var mapCacheClear = _mapCacheClear, mapCacheDelete = _mapCacheDelete, mapCacheGet = _mapCacheGet, mapCacheHas = _mapCacheHas, mapCacheSet = _mapCacheSet;
+function MapCache$1(entries) {
+  var index2 = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index2 < length) {
+    var entry = entries[index2];
+    this.set(entry[0], entry[1]);
+  }
+}
+MapCache$1.prototype.clear = mapCacheClear;
+MapCache$1.prototype["delete"] = mapCacheDelete;
+MapCache$1.prototype.get = mapCacheGet;
+MapCache$1.prototype.has = mapCacheHas;
+MapCache$1.prototype.set = mapCacheSet;
+var _MapCache = MapCache$1;
+var MapCache = _MapCache;
+var FUNC_ERROR_TEXT = "Expected a function";
+function memoize$1(func, resolver) {
+  if (typeof func != "function" || resolver != null && typeof resolver != "function") {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  var memoized = function() {
+    var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    var result = func.apply(this, args);
+    memoized.cache = cache.set(key, result) || cache;
+    return result;
+  };
+  memoized.cache = new (memoize$1.Cache || MapCache)();
+  return memoized;
+}
+memoize$1.Cache = MapCache;
+var memoize_1 = memoize$1;
+var memoize = memoize_1;
+var MAX_MEMOIZE_SIZE = 500;
+function memoizeCapped$1(func) {
+  var result = memoize(func, function(key) {
+    if (cache.size === MAX_MEMOIZE_SIZE) {
+      cache.clear();
+    }
+    return key;
+  });
+  var cache = result.cache;
+  return result;
+}
+var _memoizeCapped = memoizeCapped$1;
+var memoizeCapped = _memoizeCapped;
+var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+var reEscapeChar = /\\(\\)?/g;
+var stringToPath$1 = memoizeCapped(function(string) {
+  var result = [];
+  if (string.charCodeAt(0) === 46) {
+    result.push("");
+  }
+  string.replace(rePropName, function(match, number, quote, subString) {
+    result.push(quote ? subString.replace(reEscapeChar, "$1") : number || match);
+  });
+  return result;
+});
+var _stringToPath = stringToPath$1;
+function arrayMap$1(array, iteratee) {
+  var index2 = -1, length = array == null ? 0 : array.length, result = Array(length);
+  while (++index2 < length) {
+    result[index2] = iteratee(array[index2], index2, array);
+  }
+  return result;
+}
+var _arrayMap = arrayMap$1;
+var Symbol$1 = _Symbol, arrayMap = _arrayMap, isArray$1 = isArray_1, isSymbol$1 = isSymbol_1;
+var INFINITY$1 = 1 / 0;
+var symbolProto = Symbol$1 ? Symbol$1.prototype : void 0, symbolToString = symbolProto ? symbolProto.toString : void 0;
+function baseToString$1(value) {
+  if (typeof value == "string") {
+    return value;
+  }
+  if (isArray$1(value)) {
+    return arrayMap(value, baseToString$1) + "";
+  }
+  if (isSymbol$1(value)) {
+    return symbolToString ? symbolToString.call(value) : "";
+  }
+  var result = value + "";
+  return result == "0" && 1 / value == -INFINITY$1 ? "-0" : result;
+}
+var _baseToString = baseToString$1;
+var baseToString = _baseToString;
+function toString$1(value) {
+  return value == null ? "" : baseToString(value);
+}
+var toString_1 = toString$1;
+var isArray = isArray_1, isKey = _isKey, stringToPath = _stringToPath, toString = toString_1;
+function castPath$1(value, object) {
+  if (isArray(value)) {
+    return value;
+  }
+  return isKey(value, object) ? [value] : stringToPath(toString(value));
+}
+var _castPath = castPath$1;
+var MAX_SAFE_INTEGER = 9007199254740991;
+var reIsUint = /^(?:0|[1-9]\d*)$/;
+function isIndex$1(value, length) {
+  var type2 = typeof value;
+  length = length == null ? MAX_SAFE_INTEGER : length;
+  return !!length && (type2 == "number" || type2 != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
+}
+var _isIndex = isIndex$1;
+var isSymbol = isSymbol_1;
+var INFINITY = 1 / 0;
+function toKey$1(value) {
+  if (typeof value == "string" || isSymbol(value)) {
+    return value;
+  }
+  var result = value + "";
+  return result == "0" && 1 / value == -INFINITY ? "-0" : result;
+}
+var _toKey = toKey$1;
+var assignValue = _assignValue, castPath = _castPath, isIndex = _isIndex, isObject = isObject_1, toKey = _toKey;
+function baseSet$1(object, path, value, customizer) {
+  if (!isObject(object)) {
+    return object;
+  }
+  path = castPath(path, object);
+  var index2 = -1, length = path.length, lastIndex = length - 1, nested = object;
+  while (nested != null && ++index2 < length) {
+    var key = toKey(path[index2]), newValue = value;
+    if (key === "__proto__" || key === "constructor" || key === "prototype") {
+      return object;
+    }
+    if (index2 != lastIndex) {
+      var objValue = nested[key];
+      newValue = customizer ? customizer(objValue, key, nested) : void 0;
+      if (newValue === void 0) {
+        newValue = isObject(objValue) ? objValue : isIndex(path[index2 + 1]) ? [] : {};
+      }
+    }
+    assignValue(nested, key, newValue);
+    nested = nested[key];
+  }
+  return object;
+}
+var _baseSet = baseSet$1;
+var baseSet = _baseSet;
+function set(object, path, value) {
+  return object == null ? object : baseSet(object, path, value);
+}
+var set_1 = set;
+const set$1 = /* @__PURE__ */ getDefaultExportFromCjs(set_1);
+const register = ({ strapi: strapi2 }) => {
+  Object.values(strapi2.contentTypes).forEach((contentType) => {
+    if (!contentType.pluginOptions?.webatlas?.active) return;
+    const { attributes } = contentType;
+    const fieldSettings = {
+      writable: true,
+      private: true,
+      configurable: false,
+      editable: false,
+      visible: true,
+      default: null
+    };
+    set$1(attributes, "webatlas_path", {
+      ...fieldSettings,
+      type: "string"
+    });
+    set$1(attributes, "webatlas_override", {
+      ...fieldSettings,
+      type: "boolean"
+    });
+  });
+};
+const config = {
+  default: {},
+  validator() {
+  }
+};
+const schema$2 = {
+  collectionName: "route",
+  info: {
+    singularName: "route",
+    pluralName: "routes",
+    displayName: "Route",
+    name: "route"
+  },
+  options: {
+    increments: true,
+    timestamps: true,
+    comment: "Route"
+  },
+  pluginOptions: {
+    "content-manager": {
+      visible: true
+    },
+    "content-type-builder": {
+      visible: false
+    }
+  },
+  attributes: {
+    relatedContentType: {
+      type: "string",
+      required: true,
+      configurable: false
+    },
+    relatedId: {
+      type: "integer",
+      required: true,
+      configurable: false
+    },
+    relatedDocumentId: {
+      type: "string",
+      required: true,
+      configurable: false
+    },
+    title: {
+      type: "string",
+      required: true,
+      configurable: false
+    },
+    fullPath: {
+      type: "string",
+      configurable: false
+    },
+    slug: {
+      type: "string",
+      configurable: false
+    },
+    uidPath: {
+      type: "string",
+      configurable: false
+    },
+    documentIdPath: {
+      type: "string",
+      configurable: false
+    },
+    isOverride: {
+      type: "boolean",
+      default: false,
+      configurable: false
+    },
+    internal: {
+      type: "boolean",
+      default: true,
+      configurable: false
+    },
+    active: {
+      type: "boolean",
+      default: true,
+      configurable: false
+    },
+    navitem: {
+      type: "relation",
+      relation: "oneToOne",
+      target: "plugin::webatlas.navitem",
+      mappedBy: "route",
+      configurable: false
+    },
+    wrapper: {
+      type: "boolean",
+      default: false,
+      configurable: false
+    }
+  }
+};
+const route = {
+  schema: schema$2
+};
+const schema$1 = {
+  collectionName: "navigation",
+  info: {
+    singularName: "navigation",
+    pluralName: "navigations",
+    displayName: "Navigation",
+    name: "navigation"
+  },
+  options: {
+    increments: true,
+    comment: ""
+  },
+  pluginOptions: {
+    "content-manager": {
+      visible: false
+    },
+    "content-type-builder": {
+      visible: false
+    }
+  },
+  attributes: {
+    name: {
+      type: "text",
+      configurable: false,
+      required: true
+    },
+    slug: {
+      type: "uid",
+      target: "name",
+      configurable: false,
+      required: true
+    },
+    visible: {
+      type: "boolean",
+      default: false,
+      configurable: false
+    },
+    items: {
+      type: "relation",
+      relation: "oneToMany",
+      target: "plugin::webatlas.navitem",
+      configurable: false,
+      mappedBy: "plugin::webatlas.navigation"
+    }
+  }
+};
+const navigation = {
+  schema: schema$1
+};
+const schema = {
+  collectionName: "navitem",
+  info: {
+    singularName: "navitem",
+    pluralName: "navitems",
+    displayName: "Navigation Items",
+    name: "navitems"
+  },
+  options: {
+    increments: true,
+    comment: ""
+  },
+  pluginOptions: {
+    "content-manager": {
+      visible: false
+    },
+    "content-type-builder": {
+      visible: false
+    }
+  },
+  attributes: {
+    navigation: {
+      type: "relation",
+      relation: "manyToOne",
+      target: "plugin::webatlas.navigation",
+      configurable: false,
+      inversedBy: "items"
+    },
+    route: {
+      type: "relation",
+      relation: "oneToOne",
+      target: "plugin::webatlas.route",
+      inversedBy: "navitem",
+      configurable: false
+    },
+    parent: {
+      type: "relation",
+      relation: "oneToOne",
+      target: "plugin::webatlas.navitem",
+      configurable: false
+    },
+    order: {
+      type: "integer",
+      default: 0
+    }
+  }
+};
+const navitem = {
+  schema
+};
+const contentTypes = {
+  route,
+  navigation,
+  navitem
+};
+const admin$2 = () => ({
+  async updateConfig(ctx) {
+    try {
+      await getAdminService().updateConfig(ctx.request.body);
+    } catch (e) {
+      ctx.throw(500, e);
+    }
+    return ctx.send({ status: 200 });
+  },
+  async getConfig(ctx) {
+    try {
+      return await getAdminService().getConfig();
+    } catch (e) {
+      return ctx.throw(500, e);
+    }
+  },
+  async getRoutes(ctx) {
+    try {
+      return await getAdminService().getRoutes();
+    } catch (e) {
+      return ctx.throw(500, e);
+    }
+  },
+  async createExternalRoute(ctx) {
+    try {
+      const { data } = ctx.request.body;
+      return await getAdminService().createExternalRoute(
+        data
+      );
+    } catch (e) {
+      return ctx.throw(500, e);
+    }
+  },
+  async updateRoute(ctx) {
+    try {
+      const { documentId } = ctx.query;
+      if (!documentId) return ctx.throw(400, "Route documentId is required");
+      const { data } = ctx.request.body;
+      return await getAdminService().updateRoute(documentId, data);
+    } catch (e) {
+      return ctx.throw(500, e);
+    }
+  },
+  async getNavigation(ctx) {
+    try {
+      const { documentId, variant } = ctx.query;
+      return await getAdminService().getNavigation(documentId, variant);
+    } catch (e) {
+      return ctx.throw(500, e);
+    }
+  },
+  async createNavigation(ctx) {
+    try {
+      const data = ctx.request.body;
+      return await getAdminService().createNavigation(data);
+    } catch (e) {
+      return ctx.throw(500, e);
+    }
+  },
+  async updateNavigation(ctx) {
+    try {
+      const { documentId } = ctx.query;
+      if (!documentId) return ctx.throw(400, "Navigation documentId is required");
+      const { data } = ctx.request.body;
+      return await getAdminService().updateNavigation(documentId, data);
+    } catch (e) {
+      return ctx.throw(500, e);
+    }
+  },
+  async deleteNavigation(ctx) {
+    try {
+      const { documentId } = ctx.query;
+      if (!documentId) return ctx.throw(400, "Navigation documentId is required");
+      return await getAdminService().deleteNavigation(documentId);
+    } catch (e) {
+      return ctx.throw(500, e);
+    }
+  },
+  async createNavItem(ctx) {
+    try {
+      const { data } = ctx.request.body;
+      return await getAdminService().createNavItem(data);
+    } catch (e) {
+      return ctx.throw(500, e);
+    }
+  },
+  async updateNavItem(ctx) {
+    try {
+      const { documentId } = ctx.query;
+      if (!documentId) return ctx.throw(400, "NavItem documentId is required");
+      const { data } = ctx.request.body;
+      return await getAdminService().updateNavItem(documentId, data);
+    } catch (e) {
+      return ctx.throw(500, e);
+    }
+  },
+  async deleteNavItem(ctx) {
+    try {
+      const { documentId } = ctx.query;
+      if (!documentId) return ctx.throw(400, "NavItem documentId is required");
+      return await getAdminService().deleteNavItem(documentId);
+    } catch (e) {
+      return ctx.throw(500, e);
+    }
+  },
+  async checkUniquePath(ctx) {
+    try {
+      const { path, targetRouteDocumentId } = ctx.query;
+      if (!path) return ctx.throw(400, "Path is required");
+      return await getAdminService().checkUniquePath(path, targetRouteDocumentId || null);
+    } catch (e) {
+      return ctx.throw(500, e);
+    }
+  }
+});
+const client$2 = ({ strapi: strapi2 }) => ({
+  async getEntityByPath(ctx) {
+    try {
+      const { slug, populate, populateDeepDepth, fields } = ctx.query;
+      if (!slug) return ctx.throw(400, "Slug is required");
+      const entity = await getClientService().getEntityByPath(slug, populate, populateDeepDepth, fields);
+      if (!entity) return ctx.throw(404, "Entity not found");
+      return ctx.send(entity);
+    } catch (e) {
+      ctx.throw(500, e);
+    }
+  },
+  async getNavigation(ctx) {
+    try {
+      const { id, name: name2, documentId, variant } = ctx.query;
+      if (!id && !name2 && !documentId) return ctx.throw(400, "Navigation id, name or documentId is required");
+      const navigation2 = await getClientService().getNavigation(id, name2, documentId, variant);
+      if (!navigation2) return ctx.throw(404, "Navigation not found");
+      return ctx.send(navigation2);
+    } catch (e) {
+      return ctx.throw(500, e);
+    }
+  }
+});
+const controllers = {
+  admin: admin$2,
+  client: client$2
+};
+const middlewares = {};
+const policies = {};
+const admin$1 = {
+  type: "admin",
+  routes: [
+    {
+      method: "GET",
+      path: "/config",
+      handler: "admin.getConfig",
+      config: {
+        policies: [],
+        auth: false
+      }
+    },
+    {
+      method: "PUT",
+      path: "/config",
+      handler: "admin.updateConfig",
+      config: {
+        policies: [],
+        auth: false
+      }
+    },
+    {
+      method: "GET",
+      path: "/route",
+      handler: "admin.getRoutes",
+      config: {
+        policies: [],
+        auth: false
+      }
+    },
+    {
+      method: "POST",
+      path: "/route/external",
+      handler: "admin.createExternalRoute",
+      config: {
+        policies: [],
+        auth: false
+      }
+    },
+    {
+      method: "PUT",
+      path: "/route",
+      handler: "admin.updateRoute",
+      config: {
+        policies: [],
+        auth: false
+      }
+    },
+    {
+      method: "GET",
+      path: "/navigation",
+      handler: "admin.getNavigation",
+      config: {
+        policies: [],
+        auth: false
+      }
+    },
+    {
+      method: "POST",
+      path: "/navigation",
+      handler: "admin.createNavigation",
+      config: {
+        policies: [],
+        auth: false
+      }
+    },
+    {
+      method: "PUT",
+      path: "/navigation",
+      handler: "admin.updateNavigation",
+      config: {
+        policies: [],
+        auth: false
+      }
+    },
+    {
+      method: "DELETE",
+      path: "/navigation",
+      handler: "admin.deleteNavigation",
+      config: {
+        policies: [],
+        auth: false
+      }
+    },
+    {
+      method: "POST",
+      path: "/navitem",
+      handler: "admin.createNavItem",
+      config: {
+        policies: [],
+        auth: false
+      }
+    },
+    {
+      method: "PUT",
+      path: "/navitem",
+      handler: "admin.updateNavItem",
+      config: {
+        policies: [],
+        auth: false
+      }
+    },
+    {
+      method: "DELETE",
+      path: "/navitem",
+      handler: "admin.deleteNavItem",
+      config: {
+        policies: [],
+        auth: false
+      }
+    },
+    {
+      method: "GET",
+      path: "/checkUniquePath",
+      handler: "admin.checkUniquePath",
+      config: {
+        policies: [],
+        auth: false
+      }
+    }
+  ]
+};
+const client$1 = {
+  type: "content-api",
+  routes: [
+    {
+      method: "GET",
+      path: "/path",
+      handler: "client.getEntityByPath",
+      config: {
+        policies: []
+      }
+    },
+    {
+      method: "GET",
+      path: "/navigation",
+      handler: "client.getNavigation",
+      config: {
+        policies: []
+      }
+    }
+  ]
+};
+const routes = {
+  admin: admin$1,
+  "content-api": client$1
+};
+function getFullPath(parentPath, slug) {
+  if (!slug) return null;
+  if (!parentPath) return slug;
+  const newPath = parentPath.endsWith("/") ? parentPath : `${parentPath}/`;
+  return `${newPath}${slug}`;
+}
+function buildStructuredNavigation(navigation2, variant = "nested") {
+  const itemsById = /* @__PURE__ */ new Map();
+  const rootItems = [];
+  if (!navigation2.items || navigation2.items?.length === 0) return navigation2;
+  navigation2.items.forEach((item) => {
+    itemsById.set(item.id, { ...item, items: [] });
+  });
+  if (variant === "nested") {
+    navigation2.items.forEach((item) => {
+      const newItem = itemsById.get(item.id);
+      if (!newItem) return null;
+      if (item.parent) {
+        const parentItem = itemsById.get(item.parent.id);
+        parentItem && parentItem.items.push(newItem);
+      } else {
+        rootItems.push(newItem);
+      }
+    });
+    sortItems(rootItems);
+    return { ...navigation2, items: rootItems };
+  } else if (variant === "flat") {
+    let itemsToProcess = [...navigation2.items];
+    let itemsProcessed = /* @__PURE__ */ new Set();
+    while (itemsToProcess.length > 0) {
+      const remainingItems = [];
+      itemsToProcess.forEach((item) => {
+        const newItem = itemsById.get(item.id);
+        if (!newItem) return null;
+        if (item.parent) {
+          const parentItem = itemsById.get(item.parent.id);
+          if (!parentItem || !itemsProcessed.has(item.parent.id)) {
+            remainingItems.push(item);
+            return;
+          }
+          newItem.depth = parentItem.depth !== void 0 ? parentItem.depth + 1 : 0;
+          parentItem.items.push(newItem);
+        } else {
+          newItem.depth = 0;
+          rootItems.push(newItem);
+        }
+        itemsById.set(item.id, newItem);
+        itemsProcessed.add(item.id);
+      });
+      itemsToProcess = remainingItems;
+    }
+    const sortedItems = sortItems(rootItems);
+    const flattenedItems = flattenItems(sortedItems);
+    return { ...navigation2, items: flattenedItems };
+  }
+}
+const flattenItems = (items, result = []) => {
+  items.forEach((item) => {
+    const itemCopy = { ...item };
+    delete itemCopy.items;
+    result.push(itemCopy);
+    if (item.items && item.items.length > 0) {
+      flattenItems(item.items, result);
+    }
+  });
+  return result;
+};
+const sortItems = (items) => {
+  items.sort((a, b) => a.order - b.order);
+  items.forEach((item) => {
+    if (item.items && item.items.length > 0) {
+      sortItems(item.items);
+    }
+  });
+  return items;
+};
+function extractRouteAndItems(items) {
+  return items.map((item) => {
+    const route2 = { ...item.route };
+    if (item.depth) {
+      route2.depth = item.depth;
+    }
+    if (item.items?.length > 0) {
+      const items2 = extractRouteAndItems(item.items);
+      if (items2.length > 0) route2.items = items2;
+    }
+    let type2;
+    if (!route2.internal && route2.wrapper)
+      type2 = "wrapper";
+    else if (!route2.internal && !route2.wrapper)
+      type2 = "external";
+    else
+      type2 = "internal";
+    delete route2.relatedContentType;
+    delete route2.relatedId;
+    delete route2.createdAt;
+    delete route2.updatedAt;
+    delete route2.isOverride;
+    delete route2.internal;
+    delete route2.wrapper;
+    return {
+      __component: type2 === "wrapper" ? `${PLUGIN_NAME}.wrapper` : `${PLUGIN_NAME}.route`,
+      type: type2,
+      ...route2
+    };
+  });
+}
+function isEmpty(value) {
+  if (value == null) return true;
+  if (Array.isArray(value) || typeof value === "string") return value.length === 0;
+  if (typeof value === "object") return Object.keys(value).length === 0;
+  return false;
+}
+function merge(target, source) {
+  for (const key in source) {
+    if (source[key] && typeof source[key] === "object" && !Array.isArray(source[key])) {
+      target[key] = merge(target[key] || {}, source[key]);
+    } else {
+      target[key] = source[key];
+    }
+  }
+  return target;
+}
+const getModelPopulationAttributes = (model) => {
+  if (model.uid === "plugin::upload.file") {
+    const { related, ...attributes } = model.attributes;
+    return attributes;
+  }
+  return model.attributes;
+};
+function getFullPopulateObject(modelUid, maxDepth = 20, ignore = []) {
+  if (maxDepth <= 1) {
+    return true;
+  }
+  if (modelUid === "admin::user") {
+    return false;
+  }
+  const populate = {};
+  const model = strapi.getModel(modelUid);
+  if (model.collectionName && !ignore.includes(model.collectionName)) {
+    ignore.push(model.collectionName);
+  } else if (model.collectionName && ignore.includes(model.collectionName)) {
+    return true;
+  }
+  for (const [key, value] of Object.entries(
+    getModelPopulationAttributes(model)
+  )) {
+    if (ignore?.includes(key)) continue;
+    if (value) {
+      if (value.type === "component") {
+        populate[key] = getFullPopulateObject(value.component, maxDepth - 1, ignore);
+      } else if (value.type === "dynamiczone") {
+        const dynamicPopulate = value.components.reduce((prev, cur) => {
+          const curPopulate = getFullPopulateObject(cur, maxDepth - 1, ignore);
+          if (curPopulate === true) {
+            return prev;
+          }
+          return merge(prev, curPopulate);
+        }, {});
+        populate[key] = isEmpty(dynamicPopulate) ? true : dynamicPopulate;
+      } else if (value.type === "relation") {
+        const relationPopulate = getFullPopulateObject(
+          //@ts-ignore
+          value.target,
+          key === "localizations" && maxDepth > 2 ? 1 : maxDepth - 1,
+          ignore
+        );
+        if (relationPopulate) populate[key] = relationPopulate;
+      } else if (value.type === "media") {
+        populate[key] = true;
+      }
+    }
+  }
+  return isEmpty(populate) ? true : { populate };
+}
+function cleanRootKeys(obj) {
+  for (const key in obj) {
+    if (obj.hasOwnProperty(key)) {
+      const value = obj[key];
+      if (value === null || Array.isArray(value) && value.length === 0 || typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0) {
+        delete obj[key];
+      }
+    }
+  }
+  return obj;
+}
+function removeWaFields(obj) {
+  delete obj["webatlas_path"];
+  delete obj["webatlas_override"];
+  return obj;
+}
+const admin = ({ strapi: strapi2 }) => ({
+  async updateConfig(newConfig) {
+    if (!newConfig || !newConfig.selectedContentTypes) return;
+    try {
+      const routes2 = await strapi2.documents(waRoute).findMany();
+      const invalidRoutes = routes2.filter((route2) => !newConfig.selectedContentTypes.find((type2) => type2.uid === route2.relatedContentType));
+      invalidRoutes?.map(async (route2) => {
+        await strapi2.documents(waRoute).delete({
+          documentId: route2.documentId
+        });
+      });
+    } catch (err) {
+      console.log(err);
+      return "Error. Couldn't delete invalid routes";
+    }
+    const pluginStore = await strapi2.store({ type: "plugin", name: PLUGIN_NAME });
+    await pluginStore.set({ key: "config", value: newConfig });
+  },
+  async getConfig() {
+    const pluginStore = await strapi2.store({ type: "plugin", name: PLUGIN_NAME });
+    let config2 = await pluginStore.get({
+      key: "config"
+    });
+    if (!config2) {
+      config2 = await pluginStore.set({
+        key: "config",
+        value: {
+          selectedContentTypes: []
+        }
+      });
+    }
+    return config2;
+  },
+  async getRoutes() {
+    try {
+      const entities = await strapi2.documents(waRoute).findMany();
+      return entities;
+    } catch (e) {
+      console.log(e);
+    }
+  },
+  async createExternalRoute(data) {
+    try {
+      return await strapi2.documents(waRoute).create({
+        data: {
+          title: data.title,
+          slug: data.fullPath,
+          fullPath: data.fullPath,
+          relatedContentType: "",
+          relatedId: 0,
+          relatedDocumentId: "",
+          uidPath: "",
+          internal: false,
+          wrapper: data.wrapper
+        }
+      });
+    } catch (e) {
+      console.log(e);
+    }
+  },
+  async updateRoute(documentId, data) {
+    try {
+      let checkedPath = data.fullPath;
+      if (data.internal) {
+        const parent = data.parent ? await strapi2.documents(waNavItem).findOne({
+          documentId: data.parent
+        }) : null;
+        const fullPath = data.isOverride ? data.slug : getFullPath(parent?.fullPath, data.slug);
+        checkedPath = await duplicateCheck(fullPath, documentId);
+      }
+      const entity = await strapi2.documents(waRoute).update({
+        documentId,
+        data: {
+          ...data,
+          fullPath: checkedPath
+        }
+      });
+      return entity;
+    } catch (e) {
+      console.log(e);
+    }
+  },
+  async getNavigation(documentId, variant) {
+    try {
+      let navigation2 = null;
+      if (documentId) {
+        navigation2 = await strapi2.documents(waNavigation).findOne({
+          documentId,
+          populate: ["items", "items.route", "items.parent"]
+        });
+      } else {
+        navigation2 = await strapi2.documents(waNavigation).findMany({
+          populate: ["items", "items.route", "items.parent"]
+        });
+      }
+      if (!navigation2) throw new Error("Navigation not found");
+      if (variant) {
+        navigation2 = buildStructuredNavigation(navigation2, variant);
+      }
+      return navigation2;
+    } catch (e) {
+      console.log(e);
+    }
+  },
+  async createNavigation(data) {
+    try {
+      const navigation2 = await strapi2.documents(waNavigation).create({
+        data: {
+          name: data.name,
+          slug: transformToUrl(data.name),
+          visible: data.isActive
+        }
+      });
+      return navigation2;
+    } catch (e) {
+      console.log(e);
+    }
+  },
+  async updateNavigation(documentId, data) {
+    try {
+      const entity = await strapi2.documents(waNavigation).update({
+        documentId,
+        data: {
+          name: data.name,
+          visible: data.visible
+        }
+      });
+      return entity;
+    } catch (e) {
+      console.log(e);
+    }
+  },
+  async deleteNavigation(documentId) {
+    try {
+      return await strapi2.documents(waNavigation).delete({
+        documentId
+      });
+    } catch (e) {
+      console.log(e);
+    }
+  },
+  async createNavItem(data) {
+    try {
+      if (!data.route || !data.navigation) return false;
+      const parent = data.parent ? await strapi2.documents(waNavItem).findOne({
+        documentId: data.parent,
+        populate: ["route"]
+      }) : null;
+      const route2 = data.route ? await strapi2.documents(waRoute).findOne({
+        documentId: data.route
+      }) : null;
+      let fullPath = route2.slug;
+      if (route2.internal && !route2.isOverride && parent?.route.internal) fullPath = getFullPath(parent?.route?.fullPath, route2.slug);
+      await strapi2.documents(waRoute).update({
+        documentId: data.route,
+        data: {
+          fullPath
+        }
+      });
+      const entity = await strapi2.documents(waNavItem).create({
+        data: {
+          navigation: data.navigation,
+          route: data.route || null,
+          parent: data.parent || null
+        }
+      });
+      return entity;
+    } catch (e) {
+      console.log(e);
+    }
+  },
+  async updateNavItem(documentId, data) {
+    try {
+      return await strapi2.documents(waNavItem).update({
+        documentId,
+        data: {
+          navigation: data.navigation || null,
+          route: data.route || null,
+          parent: data.parent || null,
+          order: data.order || 0
+        }
+      });
+    } catch (e) {
+      console.log(e);
+    }
+  },
+  async deleteNavItem(documentId) {
+    try {
+      await strapi2.documents(waNavItem).delete({
+        documentId
+      });
+      return true;
+    } catch (e) {
+      console.log(e);
+    }
+  },
+  async checkUniquePath(initialPath, targetRouteDocumentId = null) {
+    try {
+      return await duplicateCheck(initialPath, targetRouteDocumentId);
+    } catch (e) {
+      console.log(e);
+    }
+  }
+});
+const client = ({ strapi: strapi2 }) => ({
+  async getEntityByPath(slug, populate, populateDeepDepth, fields) {
+    try {
+      const route2 = await strapi2.db?.query(waRoute).findOne({
+        filters: {
+          $or: [
+            { fullPath: slug },
+            { slug },
+            { uidPath: slug }
+          ]
+        }
+      });
+      if (!route2) return null;
+      let populateObject = populate;
+      if (populate === "deep") {
+        const modelObject = getFullPopulateObject(route2.relatedContentType, Number(populateDeepDepth), []);
+        if (typeof modelObject === "object" && "populate" in modelObject) {
+          populateObject = modelObject.populate;
+        }
+      }
+      const contentTypeObject = Object.entries(strapi2.contentTypes).find(([key, value]) => key === route2.relatedContentType);
+      if (!contentTypeObject) {
+        return null;
+      }
+      const [contentTypeKey, contentType] = contentTypeObject;
+      const entity = await strapi2.documents(route2.relatedContentType).findOne({
+        documentId: route2.documentIdPath,
+        populate: populateObject,
+        fields
+      });
+      if (!entity) return null;
+      let cleanEntity = cleanRootKeys(entity);
+      cleanEntity = removeWaFields(cleanEntity);
+      return { contentType: contentType.info.singularName, ...cleanEntity };
+    } catch (e) {
+      console.log(e);
+      return e;
+    }
+  },
+  async getNavigation(id, name2, documentId, variant = "nested") {
+    try {
+      let navigation2 = null;
+      if (documentId) {
+        navigation2 = await strapi2.documents(waNavigation).findOne({
+          documentId,
+          populate: ["items", "items.parent", "items.route"]
+        });
+      } else if (name2) {
+        navigation2 = await strapi2.db?.query(waNavigation).findOne({
+          where: {
+            name: name2
+          },
+          populate: ["items", "items.parent", "items.route"]
+        });
+      } else if (id) {
+        navigation2 = await strapi2.db?.query(waNavigation).findOne({
+          where: {
+            id
+          },
+          populate: ["items", "items.parent", "items.route"]
+        });
+      }
+      if (!navigation2) return null;
+      const structured = buildStructuredNavigation(navigation2, variant);
+      if (!structured) return null;
+      const entityNavigation = extractRouteAndItems(structured.items);
+      return { ...structured, items: entityNavigation };
+    } catch (e) {
+      console.log(e);
+      return e;
+    }
+  }
+});
+const services = {
+  admin,
+  client
+};
+const index = {
+  register,
+  bootstrap,
+  destroy,
+  config,
+  controllers,
+  routes,
+  services,
+  contentTypes,
+  policies,
+  middlewares
+};
+export {
+  index as default
+};