@thi.ng/arrays 2.8.7 → 2.8.8

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2024-03-07T20:40:47Z
+- **Last updated**: 2024-03-13T14:04:31Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.

package/arg-sort.d.ts

@@ -7,12 +7,14 @@
  * Also see {@link swizzle} to read an array in custom order.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/arg-sort.ts
  * import { argSort, swizzle } from "@thi.ng/arrays";
  *
  * const src = ["a", "c", "d", "b"];
  *
- * argSort(src)
+ * console.log(
+ *   argSort(src)
+ * );
  * // [ 0, 3, 1, 2 ]
  *
  * // src[0] => "a"
@@ -20,7 +22,9 @@
  * // src[1] => "c"
  * // src[2] => "d"
  *
- * swizzle(argSort(src))(src)
+ * console.log(
+ *   swizzle(argSort(src))(src)
+ * );
  * // [ 'a', 'b', 'c', 'd' ]
  * ```
  *

package/argmin.d.ts

@@ -8,14 +8,18 @@ import type { Predicate2 } from "@thi.ng/api";
  * See {@link argMax}.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/argmin.ts
  * import { argMin } from "@thi.ng/arrays";
  *
- * argMin([42, 11, 66, 23])
+ * console.log(
+ *   argMin([42, 11, 66, 23])
+ * );
  * // 1
  *
  * // same as argmax() with defaults
- * argMin([42, 11, 66, 23], -Infinity, (a, b) => a > b)
+ * console.log(
+ *   argMin([42, 11, 66, 23], -Infinity, (a, b) => a > b)
+ * );
  * // 2
  * ```
  *

package/binary-search.d.ts

@@ -16,10 +16,12 @@ import type { Comparator, Fn, FnN, FnN2 } from "@thi.ng/api";
  * compatible with that of `cmp`.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/binary-search1.ts
  * import { binarySearch } from "@thi.ng/arrays";
  *
- * binarySearch([2, 4, 6], 5);
+ * console.log(
+ *   binarySearch([2, 4, 6], 5)
+ * );
  * // -3
  * ```
  *
@@ -82,10 +84,12 @@ export declare const binarySearch32: (buf: ArrayLike<number>, x: number) => numb
  * values exist.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/binary-search2.ts
  * import { binarySearch, bsLT } from "@thi.ng/arrays";
  *
- * bsLT(binarySearch([10, 20, 30, 40], 25))
+ * console.log(
+ *   bsLT(binarySearch([10, 20, 30, 40], 25))
+ * )
  * // 1
  * ```
  *
@@ -104,15 +108,19 @@ export declare const bsLE: FnN;
  * such values exist.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/binary-search3.ts
  * import { binarySearch, bsGT } from "@thi.ng/arrays";
  *
- * src = [10, 20, 30, 40];
+ * const src = [10, 20, 30, 40];
  *
- * bsGT(binarySearch(src, 25), src.length)
+ * console.log(
+ *   bsGT(binarySearch(src, 25), src.length)
+ * )
  * // 2
  *
- * bsGT(binarySearch(src, 40), src.length)
+ * console.log(
+ *   bsGT(binarySearch(src, 40), src.length)
+ * )
  * // -1
  * ```
  *

package/blit.d.ts

@@ -9,19 +9,21 @@ import type { Fn3, TypedArray } from "@thi.ng/api";
  * the [0..dest.length) interval.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/blit1d.ts
  * import { blit1d } from "@thi.ng/arrays";
  *
- * blit1d(
- *    // dest array
- *    [1, 1, 1, 1, 1, 1, 1, 1, 1],
- *    // paste from index 2
- *    2,
- *    // source array
- *    [2, 3, 2, 3, 2],
- *    // mask value
- *    3
- * )
+ * console.log(
+ *   blit1d(
+ *      // dest array
+ *      [1, 1, 1, 1, 1, 1, 1, 1, 1],
+ *      // paste from index 2
+ *      2,
+ *      // source array
+ *      [2, 3, 2, 3, 2],
+ *      // mask value
+ *      3
+ *   )
+ * );
  * //[1, 1, 2, 1, 2, 1, 2, 1, 1]
  * ```
  *

package/fill-range.d.ts

@@ -8,13 +8,17 @@ import type { TypedArray } from "@thi.ng/api";
  * or -1 (depending on range). Returns array.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/fill-range.ts
  * import { fillRange } from "@thi.ng/arrays";
  *
- * fillRange(new Array(5))
+ * console.log(
+ *   fillRange(new Array(5))
+ * );
  * // [ 0, 1, 2, 3, 4 ]
  *
- * fillRange(fillRange([], 0, 10, 20, 2), 5, 20, 8, -2)
+ * console.log(
+ *   fillRange(fillRange([], 0, 10, 20, 2), 5, 20, 8, -2)
+ * );
  * // [ 10, 12, 14, 16, 18, 20, 18, 16, 14, 12, 10 ]
  * ```
  *

package/floyd-rivest.d.ts

@@ -12,10 +12,12 @@ import type { Comparator } from "@thi.ng/api";
  * the `[left, k]` interval are the smallest.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/floyd-rivest.ts
  * import { floydRivest } from "@thi.ng/arrays";
  *
- * floydRivest([5, 3, -1, -10, 20, 7, 0, 4, 2], 3);
+ * console.log(
+ *   floydRivest([5, 3, -1, -10, 20, 7, 0, 4, 2], 3)
+ * );
  * // [ -10, 0, -1, 2, 3,  4, 5, 20, 7 ]
  * ```
  *

package/is-sorted.d.ts

@@ -10,14 +10,18 @@ import type { Comparator } from "@thi.ng/api";
  * two elements. No bounds checking.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/is-sorted.ts
  * import { isSorted } from "@thi.ng/arrays";
  *
- * isSorted([3, 2, 1])
+ * console.log(
+ *   isSorted([3, 2, 1])
+ * );
  * // false
  *
  * // w/ custom comparator
- * isSorted([3, 2, 1], (a, b) => b - a)
+ * console.log(
+ *   isSorted([3, 2, 1], (a, b) => b - a)
+ * );
  * // true
  * ```
  *

package/levenshtein.d.ts

@@ -13,20 +13,24 @@ import type { Predicate2 } from "@thi.ng/api";
  * - https://github.com/gustf/js-levenshtein/blob/develop/index.js
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/levenshtein.ts
  * import { levenshtein } from "@thi.ng/arrays";
  *
- * levenshtein([1, 2, 3, 4, 5], [1, 2, 4, 3, 5]);
+ * console.log(
+ *   levenshtein([1, 2, 3, 4, 5], [1, 2, 4, 3, 5])
+ * );
  * // 2
  *
- * levenshtein(
- *   [{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }, { id: 5 }],
- *   [{ id: 4 }, { id: 5 }, { id: 3 }, { id: 1 }, { id: 2 }],
- *   // max dist
- *   2,
- *   // predicate
- *   (a, b) => a.id === b.id
- * )
+ * console.log(
+ *   levenshtein(
+ *     [{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }, { id: 5 }],
+ *     [{ id: 4 }, { id: 5 }, { id: 3 }, { id: 1 }, { id: 2 }],
+ *     // max dist
+ *     2,
+ *     // predicate
+ *     (a, b) => a.id === b.id
+ *   )
+ * );
  * // Infinity
  * ```
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/arrays",
-  "version": "2.8.7",
+  "version": "2.8.8",
   "description": "Array / Arraylike utilities",
   "type": "module",
   "module": "./index.js",
@@ -36,19 +36,19 @@
     "tool:tangle": "../../node_modules/.bin/tangle src/**/*.ts"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.9.29",
-    "@thi.ng/checks": "^3.5.2",
-    "@thi.ng/compare": "^2.2.25",
-    "@thi.ng/equiv": "^2.1.51",
-    "@thi.ng/errors": "^2.4.20",
-    "@thi.ng/random": "^3.6.36"
+    "@thi.ng/api": "^8.9.30",
+    "@thi.ng/checks": "^3.5.3",
+    "@thi.ng/compare": "^2.2.26",
+    "@thi.ng/equiv": "^2.1.52",
+    "@thi.ng/errors": "^2.5.0",
+    "@thi.ng/random": "^3.6.37"
   },
   "devDependencies": {
-    "@microsoft/api-extractor": "^7.40.1",
-    "esbuild": "^0.20.0",
+    "@microsoft/api-extractor": "^7.42.3",
+    "esbuild": "^0.20.1",
     "rimraf": "^5.0.5",
-    "typedoc": "^0.25.7",
-    "typescript": "^5.3.3"
+    "typedoc": "^0.25.12",
+    "typescript": "^5.4.2"
   },
   "keywords": [
     "aos",
@@ -166,5 +166,5 @@
   "thi.ng": {
     "year": 2018
   },
-  "gitHead": "69100942474942f7446ac645d59d91e7dfc352f9\n"
+  "gitHead": "7f3fcbd6c0462b0ce45afa141fe163d1f297fd51\n"
 }

package/quicksort.d.ts

@@ -16,20 +16,23 @@ import type { Comparator, Fn3, TypedArray } from "@thi.ng/api";
  * - https://en.wikipedia.org/wiki/Quicksort#Hoare_partition_scheme
  *
  * @example
- * ```ts
- * import { quickSort } from "@thi.ng/arrays";
+ * ```ts tangle:../export/quicksort.ts
+ * import { quickSort, multiSwap } from "@thi.ng/arrays";
  *
- * a = [4, 3, 1, 8, 5]
- * b = [40, 30, 10, 80, 50]
- * c = [-4, -3, -1, -8, -5]
+ * const a = [4, 3, 1, 8, 5]
+ * const b = [40, 30, 10, 80, 50]
+ * const c = [-4, -3, -1, -8, -5]
  *
  * // use `multiSwap` to sort extra arrays based on sort order of `a`
- * quickSort(a, undefined, multiSwap(b, c))
+ * console.log(
+ *   quickSort(a, undefined, multiSwap(b, c))
+ * );
  * // [ 1, 3, 4, 5, 8 ] (a)
  *
- * b
+ * console.log(b);
  * // [ 10, 30, 40, 50, 80 ]
- * c
+ *
+ * console.log(c);
  * // [ -1, -3, -4, -5, -8 ]
  * ```
  *

package/rotate.d.ts

@@ -11,7 +11,7 @@ import type { TypedArray } from "@thi.ng/api";
  * @param buf
  * @param num
  */
-export declare const rotate: <T>(buf: T[], num: number) => T[];
+export declare const rotate: <T>(buf: Array<T>, num: number) => T[];
 /**
  * Same as {@link rotate}, but for optimized for typed arrays!
  *

package/sort-cached.d.ts

@@ -13,14 +13,18 @@ import type { Comparator, Fn } from "@thi.ng/api";
  * re-evaluated multiple times from within a comparator.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/sort-cached.ts
  * import { sortByCachedKey } from "@thi.ng/arrays";
  *
  * // sort by length in descending order
- * sortByCachedKey(["a","bbbb","ccc","dd"], (x) => x.length, (a, b) => b - a);
+ * console.log(
+ *   sortByCachedKey(["a","bbbb","ccc","dd"], (x) => x.length, (a, b) => b - a)
+ * );
  * // [ 'bbbb', 'ccc', 'dd', 'a' ]
  *
- * sortByCachedKey(["a", "b", "c", "d"], [3, 2, 1, 0])
+ * console.log(
+ *   sortByCachedKey(["a", "b", "c", "d"], [3, 2, 1, 0])
+ * );
  * // [ 'd', 'c', 'b', 'a' ]
  * ```
  *
@@ -28,5 +32,5 @@ import type { Comparator, Fn } from "@thi.ng/api";
  * @param key -
  * @param cmp -
  */
-export declare const sortByCachedKey: <T, K>(src: T[], key: Fn<T, K> | K[], cmp?: Comparator<K>) => T[];
+export declare const sortByCachedKey: <T, K>(src: T[], key: K[] | Fn<T, K>, cmp?: Comparator<K>) => T[];
 //# sourceMappingURL=sort-cached.d.ts.map

package/swap.d.ts

@@ -21,19 +21,24 @@ export declare const swap: (arr: AnyArray, x: number, y: number) => void;
  * {@link quickSort}
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/multiswap.ts
  * import { multiSwap } from "@thi.ng/arrays";
  *
- * a = [2, 1];
- * b = [20, 10];
- * c = [40, 30];
+ * const a = [2, 1];
+ * const b = [20, 10];
+ * const c = [40, 30];
  *
- * ms = multiSwap(b, c);
+ * const ms = multiSwap(b, c);
  * ms(a, 0, 1);
  *
- * // a: [1, 2]
- * // b: [10, 20]
- * // c: [30, 40]
+ * console.log(a);
+ * // [1, 2]
+ *
+ * console.log(b);
+ * // [10, 20]
+ *
+ * console.log(c);
+ * // [30, 40]
  * ```
  *
  * @param xs - arrays to swap in later

package/swizzle.d.ts

@@ -8,22 +8,36 @@ import type { Fn } from "@thi.ng/api";
  * approach is used.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/swizzle1.ts
  * import { swizzle } from "@thi.ng/arrays";
  *
- * swizzle([0, 0, 0])([1, 2, 3, 4])    // [ 1, 1, 1 ]
- * swizzle([1, 1, 3, 3])([1, 2, 3, 4]) // [ 2, 2, 4, 4 ]
- * swizzle([2, 0])([1, 2, 3])          // [ 3, 1 ]
+ * console.log(
+ *   swizzle([0, 0, 0])([1, 2, 3, 4])
+ * );
+ * // [ 1, 1, 1 ]
+ *
+ * console.log(
+ *   swizzle([1, 1, 3, 3])([1, 2, 3, 4])
+ * );
+ * // [ 2, 2, 4, 4 ]
+ *
+ * console.log(
+ *   swizzle([2, 0])([1, 2, 3])
+ * );
+ * // [ 3, 1 ]
  * ```
  *
  * @example
  * Objects can be used as input to the generated function, but the
  * result will always be in array form.
 
- * ```ts
+ * ```ts tangle:../export/swizzle2.ts
  * import { swizzle } from "@thi.ng/arrays";
  *
- * swizzle(["a", "c", "b"])({a: 1, b: 2, c: 3}) // [ 1, 3, 2 ]
+ * console.log(
+ *   swizzle(["a", "c", "b"])({a: 1, b: 2, c: 3})
+ * );
+ * // [ 1, 3, 2 ]
  * ```
  *
  * @param order - indices

package/threshold.d.ts

@@ -9,18 +9,22 @@
  * comparison.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/select-threshold.ts
  * import { selectThresholdMin } from "@thi.ng/arrays";
  *
  * const numColumns = selectThresholdMin({ 480: 1, 640: 2, 960: 3 }, 4);
  *
- * numColumns(320) // 1
+ * console.log(numColumns(320));
+ * // 1
  *
- * numColumns(481) // 2
+ * console.log(numColumns(481));
+ * // 2
  *
- * numColumns(768) // 3
+ * console.log(numColumns(768));
+ * // 3
  *
- * numColumns(1024) // 4
+ * console.log(numColumns(1024));
+ * // 4
  * ```
  *
  * @param thresholds

package/topo-sort.d.ts

@@ -11,22 +11,27 @@ import type { Fn, Nullable, IObjectOf } from "@thi.ng/api";
  * cycle will be part of the error message (see second example below).
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/topo-sort.ts
  * import { topoSort } from "@thi.ng/arrays";
  *
- * const graph = {
+ * const graph: Record<string, { deps?: string[] }> = {
  *   a: { deps: ["c", "b"] },
  *   b: {},
  *   c: { deps: ["d"] },
  *   d: { deps: ["b"] }
  * };
- * topoSort(graph, (node) => node.deps);
+ *
+ * console.log(
+ *   topoSort(graph, (node) => node.deps)
+ * );
  * // [ "b", "d", "c", "a" ]
  *
  * // An error will be thrown if the graph contains cycles...
- * graph.d.deps.push("a");
+ * graph.d.deps!.push("a");
  *
- * topoSort(graph, (node) => node.deps);
+ * console.log(
+ *   topoSort(graph, (node) => node.deps)
+ * );
  * // Uncaught Error: illegal state: dependency cycle: a -> c -> d -> a
  * ```
  *