@isopodlabs/utilities 1.5.4 → 1.5.6

package/README.md

@@ -1,6 +1,6 @@
 # @isopodlabs/utilities
 [![npm version](https://img.shields.io/npm/v/@isopodlabs/utilities.svg)](https://www.npmjs.com/package/@isopodlabs/utilities)
-[![GitHub stars](https://img.shields.io/github/stars/adrianstephens/utilities.svg?style=social)](https://github.com/adrianstephens/utilities)
+[![GitHub stars](https://img.shields.io/github/stars/adrianstephens/ts-utilities.svg?style=social)](https://github.com/adrianstephens/ts-utilities)
 [![License](https://img.shields.io/npm/l/@isopodlabs/utilities.svg)](LICENSE.txt)
 
 This package provides a set of utilities for TypeScript.

package/dist/algorithm.d.ts

@@ -1,6 +1,7 @@
 type PartitionIndex<U> = U extends boolean ? 'true' | 'false' : U;
 export declare function partition<T, U extends keyof any | boolean>(array: Iterable<T>, func: (v: T) => U): Record<PartitionIndex<U>, T[]>;
-export declare function lowerBound<T>(array: T[], value: T, func: (a: T, b: T, i: number) => boolean): number;
+export declare function less<T>(a: T, b: T): boolean;
+export declare function lowerBound<T>(array: T[], value: T, func?: (a: T, b: T, i: number) => boolean): number;
 export declare function argmin<T>(array: T[], func?: (a: T, b: T) => number): number;
 export declare function min<T>(array: T[], func?: (a: T, b: T) => number): T;
 export declare function argmax<T>(array: T[], func?: (a: T, b: T) => number): number;

package/dist/algorithm.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.partition = partition;
+exports.less = less;
 exports.lowerBound = lowerBound;
 exports.argmin = argmin;
 exports.min = min;
@@ -13,7 +14,10 @@ function partition(array, func) {
         (partitions[func(i)] ??= []).push(i);
     return partitions;
 }
-function lowerBound(array, value, func) {
+function less(a, b) {
+    return a < b;
+}
+function lowerBound(array, value, func = less) {
     let i = 0;
     for (let n = array.length; n; n >>= 1) {
         const mid = i + (n >> 1);

package/dist/array.d.ts

@@ -0,0 +1,6 @@
+export declare function remove<T>(array: T[], item: T): boolean;
+export declare function compare<T>(arr1: T[], arr2: T[]): number;
+export declare function equal<T>(arr1: T[], arr2: T[]): boolean;
+export declare function reverse<T>(array: T[], start: number, end: number): void;
+export declare function rotate<T>(array: T[], start: number, end: number, shift: number): void;
+export declare function make<T>(n: number, constructor: new () => T): T[];

package/dist/array.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.remove = remove;
+exports.compare = compare;
+exports.equal = equal;
+exports.reverse = reverse;
+exports.rotate = rotate;
+exports.make = make;
+const object_1 = require("./object");
+//-----------------------------------------------------------------------------
+//	array
+//-----------------------------------------------------------------------------
+//remove element of array
+function remove(array, item) {
+    const index = array.indexOf(item);
+    if (index === -1)
+        return false;
+    array.splice(index, 1);
+    return true;
+}
+function compare(arr1, arr2) {
+    const length = Math.min(arr1.length, arr2.length);
+    for (let i = 0; i < length; i++) {
+        const r = (0, object_1.compare)(arr1[i], arr2[i]);
+        if (r)
+            return r;
+    }
+    return arr1.length - arr2.length;
+}
+function equal(arr1, arr2) {
+    if (arr1.length !== arr2.length)
+        return false;
+    for (let i = 0; i < arr1.length; i++) {
+        if (arr1[i] !== arr2[i])
+            return false;
+    }
+    return true;
+}
+function reverse(array, start, end) {
+    while (start < end) {
+        [array[start], array[end]] = [array[end], array[start]];
+        start++;
+        end--;
+    }
+}
+function rotate(array, start, end, shift) {
+    const length = end - start;
+    if (length > 1 && shift % length) {
+        shift = ((shift % length) + length) % length;
+        reverse(array, start, end - 1);
+        reverse(array, start, start + shift - 1);
+        reverse(array, start + shift, end - 1);
+    }
+}
+function make(n, constructor) {
+    return Array.from({ length: n }, () => new constructor);
+}

package/dist/async.d.ts

@@ -0,0 +1,4 @@
+export declare function map<T, U>(iterable: Iterable<T> | undefined, func: (v: T, i: number) => Promise<U>): Promise<U[]>;
+export declare function mapSerial<T, U>(iterable: Iterable<T> | undefined, func: (v: T, i: number) => Promise<U>): Promise<U[]>;
+export declare function reduce<T, U>(iterable: Iterable<T>, func: (acc: U, v: T, i: number, iterable: Iterable<T>) => Promise<U>, initialValue: U): Promise<U>;
+export declare function filter<T>(iterable: Iterable<T>, func: (v: T) => Promise<unknown>): Promise<T[]>;

package/dist/async.js

@@ -0,0 +1,65 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.map = map;
+exports.mapSerial = mapSerial;
+exports.reduce = reduce;
+exports.filter = filter;
+const iterator = __importStar(require("./iterator"));
+//-----------------------------------------------------------------------------
+//	async
+//-----------------------------------------------------------------------------
+//let forceSerial = false;
+async function map(iterable, func) {
+    return Promise.all(iterator.map(iterable, func));
+}
+async function mapSerial(iterable, func) {
+    const results = [];
+    let i = 0;
+    for (const v of iterable || [])
+        results.push(await func(v, i++));
+    return results;
+}
+async function reduce(iterable, func, initialValue) {
+    let acc = initialValue;
+    let i = 0;
+    for (const v of iterable)
+        acc = await func(acc, v, i++, iterable);
+    return acc;
+}
+async function filter(iterable, func) {
+    const filters = await map(iterable, func);
+    return iterator.filter(iterable, (_, i) => filters[i]);
+}

package/dist/bits.d.ts

@@ -0,0 +1,82 @@
+export declare function lowestSet32(x: number): number;
+export declare function highestSet32(x: number): number;
+export declare function countSet32(x: number): number;
+export declare function highestSet(x: bigint | number): number;
+export declare function lowestSet(x: number | bigint): number;
+export declare function countSet(x: bigint | number): number;
+export declare function highestClear(x: number | bigint): number;
+export declare function lowestClear(x: number | bigint): number;
+export declare function countClear(x: bigint | number): number;
+export declare class ImmutableSparseBits {
+    protected bits: number[];
+    protected undef: number;
+    static whereGenerator(bits: number[], undef: number, set: boolean, from?: number): Generator<number>;
+    constructor(initial?: boolean);
+    protected create(init?: boolean): this;
+    protected copyUndefined(other: ImmutableSparseBits): this;
+    protected flipUndefined(other: ImmutableSparseBits): this;
+    static fromEntries<T extends ImmutableSparseBits>(this: new (initial?: boolean) => T, entries: Record<number, number> | [number, number][], initial?: boolean): T;
+    keys(): number[];
+    entries(): [number, number][];
+    complement(): this;
+    intersect(other: ImmutableSparseBits): this;
+    union(other: ImmutableSparseBits): this;
+    xor(other: ImmutableSparseBits): this;
+    clean(): this;
+    contains(other: ImmutableSparseBits): boolean;
+    has(a: number): boolean;
+    next(a: number, set?: boolean): number;
+    toDense(): DenseBits;
+    where(set: boolean, from?: number): {
+        [Symbol.iterator]: () => Generator<number, any, any>;
+    };
+    ranges(): {
+        [Symbol.iterator](): Generator<number[]>;
+    };
+    [Symbol.iterator](): Generator<number>;
+}
+export declare class SparseBits extends ImmutableSparseBits {
+    private setMask;
+    private clearMask;
+    selfComplement(): this;
+    selfIntersect(other: SparseBits): this;
+    selfUnion(other: SparseBits): this;
+    selfXor(other: SparseBits): this;
+    set(a: number): void;
+    clear(a: number): void;
+    has(a: number): boolean;
+    setRange(a: number, b: number): this;
+    clearRange(a: number, b: number): this;
+}
+export declare class ImmutableDenseBits {
+    protected bits: bigint;
+    constructor(bits?: bigint);
+    protected create(bits?: bigint): this;
+    complement(): this;
+    intersect(other: DenseBits): this;
+    union(other: DenseBits): this;
+    xor(other: DenseBits): this;
+    has(a: number): boolean;
+    next(a: number, set?: boolean): number;
+    get length(): number;
+    where(set: boolean, from?: number): {
+        [Symbol.iterator](): Generator<number>;
+    };
+    ranges(): {
+        [Symbol.iterator](): Generator<number[]>;
+    };
+    [Symbol.iterator](): Generator<number>;
+    toSparse(): SparseBits;
+}
+export declare class DenseBits extends ImmutableDenseBits {
+    private setMask;
+    private clearMask;
+    selfComplement(): this;
+    selfIntersect(other: DenseBits): this;
+    selfUnion(other: DenseBits): this;
+    selfXor(other: DenseBits): this;
+    set(a: number): void;
+    clear(a: number): void;
+    setRange(a: number, b: number): this;
+    clearRange(a: number, b: number): this;
+}