@rebasepro/utils 0.0.1-canary.4d4fb3e

package/dist/index.umd.js

@@ -0,0 +1,585 @@
+(function(global, factory) {
+  typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("object-hash"), require("@rebasepro/types")) : typeof define === "function" && define.amd ? define(["exports", "object-hash", "@rebasepro/types"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global["Rebase Util"] = {}, global.hash, global.types));
+})(this, function(exports2, hash, types) {
+  "use strict";
+  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().trim().replace(/^\s+|\s+$/g, "").replace(/\s+/g, separator).replace(/&/g, separator).replace(/[^\w\\-]+/g, "").replace(new RegExp("\\" + separator + "\\" + separator + "+", "g"), separator);
+    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 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 = (obj) => obj !== obj;
+  function getIn(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(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(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 types.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 toArray(input) {
+    return Array.isArray(input) ? input : input ? [input] : [];
+  }
+  const defaultDateFormat = "MMMM dd, yyyy, HH:mm:ss";
+  function hashString(str) {
+    if (!str) return 0;
+    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 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 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 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 getOS() {
+    let OS = "Unknown";
+    if (navigator.userAgent.indexOf("Win") !== -1) OS = "Windows";
+    if (navigator.userAgent.indexOf("Mac") !== -1) OS = "MacOS";
+    if (navigator.userAgent.indexOf("X11") !== -1) OS = "UNIX";
+    if (navigator.userAgent.indexOf("Linux") !== -1) OS = "Linux";
+    return OS;
+  }
+  function getAltSymbol() {
+    if (getOS() === "MacOS") return "⌥";
+    return "Alt";
+  }
+  function generateForeignKeyName(name) {
+    const snakeCaseName = toSnakeCase(name);
+    const singularName = snakeCaseName.endsWith("s") ? snakeCaseName.slice(0, -1) : snakeCaseName;
+    return `${singularName}_id`;
+  }
+  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);
+  }
+  exports2.clone = clone;
+  exports2.defaultDateFormat = defaultDateFormat;
+  exports2.flattenObject = flattenObject;
+  exports2.generateForeignKeyName = generateForeignKeyName;
+  exports2.getAltSymbol = getAltSymbol;
+  exports2.getArrayValuesCount = getArrayValuesCount;
+  exports2.getHashValue = getHashValue;
+  exports2.getIn = getIn;
+  exports2.getOS = getOS;
+  exports2.getValueInPath = getValueInPath;
+  exports2.hashString = hashString;
+  exports2.hydrateRegExp = hydrateRegExp;
+  exports2.isDefaultFieldConfigId = isDefaultFieldConfigId;
+  exports2.isEmptyArray = isEmptyArray;
+  exports2.isEmptyObject = isEmptyObject;
+  exports2.isFunction = isFunction;
+  exports2.isInteger = isInteger;
+  exports2.isNaN = isNaN;
+  exports2.isObject = isObject;
+  exports2.isPlainObject = isPlainObject;
+  exports2.isValidRegExp = isValidRegExp;
+  exports2.mergeDeep = mergeDeep;
+  exports2.pick = pick;
+  exports2.plural = plural;
+  exports2.prettifyIdentifier = prettifyIdentifier;
+  exports2.randomColor = randomColor;
+  exports2.randomString = randomString;
+  exports2.removeFunctions = removeFunctions;
+  exports2.removeInPath = removeInPath;
+  exports2.removeNulls = removeNulls;
+  exports2.removePropsIfExisting = removePropsIfExisting;
+  exports2.removeUndefined = removeUndefined;
+  exports2.serializeRegExp = serializeRegExp;
+  exports2.setIn = setIn;
+  exports2.singular = singular;
+  exports2.slugify = slugify;
+  exports2.toArray = toArray;
+  exports2.toKebabCase = toKebabCase;
+  exports2.toSnakeCase = toSnakeCase;
+  exports2.unslugify = unslugify;
+  Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+});
+//# sourceMappingURL=index.umd.js.map