@ls-stack/utils 3.63.0 → 3.66.0

package/dist/arrayUtils.cjs

@@ -1,229 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/arrayUtils.ts
-var arrayUtils_exports = {};
-__export(arrayUtils_exports, {
-  arrayOps: () => arrayOps,
-  arrayWithPrev: () => arrayWithPrev,
-  arrayWithPrevAndIndex: () => arrayWithPrevAndIndex,
-  filterAndMap: () => filterAndMap,
-  findAfterIndex: () => findAfterIndex,
-  findAndMap: () => findAndMap,
-  findBeforeIndex: () => findBeforeIndex,
-  getAscIndexOrder: () => getAscIndexOrder,
-  hasDuplicates: () => hasDuplicates,
-  intersperse: () => intersperse,
-  isInArray: () => isInArray,
-  isInArrayWithoutNarrowing: () => isInArrayWithoutNarrowing,
-  looseIsInArray: () => looseIsInArray,
-  rejectArrayUndefinedValues: () => rejectArrayUndefinedValues,
-  rejectDuplicates: () => rejectDuplicates,
-  repeat: () => repeat,
-  sortBy: () => sortBy,
-  truncateArray: () => truncateArray
-});
-module.exports = __toCommonJS(arrayUtils_exports);
-
-// src/typeGuards.ts
-function isFunction(value) {
-  return typeof value === "function";
-}
-
-// src/assertions.ts
-var isFunction2 = isFunction;
-
-// src/arrayUtils.ts
-function filterAndMap(array, mapFilter) {
-  const result = [];
-  let i = -1;
-  for (const item of array) {
-    i += 1;
-    const filterResult = mapFilter(item, i);
-    if (filterResult !== false) {
-      result.push(filterResult);
-    }
-  }
-  return result;
-}
-function sortBy(arr, sortByValue, props = "asc") {
-  const order = Array.isArray(props) || typeof props === "string" ? props : props.order ?? "asc";
-  return [...arr].sort((a, b) => {
-    const _aPriority = sortByValue(a);
-    const _bPriority = sortByValue(b);
-    const aPriority = Array.isArray(_aPriority) ? _aPriority : [_aPriority];
-    const bPriority = Array.isArray(_bPriority) ? _bPriority : [_bPriority];
-    for (let i = 0; i < aPriority.length; i++) {
-      const levelOrder = typeof order === "string" ? order : order[i] ?? "asc";
-      const aP = aPriority[i] ?? 0;
-      const bP = bPriority[i] ?? 0;
-      if (aP === bP) {
-        continue;
-      }
-      if (bP === Infinity || aP === -Infinity || aP < bP) {
-        return levelOrder === "asc" ? -1 : 1;
-      }
-      if (aP === Infinity || bP === -Infinity || aP > bP) {
-        return levelOrder === "asc" ? 1 : -1;
-      }
-    }
-    return 0;
-  });
-}
-function getAscIndexOrder(index) {
-  return index === -1 ? Infinity : index ?? Infinity;
-}
-function arrayWithPrev(array) {
-  return array.map((item, i) => [item, array[i - 1] ?? null]);
-}
-function arrayWithPrevAndIndex(array) {
-  return array.map((item, i) => ({
-    item,
-    prev: array[i - 1] ?? null,
-    index: i
-  }));
-}
-function isInArray(value, oneOf) {
-  for (let i = 0; i < oneOf.length; i++) {
-    if (oneOf[i] === value) {
-      return true;
-    }
-  }
-  return false;
-}
-function isInArrayWithoutNarrowing(value, oneOf) {
-  return oneOf.includes(value);
-}
-function looseIsInArray(value, array) {
-  return array.includes(value);
-}
-function findAfterIndex(array, index, predicate) {
-  for (let i = index + 1; i < array.length; i++) {
-    if (predicate(array[i])) {
-      return array[i];
-    }
-  }
-  return void 0;
-}
-function findBeforeIndex(array, index, predicate) {
-  let indexToUse = index;
-  if (indexToUse >= array.length) {
-    indexToUse = array.length;
-  }
-  for (let i = indexToUse - 1; i >= 0; i--) {
-    if (predicate(array[i])) {
-      return array[i];
-    }
-  }
-  return void 0;
-}
-function rejectArrayUndefinedValues(array) {
-  return array.filter((item) => item !== void 0);
-}
-function hasDuplicates(array, getKey = (item) => item) {
-  const seen = /* @__PURE__ */ new Set();
-  for (const item of array) {
-    const key = getKey(item);
-    if (seen.has(key)) {
-      return true;
-    }
-    seen.add(key);
-  }
-  return false;
-}
-function rejectDuplicates(array, getKey = (item) => item) {
-  const seen = /* @__PURE__ */ new Set();
-  const result = [];
-  for (const item of array) {
-    const key = getKey(item);
-    if (seen.has(key)) {
-      continue;
-    }
-    seen.add(key);
-    result.push(item);
-  }
-  return result;
-}
-function truncateArray(array, maxLength, appendIfTruncated) {
-  const truncate = array.length > maxLength;
-  const result = truncate ? [...array.slice(0, maxLength)] : array;
-  if (truncate && appendIfTruncated) {
-    if (isFunction2(appendIfTruncated)) {
-      return [...result, appendIfTruncated(array.length - maxLength)];
-    }
-    return [...result, appendIfTruncated];
-  }
-  return result;
-}
-function findAndMap(array, predicate) {
-  for (const item of array) {
-    const value = predicate(item);
-    if (value !== false) return value;
-  }
-  return void 0;
-}
-function arrayOps(array) {
-  return {
-    filterAndMap: (mapFilter) => filterAndMap(array, mapFilter),
-    sortBy: (sortByValue, props) => sortBy(array, sortByValue, props),
-    rejectDuplicates: (getKey) => rejectDuplicates(array, getKey),
-    findAndMap: (predicate) => findAndMap(array, predicate)
-  };
-}
-function intersperse(array, separator) {
-  const result = [];
-  for (let i = 0; i < array.length; i++) {
-    result.push(array[i]);
-    if (i < array.length - 1) {
-      result.push(separator);
-    }
-  }
-  return result;
-}
-function repeat(value, count, separator) {
-  const result = [];
-  for (let i = 0; i < count; i++) {
-    result.push(value);
-    if (separator !== void 0 && i < count - 1) {
-      result.push(separator);
-    }
-  }
-  return result;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  arrayOps,
-  arrayWithPrev,
-  arrayWithPrevAndIndex,
-  filterAndMap,
-  findAfterIndex,
-  findAndMap,
-  findBeforeIndex,
-  getAscIndexOrder,
-  hasDuplicates,
-  intersperse,
-  isInArray,
-  isInArrayWithoutNarrowing,
-  looseIsInArray,
-  rejectArrayUndefinedValues,
-  rejectDuplicates,
-  repeat,
-  sortBy,
-  truncateArray
-});

package/dist/arrayUtils.d.ts

@@ -1,171 +0,0 @@
-/**
- * Allow to filter and map with better typing ergonomics
- *
- * In the `mapFilter` function return `false` to reject the item, or any other
- * value to map it.
- *
- * @example
- *   // Filter reject and turn value into `value mapped`
- *   const items = ['value', 'value', 'reject', 'reject'];
- *
- *   const mappedItems = filterAndMap(items, (item) =>
- *     item === 'reject' ? false : `${item} mapped`,
- *   );
- *
- *   mappedItems; // ['value mapped', 'value mapped']
- *
- * @param array
- * @param mapFilter
- */
-declare function filterAndMap<T, R>(array: IterableIterator<T> | readonly T[], mapFilter: (item: T, index: number) => false | R): R[];
-type FilterAndMapReturn<T> = false | T;
-type SortOrder = 'desc' | 'asc';
-type SortByValueFn<T> = (item: T) => (number | string)[] | number | string;
-type SortByProps = {
-    order?: SortOrder | SortOrder[];
-} | SortOrder | SortOrder[];
-/**
- * Sort an array based on a value
- *
- * Sort by `ascending` order by default
- *
- * Use `Infinity` as as wildcard to absolute max and min values
- *
- * @example
- *   const items = [1, 3, 2, 4];
- *
- *   const sortedItems = sortBy(items, (item) => item);
- *   // [1, 2, 3, 4]
- *
- *   const items2 = [
- *     { a: 1, b: 2 },
- *     { a: 2, b: 1 },
- *     { a: 1, b: 1 },
- *   ];
- *
- *   // return a array to sort by multiple values
- *   const sortedItems = sortBy(items, (item) => [item.a, item.b]);
- *
- * @param arr
- * @param sortByValue
- * @param props
- */
-declare function sortBy<T>(arr: T[], sortByValue: SortByValueFn<T>, props?: SortByProps): T[];
-/**
- * Get the correct 0 based value for sync with other array in ascending order
- *
- * @example
- *   ```ts
- *   const items = [1, 2, 3];
- *
- *   const index = sortBy(
- *     items,
- *     (item) => getAscIndexOrder(
- *       followOrder.findIndex((order) => order === item)
- *     )
- *   );
- *   ```;
- *
- * @param index
- */
-declare function getAscIndexOrder(index: number | undefined): number;
-declare function arrayWithPrev<T>(array: T[]): [current: T, prev: T | null][];
-declare function arrayWithPrevAndIndex<T>(array: T[]): {
-    item: T;
-    prev: T | null;
-    index: number;
-}[];
-declare function isInArray<T, const U extends T>(value: T, oneOf: readonly U[]): value is U;
-declare function isInArrayWithoutNarrowing<T, const U extends T>(value: T, oneOf: readonly U[]): boolean;
-declare function looseIsInArray(value: unknown, array: readonly unknown[]): boolean;
-declare function findAfterIndex<T>(array: T[], index: number, predicate: (item: T) => boolean): T | undefined;
-declare function findBeforeIndex<T>(array: T[], index: number, predicate: (item: T) => boolean): T | undefined;
-declare function rejectArrayUndefinedValues<T extends unknown[]>(array: T): T;
-declare function hasDuplicates<T>(array: T[], getKey?: (item: T) => unknown): boolean;
-declare function rejectDuplicates<T>(array: T[], getKey?: (item: T) => unknown): T[];
-declare function truncateArray<T>(array: T[], maxLength: number, appendIfTruncated?: T | ((truncatedCount: number) => T)): T[];
-/**
- * Finds the first item in an array where the predicate returns a non-false
- * value and returns that mapped value.
- *
- * Combines find and map operations - applies the predicate to each item until
- * one returns a value that is not `false`, then returns that mapped value. If
- * no item matches, returns `undefined`.
- *
- * @example
- *   const users = [
- *     { id: 1, name: 'Alice' },
- *     { id: 2, name: 'Bob' },
- *   ];
- *
- *   const foundName = findAndMap(users, (user) =>
- *     user.id === 2 ? user.name.toUpperCase() : false,
- *   );
- *   // foundName is 'BOB'
- *
- * @param array - The array to search through
- * @param predicate - Function that returns a mapped value or `false` to skip
- *   the item
- * @returns The first mapped value that is not `false`, or `undefined` if no
- *   item matches
- */
-declare function findAndMap<T, R>(array: T[], predicate: (value: T) => R | false): R | undefined;
-type ArrayOps<T> = {
-    /**
-     * Filter and map an array
-     *
-     * @example
-     *   const items = [1, 2, 3];
-     *
-     *   const enhancedItems = arrayOps(items);
-     *
-     *   enhancedItems.filterAndMap((item) => (item === 2 ? false : item));
-     *
-     * @param mapFilter - A function that takes an item and returns a value or
-     *   `false` to reject the item.
-     */
-    filterAndMap: <R>(mapFilter: (item: T, index: number) => false | R) => R[];
-    sortBy: (sortByValue: SortByValueFn<T>, props: SortByProps) => T[];
-    rejectDuplicates: (getKey: (item: T) => unknown) => T[];
-    findAndMap: <R>(predicate: (value: T) => R | false) => R | undefined;
-};
-/**
- * Enhance an array with extra methods
- *
- * @example
- *   const enhancedItems = arrayOps(array);
- *
- *   enhancedItems.filterAndMap((item) => (item === 2 ? false : item));
- *   enhancedItems.sortBy((item) => item);
- *   enhancedItems.rejectDuplicates((item) => item);
- *
- * @param array
- */
-declare function arrayOps<T>(array: T[]): ArrayOps<T>;
-/**
- * Inserts a separator value between each element in an array.
- *
- * @example
- *   intersperse([1, 2, 3], 0); // [1, 0, 2, 0, 3]
- *
- * @param array - The array to intersperse
- * @param separator - The value to insert between elements
- * @returns A new array with separator values inserted between elements
- */
-declare function intersperse<T, I>(array: T[], separator: I): (T | I)[];
-/**
- * Creates an array by repeating a value a specified number of times, optionally
- * with a separator between each repetition.
- *
- * @example
- *   repeat('x', 3); // ['x', 'x', 'x']
- *   repeat('x', 3, '-'); // ['x', '-', 'x', '-', 'x']
- *
- * @param value - The value to repeat
- * @param count - Number of times to repeat the value
- * @param separator - Optional separator to insert between repetitions
- * @returns A new array with the repeated values
- */
-declare function repeat<T>(value: T, count: number, separator?: T): T[];
-
-export { type FilterAndMapReturn, type SortByProps, type SortByValueFn, arrayOps, arrayWithPrev, arrayWithPrevAndIndex, filterAndMap, findAfterIndex, findAndMap, findBeforeIndex, getAscIndexOrder, hasDuplicates, intersperse, isInArray, isInArrayWithoutNarrowing, looseIsInArray, rejectArrayUndefinedValues, rejectDuplicates, repeat, sortBy, truncateArray };

package/dist/arrayUtils.js

@@ -1,42 +0,0 @@
-import {
-  arrayOps,
-  arrayWithPrev,
-  arrayWithPrevAndIndex,
-  filterAndMap,
-  findAfterIndex,
-  findAndMap,
-  findBeforeIndex,
-  getAscIndexOrder,
-  hasDuplicates,
-  intersperse,
-  isInArray,
-  isInArrayWithoutNarrowing,
-  looseIsInArray,
-  rejectArrayUndefinedValues,
-  rejectDuplicates,
-  repeat,
-  sortBy,
-  truncateArray
-} from "./chunk-WFQJUJTC.js";
-import "./chunk-C2SVCIWE.js";
-import "./chunk-JF2MDHOJ.js";
-export {
-  arrayOps,
-  arrayWithPrev,
-  arrayWithPrevAndIndex,
-  filterAndMap,
-  findAfterIndex,
-  findAndMap,
-  findBeforeIndex,
-  getAscIndexOrder,
-  hasDuplicates,
-  intersperse,
-  isInArray,
-  isInArrayWithoutNarrowing,
-  looseIsInArray,
-  rejectArrayUndefinedValues,
-  rejectDuplicates,
-  repeat,
-  sortBy,
-  truncateArray
-};

package/dist/assertions.cjs

@@ -1,107 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/assertions.ts
-var assertions_exports = {};
-__export(assertions_exports, {
-  assertIsNotNullish: () => assertIsNotNullish,
-  assertIsNotUndefined: () => assertIsNotUndefined,
-  exhaustiveCheck: () => exhaustiveCheck,
-  invariant: () => invariant,
-  isFunction: () => isFunction2,
-  isObject: () => isObject2,
-  isPlainObject: () => isPlainObject2,
-  isPromise: () => isPromise2,
-  notNullish: () => notNullish,
-  notUndefined: () => notUndefined
-});
-module.exports = __toCommonJS(assertions_exports);
-
-// src/typeGuards.ts
-function isObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isFunction(value) {
-  return typeof value === "function";
-}
-function isPromise(value) {
-  return isObject(value) && "then" in value && isFunction(value.then);
-}
-function isPlainObject(value) {
-  if (!value || typeof value !== "object") return false;
-  const proto = Object.getPrototypeOf(value);
-  if (proto === null) {
-    return true;
-  }
-  const Ctor = Object.hasOwnProperty.call(proto, "constructor") && proto.constructor;
-  if (Ctor === Object) return true;
-  const objectCtorString = Object.prototype.constructor.toString();
-  return typeof Ctor == "function" && Function.toString.call(Ctor) === objectCtorString;
-}
-
-// src/assertions.ts
-var undefErrMsg = "not undefined assertion failed";
-var nullishErrMsg = "not nullish assertion failed";
-function notUndefined(value, error = undefErrMsg) {
-  if (value === void 0) {
-    throw typeof error === "function" ? error() : new Error(error);
-  }
-  return value;
-}
-function notNullish(value, error = nullishErrMsg) {
-  if (value === void 0 || value === null) {
-    throw typeof error === "function" ? error() : new Error(error);
-  }
-  return value;
-}
-function assertIsNotNullish(value, error = nullishErrMsg) {
-  if (value === void 0 || value === null) {
-    throw typeof error === "function" ? error() : new Error(error);
-  }
-}
-function assertIsNotUndefined(value, error = undefErrMsg) {
-  if (value === void 0) {
-    throw typeof error === "function" ? error() : new Error(error);
-  }
-}
-function invariant(condition, error = "Invariant violation") {
-  if (!condition) {
-    throw typeof error === "function" ? error() : new Error(`Invariant violation: ${error}`);
-  }
-}
-function exhaustiveCheck(narrowedType) {
-  return new Error("This should never happen");
-}
-var isFunction2 = isFunction;
-var isObject2 = isObject;
-var isPlainObject2 = isPlainObject;
-var isPromise2 = isPromise;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  assertIsNotNullish,
-  assertIsNotUndefined,
-  exhaustiveCheck,
-  invariant,
-  isFunction,
-  isObject,
-  isPlainObject,
-  isPromise,
-  notNullish,
-  notUndefined
-});