@firecms/schema_inference 3.0.0-canary.24 → 3.0.0-canary.241

package/dist/index.es.js

@@ -1,244 +1,489 @@
-import { unslugify as b, resolveEnumValues as T, mergeDeep as j } from "@firecms/core";
-import { DocumentReference as P } from "firebase/firestore";
-function y(r) {
-  if (!r)
-    return;
-  function e(i) {
-    return typeof i == "string" ? i : i instanceof P ? i.path : void 0;
-  }
-  const s = r.values.map((i) => e(i)).filter((i) => !!i).find((i) => i.includes("/"));
-  if (!s)
-    return;
-  const n = s.substr(0, s.lastIndexOf("/"));
-  return r.values.filter((i) => {
-    const a = e(i);
-    return a ? a.startsWith(n) : !1;
-  }).length > r.values.length / 3 * 2 ? n : void 0;
-}
-function d(r) {
-  if (!Array.isArray(r))
+function findCommonInitialStringInPath(valuesCount) {
+  if (!valuesCount) return void 0;
+  function getPath(value) {
+    if (typeof value === "string") return value;
+    else if (value?.type === "document" && value.path) return value.path;
+    else return void 0;
+  }
+  const strings = valuesCount.values.map((v) => getPath(v)).filter((v) => !!v);
+  const pathWithSlash = strings.find((s) => s.includes("/"));
+  if (!pathWithSlash)
+    return void 0;
+  const searchedPath = pathWithSlash.substr(0, pathWithSlash.lastIndexOf("/"));
+  const yep = valuesCount.values.filter((value) => {
+    const path = getPath(value);
+    if (!path) return false;
+    return path.startsWith(searchedPath);
+  }).length > valuesCount.values.length / 3 * 2;
+  return yep ? searchedPath : void 0;
+}
+function extractEnumFromValues(values) {
+  if (!Array.isArray(values)) {
     return [];
-  const e = r.map((t) => typeof t == "string" ? { id: t, label: b(t) } : null).filter(Boolean);
-  return e.sort((t, s) => t.label.localeCompare(s.label)), e;
+  }
+  const enumValues = values.map((value) => {
+    if (typeof value === "string") {
+      return { id: value, label: unslugify(value) };
+    } else
+      return null;
+  }).filter(Boolean);
+  enumValues.sort((a, b) => a.label.localeCompare(b.label));
+  return enumValues;
+}
+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.substr(1);
+    }).trim();
+  } else {
+    return slug.trim();
+  }
 }
-const I = [".jpg", ".png", ".webp", ".gif"], S = [".mp3", ".ogg", ".opus", ".aac"], M = [".avi", ".mp4"], x = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
-function C({
-  totalDocsCount: r,
-  valuesResult: 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 mergeDeep(target, source, ignoreUndefined = false) {
+  const targetIsObject = isObject(target);
+  const output = targetIsObject ? { ...target } : target;
+  if (targetIsObject && isObject(source)) {
+    Object.keys(source).forEach((key) => {
+      const sourceElement = source[key];
+      if (ignoreUndefined && sourceElement === void 0) {
+        return;
+      }
+      if (sourceElement instanceof Date) {
+        Object.assign(output, { [key]: new Date(sourceElement.getTime()) });
+      } else if (isObject(sourceElement)) {
+        if (!(key in target))
+          Object.assign(output, { [key]: sourceElement });
+        else
+          output[key] = mergeDeep(target[key], sourceElement);
+      } else {
+        Object.assign(output, { [key]: sourceElement });
+      }
+    });
+  }
+  return output;
+}
+function isObject(item) {
+  return item && typeof item === "object" && !Array.isArray(item);
+}
+const IMAGE_EXTENSIONS = [".jpg", ".jpeg", ".png", ".webp", ".gif", ".avif"];
+const AUDIO_EXTENSIONS = [".mp3", ".ogg", ".opus", ".aac"];
+const VIDEO_EXTENSIONS = [".avi", ".mp4"];
+const emailRegEx = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+function buildStringProperty({
+  totalDocsCount,
+  valuesResult
 }) {
-  let t = {
+  let stringProperty = {
     dataType: "string"
   };
-  if (e) {
-    const s = e.values.length, n = Array.from(e.valuesCount.keys()).length, o = {}, i = e.values.filter((f) => typeof f == "string" && f.toString().startsWith("http")).length > r / 3 * 2;
-    i && (o.url = !0);
-    const a = e.values.filter((f) => typeof f == "string" && x.test(f)).length > r / 3 * 2;
-    a && (o.email = !0);
-    const c = e.values.filter((f) => typeof f == "string" && f.length === 28 && !f.includes(" ")).length > r / 3 * 2;
-    if (c && (o.readOnly = !0), !a && !i && !c && !i && n < s / 3) {
-      const f = d(Array.from(e.valuesCount.keys()));
-      Object.keys(f).length > 1 && (o.enumValues = f);
-    }
-    if (!a && !i && !c && !i && !o.enumValues) {
-      const f = F(e, r);
-      f && (o.storage = {
-        acceptedFiles: [f],
-        storagePath: y(e) ?? "/"
-      });
+  if (valuesResult) {
+    const totalEntriesCount = valuesResult.values.length;
+    const totalValues = Array.from(valuesResult.valuesCount.keys()).length;
+    const config = {};
+    const probablyAURL = valuesResult.values.filter((value) => typeof value === "string" && value.toString().startsWith("http")).length > totalDocsCount / 3 * 2;
+    if (probablyAURL) {
+      config.url = true;
     }
-    Object.keys(o).length > 0 && (t = {
-      ...t,
-      ...o,
-      editable: !0
-    });
+    const probablyAnEmail = valuesResult.values.filter((value) => typeof value === "string" && emailRegEx.test(value)).length > totalDocsCount / 3 * 2;
+    if (probablyAnEmail) {
+      config.email = true;
+    }
+    const probablyUserIds = valuesResult.values.filter((value) => typeof value === "string" && value.length === 28 && !value.includes(" ")).length > totalDocsCount / 3 * 2;
+    if (probablyUserIds)
+      config.readOnly = true;
+    if (!probablyAnEmail && !probablyAURL && !probablyUserIds && !probablyAURL && totalValues < totalEntriesCount / 3) {
+      const enumValues = extractEnumFromValues(Array.from(valuesResult.valuesCount.keys()));
+      if (Object.keys(enumValues).length > 1)
+        config.enumValues = enumValues;
+    }
+    if (!probablyAnEmail && !probablyAURL && !probablyUserIds && !probablyAURL && !config.enumValues) {
+      const fileType = probableFileType(valuesResult, totalDocsCount);
+      if (fileType) {
+        config.storage = {
+          acceptedFiles: [fileType],
+          storagePath: findCommonInitialStringInPath(valuesResult) ?? "/"
+        };
+      }
+    }
+    if (Object.keys(config).length > 0)
+      stringProperty = {
+        ...stringProperty,
+        ...config,
+        editable: true
+      };
   }
-  return t;
+  return stringProperty;
 }
-function F(r, e) {
-  const t = r.values.filter((i) => typeof i == "string" && I.some((a) => i.toString().endsWith(a))).length > e / 3 * 2, s = r.values.filter((i) => typeof i == "string" && S.some((a) => i.toString().endsWith(a))).length > e / 3 * 2, n = r.values.filter((i) => typeof i == "string" && M.some((a) => i.toString().endsWith(a))).length > e / 3 * 2;
-  return t ? "image/*" : s ? "audio/*" : n ? "video/*" : !1;
+function probableFileType(valuesCount, totalDocsCount) {
+  const probablyAnImage = valuesCount.values.filter((value) => typeof value === "string" && IMAGE_EXTENSIONS.some((extension) => value.toString().endsWith(extension))).length > totalDocsCount / 3 * 2;
+  const probablyAudio = valuesCount.values.filter((value) => typeof value === "string" && AUDIO_EXTENSIONS.some((extension) => value.toString().endsWith(extension))).length > totalDocsCount / 3 * 2;
+  const probablyVideo = valuesCount.values.filter((value) => typeof value === "string" && VIDEO_EXTENSIONS.some((extension) => value.toString().endsWith(extension))).length > totalDocsCount / 3 * 2;
+  const fileType = probablyAnImage ? "image/*" : probablyAudio ? "audio/*" : probablyVideo ? "video/*" : false;
+  return fileType;
 }
-function V({
-  totalDocsCount: r,
-  valuesResult: e
+function buildValidation({
+  totalDocsCount,
+  valuesResult
 }) {
-  if (e) {
-    const t = e.values.length;
-    if (r === t)
+  if (valuesResult) {
+    const totalEntriesCount = valuesResult.values.length;
+    if (totalDocsCount === totalEntriesCount)
       return {
-        required: !0
+        required: true
       };
   }
+  return void 0;
 }
-function _({
-  totalDocsCount: r,
-  valuesResult: e
+function buildReferenceProperty({
+  totalDocsCount,
+  valuesResult
 }) {
-  return {
+  const property = {
     dataType: "reference",
-    path: y(e) ?? "!!!FIX_ME!!!",
-    editable: !0
+    path: findCommonInitialStringInPath(valuesResult) ?? "!!!FIX_ME!!!",
+    editable: true
   };
+  return property;
 }
-async function k(r, e) {
-  const t = {}, s = {};
-  return r && r.forEach((n) => {
-    n && Object.entries(n).forEach(([o, i]) => {
-      E(t, o, i, e), p(s, o, i, e);
+async function buildEntityPropertiesFromData(data, getType) {
+  const typesCount = {};
+  const valuesCount = {};
+  if (data) {
+    data.forEach((entry) => {
+      if (entry) {
+        Object.entries(entry).forEach(([key, value]) => {
+          if (key.startsWith("_")) return;
+          increaseMapTypeCount(typesCount, key, value, getType);
+          increaseValuesCount(valuesCount, key, value, getType);
+        });
+      }
     });
-  }), O(r.length, t, s);
+  }
+  return buildPropertiesFromCount(data.length, typesCount, valuesCount);
 }
-function w(r, e, t) {
-  const s = {}, n = {};
-  r && r.forEach((a) => {
-    l(e.dataType, s, a, t), p(n, "inferred_prop", a, t);
-  });
-  const o = "enumValues" in e ? T(e.enumValues) : void 0;
-  if (o) {
-    const a = d(Array.from(n.inferred_prop.valuesCount.keys()));
+function buildPropertyFromData(data, property, getType) {
+  const typesCount = {};
+  const valuesCount = {};
+  if (data) {
+    data.forEach((entry) => {
+      increaseTypeCount(property.dataType, typesCount, entry, getType);
+      increaseValuesCount(valuesCount, "inferred_prop", entry, getType);
+    });
+  }
+  const enumValues = "enumValues" in property ? resolveEnumValues(property["enumValues"]) : void 0;
+  if (enumValues) {
+    const newEnumValues = extractEnumFromValues(Array.from(valuesCount["inferred_prop"].valuesCount.keys()));
     return {
-      ...e,
-      enumValues: [...a, ...o]
+      ...property,
+      enumValues: [...newEnumValues, ...enumValues]
     };
   }
-  const i = g("inferred_prop", r.length, e.dataType, s, n.inferred_prop);
-  return j(i, e);
+  const generatedProperty = buildPropertyFromCount(
+    "inferred_prop",
+    data.length,
+    property.dataType,
+    typesCount,
+    valuesCount["inferred_prop"]
+  );
+  return mergeDeep(generatedProperty, property);
 }
-function U(r) {
-  function e(s) {
-    const n = s.toLowerCase();
-    return n === "title" || n === "name" ? 3 : n.includes("title") || n.includes("name") ? 2 : n.includes("image") || n.includes("picture") ? 1 : 0;
+function buildPropertiesOrder(properties, propertiesOrder, priorityKeys) {
+  const lowerCasePriorityKeys = (priorityKeys ?? []).map((key) => key.toLowerCase());
+  function propOrder(s) {
+    const k = s.toLowerCase();
+    if (lowerCasePriorityKeys.includes(k)) return 4;
+    if (k === "title" || k === "name") return 3;
+    if (k.includes("title") || k.includes("name")) return 2;
+    if (k.includes("image") || k.includes("picture")) return 1;
+    return 0;
   }
-  const t = Object.keys(r);
-  return t.sort(), t.sort((s, n) => e(n) - e(s)), t;
+  const keys = propertiesOrder ?? Object.keys(properties);
+  keys.sort();
+  keys.sort((a, b) => {
+    return propOrder(b) - propOrder(a);
+  });
+  return keys;
 }
-function l(r, e, t, s) {
-  if (r === "map") {
-    if (t) {
-      let n = e[r];
-      n || (n = {}, e[r] = n), Object.entries(t).forEach(([o, i]) => {
-        E(n, o, i, s);
+function increaseTypeCount(type, typesCount, fieldValue, getType) {
+  if (type === "map") {
+    if (fieldValue) {
+      let mapTypesCount = typesCount[type];
+      if (!mapTypesCount) {
+        mapTypesCount = {};
+        typesCount[type] = mapTypesCount;
+      }
+      Object.entries(fieldValue).forEach(([key, value]) => {
+        increaseMapTypeCount(mapTypesCount, key, value, getType);
       });
     }
-  } else if (r === "array") {
-    let n = e[r];
-    if (n || (n = {}, e[r] = n), t && Array.isArray(t) && t.length > 0) {
-      const o = z(t, s);
-      n[o] ? n[o]++ : n[o] = 1;
-    }
-  } else
-    e[r] ? e[r]++ : e[r] = 1;
-}
-function E(r, e, t, s) {
-  let n = r[e];
-  if (n || (n = {}, r[e] = n), t != null) {
-    const o = s(t);
-    l(o, n, t, s);
-  }
-}
-function p(r, e, t, s) {
-  const n = s(t);
-  let o = r[e];
-  if (o || (o = {
-    values: [],
-    valuesCount: /* @__PURE__ */ new Map()
-  }, r[e] = o), n === "map") {
-    let i = o.map;
-    i || (i = {}, o.map = i), t && Object.entries(t).forEach(([a, c]) => p(i, a, c, s));
-  } else
-    n === "array" ? Array.isArray(t) && t.forEach((i) => {
-      o.values.push(i), o.valuesCount.set(i, (o.valuesCount.get(i) ?? 0) + 1);
-    }) : t && (o.values.push(t), o.valuesCount.set(t, (o.valuesCount.get(t) ?? 0) + 1));
-}
-function m(r) {
-  let e = 0;
-  return Object.entries(r).forEach(([t, s]) => {
-    let n = 0;
-    t === "map" ? n = A(s) : t === "array" ? n = m(s) : n = s, n > e && (e = n);
-  }), e;
-}
-function A(r) {
-  return Object.entries(r).map(([e, t]) => m(t)).reduce((e, t) => Math.max(e, t), 0);
-}
-function h(r) {
-  let e = -1, t = "string";
-  return Object.entries(r).forEach(([s, n]) => {
-    let o;
-    s === "map" ? o = A(n) : s === "array" ? o = m(n) : o = n, o > e && (e = o, t = s);
-  }), t;
-}
-function g(r, e, t, s, n) {
-  let o;
-  r && (o = b(r));
-  let i;
-  if (t === "map") {
-    W(s) && (i = {
-      dataType: "map",
-      name: o,
-      keyValue: !0,
-      properties: {}
-    });
-    const c = O(e, s.map, n ? n.mapValues : void 0);
-    i = {
+  } else if (type === "array") {
+    let arrayTypesCount = typesCount[type];
+    if (!arrayTypesCount) {
+      arrayTypesCount = {};
+      typesCount[type] = arrayTypesCount;
+    }
+    if (fieldValue && Array.isArray(fieldValue) && fieldValue.length > 0) {
+      const arrayType = getMostProbableTypeInArray(fieldValue, getType);
+      if (arrayType === "map") {
+        let mapTypesCount = arrayTypesCount[arrayType];
+        if (!mapTypesCount) {
+          mapTypesCount = {};
+        }
+        fieldValue.forEach((value) => {
+          if (value && typeof value === "object" && !Array.isArray(value)) {
+            Object.entries(value).forEach(
+              ([key, v]) => increaseMapTypeCount(mapTypesCount, key, v, getType)
+            );
+          }
+        });
+        arrayTypesCount[arrayType] = mapTypesCount;
+      } else {
+        if (!arrayTypesCount[arrayType]) arrayTypesCount[arrayType] = 1;
+        else arrayTypesCount[arrayType]++;
+      }
+    }
+  } else {
+    if (!typesCount[type]) typesCount[type] = 1;
+    else typesCount[type]++;
+  }
+}
+function increaseMapTypeCount(typesCountRecord, key, fieldValue, getType) {
+  if (key.startsWith("_")) return;
+  let typesCount = typesCountRecord[key];
+  if (!typesCount) {
+    typesCount = {};
+    typesCountRecord[key] = typesCount;
+  }
+  if (fieldValue != null) {
+    const type = getType(fieldValue);
+    increaseTypeCount(type, typesCount, fieldValue, getType);
+  }
+}
+function increaseValuesCount(typeValuesRecord, key, fieldValue, getType) {
+  if (key.startsWith("_")) return;
+  const dataType = getType(fieldValue);
+  let valuesRecord = typeValuesRecord[key];
+  if (!valuesRecord) {
+    valuesRecord = {
+      values: [],
+      valuesCount: /* @__PURE__ */ new Map()
+    };
+    typeValuesRecord[key] = valuesRecord;
+  }
+  if (dataType === "map") {
+    let mapValuesRecord = valuesRecord.map;
+    if (!mapValuesRecord) {
+      mapValuesRecord = {};
+      valuesRecord.map = mapValuesRecord;
+    }
+    if (fieldValue)
+      Object.entries(fieldValue).forEach(
+        ([subKey, value]) => increaseValuesCount(mapValuesRecord, subKey, value, getType)
+      );
+  } else if (dataType === "array") {
+    if (Array.isArray(fieldValue)) {
+      fieldValue.forEach((value) => {
+        valuesRecord.values.push(value);
+        valuesRecord.valuesCount.set(value, (valuesRecord.valuesCount.get(value) ?? 0) + 1);
+      });
+    }
+  } else {
+    if (fieldValue !== null && fieldValue !== void 0) {
+      valuesRecord.values.push(fieldValue);
+      valuesRecord.valuesCount.set(fieldValue, (valuesRecord.valuesCount.get(fieldValue) ?? 0) + 1);
+    }
+  }
+}
+function getHighestTypesCount(typesCount) {
+  let highestCount = 0;
+  Object.entries(typesCount).forEach(([type, count]) => {
+    let countValue = 0;
+    if (type === "map") {
+      countValue = getHighestRecordCount(count);
+    } else if (type === "array") {
+      countValue = getHighestTypesCount(count);
+    } else {
+      countValue = count;
+    }
+    if (countValue > highestCount) {
+      highestCount = countValue;
+    }
+  });
+  return highestCount;
+}
+function getHighestRecordCount(record) {
+  return Object.entries(record).map(([key, typesCount]) => getHighestTypesCount(typesCount)).reduce((a, b) => Math.max(a, b), 0);
+}
+function getMostProbableType(typesCount) {
+  let highestCount = -1;
+  let probableType = "string";
+  Object.entries(typesCount).forEach(([type, count]) => {
+    let countValue;
+    if (type === "map") {
+      countValue = getHighestRecordCount(count);
+    } else if (type === "array") {
+      countValue = getHighestTypesCount(count);
+    } else {
+      countValue = count;
+    }
+    if (countValue > highestCount) {
+      highestCount = countValue;
+      probableType = type;
+    }
+  });
+  return probableType;
+}
+function buildPropertyFromCount(key, totalDocsCount, mostProbableType, typesCount, valuesResult) {
+  let title;
+  if (key) {
+    title = formatString(key.toLowerCase());
+  }
+  let result = void 0;
+  if (mostProbableType === "map") {
+    const highVariability = checkTypesCountHighVariability(typesCount);
+    if (highVariability) {
+      result = {
+        dataType: "map",
+        name: title,
+        keyValue: true,
+        properties: {}
+      };
+    }
+    const properties = buildPropertiesFromCount(
+      totalDocsCount,
+      typesCount.map,
+      valuesResult ? valuesResult.mapValues : void 0
+    );
+    result = {
       dataType: "map",
-      name: o,
-      properties: c
+      name: title,
+      properties
     };
-  } else if (t === "array") {
-    const a = s.array, c = h(a), f = g(r, e, c, a, n);
-    i = {
+  } else if (mostProbableType === "array") {
+    const arrayTypesCount = typesCount.array;
+    const arrayMostProbableType = getMostProbableType(arrayTypesCount);
+    const of = buildPropertyFromCount(
+      key,
+      totalDocsCount,
+      arrayMostProbableType,
+      arrayTypesCount,
+      valuesResult
+    );
+    result = {
       dataType: "array",
-      name: o,
-      of: f
+      name: title,
+      of
     };
   }
-  if (!i) {
-    const a = {
-      name: r,
-      totalDocsCount: e,
-      valuesResult: n
+  if (!result) {
+    const propertyProps = {
+      name: key,
+      totalDocsCount,
+      valuesResult
     };
-    t === "string" ? i = C(a) : t === "reference" ? i = _(a) : i = {
-      dataType: t
-    }, o && (i.name = o);
-    const c = V(a);
-    c && (i.validation = c);
+    if (mostProbableType === "string") {
+      result = buildStringProperty(propertyProps);
+    } else if (mostProbableType === "reference") {
+      result = buildReferenceProperty(propertyProps);
+    } else {
+      result = {
+        dataType: mostProbableType
+      };
+    }
+    if (title) {
+      result.name = title;
+    }
+    const validation = buildValidation(propertyProps);
+    if (validation) {
+      result.validation = validation;
+    }
   }
   return {
-    ...i,
-    editable: !0
+    ...result,
+    editable: true
   };
 }
-function O(r, e, t) {
-  const s = {};
-  return Object.entries(e).forEach(([n, o]) => {
-    const i = h(o);
-    s[n] = g(n, r, i, o, t ? t[n] : void 0);
-  }), s;
-}
-function u(r) {
-  let e = 0;
-  return Object.entries(r).forEach(([t, s]) => {
-    typeof s == "object" ? e = Math.max(e, u(s)) : e = Math.max(e, s);
-  }), e;
-}
-function z(r, e) {
-  let t = {};
-  return r.forEach((s) => {
-    l(e(s), t, s, e);
-  }), h(t);
-}
-function W(r) {
-  const e = u(r);
-  let t = 0;
-  return Object.entries(r.map ?? {}).forEach(([s, n]) => {
-    u(n) < e / 3 && t++;
-  }), t / Object.entries(r.map ?? {}).length > 0.5;
+function buildPropertiesFromCount(totalDocsCount, typesCountRecord, valuesCountRecord) {
+  const res = {};
+  Object.entries(typesCountRecord).forEach(([key, typesCount]) => {
+    const mostProbableType = getMostProbableType(typesCount);
+    res[key] = buildPropertyFromCount(
+      key,
+      totalDocsCount,
+      mostProbableType,
+      typesCount,
+      valuesCountRecord ? valuesCountRecord[key] : void 0
+    );
+  });
+  return res;
+}
+function countMaxDocumentsUnder(typesCount) {
+  let count = 0;
+  Object.entries(typesCount).forEach(([type, value]) => {
+    if (typeof value === "object") {
+      count = Math.max(count, countMaxDocumentsUnder(value));
+    } else {
+      count = Math.max(count, value);
+    }
+  });
+  return count;
+}
+function getMostProbableTypeInArray(array, getType) {
+  const typesCount = {};
+  array.forEach((value) => {
+    increaseTypeCount(getType(value), typesCount, value, getType);
+  });
+  return getMostProbableType(typesCount);
+}
+function checkTypesCountHighVariability(typesCount) {
+  const maxCount = countMaxDocumentsUnder(typesCount);
+  let keysWithFewValues = 0;
+  Object.entries(typesCount.map ?? {}).forEach(([key, value]) => {
+    const count = countMaxDocumentsUnder(value);
+    if (count < maxCount / 3) {
+      keysWithFewValues++;
+    }
+  });
+  return keysWithFewValues / Object.entries(typesCount.map ?? {}).length > 0.5;
+}
+function formatString(input) {
+  const normalized = input.replace(/[_-]+/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase();
+  const words = normalized.split(" ");
+  const formatted = words.map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+  return formatted;
+}
+function inferTypeFromValue(value) {
+  if (value === null || value === void 0) return "string";
+  if (typeof value === "string") return "string";
+  if (typeof value === "number") return "number";
+  if (typeof value === "boolean") return "boolean";
+  if (Array.isArray(value)) return "array";
+  if (typeof value === "object") return "map";
+  return "string";
 }
 export {
-  k as buildEntityPropertiesFromData,
-  U as buildPropertiesOrder,
-  w as buildPropertyFromData,
-  d as extractEnumFromValues
+  buildEntityPropertiesFromData,
+  buildPropertiesOrder,
+  buildPropertyFromData,
+  extractEnumFromValues,
+  inferTypeFromValue,
+  isObject,
+  mergeDeep,
+  resolveEnumValues,
+  unslugify
 };
 //# sourceMappingURL=index.es.js.map