@rebasepro/common 0.0.1-canary.0

package/dist/index.es.js

@@ -0,0 +1,2380 @@
+import { GeoPoint, EntityReference, EntityRelation } from "@rebasepro/types";
+import hash from "object-hash";
+import jsonLogic from "json-logic-js";
+import { deepEqual } from "fast-equals";
+import cloneDeep from "lodash/cloneDeep.js";
+const DEFAULT_ONE_OF_TYPE = "type";
+const DEFAULT_ONE_OF_VALUE = "value";
+const isEmptyArray = (value) => Array.isArray(value) && value.length === 0;
+const isFunction = (obj) => typeof obj === "function";
+const isInteger = (obj) => String(Math.floor(Number(obj))) === String(obj);
+const isNaN$1 = (obj) => obj !== obj;
+function getIn$1(obj, key, def, p = 0) {
+  const path = toPath(key);
+  while (obj && p < path.length) {
+    obj = obj[path[p++]];
+  }
+  if (p !== path.length && !obj) {
+    return def;
+  }
+  return obj === void 0 ? def : obj;
+}
+function setIn(obj, path, value) {
+  const res = clone(obj);
+  let resVal = res;
+  let i = 0;
+  const pathArray = toPath(path);
+  for (; i < pathArray.length - 1; i++) {
+    const currentPath = pathArray[i];
+    const currentObj = getIn$1(obj, pathArray.slice(0, i + 1));
+    if (currentObj && (isObject(currentObj) || Array.isArray(currentObj))) {
+      resVal = resVal[currentPath] = clone(currentObj);
+    } else {
+      const nextPath = pathArray[i + 1];
+      resVal = resVal[currentPath] = isInteger(nextPath) && Number(nextPath) >= 0 ? [] : {};
+    }
+  }
+  if ((i === 0 ? obj : resVal)[pathArray[i]] === value) {
+    return obj;
+  }
+  if (value === void 0) {
+    delete resVal[pathArray[i]];
+  } else {
+    resVal[pathArray[i]] = value;
+  }
+  if (i === 0 && value === void 0) {
+    delete res[pathArray[i]];
+  }
+  return res;
+}
+function clone(value) {
+  if (Array.isArray(value)) {
+    return [...value];
+  } else if (typeof value === "object" && value !== null) {
+    return {
+      ...value
+    };
+  } else {
+    return value;
+  }
+}
+function toPath(value) {
+  if (Array.isArray(value)) return value;
+  return value.replace(/\[(\d+)]/g, ".$1").replace(/^\./, "").replace(/\.$/, "").split(".");
+}
+const pick = (obj, ...args) => ({
+  ...args.reduce((res, key) => ({
+    ...res,
+    [key]: obj[key]
+  }), {})
+});
+function isObject(item) {
+  return !!item && typeof item === "object" && !Array.isArray(item);
+}
+function isPlainObject(obj) {
+  if (typeof obj !== "object" || obj === null || Array.isArray(obj)) {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(obj);
+  return proto === Object.prototype;
+}
+function mergeDeep(target, source, ignoreUndefined = false) {
+  if (!isObject(target)) {
+    return target;
+  }
+  const output = {
+    ...target
+  };
+  if (!isObject(source)) {
+    return output;
+  }
+  for (const key in source) {
+    if (Object.prototype.hasOwnProperty.call(source, key)) {
+      const sourceValue = source[key];
+      const outputValue = output[key];
+      if (ignoreUndefined && sourceValue === void 0) {
+        continue;
+      }
+      if (sourceValue instanceof Date) {
+        output[key] = new Date(sourceValue.getTime());
+      } else if (Array.isArray(sourceValue)) {
+        if (Array.isArray(outputValue)) {
+          const newArray = [];
+          const maxLength = Math.max(outputValue.length, sourceValue.length);
+          for (let i = 0; i < maxLength; i++) {
+            const sourceItem = sourceValue[i];
+            const targetItem = outputValue[i];
+            if (i >= sourceValue.length) {
+              newArray[i] = targetItem;
+            } else if (i >= outputValue.length) {
+              newArray[i] = sourceItem;
+            } else if (sourceItem === null) {
+              newArray[i] = targetItem;
+            } else if (isPlainObject(sourceItem) && isPlainObject(targetItem)) {
+              newArray[i] = mergeDeep(targetItem, sourceItem, ignoreUndefined);
+            } else {
+              newArray[i] = sourceItem;
+            }
+          }
+          output[key] = newArray;
+        } else {
+          output[key] = [...sourceValue];
+        }
+      } else if (isPlainObject(sourceValue)) {
+        if (isPlainObject(outputValue)) {
+          output[key] = mergeDeep(outputValue, sourceValue, ignoreUndefined);
+        } else {
+          output[key] = sourceValue;
+        }
+      } else if (isObject(sourceValue)) {
+        output[key] = sourceValue;
+      } else {
+        output[key] = sourceValue;
+      }
+    }
+  }
+  return output;
+}
+function getValueInPath(o, path) {
+  if (!o) return void 0;
+  if (typeof o === "object") {
+    if (path in o) {
+      return o[path];
+    }
+    if (path.includes(".") || path.includes("[")) {
+      let pathSegments = path.split(/[.[]/);
+      if (path.includes("[")) {
+        pathSegments = pathSegments.map((segment) => segment.replace("]", ""));
+      }
+      const firstSegment = pathSegments[0];
+      const isArrayAndIndexExists = Array.isArray(o[firstSegment]) && !isNaN$1(parseInt(pathSegments[1]));
+      const nextObject = isArrayAndIndexExists ? o[firstSegment][parseInt(pathSegments[1])] : o[firstSegment];
+      const nextPath = pathSegments.slice(isArrayAndIndexExists ? 2 : 1).join(".");
+      if (nextPath === "") return nextObject;
+      return getValueInPath(nextObject, nextPath);
+    }
+  }
+  return void 0;
+}
+function removeInPath(o, path) {
+  let currentObject = {
+    ...o
+  };
+  const parts = path.split(".");
+  const last = parts.pop();
+  for (const part of parts) {
+    currentObject = currentObject[part];
+  }
+  if (last) delete currentObject[last];
+  return currentObject;
+}
+function removeFunctions(o) {
+  if (o === void 0) return void 0;
+  if (o === null) return null;
+  if (typeof o === "object") {
+    if (Array.isArray(o)) {
+      return o.map((v) => removeFunctions(v));
+    }
+    if (!isPlainObject(o)) {
+      return o;
+    }
+    return Object.entries(o).filter(([_, value]) => typeof value !== "function").map(([key, value]) => {
+      if (Array.isArray(value)) {
+        return {
+          [key]: value.map((v) => removeFunctions(v))
+        };
+      } else if (typeof value === "object") {
+        return {
+          [key]: removeFunctions(value)
+        };
+      } else return {
+        [key]: value
+      };
+    }).reduce((a, b) => ({
+      ...a,
+      ...b
+    }), {});
+  }
+  return o;
+}
+function getHashValue(v) {
+  if (!v) return null;
+  if (typeof v === "object" && v !== null) {
+    if ("id" in v) return String(v.id);
+    else if (v instanceof Date) return v.toLocaleString();
+    else if (v instanceof GeoPoint) return hash(v);
+  }
+  return hash(v, {
+    ignoreUnknown: true
+  });
+}
+function removeUndefined(value, removeEmptyStrings) {
+  if (typeof value === "function") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((v) => removeUndefined(v, removeEmptyStrings));
+  }
+  if (typeof value === "object") {
+    if (value === null) return value;
+    if (!isPlainObject(value)) {
+      return value;
+    }
+    const res = {};
+    Object.keys(value).forEach((key) => {
+      if (!isEmptyObject(value)) {
+        const childRes = removeUndefined(value[key], removeEmptyStrings);
+        const isString = typeof childRes === "string";
+        const shouldKeepIfString = !removeEmptyStrings || removeEmptyStrings && !isString || removeEmptyStrings && isString && childRes !== "";
+        if (childRes !== void 0 && !isEmptyObject(childRes) && shouldKeepIfString) res[key] = childRes;
+      }
+    });
+    return res;
+  }
+  return value;
+}
+function removeNulls(value) {
+  if (typeof value === "function") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((v) => removeNulls(v));
+  }
+  if (typeof value === "object") {
+    if (value === null) return value;
+    if (!isPlainObject(value)) {
+      return value;
+    }
+    const res = {};
+    const obj = value;
+    Object.keys(obj).forEach((key) => {
+      if (obj[key] !== null) res[key] = removeNulls(obj[key]);
+    });
+    return res;
+  }
+  return value;
+}
+function isEmptyObject(obj) {
+  return obj && Object.getPrototypeOf(obj) === Object.prototype && Object.keys(obj).length === 0;
+}
+function removePropsIfExisting(source, comparison) {
+  const isObject2 = (val) => typeof val === "object" && val !== null;
+  const isArray = (val) => Array.isArray(val);
+  if (!isObject2(source) || !isObject2(comparison)) {
+    return source;
+  }
+  const res = isArray(source) ? [...source] : {
+    ...source
+  };
+  if (isArray(res)) {
+    for (let i = res.length - 1; i >= 0; i--) {
+      if (res[i] === comparison[i]) {
+        res.splice(i, 1);
+      } else if (isObject2(res[i]) && isObject2(comparison[i])) {
+        res[i] = removePropsIfExisting(res[i], comparison[i]);
+      }
+    }
+  } else {
+    Object.keys(comparison).forEach((key) => {
+      if (key in res) {
+        if (isObject2(res[key]) && isObject2(comparison[key])) {
+          res[key] = removePropsIfExisting(res[key], comparison[key]);
+        } else if (res[key] === comparison[key]) {
+          delete res[key];
+        }
+      }
+    });
+  }
+  return res;
+}
+function isReadOnly(property) {
+  if (property.readOnly) return true;
+  if (property.type === "date") {
+    if (property.autoValue) return true;
+  }
+  if (property.type === "reference") {
+    return !property.path && !property.Field;
+  }
+  return false;
+}
+function isHidden(property) {
+  return typeof property.disabled === "object" && Boolean(property.disabled.hidden);
+}
+function isPropertyBuilder(property) {
+  return typeof property?.dynamicProps === "function";
+}
+function getDefaultValuesFor(properties) {
+  if (!properties) return {};
+  return Object.entries(properties).map(([key, property]) => {
+    if (!property) return {};
+    const value = getDefaultValueFor(property);
+    return value === void 0 ? {} : {
+      [key]: value
+    };
+  }).reduce((a, b) => ({
+    ...a,
+    ...b
+  }), {});
+}
+function getDefaultValueFor(property) {
+  if (!property) return void 0;
+  if (isPropertyBuilder(property)) return void 0;
+  if (property.defaultValue || property.defaultValue === null) {
+    return property.defaultValue;
+  } else if (property.type === "map" && property.properties) {
+    const defaultValuesFor = getDefaultValuesFor(property.properties);
+    if (Object.keys(defaultValuesFor).length === 0) return void 0;
+    return defaultValuesFor;
+  } else {
+    return getDefaultValueFortype(property.type);
+  }
+}
+function getDefaultValueFortype(type) {
+  if (type === "string") {
+    return null;
+  } else if (type === "number") {
+    return null;
+  } else if (type === "boolean") {
+    return false;
+  } else if (type === "date") {
+    return null;
+  } else if (type === "array") {
+    return [];
+  } else if (type === "map") {
+    return {};
+  } else {
+    return null;
+  }
+}
+function updateDateAutoValues({
+  inputValues,
+  properties,
+  status,
+  timestampNowValue
+}) {
+  return traverseValuesProperties(inputValues, properties, (inputValue, property) => {
+    if (property.type === "date") {
+      if (status === "existing" && property.autoValue === "on_update") {
+        return timestampNowValue;
+      } else if ((status === "new" || status === "copy") && (property.autoValue === "on_update" || property.autoValue === "on_create")) {
+        return timestampNowValue;
+      } else {
+        return inputValue;
+      }
+    } else {
+      return inputValue;
+    }
+  }) ?? {};
+}
+function sanitizeData(values, properties) {
+  const result = values;
+  Object.entries(properties).forEach(([key, property]) => {
+    if (values && values[key] !== void 0) result[key] = values[key];
+    else if (property.validation?.required) result[key] = null;
+  });
+  return result;
+}
+function getReferenceFrom(entity) {
+  if (typeof entity.id !== "string") throw new Error("Only string IDs are supported in references");
+  return new EntityReference({
+    id: entity.id,
+    path: entity.path,
+    datasource: entity.datasource,
+    databaseId: entity.databaseId
+  });
+}
+function getRelationFrom(entity) {
+  return new EntityRelation(entity.id, entity.path);
+}
+function traverseValuesProperties(inputValues, properties, operation) {
+  const safeInputValues = inputValues ?? {};
+  const updatedValues = Object.entries(properties).map(([key, property]) => {
+    const inputValue = safeInputValues && safeInputValues[key];
+    const updatedValue = traverseValueProperty(inputValue, property, operation);
+    if (updatedValue === null) return null;
+    if (updatedValue === void 0) return void 0;
+    return {
+      [key]: updatedValue
+    };
+  }).reduce((a, b) => ({
+    ...a,
+    ...b
+  }), {});
+  const result = mergeDeep(safeInputValues, updatedValues);
+  if (!result || Object.keys(result).length === 0) return void 0;
+  return result;
+}
+function traverseValueProperty(inputValue, property, operation) {
+  let value;
+  if (property.type === "map" && property.properties) {
+    value = traverseValuesProperties(inputValue, property.properties, operation);
+  } else if (property.type === "array") {
+    const of = property.of;
+    if (of && Array.isArray(inputValue) && !Array.isArray(of)) {
+      value = inputValue.map((e) => traverseValueProperty(e, of, operation));
+    } else if (of && Array.isArray(inputValue) && Array.isArray(of)) {
+      value = inputValue.map((e, i) => {
+        if (i < of.length) return traverseValueProperty(e, of[i], operation);
+        return null;
+      }).filter(Boolean);
+    } else if (property.oneOf && Array.isArray(inputValue)) {
+      const typeField = property.oneOf?.typeField ?? DEFAULT_ONE_OF_TYPE;
+      const valueField = property.oneOf?.valueField ?? DEFAULT_ONE_OF_VALUE;
+      value = inputValue.map((e) => {
+        if (e === null) return null;
+        if (typeof e !== "object") return e;
+        const rec = e;
+        const type = rec[typeField];
+        const childProperty = property.oneOf?.properties[type];
+        if (!type || !childProperty) return e;
+        return {
+          [typeField]: type,
+          [valueField]: traverseValueProperty(rec[valueField], childProperty, operation)
+        };
+      });
+    } else {
+      value = inputValue;
+    }
+  } else {
+    value = operation(inputValue, property);
+  }
+  return value;
+}
+function sortProperties(properties, propertiesOrder) {
+  try {
+    const propertiesKeys = Object.keys(properties);
+    if (!propertiesOrder || propertiesOrder.length === 0) {
+      return propertiesKeys.map((key) => {
+        const property = properties[key];
+        if (!isPropertyBuilder(property) && property?.type === "map" && property.properties) {
+          return {
+            [key]: {
+              ...property,
+              properties: sortProperties(property.properties, property.propertiesOrder)
+            }
+          };
+        } else {
+          return {
+            [key]: property
+          };
+        }
+      }).reduce((a, b) => ({
+        ...a,
+        ...b
+      }), {});
+    }
+    const validOrderKeys = propertiesOrder.filter((key) => {
+      return !key.includes(".") && properties[key];
+    });
+    const processedKeys = new Set(validOrderKeys);
+    const orderedResult = validOrderKeys.map((key) => {
+      const property = properties[key];
+      if (!isPropertyBuilder(property) && property?.type === "map" && property.properties) {
+        return {
+          [key]: {
+            ...property,
+            properties: sortProperties(property.properties, property.propertiesOrder)
+          }
+        };
+      } else {
+        return {
+          [key]: property
+        };
+      }
+    }).reduce((a, b) => ({
+      ...a,
+      ...b
+    }), {});
+    const missingProperties = propertiesKeys.filter((key) => !processedKeys.has(key)).map((key) => {
+      const property = properties[key];
+      if (!isPropertyBuilder(property) && property?.type === "map" && property.properties) {
+        return {
+          [key]: {
+            ...property,
+            properties: sortProperties(property.properties, property.propertiesOrder)
+          }
+        };
+      } else {
+        return {
+          [key]: property
+        };
+      }
+    }).reduce((a, b) => ({
+      ...a,
+      ...b
+    }), {});
+    return {
+      ...orderedResult,
+      ...missingProperties
+    };
+  } catch (e) {
+    console.error("Error sorting properties", e);
+    return properties;
+  }
+}
+function resolveDefaultSelectedView(defaultSelectedView, params) {
+  if (!defaultSelectedView) {
+    return void 0;
+  } else if (typeof defaultSelectedView === "string") {
+    return defaultSelectedView;
+  } else {
+    return defaultSelectedView(params);
+  }
+}
+function getLocalChangesBackup(collection) {
+  if (!collection.localChangesBackup) {
+    return "manual_apply";
+  }
+  return collection.localChangesBackup;
+}
+function getPrimaryKeys(collection) {
+  const properties = collection.properties;
+  if (!properties) {
+    return ["id"];
+  }
+  const ids = Object.entries(properties).filter(([key, prop]) => typeof prop === "object" && prop !== null && "isId" in prop && Boolean(prop.isId)).map(([key]) => key);
+  if (ids.length > 0) {
+    return ids;
+  }
+  return ["id"];
+}
+const kebabCaseRegex = /[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g;
+const toKebabCase = (str) => {
+  const regExpMatchArray = str.match(kebabCaseRegex);
+  if (!regExpMatchArray) return "";
+  return regExpMatchArray.map((x) => x.toLowerCase()).join("-");
+};
+const snakeCaseRegex = /[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g;
+const toSnakeCase = (str) => {
+  const regExpMatchArray = str.match(snakeCaseRegex);
+  if (!regExpMatchArray) return "";
+  return regExpMatchArray.map((x) => x.toLowerCase()).join("_");
+};
+function randomString(strLength = 5) {
+  return Math.random().toString(36).slice(2, 2 + strLength);
+}
+function randomColor() {
+  return Math.floor(Math.random() * 16777215).toString(16);
+}
+function slugify(text, separator = "_", lowercase = true) {
+  if (!text) return "";
+  const from = "ãàáäâẽèéëêìíïîõòóöôùúüûñç·/_,:;-";
+  const to = `aaaaaeeeeeiiiiooooouuuunc${separator}${separator}${separator}${separator}${separator}${separator}${separator}`;
+  for (let i = 0, l = from.length; i < l; i++) {
+    text = text.replace(new RegExp(from.charAt(i), "g"), to.charAt(i));
+  }
+  text = text.toString().replace(/\s+/g, separator).replace(/&/g, separator).replace(/[^\w\\-]+/g, "").replace(new RegExp("\\" + separator + "\\" + separator + "+", "g"), separator).trim().replace(/^\s+|\s+$/g, "");
+  return lowercase ? text.toLowerCase() : text;
+}
+function unslugify(slug) {
+  if (!slug) return "";
+  if (slug.includes("-") || slug.includes("_") || !slug.includes(" ")) {
+    const result = slug.replace(/[-_]/g, " ");
+    return result.replace(/\w\S*/g, function(txt) {
+      return txt.charAt(0).toUpperCase() + txt.substring(1);
+    }).trim();
+  } else {
+    return slug.trim();
+  }
+}
+function prettifyIdentifier(input) {
+  if (!input) return "";
+  let text = input;
+  text = text.replace(/([a-z])([A-Z])|([A-Z])([A-Z][a-z])/g, "$1$3 $2$4");
+  text = text.replace(/[_-]+/g, " ");
+  const s = text.trim().replace(/\b\w/g, (char) => char.toUpperCase());
+  console.log("Prettified identifier:", {
+    input,
+    s
+  });
+  return s;
+}
+const defaultDateFormat = "MMMM dd, yyyy, HH:mm:ss";
+function enumToObjectEntries(enumValues) {
+  if (Array.isArray(enumValues)) {
+    return enumValues;
+  } else {
+    return Object.entries(enumValues).map(([id, value]) => {
+      if (typeof value === "string") {
+        return {
+          id,
+          label: value
+        };
+      } else {
+        return {
+          ...value,
+          id
+        };
+      }
+    });
+  }
+}
+function getLabelOrConfigFrom(enumValues, key) {
+  if (key === null || key === void 0) return void 0;
+  return enumValues.find((entry) => String(entry.id) === String(key));
+}
+const COLLECTION_PATH_SEPARATOR = "::";
+function stripCollectionPath(path) {
+  return segmentsToStrippedPath(fullPathToCollectionSegments(path));
+}
+function segmentsToStrippedPath(paths) {
+  if (paths.length === 1) return paths[0];
+  return paths.reduce((a, b) => `${a}${COLLECTION_PATH_SEPARATOR}${b}`);
+}
+function fullPathToCollectionSegments(path) {
+  return path.split("/").filter((e, i) => i % 2 === 0);
+}
+function serializeRegExp(input) {
+  if (!input) return "";
+  return input.toString();
+}
+function hydrateRegExp(input) {
+  if (!input) return void 0;
+  const fragments = input.match(/\/(.*?)\/([a-z]*)?$/i);
+  if (fragments) {
+    return new RegExp(fragments[1], fragments[2] || "");
+  } else {
+    return new RegExp(input, "");
+  }
+}
+function isValidRegExp(input) {
+  const fullRegexp = input.match(/\/((?![*+?])(?:[^\r\n[/\\]|\\.|\[(?:[^\r\n\]\\]|\\.)*])+)\/((?:g(?:im?|mi?)?|i(?:gm?|mg?)?|m(?:gi?|ig?)?)?)/);
+  if (fullRegexp) return true;
+  const simpleRegexp = input.match(/((?![*+?])(?:[^\r\n[/\\]|\\.|\[(?:[^\r\n\]\\]|\\.)*])+)/);
+  return !!simpleRegexp;
+}
+function isDefaultFieldConfigId(id) {
+  return ["text_field", "multiline", "markdown", "url", "email", "switch", "select", "multi_select", "number_input", "number_select", "multi_number_select", "file_upload", "multi_file_upload", "reference_as_string", "reference", "multi_references", "relation", "date_time", "group", "key_value", "repeat", "custom_array", "block"].includes(id);
+}
+function resolveProperty(props) {
+  const {
+    property,
+    ignoreMissingFields = false,
+    ...rest
+  } = props;
+  let resultProperty;
+  if (isPropertyBuilder(property)) {
+    const path = rest.path;
+    if (!path) throw Error("Trying to resolve a property builder without specifying the entity path");
+    const usedPropertyValue = rest.propertyKey ? getIn$1(rest.values, rest.propertyKey) : void 0;
+    const dynamicProps = property.dynamicProps?.({
+      ...rest,
+      path,
+      propertyValue: usedPropertyValue,
+      values: rest.values ?? {},
+      previousValues: rest.previousValues ?? rest.values ?? {}
+    });
+    resultProperty = mergeDeep(property, dynamicProps ?? {});
+  } else {
+    resultProperty = property;
+  }
+  if (resultProperty.dynamicProps) {
+    const path = rest.path;
+    if (!path) throw Error("Trying to resolve dynamicProps without specifying the entity path");
+    const usedPropertyValue = rest.propertyKey ? getIn$1(rest.values, rest.propertyKey) : void 0;
+    const dynamicPropsResult = resultProperty.dynamicProps({
+      ...rest,
+      path,
+      propertyValue: usedPropertyValue,
+      values: rest.values ?? {},
+      previousValues: rest.previousValues ?? rest.values ?? {}
+    });
+    if (dynamicPropsResult) {
+      resultProperty = mergeDeep(resultProperty, dynamicPropsResult);
+    }
+  }
+  let resolvedProperty;
+  if (resultProperty?.type === "map" && resultProperty.properties) {
+    const properties = resolveProperties({
+      ignoreMissingFields,
+      ...rest,
+      properties: resultProperty.properties
+    });
+    resolvedProperty = {
+      ...resultProperty,
+      properties
+    };
+  } else if (resultProperty?.type === "array") {
+    resolvedProperty = resultProperty;
+  } else if ((resultProperty?.type === "string" || resultProperty?.type === "number") && resultProperty.enum) {
+    resolvedProperty = resolvePropertyEnum(resultProperty);
+  } else {
+    resolvedProperty = resultProperty;
+  }
+  if (resolvedProperty?.propertyConfig && !isDefaultFieldConfigId(resolvedProperty.propertyConfig)) {
+    const cmsFields = rest.propertyConfigs;
+    if (!cmsFields && !ignoreMissingFields) {
+      throw Error(`Trying to resolve a property with key '${resolvedProperty.propertyConfig}' that inherits from a custom property config but no custom property configs were provided. Use the property 'propertyConfigs' in your app config to provide them`);
+    }
+    const customField = cmsFields?.[resolvedProperty.propertyConfig];
+    if (!customField) {
+      console.warn(`Trying to resolve a property with key '${resolvedProperty.propertyConfig}' that inherits from a custom property config but no custom property config with that key was found. Check the 'propertyConfigs' in your app config`);
+      return resolvedProperty;
+    }
+    if (customField.property) {
+      const {
+        propertyConfig: _unused,
+        ...restConfigProperty
+      } = customField.property;
+      const customFieldProperty = resolveProperty({
+        property: {
+          name: "",
+          ...restConfigProperty
+        },
+        ignoreMissingFields,
+        ...rest
+      });
+      if (customFieldProperty) {
+        resolvedProperty = mergeDeep(customFieldProperty, resolvedProperty);
+      }
+    }
+  }
+  return resolvedProperty;
+}
+function resolveRelationProperty(property, relations) {
+  const relation = relations.find((rel) => rel.relationName === property.relationName);
+  if (!relation) {
+    throw Error(`Relation ${property.relationName} not found`);
+  }
+  return {
+    ...property,
+    relation
+  };
+}
+function resolvePropertyEnum(property) {
+  if (typeof property.enum === "object") {
+    return {
+      ...property,
+      enum: enumToObjectEntries(property.enum)?.filter((value) => value && (value.id || value.id === 0) && value.label) ?? []
+    };
+  }
+  return property;
+}
+function resolveProperties({
+  propertyKey,
+  properties,
+  ignoreMissingFields,
+  ...props
+}) {
+  return Object.entries(properties).map(([key, property]) => {
+    const childResolvedProperty = resolveProperty({
+      propertyKey: propertyKey ? `${propertyKey}.${key}` : void 0,
+      property,
+      ignoreMissingFields,
+      ...props
+    });
+    if (!childResolvedProperty) return {};
+    return {
+      [key]: childResolvedProperty
+    };
+  }).filter((a) => a !== null).reduce((a, b) => ({
+    ...a,
+    ...b
+  }), {});
+}
+function resolveArrayProperties({
+  propertyKey,
+  property,
+  ignoreMissingFields = false,
+  ...props
+}) {
+  const propertyValue = propertyKey ? getIn$1(props.values, propertyKey) : void 0;
+  if (property.of) {
+    if (Array.isArray(property.of)) {
+      return property.of.map((p, index) => {
+        return resolveProperty({
+          propertyKey: `${propertyKey}.${index}`,
+          property: p,
+          ignoreMissingFields,
+          ...props,
+          index
+        });
+      });
+    } else {
+      const of = property.of;
+      const resolvedProperties = getArrayResolvedProperties({
+        propertyValue,
+        propertyKey,
+        property,
+        ignoreMissingFields,
+        ...props
+      });
+      const {
+        values,
+        previousValues,
+        ...rest
+      } = props;
+      const ofProperty = resolveProperty({
+        // we don't want to pass the values of the parent entity
+        property: of,
+        ignoreMissingFields,
+        ...rest
+      });
+      if (!ofProperty && !ignoreMissingFields) throw Error("When using a property builder as the 'of' prop of an ArrayProperty, you must return a valid child property");
+      return resolvedProperties;
+    }
+  } else if (property.oneOf) {
+    const typeField = property.oneOf?.typeField ?? DEFAULT_ONE_OF_TYPE;
+    const resolvedProperties = Array.isArray(propertyValue) ? propertyValue.map((v, index) => {
+      const type = v && v[typeField];
+      const childProperty = property.oneOf?.properties[type];
+      if (!type || !childProperty) return null;
+      return resolveProperty({
+        propertyKey: `${propertyKey}.${index}`,
+        property: childProperty,
+        ignoreMissingFields,
+        ...props
+      });
+    }).filter((e) => Boolean(e)) : [];
+    return resolvedProperties;
+  } else if (!property.Field) {
+    throw Error(`The array property (${propertyKey}) needs to declare an 'of' or a 'oneOf' property, or provide a custom \`Field\` component`);
+  } else {
+    return [];
+  }
+}
+function getArrayResolvedProperties({
+  propertyKey,
+  propertyValue,
+  property,
+  ...props
+}) {
+  const of = property.of;
+  if (!of) throw Error(`Trying to resolve an array property (${propertyKey}) without providing an 'of' property`);
+  return Array.isArray(propertyValue) ? propertyValue.map((v, index) => {
+    return resolveProperty({
+      propertyKey: `${propertyKey}.${index}`,
+      property: Array.isArray(of) ? of[index] : of,
+      ...props,
+      index
+    });
+  }).filter((e) => Boolean(e)) : [];
+}
+function resolveEnumValues(input) {
+  if (typeof input === "object") {
+    return Object.entries(input).map(([id, value]) => typeof value === "string" ? {
+      id,
+      label: value
+    } : value);
+  } else if (Array.isArray(input)) {
+    return input;
+  } else {
+    return void 0;
+  }
+}
+function resolveEntityView$1(entityView, contextEntityViews) {
+  if (typeof entityView === "string") {
+    return contextEntityViews?.find((entry) => entry.key === entityView);
+  } else {
+    return entityView;
+  }
+}
+function resolveEntityAction(entityAction, contextEntityActions) {
+  if (typeof entityAction === "string") {
+    return contextEntityActions?.find((entry) => entry.key === entityAction);
+  } else {
+    return entityAction;
+  }
+}
+function resolvedSelectedEntityView(customViews, customizationController, selectedTab, canEdit) {
+  const resolvedEntityViews = customViews ? customViews.map((e) => resolveEntityView$1(e, customizationController.entityViews)).filter((e) => Boolean(e)) : [];
+  const selectedEntityView = resolvedEntityViews.find((e) => e.key === selectedTab);
+  const selectedSecondaryForm = customViews && resolvedEntityViews.filter((e) => e.includeActions).find((e) => e.key === selectedTab);
+  return {
+    resolvedEntityViews,
+    selectedEntityView,
+    selectedSecondaryForm
+  };
+}
+function getSubcollections(collection) {
+  const subcollections = [];
+  subcollections.push(...collection.subcollections?.() ?? []);
+  subcollections.push(...(collection.relations ?? []).filter((rel) => rel.cardinality === "many").map((relation) => {
+    const targetCollection = relation.target();
+    const overrides = relation.overrides;
+    return overrides ? mergeDeep(targetCollection, overrides) : targetCollection;
+  }) ?? []);
+  return subcollections;
+}
+function removeInitialAndTrailingSlashes(s) {
+  return removeInitialSlash(removeTrailingSlash(s));
+}
+function removeInitialSlash(s) {
+  if (s.startsWith("/")) return s.slice(1);
+  else return s;
+}
+function removeTrailingSlash(s) {
+  if (s.endsWith("/")) return s.slice(0, -1);
+  else return s;
+}
+function addInitialSlash(s) {
+  if (s.startsWith("/")) return s;
+  else return `/${s}`;
+}
+function getLastSegment(path) {
+  const cleanPath = removeInitialAndTrailingSlashes(path);
+  if (cleanPath.includes("/")) {
+    const segments = cleanPath.split("/");
+    return segments[segments.length - 1];
+  }
+  return cleanPath;
+}
+function resolveCollectionPathIds(path, allCollections) {
+  let remainingPath = removeInitialAndTrailingSlashes(path);
+  if (!remainingPath) {
+    return "";
+  }
+  let currentCollections = allCollections;
+  const resolvedPathParts = [];
+  while (remainingPath.length > 0) {
+    if (!currentCollections || currentCollections.length === 0) {
+      console.warn(`resolveCollectionPathIds: Path structure implies subcollections, but none found before segment starting with "${remainingPath}" in original path "${path}". Appending remaining original path.`);
+      resolvedPathParts.push(remainingPath);
+      remainingPath = "";
+      break;
+    }
+    let foundMatch = false;
+    const potentialMatches = currentCollections.flatMap((col) => [{
+      col,
+      match: col.slug
+    }]).filter((p) => p.match && remainingPath.startsWith(p.match)).sort((a, b) => b.match.length - a.match.length);
+    if (potentialMatches.length > 0) {
+      const {
+        col: foundCollection,
+        match: matchString
+      } = potentialMatches[0];
+      resolvedPathParts.push(foundCollection.dbPath);
+      remainingPath = removeInitialSlash(remainingPath.substring(matchString.length));
+      if (remainingPath.length === 0) {
+        foundMatch = true;
+        break;
+      }
+      const idSeparatorIndex = remainingPath.indexOf("/");
+      let entityId;
+      if (idSeparatorIndex > -1) {
+        entityId = remainingPath.substring(0, idSeparatorIndex);
+        remainingPath = remainingPath.substring(idSeparatorIndex + 1);
+      } else {
+        entityId = remainingPath;
+        remainingPath = "";
+        console.warn(`resolveCollectionPathIds: Path seems to end with an entity ID "${entityId}" instead of a collection segment in original path "${path}". This might indicate an invalid input path.`);
+      }
+      resolvedPathParts.push(entityId);
+      currentCollections = getSubcollections(foundCollection);
+      foundMatch = true;
+      if (!currentCollections && remainingPath.length > 0) {
+        console.warn(`resolveCollectionPathIds: Path continues after entity ID "${entityId}", but no subcollections are defined for the preceding collection "${foundCollection.slug}" in path "${path}". Appending remaining original path.`);
+        resolvedPathParts.push(remainingPath);
+        remainingPath = "";
+        break;
+      }
+    }
+    if (!foundMatch) {
+      console.warn(`resolveCollectionPathIds: Collection definition not found for segment starting with "${remainingPath}" in original path "${path}". Appending remaining original path.`);
+      resolvedPathParts.push(remainingPath);
+      remainingPath = "";
+      break;
+    }
+  }
+  return resolvedPathParts.join("/");
+}
+function getCollectionBySlugWithin(slugOrPath, collections) {
+  const subpaths = removeInitialAndTrailingSlashes(slugOrPath).split("/");
+  if (subpaths.length % 2 === 0) {
+    throw Error(`getCollectionBySlug: Collection paths must have an odd number of segments: ${slugOrPath}`);
+  }
+  const subpathCombinations = getCollectionPathsCombinations(subpaths);
+  let result;
+  for (let i = 0; i < subpathCombinations.length; i++) {
+    const subpathCombination = subpathCombinations[i];
+    const navigationEntry = collections && collections.sort((a, b) => (a.slug ?? "").localeCompare(b.slug ?? "")).find((entry) => entry.slug === subpathCombination);
+    if (navigationEntry) {
+      if (subpathCombination === slugOrPath) {
+        result = navigationEntry;
+      } else if (navigationEntry.subcollections) {
+        const newPath = slugOrPath.replace(subpathCombination, "").split("/").slice(2).join("/");
+        if (newPath.length > 0) result = getCollectionBySlugWithin(newPath, getSubcollections(navigationEntry));
+      }
+    }
+    if (result) break;
+  }
+  return result;
+}
+function getCollectionPathsCombinations(subpaths) {
+  const entries = subpaths.length > 0 && subpaths.length % 2 === 0 ? subpaths.splice(0, subpaths.length - 1) : subpaths;
+  const length = entries.length;
+  const result = [];
+  for (let i = length; i > 0; i = i - 2) {
+    result.push(entries.slice(0, i).join("/"));
+  }
+  return result;
+}
+function navigateToEntity({
+  openEntityMode,
+  collection,
+  entityId,
+  copy,
+  path,
+  selectedTab,
+  sideEntityController,
+  onClose,
+  navigation
+}) {
+  if (openEntityMode === "side_panel") {
+    sideEntityController.open({
+      entityId,
+      path,
+      copy,
+      selectedTab,
+      collection,
+      updateUrl: true,
+      onClose
+    });
+  } else {
+    let to = navigation.buildUrlCollectionPath(entityId ? `${path ?? path}/${entityId}` : path ?? path);
+    if (entityId && selectedTab) {
+      to += `/${selectedTab}`;
+    }
+    if (!entityId) {
+      to += "#new";
+    }
+    if (copy) {
+      to += "#copy";
+    }
+    navigation.navigate(to);
+  }
+}
+const reservedKeys = ["edit", "copy", "delete"];
+function mergeEntityActions(currentActions, newActions) {
+  const updatedActions = [];
+  currentActions.forEach((action) => {
+    const newAction = newActions.find((a) => a.key === action.key);
+    if (newAction) {
+      const mergedAction = {
+        ...action,
+        ...newAction
+      };
+      updatedActions.push(mergedAction);
+    } else {
+      updatedActions.push(action);
+    }
+  });
+  newActions.forEach((action) => {
+    if (!currentActions.find((a) => a.key === action.key) && (!action.key || !reservedKeys.includes(action.key))) {
+      updatedActions.push(action);
+    }
+  });
+  return updatedActions;
+}
+function evaluateAST(sqlString, auth, entity) {
+  if (!entity) return true;
+  let cleanedSQL = sqlString.trim();
+  while (cleanedSQL.startsWith("(") && cleanedSQL.endsWith(")")) {
+    let openCount = 0;
+    let isEnclosing = true;
+    for (let i = 0; i < cleanedSQL.length - 1; i++) {
+      if (cleanedSQL[i] === "(") openCount++;
+      else if (cleanedSQL[i] === ")") openCount--;
+      if (openCount === 0) {
+        isEnclosing = false;
+        break;
+      }
+    }
+    if (isEnclosing) {
+      cleanedSQL = cleanedSQL.substring(1, cleanedSQL.length - 1).trim();
+    } else {
+      break;
+    }
+  }
+  const splitByTopLevel = (str, delimiter) => {
+    const parts = [];
+    let current = "";
+    let openCount = 0;
+    let i = 0;
+    while (i < str.length) {
+      if (str[i] === "(") openCount++;
+      else if (str[i] === ")") openCount--;
+      if (openCount === 0 && str.substring(i).toUpperCase().startsWith(delimiter)) {
+        parts.push(current);
+        current = "";
+        i += delimiter.length;
+      } else {
+        current += str[i];
+        i++;
+      }
+    }
+    parts.push(current);
+    return parts;
+  };
+  const orParts = splitByTopLevel(cleanedSQL, " OR ");
+  if (orParts.length > 1) {
+    return orParts.some((part) => evaluateAST(part, auth, entity));
+  }
+  const andParts = splitByTopLevel(cleanedSQL, " AND ");
+  if (andParts.length > 1) {
+    return andParts.every((part) => evaluateAST(part, auth, entity));
+  }
+  const upperSQL = cleanedSQL.toUpperCase();
+  if (upperSQL.includes(" IN ") || upperSQL.includes(" EXISTS ")) {
+    return true;
+  }
+  const roleIntersectMatch = cleanedSQL.match(/string_to_array\s*\(\s*auth\.roles\(\)\s*,\s*','\s*\)\s*&&\s*ARRAY\[(.*?)\]/i);
+  if (roleIntersectMatch && roleIntersectMatch[1]) {
+    const requiredRoles = roleIntersectMatch[1].split(",").map((r) => r.trim().replace(/'/g, ""));
+    const userRoles = auth.user?.roles || [];
+    return requiredRoles.some((r) => userRoles.includes(r));
+  }
+  const roleContainMatch = cleanedSQL.match(/string_to_array\s*\(\s*auth\.roles\(\)\s*,\s*','\s*\)\s*@>\s*ARRAY\[(.*?)\]/i);
+  if (roleContainMatch && roleContainMatch[1]) {
+    const requiredRoles = roleContainMatch[1].split(",").map((r) => r.trim().replace(/'/g, ""));
+    const userRoles = auth.user?.roles || [];
+    return requiredRoles.every((r) => userRoles.includes(r));
+  }
+  const pattern1 = new RegExp(`^\\{?([a-zA-Z0-9_]+)\\}?\\s*=\\s*(?:current_setting\\s*\\(\\s*'app\\.user_id'\\s*\\)|auth\\.uid\\(\\))`);
+  const pattern2 = new RegExp(`^(?:current_setting\\s*\\(\\s*'app\\.user_id'\\s*\\)|auth\\.uid\\(\\))\\s*=\\s*\\{?([a-zA-Z0-9_]+)\\}?`);
+  const match1 = cleanedSQL.match(pattern1);
+  if (match1 && match1[1]) {
+    return entity.values[match1[1]] === auth.user?.uid;
+  }
+  const match2 = cleanedSQL.match(pattern2);
+  if (match2 && match2[1]) {
+    return entity.values[match2[1]] === auth.user?.uid;
+  }
+  const simpleEqualityMatch = cleanedSQL.match(/^\{?([\w_]+)\}?\s*(=|!=)\s*'([^']+)'$/i);
+  if (simpleEqualityMatch) {
+    const field = simpleEqualityMatch[1];
+    const operator = simpleEqualityMatch[2];
+    const value = simpleEqualityMatch[3];
+    const entityValue = entity.values[field];
+    if (operator === "=") return entityValue === value;
+    if (operator === "!=") return entityValue !== value;
+  }
+  return true;
+}
+function evaluateRule(rule, auth, entity) {
+  if (rule.access === "public") return true;
+  if (rule.ownerField) {
+    if (!entity) ;
+    else {
+      if (entity.values[rule.ownerField] !== auth.user?.uid) return false;
+    }
+  }
+  if (rule.using && !evaluateAST(rule.using, auth, entity)) return false;
+  if (rule.withCheck && !evaluateAST(rule.withCheck, auth, entity)) return false;
+  return true;
+}
+function checkOperation(collection, authController, entity, targetOperation) {
+  if (!collection.securityRules || collection.securityRules.length === 0) {
+    return true;
+  }
+  const applicableRules = collection.securityRules.filter((r) => r.operation === targetOperation || r.operation === "all" || r.operations?.includes(targetOperation) || r.operations?.includes("all"));
+  if (applicableRules.length === 0) return false;
+  const userRoleIds = authController.user?.roles ?? [];
+  const userRoles = [...userRoleIds, "public"];
+  const roleApplicableRules = applicableRules.filter((rule) => {
+    if (!rule.roles || rule.roles.length === 0) return true;
+    return rule.roles.some((r) => userRoles.includes(r));
+  });
+  if (roleApplicableRules.length === 0) return false;
+  let grantedByPermissive = false;
+  let deniedByRestrictive = false;
+  for (const rule of roleApplicableRules) {
+    const mode = rule.mode || "permissive";
+    const passed = evaluateRule(rule, authController, entity);
+    if (mode === "restrictive" && !passed) {
+      deniedByRestrictive = true;
+      break;
+    }
+    if (mode === "permissive" && passed) {
+      grantedByPermissive = true;
+    }
+  }
+  if (deniedByRestrictive) return false;
+  const hasPermissive = roleApplicableRules.some((r) => (r.mode || "permissive") === "permissive");
+  if (hasPermissive) {
+    return grantedByPermissive;
+  } else {
+    return false;
+  }
+}
+function canReadCollection(collection, authController) {
+  return checkOperation(collection, authController, null, "select");
+}
+function canEditEntity(collection, authController, path, entity) {
+  return checkOperation(collection, authController, entity, "update");
+}
+function canCreateEntity(collection, authController, path, entity) {
+  if (collection.collectionGroup) return false;
+  return checkOperation(collection, authController, entity, "insert");
+}
+function canDeleteEntity(collection, authController, path, entity) {
+  return checkOperation(collection, authController, entity, "delete");
+}
+function plural(word, amount) {
+  if (amount !== void 0 && amount === 1) {
+    return word;
+  }
+  const plurals = {
+    "(quiz)$": "$1zes",
+    "^(ox)$": "$1en",
+    "([m|l])ouse$": "$1ice",
+    "(matr|vert|ind)ix|ex$": "$1ices",
+    "(x|ch|ss|sh)$": "$1es",
+    "([^aeiouy]|qu)y$": "$1ies",
+    "(hive)$": "$1s",
+    "(?:([^f])fe|([lr])f)$": "$1$2ves",
+    "(shea|lea|loa|thie)f$": "$1ves",
+    sis$: "ses",
+    "([ti])um$": "$1a",
+    "(tomat|potat|ech|her|vet)o$": "$1oes",
+    "(bu)s$": "$1ses",
+    "(alias)$": "$1es",
+    "(octop)us$": "$1i",
+    "(ax|test)is$": "$1es",
+    "(us)$": "$1es",
+    "([^s]+)$": "$1s"
+  };
+  const irregular = {
+    move: "moves",
+    foot: "feet",
+    goose: "geese",
+    sex: "sexes",
+    child: "children",
+    man: "men",
+    tooth: "teeth",
+    person: "people"
+  };
+  const uncountable = ["sheep", "fish", "deer", "moose", "series", "species", "money", "rice", "information", "equipment", "bison", "cod", "offspring", "pike", "salmon", "shrimp", "swine", "trout", "aircraft", "hovercraft", "spacecraft", "sugar", "tuna", "you", "wood"];
+  if (uncountable.indexOf(word.toLowerCase()) >= 0) {
+    return word;
+  }
+  for (const w in irregular) {
+    const pattern = new RegExp(`${w}$`, "i");
+    const replace = irregular[w];
+    if (pattern.test(word)) {
+      return word.replace(pattern, replace);
+    }
+  }
+  for (const reg in plurals) {
+    const pattern = new RegExp(reg, "i");
+    if (pattern.test(word)) {
+      return word.replace(pattern, plurals[reg]);
+    }
+  }
+  return word;
+}
+function singular(word, amount) {
+  if (amount !== void 0 && amount !== 1) {
+    return word;
+  }
+  const singulars = {
+    "(quiz)zes$": "$1",
+    "(matr)ices$": "$1ix",
+    "(vert|ind)ices$": "$1ex",
+    "^(ox)en$": "$1",
+    "(alias)es$": "$1",
+    "(octop|vir)i$": "$1us",
+    "(cris|ax|test)es$": "$1is",
+    "(shoe)s$": "$1",
+    "(o)es$": "$1",
+    "(bus)es$": "$1",
+    "([m|l])ice$": "$1ouse",
+    "(x|ch|ss|sh)es$": "$1",
+    "(m)ovies$": "$1ovie",
+    "(s)eries$": "$1eries",
+    "([^aeiouy]|qu)ies$": "$1y",
+    "([lr])ves$": "$1f",
+    "(tive)s$": "$1",
+    "(hive)s$": "$1",
+    "(li|wi|kni)ves$": "$1fe",
+    "(shea|loa|lea|thie)ves$": "$1f",
+    "(^analy)ses$": "$1sis",
+    "((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$": "$1$2sis",
+    "([ti])a$": "$1um",
+    "(n)ews$": "$1ews",
+    "(h|bl)ouses$": "$1ouse",
+    "(corpse)s$": "$1",
+    "(us)es$": "$1",
+    s$: ""
+  };
+  const irregular = {
+    move: "moves",
+    foot: "feet",
+    goose: "geese",
+    sex: "sexes",
+    child: "children",
+    man: "men",
+    tooth: "teeth",
+    person: "people"
+  };
+  const uncountable = ["sheep", "fish", "deer", "moose", "series", "species", "money", "rice", "information", "equipment", "bison", "cod", "offspring", "pike", "salmon", "shrimp", "swine", "trout", "aircraft", "hovercraft", "spacecraft", "sugar", "tuna", "you", "wood"];
+  if (uncountable.indexOf(word.toLowerCase()) >= 0) {
+    return word;
+  }
+  for (const w in irregular) {
+    const pattern = new RegExp(`${irregular[w]}$`, "i");
+    if (pattern.test(word)) {
+      return word.replace(pattern, w);
+    }
+  }
+  for (const reg in singulars) {
+    const pattern = new RegExp(reg, "i");
+    if (pattern.test(word)) {
+      return word.replace(pattern, singulars[reg]);
+    }
+  }
+  return word;
+}
+function getEntityImagePreviewPropertyKey(collection) {
+  for (const key in collection.properties) {
+    const property = collection.properties[key];
+    if (property.type === "string" && property.storage?.acceptedFiles?.includes("image/*")) {
+      return key;
+    }
+  }
+  for (const key in collection.properties) {
+    const property = collection.properties[key];
+    if (property.type === "array" && !Array.isArray(property.of) && property.of?.type === "string" && property.of.storage?.acceptedFiles?.includes("image/*")) {
+      return key;
+    }
+  }
+  for (const key in collection.properties) {
+    const property = collection.properties[key];
+    if (property.type === "string" && property.url === "image") {
+      return key;
+    }
+  }
+  for (const key in collection.properties) {
+    const property = collection.properties[key];
+    if (property.type === "array" && property.of?.type === "string" && property.of.url === "image") {
+      return key;
+    }
+  }
+  return void 0;
+}
+function flattenObject(obj, parentKey = "") {
+  if (!obj) return obj;
+  return Object.keys(obj).reduce((flatObj, key) => {
+    const newKey = parentKey ? `${parentKey}.${key}` : key;
+    if (typeof obj[key] === "object" && obj[key] !== null) {
+      if (Array.isArray(obj[key])) {
+        obj[key].forEach((item, index) => {
+          Object.assign(flatObj, flattenObject(item, `${newKey}[${index}]`));
+        });
+      } else {
+        Object.assign(flatObj, flattenObject(obj[key], newKey));
+      }
+    } else {
+      flatObj[newKey] = obj[key];
+    }
+    return flatObj;
+  }, {});
+}
+function getArrayValuesCount(array) {
+  return array.reduce((acc, obj) => {
+    Object.entries(obj).forEach(([key, value]) => {
+      if (Array.isArray(value)) {
+        acc[key] = Math.max(acc[key] || 0, value.length);
+      }
+      if (typeof value === "object" && value !== null) {
+        const nested = getArrayValuesCount([value]);
+        Object.entries(nested).forEach(([nestedKey, nestedCount]) => {
+          const compoundKey = `${key}.${nestedKey}`;
+          acc[compoundKey] = Math.max(acc[compoundKey] || 0, nestedCount);
+        });
+      }
+    });
+    return acc;
+  }, {});
+}
+function getNavigationEntriesFromPath(props) {
+  const {
+    path,
+    collections = [],
+    currentFullPath
+  } = props;
+  const subpaths = removeInitialAndTrailingSlashes(path).split("/");
+  const subpathCombinations = getCollectionPathsCombinations(subpaths);
+  const result = [];
+  for (let i = 0; i < subpathCombinations.length; i++) {
+    const subpathCombination = subpathCombinations[i];
+    const collection = collections && collections.find((entry) => entry.slug === subpathCombination);
+    if (collection) {
+      const collectionPath = currentFullPath && currentFullPath.length > 0 ? currentFullPath + "/" + collection.slug : collection.slug;
+      result.push({
+        type: "collection",
+        id: collection.slug,
+        slug: collectionPath,
+        path: collectionPath,
+        collection
+      });
+      const restOfThePath = removeInitialAndTrailingSlashes(removeInitialAndTrailingSlashes(path).replace(subpathCombination, ""));
+      const nextSegments = restOfThePath.length > 0 ? restOfThePath.split("/") : [];
+      if (nextSegments.length > 0) {
+        const entityId = nextSegments[0];
+        const path2 = collectionPath + "/" + entityId;
+        result.push({
+          type: "entity",
+          entityId,
+          slug: collectionPath,
+          path: path2,
+          parentCollection: collection
+        });
+        if (nextSegments.length > 1) {
+          const newPath = nextSegments.slice(1).join("/");
+          if (!collection) {
+            throw Error("collection not found resolving path: " + collection);
+          }
+          const entityViews = collection.entityViews;
+          const customView = entityViews && entityViews.map((entry) => resolveEntityView(entry, props.contextEntityViews)).filter(Boolean).find((entry) => entry.key === newPath);
+          const subcollections = getSubcollections(collection);
+          if (customView) {
+            result.push({
+              type: "custom_view",
+              slug: collectionPath,
+              entityId,
+              path: path2 + "/" + customView.key,
+              view: customView
+            });
+          } else if (subcollections) {
+            result.push(...getNavigationEntriesFromPath({
+              path: newPath,
+              collections: subcollections,
+              currentFullPath: path2,
+              contextEntityViews: props.contextEntityViews
+            }));
+          }
+        }
+      }
+      break;
+    }
+  }
+  return result;
+}
+function resolveEntityView(entityView, contextEntityViews) {
+  if (typeof entityView === "string") {
+    return contextEntityViews?.find((entry) => entry.key === entityView);
+  } else {
+    return entityView;
+  }
+}
+function getParentReferencesFromPath(props) {
+  const {
+    path,
+    collections = [],
+    currentFullPath
+  } = props;
+  const subpaths = removeInitialAndTrailingSlashes(path).split("/");
+  const subpathCombinations = getCollectionPathsCombinations(subpaths);
+  const result = [];
+  for (let i = 0; i < subpathCombinations.length; i++) {
+    const subpathCombination = subpathCombinations[i];
+    const collection = collections && collections.find((entry) => entry.slug === subpathCombination);
+    if (collection) {
+      const collectionPath = currentFullPath && currentFullPath.length > 0 ? currentFullPath + "/" + collection.slug : collection.slug;
+      const restOfThePath = removeInitialAndTrailingSlashes(removeInitialAndTrailingSlashes(path).replace(subpathCombination, ""));
+      const nextSegments = restOfThePath.length > 0 ? restOfThePath.split("/") : [];
+      if (nextSegments.length > 0) {
+        const entityId = nextSegments[0];
+        const path2 = collectionPath + "/" + entityId;
+        result.push(new EntityReference({
+          id: entityId,
+          path: collectionPath
+        }));
+        if (nextSegments.length > 1) {
+          const newPath = nextSegments.slice(1).join("/");
+          if (!collection) {
+            throw Error("collection not found resolving path: " + collection);
+          }
+          if (collection.subcollections) {
+            result.push(...getParentReferencesFromPath({
+              path: newPath,
+              collections: getSubcollections(collection),
+              currentFullPath: path2
+            }));
+          }
+        }
+      }
+      break;
+    }
+  }
+  return result;
+}
+function buildCollection(collection) {
+  return collection;
+}
+function buildProperty(property) {
+  return property;
+}
+function buildProperties(properties) {
+  return properties;
+}
+function buildPropertiesOrBuilder(propertiesOrBuilder) {
+  return propertiesOrBuilder;
+}
+function buildEnum(enumValues) {
+  return enumValues;
+}
+function buildEnumValueConfig(enumValueConfig) {
+  return enumValueConfig;
+}
+function buildEntityCallbacks(callbacks) {
+  return callbacks;
+}
+function buildAdditionalFieldDelegate(additionalFieldDelegate) {
+  return additionalFieldDelegate;
+}
+function buildFieldConfig(propertyConfig) {
+  return propertyConfig;
+}
+async function resolveStorageFilenameString({
+  input,
+  storage,
+  values,
+  entityId,
+  path,
+  property,
+  file,
+  propertyKey
+}) {
+  let result;
+  if (typeof input === "function") {
+    result = await input({
+      path,
+      entityId,
+      values,
+      property,
+      file,
+      storage,
+      propertyKey
+    });
+    if (!result) console.warn("Storage callback returned empty result. Using default name value");
+  } else {
+    result = replacePlaceholders({
+      file,
+      input,
+      entityId,
+      propertyKey,
+      path
+    });
+  }
+  if (!result) result = randomString() + "_" + file.name;
+  return result;
+}
+function resolveStoragePathString({
+  input,
+  storage,
+  values,
+  entityId,
+  path,
+  property,
+  file,
+  propertyKey
+}) {
+  let result;
+  if (typeof input === "function") {
+    result = input({
+      path,
+      entityId,
+      values,
+      property,
+      file,
+      storage,
+      propertyKey
+    });
+    if (!result) console.warn("Storage callback returned empty result. Using default name value");
+  } else {
+    result = replacePlaceholders({
+      file,
+      input,
+      entityId,
+      propertyKey,
+      path
+    });
+  }
+  if (!result) result = randomString() + "_" + file.name;
+  return result;
+}
+function replacePlaceholders({
+  file,
+  input,
+  entityId,
+  propertyKey,
+  path
+}) {
+  const ext = file.name.split(".").pop();
+  let result = input.replace("{propertyKey}", propertyKey).replace("{rand}", randomString()).replace("{file}", file.name).replace("{file.type}", file.type);
+  if (entityId) {
+    result = result.replace("{entityId}", String(entityId));
+  }
+  if (path) {
+    result = result.replace("{path}", path);
+  }
+  if (ext) {
+    result = result.replace("{file.ext}", ext);
+    const name = file.name.replace(`.${ext}`, "");
+    result = result.replace("{file.name}", name);
+  }
+  if (!result) result = randomString() + "_" + file.name;
+  return result;
+}
+function toArray(input) {
+  return Array.isArray(input) ? input : input ? [input] : [];
+}
+function hasPropertyCallbacks(properties, callbackName) {
+  if (!properties) return false;
+  for (const property of Object.values(properties)) {
+    if (property.callbacks?.[callbackName]) return true;
+    if (property.type === "map" && property.properties) {
+      if (hasPropertyCallbacks(property.properties, callbackName)) return true;
+    } else if (property.type === "array" && property.of) {
+      const ofs = Array.isArray(property.of) ? property.of : [property.of];
+      for (const of of ofs) {
+        if (of.callbacks?.[callbackName]) return true;
+        if (of.type === "map" && of.properties && hasPropertyCallbacks(of.properties, callbackName)) return true;
+      }
+    }
+  }
+  return false;
+}
+async function processProperties(properties, values, previousValues, propsContext, callbackName) {
+  if (!values || typeof values !== "object") return values;
+  let result = {
+    ...values
+  };
+  for (const [key, property] of Object.entries(properties)) {
+    if (result[key] === void 0) continue;
+    let currentValue = result[key];
+    let previousValue = previousValues?.[key];
+    if (property.type === "array" && Array.isArray(currentValue)) {
+      if (property.of && !Array.isArray(property.of)) {
+        currentValue = await Promise.all(currentValue.map(async (item, index) => {
+          const prevItem = Array.isArray(previousValue) ? previousValue[index] : void 0;
+          const singlePropData = {
+            "_tmp": property.of
+          };
+          const res = await processProperties(singlePropData, {
+            "_tmp": item
+          }, {
+            "_tmp": prevItem
+          }, propsContext, callbackName);
+          return res["_tmp"];
+        }));
+      }
+    } else if (property.type === "map" && property.properties && typeof currentValue === "object") {
+      currentValue = await processProperties(property.properties, currentValue, previousValue ?? {}, propsContext, callbackName);
+    }
+    if (property.callbacks?.[callbackName]) {
+      const cbRes = await Promise.resolve(property.callbacks[callbackName]({
+        ...propsContext,
+        value: currentValue,
+        previousValue
+      }));
+      if (cbRes !== void 0) {
+        currentValue = cbRes;
+      }
+    }
+    result[key] = currentValue;
+  }
+  return result;
+}
+const buildPropertyCallbacks = (properties) => {
+  if (!properties) return void 0;
+  const propertyCallbacks = {};
+  if (hasPropertyCallbacks(properties, "afterRead")) {
+    propertyCallbacks.afterRead = async (props) => {
+      const processedValues = await processProperties(properties, props.entity.values, props.entity.values, props, "afterRead");
+      return {
+        ...props.entity,
+        values: processedValues
+      };
+    };
+  }
+  if (hasPropertyCallbacks(properties, "beforeSave")) {
+    propertyCallbacks.beforeSave = async (props) => {
+      return await processProperties(properties, props.values, props.previousValues ?? {}, props, "beforeSave");
+    };
+  }
+  return Object.keys(propertyCallbacks).length > 0 ? propertyCallbacks : void 0;
+};
+function hashString(str) {
+  let hash2 = 0;
+  let i;
+  let chr;
+  for (i = 0; i < str.length; i++) {
+    chr = str.charCodeAt(i);
+    hash2 = (hash2 << 5) - hash2 + chr;
+    hash2 |= 0;
+  }
+  return Math.abs(hash2);
+}
+function generateForeignKeyName(name) {
+  const snakeCaseName = toSnakeCase(name);
+  const singularName = snakeCaseName.endsWith("s") ? snakeCaseName.slice(0, -1) : snakeCaseName;
+  return `${singularName}_id`;
+}
+function sanitizeRelation(relation, sourceCollection) {
+  if (!relation.target) {
+    throw new Error("Relation is missing a `target` collection.");
+  }
+  const targetCollection = relation.target();
+  const newRelation = {
+    ...relation
+  };
+  if (!newRelation.relationName) {
+    newRelation.relationName = toSnakeCase(targetCollection.slug ?? targetCollection.dbPath);
+  }
+  if (!newRelation.direction) {
+    if (newRelation.foreignKeyOnTarget) newRelation.direction = "inverse";
+    else if (newRelation.through) newRelation.direction = "owning";
+    else if (newRelation.cardinality === "many") newRelation.direction = "inverse";
+    else newRelation.direction = "owning";
+  }
+  if (!newRelation.joinPath) {
+    const sourceName = toSnakeCase(sourceCollection.slug ?? sourceCollection.name);
+    if (newRelation.cardinality === "one" && newRelation.direction === "owning") {
+      if (!newRelation.localKey) {
+        newRelation.localKey = generateForeignKeyName(newRelation.relationName);
+      }
+    } else if (newRelation.cardinality === "one" && newRelation.direction === "inverse") {
+      if (!newRelation.foreignKeyOnTarget) {
+        let foundForeignKey = false;
+        try {
+          const targetRelations = targetCollection.relations || [];
+          for (const targetRel of targetRelations) {
+            if (targetRel.direction === "owning" && targetRel.cardinality === "one" && targetRel.localKey) {
+              try {
+                const targetRelTarget = targetRel.target();
+                if (targetRelTarget.slug === sourceCollection.slug || targetRelTarget.dbPath === sourceCollection.dbPath) {
+                  newRelation.foreignKeyOnTarget = targetRel.localKey;
+                  foundForeignKey = true;
+                  break;
+                }
+              } catch (e) {
+                continue;
+              }
+            }
+          }
+        } catch (e) {
+        }
+        if (!foundForeignKey) {
+          const keyPrefix = newRelation.inverseRelationName ? toSnakeCase(newRelation.inverseRelationName) : sourceName;
+          newRelation.foreignKeyOnTarget = generateForeignKeyName(keyPrefix);
+        }
+      }
+    } else if (newRelation.cardinality === "many" && newRelation.direction === "inverse") {
+      let isManyToManyInverse = false;
+      if (newRelation.inverseRelationName && !newRelation.foreignKeyOnTarget) {
+        try {
+          const targetRelations = targetCollection.relations || [];
+          for (const targetRel of targetRelations) {
+            if (targetRel.cardinality === "many" && targetRel.direction === "owning" && targetRel.through && targetRel.relationName === newRelation.inverseRelationName) {
+              isManyToManyInverse = true;
+              break;
+            }
+          }
+        } catch (e) {
+        }
+      }
+      if (!isManyToManyInverse && !newRelation.foreignKeyOnTarget) {
+        newRelation.foreignKeyOnTarget = generateForeignKeyName(sourceName);
+      }
+    } else if (newRelation.cardinality === "many" && newRelation.direction === "owning") {
+      const sourceTableName = getTableName(sourceCollection);
+      const targetTableName = getTableName(targetCollection);
+      newRelation.through = {
+        table: newRelation.through?.table ?? [sourceTableName, targetTableName].sort().join("_"),
+        sourceColumn: newRelation.through?.sourceColumn ?? generateForeignKeyName(sourceName),
+        targetColumn: newRelation.through?.targetColumn ?? generateForeignKeyName(newRelation.relationName)
+      };
+    }
+  }
+  if (newRelation.cardinality === "one" && newRelation.direction === "owning" && !newRelation.localKey && !newRelation.joinPath) {
+    throw new Error(`Configuration Error in relation from '${sourceCollection.name}': An 'owning' one-to-one relation requires a 'localKey'. Check the relation config for '${newRelation.relationName}'`);
+  }
+  if (newRelation.cardinality === "one" && newRelation.direction === "inverse" && !newRelation.foreignKeyOnTarget && !newRelation.joinPath) {
+    throw new Error(`Configuration Error in relation from '${sourceCollection.name}': An 'inverse' one-to-one relation requires a 'foreignKeyOnTarget'. Check the relation config for '${newRelation.relationName}'`);
+  }
+  if (newRelation.cardinality === "many" && newRelation.direction === "inverse" && !newRelation.foreignKeyOnTarget && !newRelation.joinPath) {
+    throw new Error(`Configuration Error in relation from '${sourceCollection.name}': An 'inverse' one-to-many relation requires a 'foreignKeyOnTarget'. Check the relation config for '${newRelation.relationName}'`);
+  }
+  return newRelation;
+}
+function resolveCollectionRelations(collection) {
+  const relations = {};
+  if (collection.relations) {
+    collection.relations.forEach((relation) => {
+      const normalizedRelation = sanitizeRelation(relation, collection);
+      const relationKey = normalizedRelation.relationName;
+      if (relationKey) {
+        relations[relationKey] = normalizedRelation;
+      }
+    });
+  }
+  if (collection.properties) {
+    Object.entries(collection.properties).forEach(([propKey, prop]) => {
+      const relation = resolvePropertyRelation({
+        propertyKey: propKey,
+        property: prop,
+        sourceCollection: collection
+      });
+      if (relation) {
+        if (!relations[propKey]) {
+          if (!relation.relationName) {
+            relation.relationName = propKey;
+          }
+          relations[propKey] = sanitizeRelation(relation, collection);
+        }
+      }
+    });
+  }
+  return relations;
+}
+function resolvePropertyRelation({
+  propertyKey,
+  property,
+  sourceCollection
+}) {
+  if (property.type !== "relation") return void 0;
+  const relation = sourceCollection.relations?.find((rel) => rel.relationName === property.relationName);
+  if (!relation) {
+    console.warn(`Unrecognized relation format for property '${propertyKey}' in collection '${sourceCollection.slug || sourceCollection.dbPath}'`);
+    return void 0;
+  }
+  return relation;
+}
+function getTableName(collection) {
+  return collection.dbPath ?? toSnakeCase(collection.slug) ?? toSnakeCase(collection.name);
+}
+function getTableVarName(tableName) {
+  return tableName.replace(/_([a-z])/g, (_, char) => char.toUpperCase());
+}
+function getEnumVarName(tableName, propName) {
+  const tableVar = getTableVarName(tableName);
+  const propVar = propName.charAt(0).toUpperCase() + propName.slice(1);
+  return `${tableVar}${propVar}`;
+}
+function getColumnName(fullColumn) {
+  return fullColumn.includes(".") ? fullColumn.split(".").pop() : fullColumn;
+}
+function getIn(obj, path) {
+  if (!obj || !path) return void 0;
+  return path.split(".").reduce((acc, part) => acc && acc[part], obj);
+}
+let operationsRegistered = false;
+function registerConditionOperations() {
+  if (operationsRegistered) return;
+  jsonLogic.add_operation("hasRole", function(roleId) {
+    return this?.user?.roles?.includes(roleId) ?? false;
+  });
+  jsonLogic.add_operation("hasAnyRole", function(roleIds) {
+    if (!this?.user?.roles || !Array.isArray(roleIds)) return false;
+    return roleIds.some((role) => this.user.roles.includes(role));
+  });
+  jsonLogic.add_operation("isToday", (timestamp) => {
+    if (!timestamp) return false;
+    const date = new Date(timestamp);
+    const today = /* @__PURE__ */ new Date();
+    return date.getFullYear() === today.getFullYear() && date.getMonth() === today.getMonth() && date.getDate() === today.getDate();
+  });
+  jsonLogic.add_operation("isPast", (timestamp) => {
+    if (!timestamp) return false;
+    return timestamp < Date.now();
+  });
+  jsonLogic.add_operation("isFuture", (timestamp) => {
+    if (!timestamp) return false;
+    return timestamp > Date.now();
+  });
+  operationsRegistered = true;
+}
+function evaluateCondition(rule, context) {
+  registerConditionOperations();
+  return jsonLogic.apply(rule, context);
+}
+function serializeValueForConditions(value) {
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (value instanceof Date) {
+    return value.getTime();
+  }
+  if (typeof value?.toMillis === "function") {
+    return value.toMillis();
+  }
+  if (typeof value?.toDate === "function") {
+    return value.toDate().getTime();
+  }
+  if (Array.isArray(value)) {
+    return value.map(serializeValueForConditions);
+  }
+  if (typeof value === "object") {
+    const result = {};
+    for (const key of Object.keys(value)) {
+      result[key] = serializeValueForConditions(value[key]);
+    }
+    return result;
+  }
+  return value;
+}
+function buildConditionContext(params) {
+  const {
+    propertyKey,
+    values,
+    previousValues,
+    path,
+    entityId,
+    index,
+    authController
+  } = params;
+  const user = authController.user;
+  const serializedValues = serializeValueForConditions(values ?? {});
+  const serializedPreviousValues = serializeValueForConditions(previousValues ?? values ?? {});
+  return {
+    values: serializedValues,
+    previousValues: serializedPreviousValues,
+    propertyValue: propertyKey ? getIn(serializedValues, propertyKey) : void 0,
+    path,
+    entityId,
+    isNew: !entityId,
+    index,
+    user: {
+      uid: user?.uid ?? "",
+      email: user?.email ?? null,
+      displayName: user?.displayName ?? null,
+      photoURL: user?.photoURL ?? null,
+      roles: user?.roles ?? []
+    },
+    now: Date.now()
+  };
+}
+function applyPropertyConditions(property, context) {
+  const {
+    conditions
+  } = property;
+  if (!conditions) return property;
+  let result = {
+    ...property
+  };
+  if (conditions.disabled) {
+    const isDisabled = evaluateCondition(conditions.disabled, context);
+    if (isDisabled) {
+      result.disabled = {
+        clearOnDisabled: conditions.clearOnDisabled ?? false,
+        disabledMessage: conditions.disabledMessage,
+        hidden: false
+      };
+    }
+  }
+  if (conditions.hidden) {
+    const isHidden2 = evaluateCondition(conditions.hidden, context);
+    if (isHidden2) {
+      result.disabled = {
+        ...typeof result.disabled === "object" ? result.disabled : {},
+        hidden: true,
+        clearOnDisabled: conditions.clearOnDisabled ?? false
+      };
+    }
+  }
+  if (conditions.readOnly) {
+    const isReadOnly2 = evaluateCondition(conditions.readOnly, context);
+    if (isReadOnly2) {
+      result.readOnly = true;
+    }
+  }
+  if (conditions.required !== void 0) {
+    const isRequired = evaluateCondition(conditions.required, context);
+    result.validation = {
+      ...result.validation,
+      required: isRequired,
+      requiredMessage: conditions.requiredMessage
+    };
+  }
+  if (context.isNew && conditions.defaultValue !== void 0) {
+    result.defaultValue = evaluateCondition(conditions.defaultValue, context);
+  }
+  if ("enumValues" in result && result.enumValues && (conditions.enumConditions || conditions.allowedEnumValues || conditions.excludedEnumValues)) {
+    result.enumValues = applyEnumConditions(result.enumValues, conditions, context);
+  }
+  if (result.type === "reference") {
+    if (conditions.referencePath) {
+      result.path = evaluateCondition(conditions.referencePath, context);
+    }
+    if (conditions.referenceFilter) {
+      result.forceFilter = evaluateCondition(conditions.referenceFilter, context);
+    }
+  }
+  if (result.type === "array") {
+    if (conditions.canAddElements !== void 0) {
+      result.canAddElements = evaluateCondition(conditions.canAddElements, context);
+    }
+    if (conditions.sortable !== void 0) {
+      result.sortable = evaluateCondition(conditions.sortable, context);
+    }
+  }
+  return result;
+}
+function objectToArray(obj) {
+  if (Array.isArray(obj)) return obj.map(String);
+  if (obj && typeof obj === "object") {
+    const keys = Object.keys(obj);
+    if (keys.length > 0 && keys.every((k) => !isNaN(Number(k)))) {
+      return keys.sort((a, b) => Number(a) - Number(b)).map((k) => obj[k]).filter((v) => typeof v === "string" || typeof v === "number").map(String);
+    }
+  }
+  return [];
+}
+function applyEnumConditions(enumValues, conditions, context) {
+  let result = [...enumValues];
+  if (conditions.allowedEnumValues) {
+    const allowed = evaluateCondition(conditions.allowedEnumValues, context);
+    const allowedArray = objectToArray(allowed);
+    if (allowedArray.length > 0) {
+      result = result.filter((ev) => allowedArray.includes(String(ev.id)));
+    }
+  }
+  if (conditions.excludedEnumValues) {
+    const excluded = evaluateCondition(conditions.excludedEnumValues, context);
+    const excludedArray = objectToArray(excluded);
+    if (excludedArray.length > 0) {
+      result = result.filter((ev) => !excludedArray.includes(String(ev.id)));
+    }
+  }
+  if (conditions.enumConditions) {
+    result = result.map((ev) => {
+      const evConditions = conditions.enumConditions?.[ev.id];
+      if (!evConditions) return ev;
+      if (evConditions.hidden && evaluateCondition(evConditions.hidden, context)) {
+        return null;
+      }
+      if (evConditions.disabled && evaluateCondition(evConditions.disabled, context)) {
+        return {
+          ...ev,
+          disabled: true
+        };
+      }
+      return ev;
+    }).filter((ev) => ev !== null);
+  }
+  return result;
+}
+class CollectionRegistry {
+  // Normalized runtime layer (used by Data Grid / UI)
+  collectionsByDbPath = /* @__PURE__ */ new Map();
+  collectionsBySlug = /* @__PURE__ */ new Map();
+  rootCollections = [];
+  // Raw configuration layer (used by Collection Editor AST generator)
+  rawCollectionsByDbPath = /* @__PURE__ */ new Map();
+  rawCollectionsBySlug = /* @__PURE__ */ new Map();
+  rawRootCollections = [];
+  // Snapshot of raw input for idempotency check — compared BEFORE normalization
+  // to avoid the issue where normalization creates new objects that always fail equality.
+  lastRawInputSnapshot = null;
+  constructor(collections) {
+    if (collections) {
+      this.registerMultiple(collections);
+    }
+  }
+  reset() {
+    this.collectionsByDbPath.clear();
+    this.collectionsBySlug.clear();
+    this.rootCollections = [];
+    this.rawCollectionsByDbPath.clear();
+    this.rawCollectionsBySlug.clear();
+    this.rawRootCollections = [];
+  }
+  /**
+   * Registers a collection and its subcollections recursively.
+   * Returns true if the collections have changed, false otherwise.
+   *
+   * Idempotent: compares the raw input (before normalization) against a stored
+   * snapshot. Only re-normalizes and re-registers when the raw input actually changed.
+   * @param collections
+   */
+  registerMultiple(collections) {
+    const rawSnapshot = collections.map((c) => removeFunctions(c));
+    if (this.lastRawInputSnapshot && deepEqual(this.lastRawInputSnapshot, rawSnapshot)) {
+      return false;
+    }
+    this.reset();
+    const normalizedCollections = collections.map((c) => this.normalizeCollection({
+      ...c
+    }));
+    normalizedCollections.forEach((c, index) => this.register(c, collections[index]));
+    this.lastRawInputSnapshot = rawSnapshot;
+    return true;
+  }
+  register(collection, rawCollection) {
+    const raw = rawCollection ? cloneDeep(rawCollection) : cloneDeep(collection);
+    this.rootCollections.push(collection);
+    this.rawRootCollections.push(raw);
+    this._registerRecursively(collection, raw);
+  }
+  _registerRecursively(collection, rawCollection) {
+    if (this.collectionsByDbPath.has(collection.dbPath)) {
+      return;
+    }
+    const normalizedCollection = this.normalizeCollection(collection);
+    this.collectionsByDbPath.set(normalizedCollection.dbPath, normalizedCollection);
+    this.rawCollectionsByDbPath.set(rawCollection.dbPath, rawCollection);
+    if (normalizedCollection.slug) {
+      this.collectionsBySlug.set(normalizedCollection.slug, normalizedCollection);
+    }
+    if (rawCollection.slug) {
+      this.rawCollectionsBySlug.set(rawCollection.slug, rawCollection);
+    }
+    const subcollections = getSubcollections(collection);
+    const rawSubcollections = getSubcollections(rawCollection);
+    if (subcollections && rawSubcollections) {
+      subcollections.forEach((subCollection, index) => {
+        this._registerRecursively(this.normalizeCollection(subCollection), cloneDeep(rawSubcollections[index]));
+      });
+    }
+  }
+  normalizeCollection(collection) {
+    const properties = this.normalizeProperties(collection.properties, collection.relations ?? []);
+    collection.properties = properties;
+    return collection;
+  }
+  normalizeProperties(properties, relations) {
+    const newProperties = {};
+    for (const key in properties) {
+      newProperties[key] = this.normalizeProperty(properties[key], relations);
+    }
+    return newProperties;
+  }
+  normalizeProperty(property, relations) {
+    const newProperty = {
+      ...property
+    };
+    if (newProperty.type === "map" && newProperty.properties) {
+      newProperty.properties = this.normalizeProperties(newProperty.properties, relations);
+    } else if (newProperty.type === "array") {
+      if (newProperty.of) {
+        newProperty.of = this.normalizeProperty(newProperty.of, relations);
+      } else if (newProperty.oneOf && newProperty.oneOf.properties) {
+        newProperty.oneOf.properties = this.normalizeProperties(newProperty.oneOf.properties, relations);
+      }
+    } else if ((newProperty.type === "string" || newProperty.type === "number") && newProperty.enum) {
+      const stringOrNumberProperty = newProperty;
+      if (typeof stringOrNumberProperty.enum === "object" && !Array.isArray(stringOrNumberProperty.enum)) {
+        stringOrNumberProperty.enum = enumToObjectEntries(stringOrNumberProperty.enum)?.filter((value) => value && (value.id || value.id === 0) && value.label) ?? [];
+      }
+    } else if (newProperty.type === "relation") {
+      const relationProperty = newProperty;
+      const relation = relations.find((r) => r.relationName === relationProperty.relationName);
+      if (relation) {
+        relationProperty.relation = relation;
+      } else {
+        console.warn(`Could not find relation for property with relationName: ${relationProperty.relationName}`);
+      }
+    }
+    return newProperty;
+  }
+  get(path) {
+    const bySlug = this.collectionsBySlug.get(path);
+    if (bySlug) return bySlug;
+    return this.collectionsByDbPath.get(path);
+  }
+  /**
+   * Gets the pristine, un-normalized collection exactly as it was provided.
+   * Useful for the AST editor so it doesn't accidentally serialize injected metadata back to disk.
+   */
+  getRaw(path) {
+    const bySlug = this.rawCollectionsBySlug.get(path);
+    if (bySlug) return bySlug;
+    return this.rawCollectionsByDbPath.get(path);
+  }
+  /**
+   * Get collection by resolving multi-segment paths through relations
+   * e.g., "authors/70/posts" resolves to the posts collection
+   */
+  getCollectionByPath(collectionPath) {
+    if (!collectionPath.includes("/")) {
+      return this.get(collectionPath);
+    }
+    const pathSegments = collectionPath.split("/").filter((p) => p);
+    if (pathSegments.length < 3 || pathSegments.length % 2 === 0) {
+      throw new Error(`Invalid relation path: ${collectionPath}. Expected format: collection/id/relation or collection/id/relation/id/relation`);
+    }
+    const rootCollectionPath = pathSegments[0];
+    let currentCollection = this.get(rootCollectionPath);
+    if (!currentCollection) {
+      throw new Error(`Root collection not found: ${rootCollectionPath}`);
+    }
+    for (let i = 2; i < pathSegments.length; i += 2) {
+      const relationKey = pathSegments[i];
+      const resolvedRelations = resolveCollectionRelations(currentCollection);
+      const relation = resolvedRelations[relationKey];
+      if (!relation) {
+        throw new Error(`Relation '${relationKey}' not found in collection '${currentCollection.slug || currentCollection.dbPath}'`);
+      }
+      currentCollection = relation.target();
+      if (i + 1 < pathSegments.length) ;
+    }
+    return currentCollection;
+  }
+  getCollections() {
+    return Array.from(this.collectionsByDbPath.values());
+  }
+  getRawCollections() {
+    return Array.from(this.rawCollectionsByDbPath.values());
+  }
+  /**
+   * Resolves a multi-segment path like "products/123/locales" and returns
+   * information about the collections and entity IDs along the path
+   */
+  resolvePathToCollections(path) {
+    const pathSegments = path.split("/").filter((p) => p);
+    if (pathSegments.length === 0) {
+      throw new Error(`Invalid path: ${path}`);
+    }
+    if (pathSegments.length % 2 !== 1) {
+      throw new Error(`Invalid collection path: ${path}. It must have an odd number of segments.`);
+    }
+    const collections = [];
+    const entityIds = [];
+    let currentCollection = this.get(pathSegments[0]);
+    if (!currentCollection) {
+      throw new Error(`Unknown collection path or slug: ${pathSegments[0]}`);
+    }
+    collections.push(currentCollection);
+    for (let i = 1; i < pathSegments.length; i += 2) {
+      const entityId = pathSegments[i];
+      entityIds.push(entityId);
+      if (i + 1 < pathSegments.length) {
+        const subcollectionSlug = pathSegments[i + 1];
+        const subcollections = currentCollection.subcollections?.();
+        if (!subcollections) {
+          throw new Error(`No subcollections found for ${currentCollection.slug || currentCollection.dbPath} in path: ${path}`);
+        }
+        const subcollection = subcollections.find((c) => c.slug === subcollectionSlug);
+        if (!subcollection) {
+          throw new Error(`Subcollection '${subcollectionSlug}' not found in ${currentCollection.slug || currentCollection.dbPath}`);
+        }
+        currentCollection = subcollection;
+        collections.push(currentCollection);
+      }
+    }
+    return {
+      collections,
+      entityIds,
+      finalCollection: currentCollection
+    };
+  }
+}
+export {
+  COLLECTION_PATH_SEPARATOR,
+  CollectionRegistry,
+  DEFAULT_ONE_OF_TYPE,
+  DEFAULT_ONE_OF_VALUE,
+  addInitialSlash,
+  applyPropertyConditions,
+  buildAdditionalFieldDelegate,
+  buildCollection,
+  buildConditionContext,
+  buildEntityCallbacks,
+  buildEnum,
+  buildEnumValueConfig,
+  buildFieldConfig,
+  buildProperties,
+  buildPropertiesOrBuilder,
+  buildProperty,
+  buildPropertyCallbacks,
+  canCreateEntity,
+  canDeleteEntity,
+  canEditEntity,
+  canReadCollection,
+  clone,
+  defaultDateFormat,
+  enumToObjectEntries,
+  evaluateCondition,
+  flattenObject,
+  fullPathToCollectionSegments,
+  getArrayResolvedProperties,
+  getArrayValuesCount,
+  getCollectionBySlugWithin,
+  getCollectionPathsCombinations,
+  getColumnName,
+  getDefaultValueFor,
+  getDefaultValueFortype,
+  getDefaultValuesFor,
+  getEntityImagePreviewPropertyKey,
+  getEnumVarName,
+  getHashValue,
+  getIn$1 as getIn,
+  getLabelOrConfigFrom,
+  getLastSegment,
+  getLocalChangesBackup,
+  getNavigationEntriesFromPath,
+  getParentReferencesFromPath,
+  getPrimaryKeys,
+  getReferenceFrom,
+  getRelationFrom,
+  getSubcollections,
+  getTableName,
+  getTableVarName,
+  getValueInPath,
+  hashString,
+  hydrateRegExp,
+  isDefaultFieldConfigId,
+  isEmptyArray,
+  isEmptyObject,
+  isFunction,
+  isHidden,
+  isInteger,
+  isNaN$1 as isNaN,
+  isObject,
+  isPlainObject,
+  isPropertyBuilder,
+  isReadOnly,
+  isValidRegExp,
+  mergeDeep,
+  mergeEntityActions,
+  navigateToEntity,
+  pick,
+  plural,
+  prettifyIdentifier,
+  randomColor,
+  randomString,
+  registerConditionOperations,
+  removeFunctions,
+  removeInPath,
+  removeInitialAndTrailingSlashes,
+  removeInitialSlash,
+  removeNulls,
+  removePropsIfExisting,
+  removeTrailingSlash,
+  removeUndefined,
+  resolveArrayProperties,
+  resolveCollectionPathIds,
+  resolveCollectionRelations,
+  resolveDefaultSelectedView,
+  resolveEntityAction,
+  resolveEntityView$1 as resolveEntityView,
+  resolveEnumValues,
+  resolveProperties,
+  resolveProperty,
+  resolvePropertyEnum,
+  resolvePropertyRelation,
+  resolveRelationProperty,
+  resolveStorageFilenameString,
+  resolveStoragePathString,
+  resolvedSelectedEntityView,
+  sanitizeData,
+  sanitizeRelation,
+  segmentsToStrippedPath,
+  serializeRegExp,
+  setIn,
+  singular,
+  slugify,
+  sortProperties,
+  stripCollectionPath,
+  toArray,
+  toKebabCase,
+  toSnakeCase,
+  traverseValueProperty,
+  traverseValuesProperties,
+  unslugify,
+  updateDateAutoValues
+};
+//# sourceMappingURL=index.es.js.map