ts-data-forge 14.6.0 → 14.6.2

package/dist/array/impl/array-utils-validation.mjs

@@ -1,60 +1,58 @@
-import '../../number/branded-types/finite-number.mjs';
-import '../../number/branded-types/int.mjs';
-import '../../number/branded-types/int16.mjs';
-import '../../number/branded-types/int32.mjs';
-import '../../number/branded-types/negative-finite-number.mjs';
-import '../../number/branded-types/negative-int.mjs';
-import '../../number/branded-types/negative-safe-int.mjs';
-import '../../number/branded-types/non-negative-finite-number.mjs';
-import '../../number/branded-types/non-negative-int16.mjs';
-import '../../number/branded-types/non-negative-int32.mjs';
-import '../../number/branded-types/non-positive-finite-number.mjs';
-import '../../number/branded-types/non-positive-int.mjs';
-import '../../number/branded-types/non-positive-safe-int.mjs';
-import '../../number/branded-types/non-zero-finite-number.mjs';
-import '../../number/branded-types/non-zero-int.mjs';
-import '../../number/branded-types/non-zero-int16.mjs';
-import '../../number/branded-types/non-zero-int32.mjs';
-import '../../number/branded-types/non-zero-safe-int.mjs';
-import '../../number/branded-types/non-zero-uint16.mjs';
-import '../../number/branded-types/non-zero-uint32.mjs';
-import '../../number/branded-types/positive-finite-number.mjs';
-import '../../number/branded-types/positive-int.mjs';
-import '../../number/branded-types/positive-int16.mjs';
-import '../../number/branded-types/positive-int32.mjs';
-import '../../number/branded-types/positive-safe-int.mjs';
-import '../../number/branded-types/positive-uint16.mjs';
-import '../../number/branded-types/positive-uint32.mjs';
-import '../../number/branded-types/safe-int.mjs';
-import '../../number/branded-types/safe-uint.mjs';
-import '../../number/branded-types/uint.mjs';
-import '../../number/branded-types/uint16.mjs';
-import { asUint32 } from '../../number/branded-types/uint32.mjs';
-import '../../number/enum/int8.mjs';
-import '../../number/enum/uint8.mjs';
-import { Num } from '../../number/num.mjs';
-import '../../number/refined-number-utils.mjs';
-
-const isArray = (value) => Array.isArray(value);
-function every(...args) {
-  switch (args.length) {
-    case 2:
-      return everyImpl(...args);
-    case 1:
-      return (array) => everyImpl(array, ...args);
-  }
+import { asUint32, Num } from '../../number/index.mjs';
+/**
+ * Type guard that checks if a value is an array.
+ *
+ * @example
+ *
+ * ```ts
+ * const maybeArray: unknown = [1, 2, 3] as const;
+ *
+ * const maybeValue: unknown = 'Ada';
+ *
+ * assert.isTrue(Arr.isArray(maybeArray));
+ *
+ * assert.isFalse(Arr.isArray(maybeValue));
+ *
+ * if (Arr.isArray(maybeArray)) {
+ *   assert.deepStrictEqual(maybeArray, [1, 2, 3]);
+ * }
+ * ```
+ */
+export const isArray = (value) => Array.isArray(value);
+export function every(...args) {
+    switch (args.length) {
+        case 2:
+            return everyImpl(...args);
+        case 1:
+            return (array) => everyImpl(array, ...args);
+    }
 }
 const everyImpl = (array, predicate) => array.every((a, i) => predicate(a, asUint32(i)));
-function some(...args) {
-  switch (args.length) {
-    case 2:
-      return someImpl(...args);
-    case 1:
-      return (array) => someImpl(array, ...args);
-  }
+export function some(...args) {
+    switch (args.length) {
+        case 2:
+            return someImpl(...args);
+        case 1:
+            return (array) => someImpl(array, ...args);
+    }
 }
 const someImpl = (array, predicate) => array.some((a, i) => predicate(a, asUint32(i)));
-const indexIsInRange = (array, index) => Num.isInRange(0, array.length)(index);
-
-export { every, indexIsInRange, isArray, some };
-//# sourceMappingURL=array-utils-validation.mjs.map
+/**
+ * Checks if an index is within the valid range of an array.
+ *
+ * @example
+ *
+ * ```ts
+ * const items = ['Ada', 'Grace', 'Katherine'] as const;
+ *
+ * assert.isTrue(Arr.indexIsInRange(items, 1));
+ *
+ * assert.isFalse(Arr.indexIsInRange(items, 3));
+ *
+ * if (Arr.indexIsInRange(items, 2)) {
+ *   assert.isTrue(items[2] === 'Katherine');
+ * }
+ * ```
+ */
+export const indexIsInRange = (array, index) => Num.isInRange(0, array.length)(index);
+//# sourceMappingURL=array-utils-validation.mjs.map

package/dist/array/impl/array-utils-validation.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"array-utils-validation.mjs","sources":["../../../src/array/impl/array-utils-validation.mts"],"sourcesContent":["import {\n  type BoolOr,\n  type ChangeArrayElement,\n  type IsAny,\n  type IsUnknown,\n  type UnknownBrand,\n} from 'ts-type-forge';\nimport { asUint32, Num } from '../../number/index.mjs';\nimport { type ArrayIndex, type SizeType } from '../../types.mjs';\n\n/**\n * Type guard that checks if a value is an array.\n *\n * @example\n *\n * ```ts\n * const maybeArray: unknown = [1, 2, 3] as const;\n *\n * const maybeValue: unknown = 'Ada';\n *\n * assert.isTrue(Arr.isArray(maybeArray));\n *\n * assert.isFalse(Arr.isArray(maybeValue));\n *\n * if (Arr.isArray(maybeArray)) {\n *   assert.deepStrictEqual(maybeArray, [1, 2, 3]);\n * }\n * ```\n */\nexport const isArray = <E,>(value: E): value is FilterArray<E> =>\n  Array.isArray(value);\n\ntype FilterArray<T> = T extends T\n  ? BoolOr<IsUnknown<T>, IsAny<T>> extends true\n    ? Cast<readonly unknown[], T>\n    : T extends readonly unknown[]\n      ? T\n      : never // Exclude non-array types\n  : never;\n\ntype Cast<A, B> = A extends B ? A : never;\n\n// validation\n\n/**\n * Tests whether all elements in an array pass a test implemented by a predicate.\n *\n * @example\n *\n * ```ts\n * const numbers = [2, 4, 6] as const;\n *\n * const words = ['Ada', 'Grace'] as const;\n *\n * const allEven = Arr.every(numbers, (value) => value % 2 === 0);\n *\n * const allStartWithA = Arr.every(words, (value) => value.startsWith('A'));\n *\n * assert.isTrue(allEven);\n *\n * assert.isFalse(allStartWithA);\n * ```\n */\n// Type guard overloads - narrow the entire array type.\n//\n// Both narrowed types are intersected with `Ar`: a type predicate's type has\n// to be assignable to the parameter's type, and neither the deferred\n// conditional `ChangeArrayElement<Ar, S>` nor the mapped type over a generic\n// `Ar` is (TS2677). The intersection also keeps whatever the caller already\n// knew about the array — a branded five-tuple stays a five-tuple.\nexport function every<\n  const Ar extends readonly unknown[] & UnknownBrand,\n  S extends Ar[number],\n>(\n  array: Ar,\n  predicate: (a: Ar[number], index: ArrayIndex<Ar>) => a is S,\n): array is ChangeArrayElement<Ar, S> & Ar;\n\n// A plain array or tuple carries no length brand, so the homomorphic mapping\n// is the whole answer — same reasoning as in `map`.\nexport function every<\n  const Ar extends readonly unknown[],\n  S extends Ar[number],\n>(\n  array: Ar,\n  predicate: (a: Ar[number], index: ArrayIndex<Ar>) => a is S,\n): array is Readonly<{ [K in keyof Ar]: S }> & Ar;\n\n// Regular boolean predicate overloads\nexport function every<const Ar extends readonly unknown[]>(\n  array: Ar,\n  predicate: (a: Ar[number], index: ArrayIndex<Ar>) => boolean,\n): boolean;\n\n// curried version\n//\n// As in `map`, the branded and the plain case have to be overloads *of the\n// returned function*, not two overloads of `every` itself: both curried\n// signatures take the same single predicate, so overload resolution would\n// always pick the first and the second would be dead — which is what left a\n// plain `readonly unknown[]` unable to satisfy the `UnknownBrand` constraint\n// at the call site of the returned guard.\n//\n// The intersection is also what keeps the group compatible with the\n// implementation signature. A lone `<Ar extends readonly E[] & UnknownBrand>`\n// signature is not something `(array: readonly E[]) => boolean` can implement\n// (TS2394); the unbranded member of the intersection is, and one matching\n// member is enough.\nexport function every<E, S extends E>(\n  predicate: (a: E, index: SizeType.Arr) => a is S,\n): (<const Ar extends readonly E[] & UnknownBrand>(\n  array: Ar,\n) => array is ChangeArrayElement<Ar, S> & Ar) &\n  (<const Ar extends readonly E[]>(\n    array: Ar,\n  ) => array is Readonly<{ [K in keyof Ar]: S }> & Ar);\n\nexport function every<E>(\n  predicate: (a: E, index: SizeType.Arr) => boolean,\n): (array: readonly E[]) => boolean;\n\nexport function every<E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        predicate: (a: E, index: SizeType.Arr) => boolean,\n      ]\n    | readonly [predicate: (a: E, index: SizeType.Arr) => boolean]\n): boolean | ((array: readonly E[]) => boolean) {\n  switch (args.length) {\n    case 2:\n      return everyImpl(...args);\n\n    case 1:\n      return (array) => everyImpl(array, ...args);\n  }\n}\n\nconst everyImpl = <E,>(\n  array: readonly E[],\n  predicate: (a: E, index: SizeType.Arr) => boolean,\n): boolean => array.every((a, i) => predicate(a, asUint32(i)));\n\n/**\n * Tests whether at least one element in an array passes a test implemented by a predicate.\n *\n * @example\n *\n * ```ts\n * const numbers = [1, 3, 5] as const;\n *\n * const words = ['Ada', 'Grace'] as const;\n *\n * const hasEven = Arr.some(numbers, (value) => value % 2 === 0);\n *\n * const hasShortName = Arr.some(words, (value) => value.length <= 3);\n *\n * assert.isFalse(hasEven);\n *\n * assert.isTrue(hasShortName);\n * ```\n */\nexport function some<const Ar extends readonly unknown[]>(\n  array: Ar,\n  predicate: (a: Ar[number], index: ArrayIndex<Ar>) => boolean,\n): boolean;\n\nexport function some<E>(\n  predicate: (a: E, index: SizeType.Arr) => boolean,\n): (array: readonly E[]) => boolean;\n\nexport function some<E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        predicate: (a: E, index: SizeType.Arr) => boolean,\n      ]\n    | readonly [predicate: (a: E, index: SizeType.Arr) => boolean]\n): boolean | ((array: readonly E[]) => boolean) {\n  switch (args.length) {\n    case 2:\n      return someImpl(...args);\n\n    case 1:\n      return (array) => someImpl(array, ...args);\n  }\n}\n\nconst someImpl = <E,>(\n  array: readonly E[],\n  predicate: (a: E, index: SizeType.Arr) => boolean,\n): boolean => array.some((a, i) => predicate(a, asUint32(i)));\n\n/**\n * Checks if an index is within the valid range of an array.\n *\n * @example\n *\n * ```ts\n * const items = ['Ada', 'Grace', 'Katherine'] as const;\n *\n * assert.isTrue(Arr.indexIsInRange(items, 1));\n *\n * assert.isFalse(Arr.indexIsInRange(items, 3));\n *\n * if (Arr.indexIsInRange(items, 2)) {\n *   assert.isTrue(items[2] === 'Katherine');\n * }\n * ```\n */\nexport const indexIsInRange = <E,>(\n  array: readonly E[],\n  index: SizeType.ArgArr,\n): boolean => Num.isInRange(0, array.length)(index);\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BO,MAAM,OAAA,GAAU,CAAK,KAAA,KAC1B,KAAA,CAAM,QAAQ,KAAK;AA2Fd,SAAS,SACX,IAAA,EAM2C;AAC9C,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA;AACH,MAAA,OAAO,SAAA,CAAU,GAAG,IAAI,CAAA;AAAA,IAE1B,KAAK,CAAA;AACH,MAAA,OAAO,CAAC,KAAA,KAAU,SAAA,CAAU,KAAA,EAAO,GAAG,IAAI,CAAA;AAAA;AAEhD;AAEA,MAAM,SAAA,GAAY,CAChB,KAAA,EACA,SAAA,KACY,MAAM,KAAA,CAAM,CAAC,CAAA,EAAG,CAAA,KAAM,SAAA,CAAU,CAAA,EAAG,QAAA,CAAS,CAAC,CAAC,CAAC,CAAA;AA8BtD,SAAS,QACX,IAAA,EAM2C;AAC9C,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA;AACH,MAAA,OAAO,QAAA,CAAS,GAAG,IAAI,CAAA;AAAA,IAEzB,KAAK,CAAA;AACH,MAAA,OAAO,CAAC,KAAA,KAAU,QAAA,CAAS,KAAA,EAAO,GAAG,IAAI,CAAA;AAAA;AAE/C;AAEA,MAAM,QAAA,GAAW,CACf,KAAA,EACA,SAAA,KACY,MAAM,IAAA,CAAK,CAAC,CAAA,EAAG,CAAA,KAAM,SAAA,CAAU,CAAA,EAAG,QAAA,CAAS,CAAC,CAAC,CAAC,CAAA;AAmBrD,MAAM,cAAA,GAAiB,CAC5B,KAAA,EACA,KAAA,KACY,GAAA,CAAI,UAAU,CAAA,EAAG,KAAA,CAAM,MAAM,CAAA,CAAE,KAAK;;;;"}
+{"version":3,"file":"array-utils-validation.mjs","sourceRoot":"","sources":["../../../src/array/impl/array-utils-validation.mts"],"names":[],"mappings":"AAOA,OAAO,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAGvD;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,CAAK,KAAQ,EAA2B,EAAE,CAC/D,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AA2FvB,MAAM,UAAU,KAAK,CACnB,GAAG,IAK6D;IAEhE,QAAQ,IAAI,CAAC,MAAM,EAAE,CAAC;QACpB,KAAK,CAAC;YACJ,OAAO,SAAS,CAAC,GAAG,IAAI,CAAC,CAAC;QAE5B,KAAK,CAAC;YACJ,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,SAAS,CAAC,KAAK,EAAE,GAAG,IAAI,CAAC,CAAC;IAChD,CAAC;AACH,CAAC;AAED,MAAM,SAAS,GAAG,CAChB,KAAmB,EACnB,SAAiD,EACxC,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,SAAS,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AA8B/D,MAAM,UAAU,IAAI,CAClB,GAAG,IAK6D;IAEhE,QAAQ,IAAI,CAAC,MAAM,EAAE,CAAC;QACpB,KAAK,CAAC;YACJ,OAAO,QAAQ,CAAC,GAAG,IAAI,CAAC,CAAC;QAE3B,KAAK,CAAC;YACJ,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,QAAQ,CAAC,KAAK,EAAE,GAAG,IAAI,CAAC,CAAC;IAC/C,CAAC;AACH,CAAC;AAED,MAAM,QAAQ,GAAG,CACf,KAAmB,EACnB,SAAiD,EACxC,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,SAAS,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAE9D;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAC5B,KAAmB,EACnB,KAAsB,EACb,EAAE,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,CAAC"}

package/dist/array/impl/index.mjs

@@ -1,17 +1,17 @@
-export { copy, create, generate, generateAsync, newArray, range, seq, zeros } from './array-utils-creation.mjs';
-export { at, first, head, last } from './array-utils-element-access.mjs';
-export { entries, indices, keys, values } from './array-utils-iterators.mjs';
-export { asBoundedLengthArray, asEmptyArray, asFixedLengthArray, asMaxLengthArray, asMinLengthArray, asNonEmptyArray } from './array-utils-length-bounded-array-cast.mjs';
-export { isBoundedLengthArray, isEmpty, isFixedLengthArray, isMaxLengthArray, isMinLengthArray, isNonEmpty } from './array-utils-length-bounded-array-guard.mjs';
-export { asBoundedLengthTuple, asEmptyTuple, asFixedLengthTuple, asMaxLengthTuple, asMinLengthTuple, asNonEmptyTuple } from './array-utils-length-bounded-tuple-cast.mjs';
-export { isBoundedLengthTuple, isEmptyTuple, isFixedLengthTuple, isMaxLengthTuple, isMinLengthTuple, isNonEmptyTuple } from './array-utils-length-bounded-tuple-guard.mjs';
-export { set, toFilled, toInserted, toPushed, toRangeFilled, toRemoved, toUnshifted, toUpdated } from './array-utils-modification.mjs';
-export { count, countBy, foldl, foldr, join, max, maxBy, min, minBy, reduce, reduceRight, sum, sumBy } from './array-utils-reducing-value.mjs';
-export { find, findIndex, findLast, findLastIndex, indexOf, indexOfFrom, lastIndexOf, lastIndexOfFrom } from './array-utils-search.mjs';
-export { eq, equal, isSubset, isSuperset, setDifference, setIntersection, sortedNumSetDifference } from './array-utils-set-op.mjs';
-export { length, size } from './array-utils-size.mjs';
-export { sliceClamped } from './array-utils-slice-clamped.mjs';
-export { butLast, drop, rest, skip, skipLast, tail, take, takeLast } from './array-utils-slicing.mjs';
-export { cartesianProduct, chunk, concat, filter, filterNot, flat, flatMap, groupBy, map, partition, scan, toReversed, toSorted, toSortedBy, uniq, uniqBy, zip } from './array-utils-transformation.mjs';
-export { every, indexIsInRange, isArray, some } from './array-utils-validation.mjs';
-//# sourceMappingURL=index.mjs.map
+export * from './array-utils-creation.mjs';
+export * from './array-utils-element-access.mjs';
+export * from './array-utils-iterators.mjs';
+export * from './array-utils-length-bounded-array-cast.mjs';
+export * from './array-utils-length-bounded-array-guard.mjs';
+export * from './array-utils-length-bounded-tuple-cast.mjs';
+export * from './array-utils-length-bounded-tuple-guard.mjs';
+export * from './array-utils-modification.mjs';
+export * from './array-utils-reducing-value.mjs';
+export * from './array-utils-search.mjs';
+export * from './array-utils-set-op.mjs';
+export * from './array-utils-size.mjs';
+export * from './array-utils-slice-clamped.mjs';
+export * from './array-utils-slicing.mjs';
+export * from './array-utils-transformation.mjs';
+export * from './array-utils-validation.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/array/impl/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../../../src/array/impl/index.mts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,kCAAkC,CAAC;AACjD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,6CAA6C,CAAC;AAC5D,cAAc,8CAA8C,CAAC;AAC7D,cAAc,6CAA6C,CAAC;AAC5D,cAAc,8CAA8C,CAAC;AAC7D,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kCAAkC,CAAC;AACjD,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,iCAAiC,CAAC;AAChD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kCAAkC,CAAC;AACjD,cAAc,8BAA8B,CAAC"}

package/dist/array/index.mjs

@@ -1,3 +1,2 @@
-import * as index from './impl/index.mjs';
-export { index as Arr };
-//# sourceMappingURL=index.mjs.map
+export * as Arr from './impl/index.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/array/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";"}
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../../src/array/index.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,kBAAkB,CAAC"}