@rebasepro/utils 0.0.1-canary.4d4fb3e

package/LICENSE

@@ -0,0 +1,6 @@
+Source code in this repository is variously licensed under the Business Source
+License 1.1 (BSL), Apache version 2.0 and the MIT license. A copy of each
+license can be found in each one of the packages under the folder packages
+under a file called License. Source code in a given file is licensed under the
+BSL and the copyright belongs to Rebase Authors unless otherwise noted at the
+beginning of the file.

package/dist/arrays.d.ts

@@ -0,0 +1 @@
+export declare function toArray<T>(input?: T | T[]): T[];

package/dist/dates.d.ts

@@ -0,0 +1 @@
+export declare const defaultDateFormat = "MMMM dd, yyyy, HH:mm:ss";

package/dist/fields.d.ts

@@ -0,0 +1 @@
+export declare function isDefaultFieldConfigId(id: string): boolean;

package/dist/flatten_object.d.ts

@@ -0,0 +1,5 @@
+export declare function flattenObject(obj: Record<string, unknown>, parentKey?: string): {
+    [key: string]: unknown;
+};
+export type ArrayValuesCount = Record<string, number>;
+export declare function getArrayValuesCount(array: Record<string, unknown>[]): ArrayValuesCount;

package/dist/hash.d.ts

@@ -0,0 +1 @@
+export declare function hashString(str: string): number;

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./strings";
+export * from "./objects";
+export * from "./arrays";
+export * from "./dates";
+export * from "./hash";
+export * from "./regexp";
+export * from "./flatten_object";
+export * from "./plurals";
+export * from "./os";
+export * from "./names";
+export * from "./fields";

package/dist/index.es.js

@@ -0,0 +1,583 @@
+import hash from "object-hash";
+import { GeoPoint } from "@rebasepro/types";
+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 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);
+}
+export {
+  clone,
+  defaultDateFormat,
+  flattenObject,
+  generateForeignKeyName,
+  getAltSymbol,
+  getArrayValuesCount,
+  getHashValue,
+  getIn,
+  getOS,
+  getValueInPath,
+  hashString,
+  hydrateRegExp,
+  isDefaultFieldConfigId,
+  isEmptyArray,
+  isEmptyObject,
+  isFunction,
+  isInteger,
+  isNaN,
+  isObject,
+  isPlainObject,
+  isValidRegExp,
+  mergeDeep,
+  pick,
+  plural,
+  prettifyIdentifier,
+  randomColor,
+  randomString,
+  removeFunctions,
+  removeInPath,
+  removeNulls,
+  removePropsIfExisting,
+  removeUndefined,
+  serializeRegExp,
+  setIn,
+  singular,
+  slugify,
+  toArray,
+  toKebabCase,
+  toSnakeCase,
+  unslugify
+};
+//# sourceMappingURL=index.es.js.map