@firecms/schema_inference 3.0.0-beta.7 → 3.0.0-beta.9

package/dist/index.es.js

@@ -1,284 +1,432 @@
-import { unslugify as O, resolveEnumValues as T, mergeDeep as j } from "@firecms/core";
-import { DocumentReference as C } from "@firebase/firestore";
-function b(r) {
-  if (!r)
-    return;
-  function e(n) {
-    return typeof n == "string" ? n : n instanceof C ? n.path : void 0;
+import { unslugify, resolveEnumValues, mergeDeep } from "@firecms/core";
+import { DocumentReference } from "@firebase/firestore";
+function findCommonInitialStringInPath(valuesCount) {
+  if (!valuesCount) return void 0;
+  function getPath(value) {
+    if (typeof value === "string") return value;
+    else if (value instanceof DocumentReference) return value.path;
+    else return void 0;
   }
-  const s = r.values.map((n) => e(n)).filter((n) => !!n).find((n) => n.includes("/"));
-  if (!s)
-    return;
-  const i = s.substr(0, s.lastIndexOf("/"));
-  return r.values.filter((n) => {
-    const a = e(n);
-    return a ? a.startsWith(i) : !1;
-  }).length > r.values.length / 3 * 2 ? i : 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 d(r) {
-  if (!Array.isArray(r))
+function extractEnumFromValues(values) {
+  if (!Array.isArray(values)) {
     return [];
-  const e = r.map((t) => typeof t == "string" ? { id: t, label: O(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;
 }
-const P = [".jpg", ".jpeg", ".png", ".webp", ".gif", ".avif"], S = [".mp3", ".ogg", ".opus", ".aac"], I = [".avi", ".mp4"], M = /^[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 w({
-  totalDocsCount: r,
-  valuesResult: e
+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, i = Array.from(e.valuesCount.keys()).length, o = {}, n = e.values.filter((f) => typeof f == "string" && f.toString().startsWith("http")).length > r / 3 * 2;
-    n && (o.url = !0);
-    const a = e.values.filter((f) => typeof f == "string" && M.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 && !n && !c && !n && i < s / 3) {
-      const f = d(Array.from(e.valuesCount.keys()));
-      Object.keys(f).length > 1 && (o.enumValues = f);
+  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;
     }
-    if (!a && !n && !c && !n && !o.enumValues) {
-      const f = z(e, r);
-      f && (o.storage = {
-        acceptedFiles: [f],
-        storagePath: b(e) ?? "/"
-      });
+    const probablyAnEmail = valuesResult.values.filter((value) => typeof value === "string" && emailRegEx.test(value)).length > totalDocsCount / 3 * 2;
+    if (probablyAnEmail) {
+      config.email = true;
     }
-    Object.keys(o).length > 0 && (t = {
-      ...t,
-      ...o,
-      editable: !0
-    });
+    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 z(r, e) {
-  const t = r.values.filter((n) => typeof n == "string" && P.some((a) => n.toString().endsWith(a))).length > e / 3 * 2, s = r.values.filter((n) => typeof n == "string" && S.some((a) => n.toString().endsWith(a))).length > e / 3 * 2, i = r.values.filter((n) => typeof n == "string" && I.some((a) => n.toString().endsWith(a))).length > e / 3 * 2;
-  return t ? "image/*" : s ? "audio/*" : i ? "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 F({
-  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: b(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((i) => {
-    i && Object.entries(i).forEach(([o, n]) => {
-      u(t, o, n, e), m(s, o, n, e);
+async function buildEntityPropertiesFromData(data, getType) {
+  const typesCount = {};
+  const valuesCount = {};
+  if (data) {
+    data.forEach((entry) => {
+      if (entry) {
+        Object.entries(entry).forEach(([key, value]) => {
+          increaseMapTypeCount(typesCount, key, value, getType);
+          increaseValuesCount(valuesCount, key, value, getType);
+        });
+      }
     });
-  }), A(r.length, t, s);
+  }
+  return buildPropertiesFromCount(data.length, typesCount, valuesCount);
 }
-function L(r, e, t) {
-  const s = {}, i = {};
-  r && r.forEach((a) => {
-    p(e.dataType, s, a, t), m(i, "inferred_prop", a, t);
-  });
-  const o = "enumValues" in e ? T(e.enumValues) : void 0;
-  if (o) {
-    const a = d(Array.from(i.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 n = y(
+  const generatedProperty = buildPropertyFromCount(
     "inferred_prop",
-    r.length,
-    e.dataType,
-    s,
-    i.inferred_prop
+    data.length,
+    property.dataType,
+    typesCount,
+    valuesCount["inferred_prop"]
   );
-  return j(n, e);
+  return mergeDeep(generatedProperty, property);
 }
-function U(r, e, t) {
-  const s = (t ?? []).map((n) => n.toLowerCase());
-  function i(n) {
-    const a = n.toLowerCase();
-    return s.includes(a) ? 4 : a === "title" || a === "name" ? 3 : a.includes("title") || a.includes("name") ? 2 : a.includes("image") || a.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 o = e ?? Object.keys(r);
-  return o.sort(), o.sort((n, a) => i(a) - i(n)), o;
+  const keys = propertiesOrder ?? Object.keys(properties);
+  keys.sort();
+  keys.sort((a, b) => {
+    return propOrder(b) - propOrder(a);
+  });
+  return keys;
 }
-function p(r, e, t, s) {
-  if (r === "map") {
-    if (t) {
-      let i = e[r];
-      i || (i = {}, e[r] = i), Object.entries(t).forEach(([o, n]) => {
-        u(i, o, n, 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 i = e[r];
-    if (i || (i = {}, e[r] = i), t && Array.isArray(t) && t.length > 0) {
-      const o = x(t, s);
-      if (o === "map") {
-        let n = i[o];
-        n || (n = {}), t.forEach((a) => {
-          Object.entries(a).forEach(
-            ([c, f]) => u(n, c, f, s)
+  } 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) => {
+          Object.entries(value).forEach(
+            ([key, v]) => increaseMapTypeCount(mapTypesCount, key, v, getType)
           );
-        }), i[o] = n;
-      } else
-        i[o] ? i[o]++ : i[o] = 1;
+        });
+        arrayTypesCount[arrayType] = mapTypesCount;
+      } else {
+        if (!arrayTypesCount[arrayType]) arrayTypesCount[arrayType] = 1;
+        else arrayTypesCount[arrayType]++;
+      }
     }
-  } else
-    e[r] ? e[r]++ : e[r] = 1;
+  } else {
+    if (!typesCount[type]) typesCount[type] = 1;
+    else typesCount[type]++;
+  }
 }
-function u(r, e, t, s) {
-  let i = r[e];
-  if (i || (i = {}, r[e] = i), t != null) {
-    const o = s(t);
-    p(o, i, t, s);
+function increaseMapTypeCount(typesCountRecord, key, fieldValue, getType) {
+  let typesCount = typesCountRecord[key];
+  if (!typesCount) {
+    typesCount = {};
+    typesCountRecord[key] = typesCount;
+  }
+  if (fieldValue != null) {
+    const type = getType(fieldValue);
+    increaseTypeCount(type, typesCount, fieldValue, getType);
   }
 }
-function m(r, e, t, s) {
-  const i = s(t);
-  let o = r[e];
-  if (o || (o = {
-    values: [],
-    valuesCount: /* @__PURE__ */ new Map()
-  }, r[e] = o), i === "map") {
-    let n = o.map;
-    n || (n = {}, o.map = n), t && Object.entries(t).forEach(
-      ([a, c]) => m(n, a, c, s)
-    );
-  } else
-    i === "array" ? Array.isArray(t) && t.forEach((n) => {
-      o.values.push(n), o.valuesCount.set(n, (o.valuesCount.get(n) ?? 0) + 1);
-    }) : t && (o.values.push(t), o.valuesCount.set(t, (o.valuesCount.get(t) ?? 0) + 1));
+function increaseValuesCount(typeValuesRecord, key, fieldValue, getType) {
+  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(
+        ([key2, value]) => increaseValuesCount(mapValuesRecord, key2, 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) {
+      valuesRecord.values.push(fieldValue);
+      valuesRecord.valuesCount.set(fieldValue, (valuesRecord.valuesCount.get(fieldValue) ?? 0) + 1);
+    }
+  }
 }
-function h(r) {
-  let e = 0;
-  return Object.entries(r).forEach(([t, s]) => {
-    let i = 0;
-    t === "map" ? i = E(s) : t === "array" ? i = h(s) : i = s, i > e && (e = i);
-  }), e;
+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 E(r) {
-  return Object.entries(r).map(([e, t]) => h(t)).reduce((e, t) => Math.max(e, t), 0);
+function getHighestRecordCount(record) {
+  return Object.entries(record).map(([key, typesCount]) => getHighestTypesCount(typesCount)).reduce((a, b) => Math.max(a, b), 0);
 }
-function g(r) {
-  let e = -1, t = "string";
-  return Object.entries(r).forEach(([s, i]) => {
-    let o;
-    s === "map" ? o = E(i) : s === "array" ? o = h(i) : o = i, o > e && (e = o, t = s);
-  }), t;
+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 y(r, e, t, s, i) {
-  let o;
-  r && (o = Z(r.toLowerCase()));
-  let n;
-  if (t === "map") {
-    V(s) && (n = {
-      dataType: "map",
-      name: o,
-      keyValue: !0,
-      properties: {}
-    });
-    const c = A(
-      e,
-      s.map,
-      i ? i.mapValues : void 0
+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
     );
-    n = {
+    result = {
       dataType: "map",
-      name: o,
-      properties: c
+      name: title,
+      properties
     };
-  } else if (t === "array") {
-    const a = s.array, c = g(a), f = y(
-      r,
-      e,
-      c,
-      a,
-      i
+  } else if (mostProbableType === "array") {
+    const arrayTypesCount = typesCount.array;
+    const arrayMostProbableType = getMostProbableType(arrayTypesCount);
+    const of = buildPropertyFromCount(
+      key,
+      totalDocsCount,
+      arrayMostProbableType,
+      arrayTypesCount,
+      valuesResult
     );
-    n = {
+    result = {
       dataType: "array",
-      name: o,
-      of: f
+      name: title,
+      of
     };
   }
-  if (!n) {
-    const a = {
-      name: r,
-      totalDocsCount: e,
-      valuesResult: i
+  if (!result) {
+    const propertyProps = {
+      name: key,
+      totalDocsCount,
+      valuesResult
     };
-    t === "string" ? n = w(a) : t === "reference" ? n = _(a) : n = {
-      dataType: t
-    }, o && (n.name = o);
-    const c = F(a);
-    c && (n.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 {
-    ...n,
-    editable: !0
+    ...result,
+    editable: true
   };
 }
-function A(r, e, t) {
-  const s = {};
-  return Object.entries(e).forEach(([i, o]) => {
-    const n = g(o);
-    s[i] = y(
-      i,
-      r,
-      n,
-      o,
-      t ? t[i] : void 0
+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
     );
-  }), s;
+  });
+  return res;
 }
-function l(r) {
-  let e = 0;
-  return Object.entries(r).forEach(([t, s]) => {
-    typeof s == "object" ? e = Math.max(e, l(s)) : e = Math.max(e, s);
-  }), e;
+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 x(r, e) {
-  let t = {};
-  return r.forEach((s) => {
-    p(e(s), t, s, e);
-  }), g(t);
+function getMostProbableTypeInArray(array, getType) {
+  let typesCount = {};
+  array.forEach((value) => {
+    increaseTypeCount(getType(value), typesCount, value, getType);
+  });
+  return getMostProbableType(typesCount);
 }
-function V(r) {
-  const e = l(r);
-  let t = 0;
-  return Object.entries(r.map ?? {}).forEach(([s, i]) => {
-    l(i) < e / 3 && t++;
-  }), t / Object.entries(r.map ?? {}).length > 0.5;
+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 Z(r) {
-  return r.replace(/[_\-]+/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase().split(" ").map((i) => i.charAt(0).toUpperCase() + i.slice(1)).join(" ");
+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 X(r) {
-  return typeof r == "string" ? "string" : typeof r == "number" ? "number" : typeof r == "boolean" ? "boolean" : Array.isArray(r) ? "array" : typeof r == "object" ? "map" : "string";
+function inferTypeFromValue(value) {
+  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,
-  L as buildPropertyFromData,
-  d as extractEnumFromValues,
-  X as inferTypeFromValue
+  buildEntityPropertiesFromData,
+  buildPropertiesOrder,
+  buildPropertyFromData,
+  extractEnumFromValues,
+  inferTypeFromValue
 };
 //# sourceMappingURL=index.es.js.map