@rebasepro/schema-inference 0.5.0 → 0.6.0

package/dist/index.umd.cjs

@@ -1,541 +1,470 @@
 (function(global, factory) {
-  typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("@rebasepro/utils"), require("@rebasepro/types")) : typeof define === "function" && define.amd ? define(["exports", "@rebasepro/utils", "@rebasepro/types"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global["Rebase schema inference"] = {}, global.utils, global.types));
-})(this, (function(exports2, utils, types) {
-  "use strict";
-  function parseReferenceString(value) {
-    if (!value) return null;
-    let database = void 0;
-    let fullPath = value;
-    if (value.includes(":::")) {
-      const [dbName, pathPart] = value.split(":::");
-      if (dbName && dbName !== "(default)") {
-        database = dbName;
-      }
-      fullPath = pathPart;
-    }
-    if (!fullPath || !fullPath.includes("/")) {
-      return null;
-    }
-    const path = fullPath.substring(0, fullPath.lastIndexOf("/"));
-    return {
-      path,
-      database
-    };
-  }
-  function looksLikeReference(value) {
-    if (typeof value !== "string") return false;
-    return parseReferenceString(value) !== null;
-  }
-  function findCommonInitialStringInPath(valuesCount) {
-    if (!valuesCount) return void 0;
-    function getPath(value) {
-      let pathString;
-      if (typeof value === "string") {
-        pathString = value;
-      } else if (value && typeof value === "object" && "slug" in value && typeof value.slug === "string") {
-        pathString = value.slug;
-      } else {
-        console.warn("findCommonInitialStringInPath: value is not a string or document with path", value);
-        return void 0;
-      }
-      if (!pathString) return void 0;
-      if (pathString.includes(":::")) {
-        const [, pathPart] = pathString.split(":::");
-        pathString = pathPart;
-      }
-      return pathString;
-    }
-    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.substring(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 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 extractEnumFromValues(values) {
-    if (!Array.isArray(values)) {
-      return [];
-    }
-    const enumValues = values.map((value) => {
-      if (typeof value === "string") {
-        return {
-          id: value,
-          label: utils.unslugify(value)
-        };
-      } else
-        return null;
-    }).filter(Boolean);
-    enumValues.sort((a, b) => a.label.localeCompare(b.label));
-    return enumValues;
-  }
-  function resolveEnumValues(input) {
-    if (Array.isArray(input)) {
-      return input;
-    } else if (typeof input === "object" && input !== null) {
-      return Object.entries(input).map(([id, value]) => typeof value === "string" ? {
-        id,
-        label: value
-      } : value);
-    } else {
-      return void 0;
-    }
-  }
-  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({
-    name,
-    totalDocsCount,
-    valuesResult
-  }) {
-    let stringProperty = {
-      name: name ?? "",
-      type: "string"
-    };
-    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.ui = { url: true };
-      }
-      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.ui = { ...config.ui, 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.enum = enumValues;
-      }
-      if (!probablyAnEmail && !probablyAURL && !probablyUserIds && !probablyAURL && !config.enum) {
-        const fileType = probableFileType(valuesResult, totalDocsCount);
-        if (fileType) {
-          config.storage = {
-            acceptedFiles: fileType,
-            storagePath: findCommonInitialStringInPath(valuesResult) ?? "/"
-          };
-        }
-      }
-      if (Object.keys(config).length > 0)
-        stringProperty = {
-          ...stringProperty,
-          ...config
-        };
-    }
-    return stringProperty;
-  }
-  function probableFileType(valuesCount, totalDocsCount) {
-    const isImage = (value) => IMAGE_EXTENSIONS.some((extension) => value.toString().endsWith(extension));
-    const isAudio = (value) => AUDIO_EXTENSIONS.some((extension) => value.toString().endsWith(extension));
-    const isVideo = (value) => VIDEO_EXTENSIONS.some((extension) => value.toString().endsWith(extension));
-    const stringValues = valuesCount.values.filter((v) => typeof v === "string");
-    let imageCount = 0;
-    let audioCount = 0;
-    let videoCount = 0;
-    for (const value of stringValues) {
-      if (isImage(value)) imageCount++;
-      else if (isAudio(value)) audioCount++;
-      else if (isVideo(value)) videoCount++;
-    }
-    const totalMediaCount = imageCount + audioCount + videoCount;
-    if (totalMediaCount > totalDocsCount * 2 / 3) {
-      const fileTypes = [];
-      if (imageCount > 0) fileTypes.push("image/*");
-      if (audioCount > 0) fileTypes.push("audio/*");
-      if (videoCount > 0) fileTypes.push("video/*");
-      return fileTypes.length > 0 ? fileTypes : false;
-    }
-    return false;
-  }
-  function buildValidation({
-    totalDocsCount,
-    valuesResult
-  }) {
-    if (valuesResult) {
-      const totalEntriesCount = valuesResult.values.length;
-      if (totalDocsCount === totalEntriesCount)
-        return {
-          required: true
-        };
-    }
-    return void 0;
-  }
-  function buildReferenceProperty({
-    name,
-    totalDocsCount,
-    valuesResult
-  }) {
-    const property = {
-      name: name ?? "",
-      type: "reference",
-      path: findCommonInitialStringInPath(valuesResult) ?? "!!!FIX_ME!!!"
-    };
-    return property;
-  }
-  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);
-          });
-        }
-      });
-    }
-    return buildPropertiesFromCount(data.length, typesCount, valuesCount);
-  }
-  function buildPropertyFromData(data, property, getType) {
-    const typesCount = {};
-    const valuesCount = {};
-    if (data) {
-      data.forEach((entry) => {
-        increaseTypeCount(property.type, typesCount, entry, getType);
-        increaseValuesCount(valuesCount, "inferred_prop", entry, getType);
-      });
-    }
-    const enumValues = "enum" in property ? resolveEnumValues(property["enum"]) : void 0;
-    if (enumValues) {
-      const newEnumValues = extractEnumFromValues(Array.from(valuesCount["inferred_prop"].valuesCount.keys()));
-      return {
-        ...property,
-        enum: [...newEnumValues, ...enumValues]
-      };
-    }
-    const generatedProperty = buildPropertyFromCount(
-      "inferred_prop",
-      data.length,
-      property.type,
-      typesCount,
-      valuesCount["inferred_prop"]
-    );
-    return utils.mergeDeep(generatedProperty, property);
-  }
-  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 keys = propertiesOrder ?? Object.keys(properties);
-    keys.sort();
-    keys.sort((a, b) => {
-      return propOrder(b) - propOrder(a);
-    });
-    return keys;
-  }
-  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 (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] = Number(arrayTypesCount[arrayType]) + 1;
-        }
-      }
-    } else {
-      if (!typesCount[type]) typesCount[type] = 1;
-      else typesCount[type] = Number(typesCount[type]) + 1;
-    }
-  }
-  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 type = getType(fieldValue);
-    let valuesRecord = typeValuesRecord[key];
-    if (!valuesRecord) {
-      valuesRecord = {
-        values: [],
-        valuesCount: /* @__PURE__ */ new Map()
-      };
-      typeValuesRecord[key] = valuesRecord;
-    }
-    if (type === "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 (type === "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 = Number(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 = Number(count);
-      }
-      if (countValue > highestCount) {
-        highestCount = countValue;
-        probableType = type;
-      }
-    });
-    return probableType;
-  }
-  function buildPropertyFromCount(key, totalDocsCount, mostProbableType, typesCount, valuesResult) {
-    let title;
-    if (key) {
-      title = utils.prettifyIdentifier(key);
-    }
-    let result = void 0;
-    if (mostProbableType === "map") {
-      const highVariability = checkTypesCountHighVariability(typesCount);
-      if (highVariability) {
-        result = {
-          type: "map",
-          name: title ?? key ?? "",
-          keyValue: true,
-          properties: {}
-        };
-      }
-      const properties = buildPropertiesFromCount(
-        totalDocsCount,
-        typesCount.map,
-        valuesResult ? valuesResult.mapValues : void 0
-      );
-      result = {
-        type: "map",
-        name: title ?? key ?? "",
-        properties
-      };
-    } else if (mostProbableType === "array") {
-      const arrayTypesCount = typesCount.array;
-      const arrayMostProbableType = getMostProbableType(arrayTypesCount);
-      const of = buildPropertyFromCount(
-        key,
-        totalDocsCount,
-        arrayMostProbableType,
-        arrayTypesCount,
-        valuesResult
-      );
-      result = {
-        type: "array",
-        name: title ?? key ?? "",
-        of
-      };
-    }
-    if (!result) {
-      const propertyProps = {
-        name: key,
-        totalDocsCount,
-        valuesResult
-      };
-      if (mostProbableType === "string") {
-        result = buildStringProperty(propertyProps);
-      } else if (mostProbableType === "reference") {
-        result = buildReferenceProperty(propertyProps);
-      } else {
-        result = {
-          type: mostProbableType
-        };
-      }
-      if (title) {
-        result.name = title;
-      }
-      const validation = buildValidation(propertyProps);
-      if (validation) {
-        result.validation = validation;
-      }
-    }
-    return result;
-  }
-  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, Number(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 inferTypeFromValue(value) {
-    if (value === null || value === void 0) return "string";
-    if (value instanceof types.Vector || value && typeof value === "object" && "__type" in value && value.__type === "Vector") return "vector";
-    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";
-  }
-  Object.defineProperty(exports2, "isObject", {
-    enumerable: true,
-    get: () => utils.isObject
-  });
-  Object.defineProperty(exports2, "isPlainObject", {
-    enumerable: true,
-    get: () => utils.isPlainObject
-  });
-  Object.defineProperty(exports2, "mergeDeep", {
-    enumerable: true,
-    get: () => utils.mergeDeep
-  });
-  Object.defineProperty(exports2, "prettifyIdentifier", {
-    enumerable: true,
-    get: () => utils.prettifyIdentifier
-  });
-  Object.defineProperty(exports2, "unslugify", {
-    enumerable: true,
-    get: () => utils.unslugify
-  });
-  exports2.buildEntityPropertiesFromData = buildEntityPropertiesFromData;
-  exports2.buildPropertiesOrder = buildPropertiesOrder;
-  exports2.buildPropertyFromData = buildPropertyFromData;
-  exports2.extractEnumFromValues = extractEnumFromValues;
-  exports2.findCommonInitialStringInPath = findCommonInitialStringInPath;
-  exports2.inferTypeFromValue = inferTypeFromValue;
-  exports2.looksLikeReference = looksLikeReference;
-  exports2.parseReferenceString = parseReferenceString;
-  exports2.removeInitialAndTrailingSlashes = removeInitialAndTrailingSlashes;
-  exports2.removeInitialSlash = removeInitialSlash;
-  exports2.removeTrailingSlash = removeTrailingSlash;
-  exports2.resolveEnumValues = resolveEnumValues;
-  Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
-}));
-//# sourceMappingURL=index.umd.cjs.map
+	typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("@rebasepro/utils"), require("@rebasepro/types")) : typeof define === "function" && define.amd ? define([
+		"exports",
+		"@rebasepro/utils",
+		"@rebasepro/types"
+	], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global["Rebase schema inference"] = {}, global._rebasepro_utils, global._rebasepro_types));
+})(this, function(exports, _rebasepro_utils, _rebasepro_types) {
+	Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+	//#region src/strings.ts
+	/**
+	* Parse a reference string value which can be in the format:
+	* - Simple: "path/entityId"
+	* - With database: "database_name:::path/entityId"
+	* Returns the path and database (undefined if not specified or if "(default)")
+	*/
+	function parseReferenceString(value) {
+		if (!value) return null;
+		let database = void 0;
+		let fullPath = value;
+		if (value.includes(":::")) {
+			const [dbName, pathPart] = value.split(":::");
+			if (dbName && dbName !== "(default)") database = dbName;
+			fullPath = pathPart;
+		}
+		if (!fullPath || !fullPath.includes("/")) return null;
+		return {
+			path: fullPath.substring(0, fullPath.lastIndexOf("/")),
+			database
+		};
+	}
+	/**
+	* Check if a string value looks like a reference
+	*/
+	function looksLikeReference(value) {
+		if (typeof value !== "string") return false;
+		return parseReferenceString(value) !== null;
+	}
+	function findCommonInitialStringInPath(valuesCount) {
+		if (!valuesCount) return void 0;
+		function getPath(value) {
+			let pathString;
+			if (typeof value === "string") pathString = value;
+			else if (value && typeof value === "object" && "slug" in value && typeof value.slug === "string") pathString = value.slug;
+			else {
+				console.warn("findCommonInitialStringInPath: value is not a string or document with path", value);
+				return;
+			}
+			if (!pathString) return void 0;
+			if (pathString.includes(":::")) {
+				const [, pathPart] = pathString.split(":::");
+				pathString = pathPart;
+			}
+			return pathString;
+		}
+		const pathWithSlash = valuesCount.values.map((v) => getPath(v)).filter((v) => !!v).find((s) => s.includes("/"));
+		if (!pathWithSlash) return void 0;
+		const searchedPath = pathWithSlash.substring(0, pathWithSlash.lastIndexOf("/"));
+		return valuesCount.values.filter((value) => {
+			const path = getPath(value);
+			if (!path) return false;
+			return path.startsWith(searchedPath);
+		}).length > valuesCount.values.length / 3 * 2 ? searchedPath : void 0;
+	}
+	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;
+	}
+	//#endregion
+	//#region src/util.ts
+	/**
+	* Extract enum values from a list of sample values.
+	* This is schema-inference-specific logic (not a general utility).
+	*/
+	function extractEnumFromValues(values) {
+		if (!Array.isArray(values)) return [];
+		const enumValues = values.map((value) => {
+			if (typeof value === "string") return {
+				id: value,
+				label: (0, _rebasepro_utils.unslugify)(value)
+			};
+			else return null;
+		}).filter(Boolean);
+		enumValues.sort((a, b) => a.label.localeCompare(b.label));
+		return enumValues;
+	}
+	function resolveEnumValues(input) {
+		if (Array.isArray(input)) return input;
+		else if (typeof input === "object" && input !== null) return Object.entries(input).map(([id, value]) => typeof value === "string" ? {
+			id,
+			label: value
+		} : value);
+		else return;
+	}
+	//#endregion
+	//#region src/builders/string_property_builder.ts
+	var IMAGE_EXTENSIONS = [
+		".jpg",
+		".jpeg",
+		".png",
+		".webp",
+		".gif",
+		".avif"
+	];
+	var AUDIO_EXTENSIONS = [
+		".mp3",
+		".ogg",
+		".opus",
+		".aac"
+	];
+	var VIDEO_EXTENSIONS = [".avi", ".mp4"];
+	var 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({ name, totalDocsCount, valuesResult }) {
+		let stringProperty = {
+			name: name ?? "",
+			type: "string"
+		};
+		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.ui = { url: true };
+			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.ui = {
+				...config.ui,
+				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.enum = enumValues;
+			}
+			if (!probablyAnEmail && !probablyAURL && !probablyUserIds && !probablyAURL && !config.enum) {
+				const fileType = probableFileType(valuesResult, totalDocsCount);
+				if (fileType) config.storage = {
+					acceptedFiles: fileType,
+					storagePath: findCommonInitialStringInPath(valuesResult) ?? "/"
+				};
+			}
+			if (Object.keys(config).length > 0) stringProperty = {
+				...stringProperty,
+				...config
+			};
+		}
+		return stringProperty;
+	}
+	function probableFileType(valuesCount, totalDocsCount) {
+		const isImage = (value) => IMAGE_EXTENSIONS.some((extension) => value.toString().endsWith(extension));
+		const isAudio = (value) => AUDIO_EXTENSIONS.some((extension) => value.toString().endsWith(extension));
+		const isVideo = (value) => VIDEO_EXTENSIONS.some((extension) => value.toString().endsWith(extension));
+		const stringValues = valuesCount.values.filter((v) => typeof v === "string");
+		let imageCount = 0;
+		let audioCount = 0;
+		let videoCount = 0;
+		for (const value of stringValues) if (isImage(value)) imageCount++;
+		else if (isAudio(value)) audioCount++;
+		else if (isVideo(value)) videoCount++;
+		if (imageCount + audioCount + videoCount > totalDocsCount * 2 / 3) {
+			const fileTypes = [];
+			if (imageCount > 0) fileTypes.push("image/*");
+			if (audioCount > 0) fileTypes.push("audio/*");
+			if (videoCount > 0) fileTypes.push("video/*");
+			return fileTypes.length > 0 ? fileTypes : false;
+		}
+		return false;
+	}
+	//#endregion
+	//#region src/builders/validation_builder.ts
+	function buildValidation({ totalDocsCount, valuesResult }) {
+		if (valuesResult) {
+			if (totalDocsCount === valuesResult.values.length) return { required: true };
+		}
+	}
+	//#endregion
+	//#region src/builders/reference_property_builder.ts
+	function buildReferenceProperty({ name, totalDocsCount, valuesResult }) {
+		return {
+			name: name ?? "",
+			type: "reference",
+			path: findCommonInitialStringInPath(valuesResult) ?? "!!!FIX_ME!!!"
+		};
+	}
+	//#endregion
+	//#region src/collection_builder.ts
+	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);
+			});
+		});
+		return buildPropertiesFromCount(data.length, typesCount, valuesCount);
+	}
+	function buildPropertyFromData(data, property, getType) {
+		const typesCount = {};
+		const valuesCount = {};
+		if (data) data.forEach((entry) => {
+			increaseTypeCount(property.type, typesCount, entry, getType);
+			increaseValuesCount(valuesCount, "inferred_prop", entry, getType);
+		});
+		const enumValues = "enum" in property ? resolveEnumValues(property["enum"]) : void 0;
+		if (enumValues) {
+			const newEnumValues = extractEnumFromValues(Array.from(valuesCount["inferred_prop"].valuesCount.keys()));
+			return {
+				...property,
+				enum: [...newEnumValues, ...enumValues]
+			};
+		}
+		return (0, _rebasepro_utils.mergeDeep)(buildPropertyFromCount("inferred_prop", data.length, property.type, typesCount, valuesCount["inferred_prop"]), property);
+	}
+	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 keys = propertiesOrder ?? Object.keys(properties);
+		keys.sort();
+		keys.sort((a, b) => {
+			return propOrder(b) - propOrder(a);
+		});
+		return keys;
+	}
+	/**
+	* @param type
+	* @param typesCount
+	* @param fieldValue
+	* @param getType
+	*/
+	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 (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] = Number(arrayTypesCount[arrayType]) + 1;
+			}
+		} else if (!typesCount[type]) typesCount[type] = 1;
+		else typesCount[type] = Number(typesCount[type]) + 1;
+	}
+	function increaseMapTypeCount(typesCountRecord, key, fieldValue, getType) {
+		if (key.startsWith("_")) return;
+		let typesCount = typesCountRecord[key];
+		if (!typesCount) {
+			typesCount = {};
+			typesCountRecord[key] = typesCount;
+		}
+		if (fieldValue != null) increaseTypeCount(getType(fieldValue), typesCount, fieldValue, getType);
+	}
+	function increaseValuesCount(typeValuesRecord, key, fieldValue, getType) {
+		if (key.startsWith("_")) return;
+		const type = getType(fieldValue);
+		let valuesRecord = typeValuesRecord[key];
+		if (!valuesRecord) {
+			valuesRecord = {
+				values: [],
+				valuesCount: /* @__PURE__ */ new Map()
+			};
+			typeValuesRecord[key] = valuesRecord;
+		}
+		if (type === "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 (type === "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 = Number(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 = Number(count);
+			if (countValue > highestCount) {
+				highestCount = countValue;
+				probableType = type;
+			}
+		});
+		return probableType;
+	}
+	function buildPropertyFromCount(key, totalDocsCount, mostProbableType, typesCount, valuesResult) {
+		let title;
+		if (key) title = (0, _rebasepro_utils.prettifyIdentifier)(key);
+		let result = void 0;
+		if (mostProbableType === "map") {
+			if (checkTypesCountHighVariability(typesCount)) result = {
+				type: "map",
+				name: title ?? key ?? "",
+				keyValue: true,
+				properties: {}
+			};
+			const properties = buildPropertiesFromCount(totalDocsCount, typesCount.map, valuesResult ? valuesResult.mapValues : void 0);
+			result = {
+				type: "map",
+				name: title ?? key ?? "",
+				properties
+			};
+		} else if (mostProbableType === "array") {
+			const arrayTypesCount = typesCount.array;
+			const of = buildPropertyFromCount(key, totalDocsCount, getMostProbableType(arrayTypesCount), arrayTypesCount, valuesResult);
+			result = {
+				type: "array",
+				name: title ?? key ?? "",
+				of
+			};
+		}
+		if (!result) {
+			const propertyProps = {
+				name: key,
+				totalDocsCount,
+				valuesResult
+			};
+			if (mostProbableType === "string") result = buildStringProperty(propertyProps);
+			else if (mostProbableType === "reference") result = buildReferenceProperty(propertyProps);
+			else result = { type: mostProbableType };
+			if (title) result.name = title;
+			const validation = buildValidation(propertyProps);
+			if (validation) result.validation = validation;
+		}
+		return result;
+	}
+	function buildPropertiesFromCount(totalDocsCount, typesCountRecord, valuesCountRecord) {
+		const res = {};
+		Object.entries(typesCountRecord).forEach(([key, typesCount]) => {
+			res[key] = buildPropertyFromCount(key, totalDocsCount, getMostProbableType(typesCount), 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, Number(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]) => {
+			if (countMaxDocumentsUnder(value) < maxCount / 3) keysWithFewValues++;
+		});
+		return keysWithFewValues / Object.entries(typesCount.map ?? {}).length > .5;
+	}
+	function inferTypeFromValue(value) {
+		if (value === null || value === void 0) return "string";
+		if (value instanceof _rebasepro_types.Vector || value && typeof value === "object" && "__type" in value && value.__type === "Vector") return "vector";
+		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";
+	}
+	//#endregion
+	exports.buildEntityPropertiesFromData = buildEntityPropertiesFromData;
+	exports.buildPropertiesOrder = buildPropertiesOrder;
+	exports.buildPropertyFromData = buildPropertyFromData;
+	exports.extractEnumFromValues = extractEnumFromValues;
+	exports.findCommonInitialStringInPath = findCommonInitialStringInPath;
+	exports.inferTypeFromValue = inferTypeFromValue;
+	Object.defineProperty(exports, "isObject", {
+		enumerable: true,
+		get: function() {
+			return _rebasepro_utils.isObject;
+		}
+	});
+	Object.defineProperty(exports, "isPlainObject", {
+		enumerable: true,
+		get: function() {
+			return _rebasepro_utils.isPlainObject;
+		}
+	});
+	exports.looksLikeReference = looksLikeReference;
+	Object.defineProperty(exports, "mergeDeep", {
+		enumerable: true,
+		get: function() {
+			return _rebasepro_utils.mergeDeep;
+		}
+	});
+	exports.parseReferenceString = parseReferenceString;
+	Object.defineProperty(exports, "prettifyIdentifier", {
+		enumerable: true,
+		get: function() {
+			return _rebasepro_utils.prettifyIdentifier;
+		}
+	});
+	exports.removeInitialAndTrailingSlashes = removeInitialAndTrailingSlashes;
+	exports.removeInitialSlash = removeInitialSlash;
+	exports.removeTrailingSlash = removeTrailingSlash;
+	exports.resolveEnumValues = resolveEnumValues;
+	Object.defineProperty(exports, "unslugify", {
+		enumerable: true,
+		get: function() {
+			return _rebasepro_utils.unslugify;
+		}
+	});
+});
+
+//# sourceMappingURL=index.umd.cjs.map