@isopodlabs/utilities 1.7.0 → 1.8.0

package/dist/array.d.ts

@@ -4,3 +4,4 @@ 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[];
+export declare function lazySlice<T>(array: T[], start?: number, end?: number): Generator<T>;

package/dist/array.js

@@ -6,6 +6,7 @@ exports.equal = equal;
 exports.reverse = reverse;
 exports.rotate = rotate;
 exports.make = make;
+exports.lazySlice = lazySlice;
 const object_1 = require("./object");
 //-----------------------------------------------------------------------------
 //	array
@@ -55,3 +56,20 @@ function rotate(array, start, end, shift) {
 function make(n, constructor) {
     return Array.from({ length: n }, () => new constructor);
 }
+function* lazySlice(array, start, end) {
+    const len = array.length;
+    if (start === undefined)
+        start = 0;
+    else if (start < 0)
+        start = Math.max(len + start, 0);
+    else
+        start = Math.min(start, len);
+    if (end === undefined)
+        end = len;
+    else if (end < 0)
+        end = Math.max(len + start, 0);
+    else
+        end = Math.min(end, len);
+    for (let i = start; i < end; i++)
+        yield array[i];
+}

package/dist/bits.d.ts

@@ -126,13 +126,14 @@ export declare class DenseBits32 implements BitSet {
     selfDifference(other: DenseBits32): this;
     clean(): this;
 }
-type SparseNumberArray = number[] | Record<number, number>;
+type sparsebits = Record<number, number>;
+type SparseNumberArray = number[] | sparsebits;
 type ExtraParams<T> = T extends new (bits: SparseNumberArray, ...args: infer P) => any ? P : never;
 export declare class SparseBits implements BitSet {
-    protected bits: number[];
+    protected bits: sparsebits;
     constructor(bits?: SparseNumberArray);
     protected create(bits?: SparseNumberArray): this;
-    static fromEntries<C extends new (bits: SparseNumberArray, ...args: any[]) => any>(this: C, entries: Record<number, number> | [number, number][], ...extra: ExtraParams<C>): InstanceType<C>;
+    static fromEntries<C extends new (bits: SparseNumberArray, ...args: any[]) => any>(this: C, entries: sparsebits | [number, number][], ...extra: ExtraParams<C>): InstanceType<C>;
     static fromIndices<C extends new (bits: SparseNumberArray, ...args: any[]) => any>(this: C, ...indices: number[]): InstanceType<C>;
     static fromIndices<C extends new (bits: SparseNumberArray, ...args: any[]) => any>(this: C, indices: number[], ...extra: ExtraParams<C>): InstanceType<C>;
     copy(): this;

package/dist/bits.js

@@ -28,7 +28,7 @@ function highestSet32(x) {
     return x ? 32 - Math.clz32(x) : 0;
 }
 function highestSet1024(x) {
-    let b = Math.floor(Math.log2(x));
+    const b = Math.floor(Math.log2(x));
     return 1n << BigInt(b) <= x ? b + 1 : b;
 }
 // Returns the number of set bits
@@ -42,7 +42,7 @@ function nthSet32(x, i) {
     let b2 = x - ((x >> 1) & 0x55555555);
     let b4 = (b2 & 0x33333333) + ((b2 >> 2) & 0x33333333);
     let b8 = (b4 + (b4 >> 4) & 0xF0F0F0F);
-    let b16 = (b8 + (b8 >> 8)) & 0xff;
+    const b16 = (b8 + (b8 >> 8)) & 0xff;
     let n = 0;
     if (i >= b16) {
         i -= b16;
@@ -702,11 +702,8 @@ class DenseBits32 {
 }
 exports.DenseBits32 = DenseBits32;
 ;
-//-----------------------------------------------------------------------------
-// SparseBits - a sparse bitset where each entry in the 'bits' array represents 32 bits
-//-----------------------------------------------------------------------------
 function sparseFromIndices(indices) {
-    const bits = [];
+    const bits = {};
     for (const i of indices)
         bits[i >> 5] |= 1 << (i & 0x1f);
     return bits;
@@ -747,7 +744,8 @@ function sparseClearMask(bits, i, m, undef = 0) {
         bits[i] = ~m;
 }
 function sparseSetRange(bits, a, b, undef = 0) {
-    let i = a >> 5, j = b >> 5;
+    let i = a >> 5;
+    const j = b >> 5;
     if (i === j) {
         sparseSetMask(bits, i, (1 << (b & 0x1f)) - (1 << (a & 0x1f)), undef);
     }
@@ -765,7 +763,8 @@ function sparseSetRange(bits, a, b, undef = 0) {
     }
 }
 function sparseClearRange(bits, a, b, undef = 0) {
-    let i = a >> 5, j = b >> 5;
+    let i = a >> 5;
+    const j = b >> 5;
     if (i === j) {
         sparseClearMask(bits, i, (1 << (b & 0x1f)) - (1 << (a & 0x1f)), undef);
     }
@@ -816,41 +815,40 @@ function sparseNthSet(bits, a, undef = 0) {
     return -1;
 }
 function sparseComplement(bits) {
-    return bits.map(b => ~b);
+    const result = [];
+    for (const i in bits)
+        result[i] = ~bits[i];
+    return result;
 }
 function sparseIntersect(bits, other) {
     const result = [];
     for (const i in bits) {
-        if (other[i] !== undefined) {
+        if (other[i] !== undefined)
             result[i] = bits[i] & other[i];
-        }
     }
     return result;
 }
 function sparseUnion(bits, other) {
     const result = [];
     for (const i in bits) {
-        if (other[i] !== undefined) {
+        if (other[i] !== undefined)
             result[i] = bits[i] | other[i];
-        }
     }
     return result;
 }
 function sparseXor(bits, other) {
     const result = [];
     for (const i in bits) {
-        if (other[i] !== undefined) {
+        if (other[i] !== undefined)
             result[i] = bits[i] ^ other[i];
-        }
     }
     return result;
 }
 function sparseDifference(bits, other) {
     const result = [];
     for (const i in bits) {
-        if (other[i] !== undefined) {
+        if (other[i] !== undefined)
             result[i] = bits[i] & ~other[i];
-        }
     }
     return result;
 }
@@ -975,7 +973,7 @@ function* sparseWhere(bits, set, from = -1, to, undef = 0) {
 }
 function* sparseRanges(bits, set, undef = 0) {
     let start = -1, end = 0;
-    let other = undef ? set : !set;
+    const other = undef ? set : !set;
     for (const i in bits) {
         let b = bits[i] ^ undef;
         const c0 = +i * 32;
@@ -1013,13 +1011,15 @@ function sparseSlice(bits, from, to) {
     for (const k in bits) {
         const i = +k;
         if (i >= from32) {
-            if (i > to32)
-                break;
             let b = bits[k];
             if (i === from32)
                 b &= -fromM;
-            if (i === to32)
+            if (i === to32) {
                 b &= toM - 1;
+                if (b !== 0)
+                    result[k] = b;
+                break;
+            }
             if (b !== 0)
                 result[k] = b;
         }
@@ -1029,7 +1029,7 @@ function sparseSlice(bits, from, to) {
 class SparseBits {
     bits;
     constructor(bits = []) {
-        this.bits = bits;
+        this.bits = bits; // as Record<number, number>;
     }
     create(bits = []) {
         return new this.constructor(bits);

package/dist/object.d.ts

@@ -11,7 +11,7 @@ export declare class Lazy<T> {
     private _value;
     constructor(factory: () => T);
     get value(): T;
-    then<U>(this: T extends Promise<infer R> ? Lazy<T> : never, onFulfilled: (value: T extends Promise<infer R> ? R : never) => U): Promise<U>;
+    then<U>(this: T extends Promise<infer _R> ? Lazy<T> : never, onFulfilled: (value: T extends Promise<infer R> ? R : never) => U): Promise<U>;
 }
 export declare class CallCombiner0 {
     private timeout?;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@isopodlabs/utilities",
-	"version": "1.7.0",
+	"version": "1.8.0",
 	"description": "Various typescript helpers.",
 	"repository": {
 		"type": "git",
@@ -16,7 +16,8 @@
 		"README.md"
 	],
 	"scripts": {
-		"build": "tsc"
+		"build": "tsc",
+		"lint": "eslint \"src/**/*.ts\""
 	},
 	"keywords": [
 		"typescript",
@@ -29,7 +30,6 @@
 	"devDependencies": {
 		"@types/node": "^22.13.8",
 		"eslint": "^9.21.0",
-		"typescript": "^5.8.2",
 		"typescript-eslint": "^8.26.0"
 	}
 }