@web-ts-toolkit/utils 0.2.0

package/index.mjs

@@ -0,0 +1,718 @@
+// src/addLeadingSlash.ts
+function addLeadingSlash(value) {
+  return value.startsWith("/") ? value : `/${value}`;
+}
+
+// src/assign.ts
+function assign(target, ...sources) {
+  return Object.assign(target, ...sources);
+}
+
+// src/castArray.ts
+function castArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+
+// src/_internal.ts
+var pathPattern = /[^.[\]]+|\[(?:([^"'[\]]+)|["']([^"']+)["'])\]/g;
+function isObject(value) {
+  return value !== null && (typeof value === "object" || typeof value === "function");
+}
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === null || prototype === Object.prototype;
+}
+function normalizePathPart(part) {
+  if (typeof part === "number") {
+    return part;
+  }
+  return /^\d+$/.test(part) ? Number(part) : part;
+}
+function toPath(path) {
+  if (Array.isArray(path)) {
+    return path.map(normalizePathPart);
+  }
+  const input = String(path);
+  if (input.length === 0) {
+    return [];
+  }
+  const result = [];
+  input.replace(pathPattern, (_, bare, quoted) => {
+    const token = bare ?? quoted ?? _;
+    result.push(normalizePathPart(token));
+    return "";
+  });
+  return result.length > 0 ? result : [input];
+}
+function hasPath(value, path) {
+  const parts = toPath(path);
+  if (parts.length === 0) {
+    return true;
+  }
+  let current = value;
+  for (let index = 0; index < parts.length; index++) {
+    if (current === null || current === void 0) {
+      return false;
+    }
+    const key = parts[index];
+    if (!(key in Object(current))) {
+      return false;
+    }
+    current = current[key];
+  }
+  return true;
+}
+function getPath(value, path, defaultValue) {
+  const parts = toPath(path);
+  let current = value;
+  for (let index = 0; index < parts.length; index++) {
+    if (current === null || current === void 0) {
+      return defaultValue;
+    }
+    current = current[parts[index]];
+  }
+  return current === void 0 ? defaultValue : current;
+}
+function setPath(target, path, value) {
+  if (!isObject(target)) {
+    return target;
+  }
+  const parts = toPath(path);
+  if (parts.length === 0) {
+    return target;
+  }
+  let current = target;
+  for (let index = 0; index < parts.length - 1; index++) {
+    const key = parts[index];
+    const nextKey = parts[index + 1];
+    const existing = current[key];
+    if (!isObject(existing)) {
+      current[key] = typeof nextKey === "number" ? [] : {};
+    }
+    current = current[key];
+  }
+  current[parts[parts.length - 1]] = value;
+  return target;
+}
+function deletePath(target, path) {
+  if (!isObject(target)) {
+    return;
+  }
+  const parts = toPath(path);
+  if (parts.length === 0) {
+    return;
+  }
+  let current = target;
+  for (let index = 0; index < parts.length - 1; index++) {
+    const key = parts[index];
+    const nextValue = current[key];
+    if (!isObject(nextValue)) {
+      return;
+    }
+    current = nextValue;
+  }
+  delete current[parts[parts.length - 1]];
+}
+function sameValueZero(left, right) {
+  return left === right || left !== left && right !== right;
+}
+function arrayIncludes(array, value) {
+  for (let index = 0; index < array.length; index++) {
+    if (sameValueZero(array[index], value)) {
+      return true;
+    }
+  }
+  return false;
+}
+function baseUniq(array) {
+  const result = [];
+  for (let index = 0; index < array.length; index++) {
+    if (!arrayIncludes(result, array[index])) {
+      result.push(array[index]);
+    }
+  }
+  return result;
+}
+function identity(value) {
+  return value;
+}
+function getIteratee(iteratee) {
+  if (typeof iteratee === "function") {
+    return iteratee;
+  }
+  if (iteratee === void 0) {
+    return identity;
+  }
+  return (value) => getPath(value, iteratee);
+}
+function compareAscending(left, right) {
+  if (sameValueZero(left, right)) {
+    return 0;
+  }
+  if (left === void 0) {
+    return 1;
+  }
+  if (right === void 0) {
+    return -1;
+  }
+  if (left === null) {
+    return 1;
+  }
+  if (right === null) {
+    return -1;
+  }
+  if (left > right) {
+    return 1;
+  }
+  if (left < right) {
+    return -1;
+  }
+  const leftString = String(left);
+  const rightString = String(right);
+  if (leftString === rightString) {
+    return 0;
+  }
+  return leftString > rightString ? 1 : -1;
+}
+function cloneValue(value) {
+  if (typeof structuredClone === "function") {
+    try {
+      return structuredClone(value);
+    } catch {
+    }
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => cloneValue(item));
+  }
+  if (value instanceof Date) {
+    return new Date(value.getTime());
+  }
+  if (value instanceof RegExp) {
+    return new RegExp(value.source, value.flags);
+  }
+  if (isPlainObject(value)) {
+    const result = {};
+    const keys2 = Object.keys(value);
+    for (let index = 0; index < keys2.length; index++) {
+      const key = keys2[index];
+      result[key] = cloneValue(value[key]);
+    }
+    return result;
+  }
+  return value;
+}
+function deepEqual(left, right) {
+  if (sameValueZero(left, right)) {
+    return true;
+  }
+  if (left instanceof Date && right instanceof Date) {
+    return left.getTime() === right.getTime();
+  }
+  if (left instanceof RegExp && right instanceof RegExp) {
+    return left.source === right.source && left.flags === right.flags;
+  }
+  if (Array.isArray(left) || Array.isArray(right)) {
+    if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) {
+      return false;
+    }
+    for (let index = 0; index < left.length; index++) {
+      if (!deepEqual(left[index], right[index])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (!isObject(left) || !isObject(right)) {
+    return false;
+  }
+  const leftKeys = Object.keys(left);
+  const rightKeys = Object.keys(right);
+  if (leftKeys.length !== rightKeys.length) {
+    return false;
+  }
+  for (let index = 0; index < leftKeys.length; index++) {
+    const key = leftKeys[index];
+    if (!(key in right) || !deepEqual(left[key], right[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+function partialMatch(object, source) {
+  if (sameValueZero(object, source)) {
+    return true;
+  }
+  if (Array.isArray(source)) {
+    if (!Array.isArray(object) || object.length < source.length) {
+      return false;
+    }
+    for (let index = 0; index < source.length; index++) {
+      if (!partialMatch(object[index], source[index])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (isPlainObject(source)) {
+    if (!isObject(object)) {
+      return false;
+    }
+    const keys2 = Object.keys(source);
+    for (let index = 0; index < keys2.length; index++) {
+      const key = keys2[index];
+      if (!partialMatch(object[key], source[key])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return deepEqual(object, source);
+}
+
+// src/cloneDeep.ts
+function cloneDeep(value) {
+  return cloneValue(value);
+}
+
+// src/compact.ts
+function compact(array) {
+  if (!Array.isArray(array)) {
+    return [];
+  }
+  return array.filter(Boolean);
+}
+
+// src/difference.ts
+function difference(array, ...values) {
+  if (!Array.isArray(array)) {
+    return [];
+  }
+  const excluded = values.flatMap((value) => Array.isArray(value) ? value : []);
+  return array.filter((item) => !arrayIncludes(excluded, item));
+}
+
+// src/filter.ts
+function filter(collection, predicate) {
+  if (!collection) {
+    return [];
+  }
+  const result = [];
+  if (Array.isArray(collection)) {
+    for (let index = 0; index < collection.length; index++) {
+      const value = collection[index];
+      if (predicate(value, index)) {
+        result.push(value);
+      }
+    }
+    return result;
+  }
+  const keys2 = Object.keys(collection);
+  for (let index = 0; index < keys2.length; index++) {
+    const key = keys2[index];
+    const value = collection[key];
+    if (predicate(value, key)) {
+      result.push(value);
+    }
+  }
+  return result;
+}
+
+// src/find.ts
+function find(collection, predicate) {
+  if (!collection) {
+    return void 0;
+  }
+  if (Array.isArray(collection)) {
+    for (let index = 0; index < collection.length; index++) {
+      const value = collection[index];
+      if (predicate(value, index)) {
+        return value;
+      }
+    }
+    return void 0;
+  }
+  const keys2 = Object.keys(collection);
+  for (let index = 0; index < keys2.length; index++) {
+    const key = keys2[index];
+    const value = collection[key];
+    if (predicate(value, key)) {
+      return value;
+    }
+  }
+  return void 0;
+}
+
+// src/flatten.ts
+function flatten(array) {
+  if (!Array.isArray(array)) {
+    return [];
+  }
+  const result = [];
+  for (let index = 0; index < array.length; index++) {
+    const value = array[index];
+    if (Array.isArray(value)) {
+      result.push(...value);
+    } else {
+      result.push(value);
+    }
+  }
+  return result;
+}
+
+// src/flattenDeep.ts
+function flattenDeep(array) {
+  if (!Array.isArray(array)) {
+    return [];
+  }
+  const result = [];
+  for (let index = 0; index < array.length; index++) {
+    const value = array[index];
+    if (Array.isArray(value)) {
+      result.push(...flattenDeep(value));
+    } else {
+      result.push(value);
+    }
+  }
+  return result;
+}
+
+// src/forEach.ts
+function forEach(collection, iteratee) {
+  if (!collection) {
+    return collection;
+  }
+  const callback = iteratee;
+  if (Array.isArray(collection)) {
+    for (let index = 0; index < collection.length; index++) {
+      if (callback(collection[index], index, collection) === false) {
+        break;
+      }
+    }
+    return collection;
+  }
+  const keys2 = Object.keys(collection);
+  for (let index = 0; index < keys2.length; index++) {
+    const key = keys2[index];
+    if (callback(collection[key], key, collection) === false) {
+      break;
+    }
+  }
+  return collection;
+}
+
+// src/get.ts
+function get(object, path, defaultValue) {
+  return getPath(object, path, defaultValue);
+}
+
+// src/intersection.ts
+function intersection(...arrays) {
+  const [first = [], ...rest] = arrays;
+  if (!Array.isArray(first)) {
+    return [];
+  }
+  const uniqueValues = baseUniq(first);
+  return uniqueValues.filter((value) => rest.every((array) => Array.isArray(array) && arrayIncludes(array, value)));
+}
+
+// src/intersectionBy.ts
+function intersectionBy(...args) {
+  const arrays = [...args];
+  const last = arrays[arrays.length - 1];
+  const iteratee = typeof last === "function" || typeof last === "string" || typeof last === "number" ? arrays.pop() : void 0;
+  const callback = getIteratee(iteratee);
+  const sources = arrays.filter(Array.isArray);
+  if (sources.length === 0) {
+    return [];
+  }
+  const [first, ...rest] = sources;
+  const result = [];
+  const seen = [];
+  for (let index = 0; index < first.length; index++) {
+    const item = first[index];
+    const computed = callback(item);
+    if (seen.some((entry) => sameValueZero(entry, computed))) {
+      continue;
+    }
+    if (rest.every(
+      (array) => baseUniq(array.map((value) => callback(value))).some((entry) => sameValueZero(entry, computed))
+    )) {
+      seen.push(computed);
+      result.push(item);
+    }
+  }
+  return result;
+}
+
+// src/isArray.ts
+function isArray(value) {
+  return Array.isArray(value);
+}
+
+// src/isBoolean.ts
+function isBoolean(value) {
+  return value === true || value === false || value instanceof Boolean;
+}
+
+// src/isEmpty.ts
+function isEmpty(value) {
+  if (value == null) {
+    return true;
+  }
+  if (Array.isArray(value) || typeof value === "string") {
+    return value.length === 0;
+  }
+  if (value instanceof Map || value instanceof Set) {
+    return value.size === 0;
+  }
+  if (isObject(value)) {
+    return Object.keys(value).length === 0;
+  }
+  return false;
+}
+
+// src/isEqual.ts
+function isEqual(left, right) {
+  return deepEqual(left, right);
+}
+
+// src/isFunction.ts
+function isFunction(value) {
+  return typeof value === "function";
+}
+
+// src/isMatch.ts
+function isMatch(object, source) {
+  return partialMatch(object, source);
+}
+
+// src/isNaN.ts
+function isNaNValue(value) {
+  if (value instanceof Number) {
+    return Number.isNaN(value.valueOf());
+  }
+  return typeof value === "number" && Number.isNaN(value);
+}
+
+// src/isNil.ts
+function isNil(value) {
+  return value == null;
+}
+
+// src/isNumber.ts
+function isNumber(value) {
+  return typeof value === "number" || value instanceof Number;
+}
+
+// src/isObject.ts
+function isObject2(value) {
+  return isObject(value);
+}
+
+// src/isPlainObject.ts
+function isPlainObject2(value) {
+  return isPlainObject(value);
+}
+
+// src/isPromise.ts
+function isPromise(value) {
+  return !!value && isFunction(value.then);
+}
+
+// src/isString.ts
+function isString(value) {
+  return typeof value === "string" || value instanceof String;
+}
+
+// src/isUndefined.ts
+function isUndefined(value) {
+  return value === void 0;
+}
+
+// src/keys.ts
+function keys(value) {
+  if (value == null) {
+    return [];
+  }
+  return Object.keys(Object(value));
+}
+
+// src/map.ts
+function map(collection, iteratee) {
+  if (!collection) {
+    return [];
+  }
+  const callback = getIteratee(iteratee);
+  const result = [];
+  if (Array.isArray(collection)) {
+    for (let index = 0; index < collection.length; index++) {
+      result.push(callback(collection[index], index, collection));
+    }
+    return result;
+  }
+  const keys2 = Object.keys(collection);
+  for (let index = 0; index < keys2.length; index++) {
+    const key = keys2[index];
+    result.push(callback(collection[key], key, collection));
+  }
+  return result;
+}
+
+// src/noop.ts
+function noop() {
+}
+
+// src/omit.ts
+function omit(object, paths) {
+  if (!isObject(object)) {
+    return {};
+  }
+  const result = cloneDeep(object);
+  const pathList = Array.isArray(paths) ? paths : [paths];
+  for (let index = 0; index < pathList.length; index++) {
+    deletePath(result, pathList[index]);
+  }
+  return result;
+}
+
+// src/orderBy.ts
+function orderBy(collection, iteratees = [], orders = []) {
+  if (!Array.isArray(collection)) {
+    return [];
+  }
+  const callbacks = (iteratees.length > 0 ? iteratees : [void 0]).map((iteratee) => getIteratee(iteratee));
+  return [...collection].map((value, index) => ({ value, index })).sort((left, right) => {
+    for (let index = 0; index < callbacks.length; index++) {
+      const callback = callbacks[index];
+      const comparison = compareAscending(callback(left.value), callback(right.value));
+      if (comparison !== 0) {
+        return orders[index] === "desc" ? comparison * -1 : comparison;
+      }
+    }
+    return left.index - right.index;
+  }).map((entry) => entry.value);
+}
+
+// src/padEnd.ts
+function padEnd(value, length = 0, chars = " ") {
+  return String(value).padEnd(length, chars);
+}
+
+// src/pick.ts
+function pick(object, paths) {
+  if (!isObject(object)) {
+    return {};
+  }
+  const result = {};
+  const pathList = Array.isArray(paths) ? paths : [paths];
+  for (let index = 0; index < pathList.length; index++) {
+    const path = pathList[index];
+    if (!hasPath(object, path)) {
+      continue;
+    }
+    setPath(result, path, getPath(object, path));
+  }
+  return result;
+}
+
+// src/reduce.ts
+function reduce(collection, iteratee, accumulator) {
+  const hasAccumulator = arguments.length >= 3;
+  const entries = [];
+  const callback = iteratee;
+  if (Array.isArray(collection)) {
+    for (let index = 0; index < collection.length; index++) {
+      entries.push([index, collection[index]]);
+    }
+  } else if (collection) {
+    const keys2 = Object.keys(collection);
+    for (let index = 0; index < keys2.length; index++) {
+      const key = keys2[index];
+      entries.push([key, collection[key]]);
+    }
+  }
+  if (!hasAccumulator) {
+    if (entries.length === 0) {
+      throw new TypeError("Reduce of empty collection with no initial value");
+    }
+    accumulator = entries[0][1];
+    entries.shift();
+  }
+  let result = accumulator;
+  for (let index = 0; index < entries.length; index++) {
+    const [key, value] = entries[index];
+    result = callback(result, value, key, collection);
+  }
+  return result;
+}
+
+// src/set.ts
+function set(object, path, value) {
+  return setPath(object, path, value);
+}
+
+// src/toStringRecord.ts
+function toStringRecord(value) {
+  if (!isPlainObject2(value)) {
+    return void 0;
+  }
+  const result = {};
+  const entries = Object.entries(value);
+  for (let index = 0; index < entries.length; index++) {
+    const [key, entryValue] = entries[index];
+    result[key] = String(entryValue);
+  }
+  return entries.length > 0 ? result : void 0;
+}
+
+// src/uniq.ts
+function uniq(array) {
+  if (!Array.isArray(array)) {
+    return [];
+  }
+  return baseUniq(array);
+}
+export {
+  addLeadingSlash,
+  assign,
+  castArray,
+  cloneDeep,
+  compact,
+  difference,
+  filter,
+  find,
+  flatten,
+  flattenDeep,
+  forEach,
+  get,
+  intersection,
+  intersectionBy,
+  isArray,
+  isBoolean,
+  isEmpty,
+  isEqual,
+  isFunction,
+  isMatch,
+  isNaNValue as isNaN,
+  isNil,
+  isNumber,
+  isObject2 as isObject,
+  isPlainObject2 as isPlainObject,
+  isPromise,
+  isString,
+  isUndefined,
+  keys,
+  map,
+  noop,
+  omit,
+  orderBy,
+  padEnd,
+  pick,
+  reduce,
+  set,
+  toStringRecord,
+  uniq
+};