@yorozu/utils 0.1.4 → 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ivan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/arrays/index.d.ts

@@ -0,0 +1,4 @@
+import * as typed from "./typed";
+import * as u8 from "./u8";
+export * from './typed/types';
+export { typed, u8 };

package/arrays/typed/compare.d.ts

@@ -0,0 +1,3 @@
+import { TypedArray } from './types';
+export declare function compare<T extends TypedArray>(a: T, b: T): -1 | 0 | 1;
+export declare function equal<T extends TypedArray>(a: T, b: T): boolean;

package/arrays/typed/find.d.ts

@@ -0,0 +1,10 @@
+import { TypedArray } from './types';
+export declare function indexOf(haystack: Exclude<TypedArray, BigInt64Array | BigUint64Array>, needle: number, start?: number): number;
+export declare function indexOf(haystack: BigInt64Array | BigUint64Array, needle: bigint, start?: number): number;
+export declare function lastIndexOf(haystack: Exclude<TypedArray, BigInt64Array | BigUint64Array>, needle: number, start?: number): number;
+export declare function lastIndexOf(haystack: BigInt64Array | BigUint64Array, needle: bigint, start?: number): number;
+export declare function indexOfArray<T extends TypedArray>(haystack: T, needle: T, start?: number): number;
+export declare function lastIndexOfArray<T extends TypedArray>(haystack: T, needle: T, start?: number): number;
+export declare function includes(haystack: Exclude<TypedArray, BigInt64Array | BigUint64Array>, needle: number): boolean;
+export declare function includes(haystack: BigInt64Array | BigUint64Array, needle: bigint): boolean;
+export declare function includesArray<T extends TypedArray>(haystack: T, needle: T): boolean;

package/arrays/typed/index.d.ts

@@ -0,0 +1,4 @@
+export * from './compare';
+export * from './find';
+export * from './misc';
+export * from './types';

package/arrays/typed/misc.d.ts

@@ -0,0 +1,10 @@
+import { TypedArray } from './types';
+export declare function toDataView(buf: TypedArray): DataView;
+export declare function view<R extends TypedArray>(ctor: {
+    new (buffer: ArrayBufferLike, byteOffset: number, byteLength: number): R;
+    BYTES_PER_ELEMENT: number;
+}, buf: ArrayBufferView): R;
+export declare function getPlatformByteOrder(): "little" | "big";
+export declare namespace getPlatformByteOrder {
+    var _cachedByteOrder: boolean | null;
+}

package/arrays/typed/types.d.ts

@@ -0,0 +1,2 @@
+import { AnyToNever } from '../../types';
+export type TypedArray = Uint8Array | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array | Float32Array | Float64Array | AnyToNever<BigInt64Array> | AnyToNever<BigUint64Array>;

package/arrays/u8/concat.d.ts

@@ -0,0 +1,3 @@
+export declare function concat(bufs: Array<Uint8Array>): Uint8Array;
+export declare function concat2(a: ArrayLike<number>, b: ArrayLike<number>): Uint8Array;
+export declare function concat3(a: ArrayLike<number>, b: ArrayLike<number>, c: ArrayLike<number>): Uint8Array;

package/arrays/u8/index.d.ts

@@ -0,0 +1,6 @@
+export * from './concat';
+export * from './misc';
+export * from './pool';
+export * from './reverse';
+export * from './swap';
+export * from './xor';

package/arrays/u8/misc.d.ts

@@ -0,0 +1,3 @@
+export declare const empty: Uint8Array;
+export declare function clone(buf: Uint8Array): Uint8Array;
+export declare function readNthBit(byte: number, bit: number): number;

package/arrays/u8/pool.d.ts

@@ -0,0 +1,11 @@
+export declare class BufferPool {
+    #private;
+    readonly size: number;
+    readonly maxAllocSize: number;
+    constructor(size?: number);
+    allocate(size: number): Uint8Array;
+    reset(): void;
+}
+export declare function setDefaultPool(size: number): void;
+export declare function allocate(size: number): Uint8Array;
+export declare function allocateWith(init: ArrayLike<number>): Uint8Array;

package/arrays/u8/reverse.d.ts

@@ -0,0 +1,2 @@
+export declare function reverse(buffer: Uint8Array): void;
+export declare function toReversed(buffer: ArrayLike<number>): Uint8Array;

package/arrays/u8/swap.d.ts

@@ -0,0 +1,4 @@
+export declare function swap16(buf: Uint8Array): void;
+export declare function swap32(buf: Uint8Array): void;
+export declare function swap64(buf: Uint8Array): void;
+export declare function swapNibbles(buf: Uint8Array): void;

package/arrays/u8/xor.d.ts

@@ -0,0 +1,2 @@
+export declare function xor(data: Uint8Array, key: Uint8Array): Uint8Array;
+export declare function xorInPlace(data: Uint8Array, key: Uint8Array): void;

package/async/async-interval.d.ts

@@ -0,0 +1,8 @@
+export declare class AsyncInterval {
+    #private;
+    constructor(handler: (abortSignal: AbortSignal) => Promise<void>, interval: number);
+    start(after?: number): void;
+    startNow(): void;
+    stop(): void;
+    onError(handler: (err: unknown) => void): void;
+}

package/async/async-lock.d.ts

@@ -0,0 +1,6 @@
+export declare class AsyncLock {
+    private _queue;
+    acquire(): Promise<void>;
+    release(): void;
+    with<T>(func: () => Promise<T>): Promise<T>;
+}

package/async/async-queue.d.ts

@@ -0,0 +1,18 @@
+import { Deque } from '../structures';
+export declare class AsyncQueue<T> {
+    #private;
+    readonly queue: Deque<T>;
+    readonly maxSize: number | undefined;
+    constructor(from?: ArrayLike<T> | Deque<T>, maxSize?: number);
+    get length(): number;
+    get isFull(): boolean;
+    get remainingCapacity(): number;
+    get ended(): boolean;
+    enqueue(item: T): Promise<void>;
+    tryEnqueue(item: T): boolean;
+    end(): void;
+    peek(): T | undefined;
+    next(): T | undefined;
+    nextOrWait(): Promise<T | undefined>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<T>;
+}

package/async/async-resource.d.ts

@@ -0,0 +1,33 @@
+import { Emitter } from './emitter';
+export interface AsyncResourceContext<T> {
+    readonly current: T | null;
+    readonly currentFetchedAt: number;
+    readonly currentExpiresAt: number;
+    readonly isBackground: boolean;
+    readonly abort: AbortSignal | null;
+}
+export interface AsyncResourceOptions<T> {
+    autoReload?: boolean;
+    autoReloadAfter?: number;
+    /** @deprecated Use `autoReloadAfter`. */
+    authReloadAfter?: number;
+    swr?: boolean;
+    swrValidator?: (ctx: AsyncResourceContext<T>) => boolean;
+    fetcher: (ctx: AsyncResourceContext<T>) => Promise<{
+        data: T;
+        expiresIn: number;
+    }>;
+    onError?: (err: unknown, ctx: AsyncResourceContext<T>) => void;
+}
+export declare class AsyncResource<T> {
+    #private;
+    readonly options: AsyncResourceOptions<T>;
+    readonly onUpdated: Emitter<AsyncResourceContext<T>>;
+    constructor(options: AsyncResourceOptions<T>);
+    get isStale(): boolean;
+    setData(data: T, expiresIn: number): void;
+    update(force?: boolean): Promise<void>;
+    get(): Promise<T | null>;
+    getCached(): T | null;
+    destroy(): void;
+}

package/async/condition-variable.d.ts

@@ -0,0 +1,5 @@
+export declare class ConditionVariable {
+    #private;
+    wait(): Promise<void>;
+    notify(): void;
+}

package/async/deferred.d.ts

@@ -0,0 +1,24 @@
+export declare class Deferred<T = void> {
+    readonly resolve: (value: T) => void;
+    readonly reject: (reason: unknown) => void;
+    readonly promise: Promise<T>;
+    constructor();
+}
+export declare class DeferredTracked<T = void> {
+    #private;
+    readonly promise: Promise<T>;
+    readonly status: {
+        type: "pending";
+    } | {
+        type: "fulfilled";
+        value: T;
+    } | {
+        type: "rejected";
+        reason: unknown;
+    };
+    constructor();
+    get result(): T | undefined;
+    get error(): unknown | undefined;
+    resolve(value: T): void;
+    reject(reason: unknown): void;
+}

package/async/emitter.d.ts

@@ -0,0 +1,11 @@
+export declare class Emitter<T> {
+    #private;
+    get length(): number;
+    add(listener: (value: T) => void): void;
+    forwardTo(emitter: Emitter<T>): void;
+    remove(listener: (value: T) => void): void;
+    emit(value: T): void;
+    once(listener: (value: T) => void): void;
+    listeners(): readonly ((value: T) => void)[];
+    clear(): void;
+}

package/async/index.d.ts

@@ -0,0 +1,11 @@
+import * as timers from "./timers";
+export * from './async-interval';
+export * from './async-lock';
+export * from './async-queue';
+export * from './async-resource';
+export * from './condition-variable';
+export * from './deferred';
+export * from './emitter';
+export * from './pool';
+export * from './sleep';
+export { timers };

package/async/pool.d.ts

@@ -0,0 +1,19 @@
+import { MaybePromise } from '../types';
+export interface AsyncPoolOptions<T> {
+    limit?: number;
+    signal?: AbortSignal;
+    onErrorStrategy?: (item: T, index: number, error: unknown) => MaybePromise<"ignore" | "collect" | "throw">;
+}
+declare class ErrorInfo<T> {
+    readonly item: T;
+    readonly index: number;
+    readonly error: unknown;
+    constructor(item: T, index: number, error: unknown);
+}
+export declare class AggregateError<T> extends Error {
+    readonly errors: Array<ErrorInfo<T>>;
+    constructor(errors: Array<ErrorInfo<T>>);
+}
+export declare function asyncPool<T>(iterable: Iterable<T> | AsyncIterable<T>, executor: (item: T, index: number) => MaybePromise<T | void>, options?: AsyncPoolOptions<T>): Promise<void>;
+export declare function parallelMap<T, R>(iterable: Iterable<T> | AsyncIterable<T>, executor: (item: T, index: number) => MaybePromise<R>, options?: AsyncPoolOptions<T>): Promise<Array<R>>;
+export {};

package/async/sleep.d.ts

@@ -0,0 +1 @@
+export declare function sleep(ms: number, signal?: AbortSignal): Promise<void>;

package/async/timers.d.ts

@@ -0,0 +1,8 @@
+import { Brand } from '../types/brand';
+export type Timer = Brand<object, "Timer">;
+export type Interval = Brand<object, "Interval">;
+declare const setTimeoutWrap: <T extends (...args: any[]) => any>(fn: T, ms: number, ...args: Parameters<T>) => Timer;
+declare const setIntervalWrap: <T extends (...args: any[]) => any>(fn: T, ms: number, ...args: Parameters<T>) => Interval;
+declare const clearTimeoutWrap: (timer?: Timer) => void;
+declare const clearIntervalWrap: (timer?: Interval) => void;
+export { clearIntervalWrap as clearInterval, clearTimeoutWrap as clearTimeout, setIntervalWrap as setInterval, setTimeoutWrap as setTimeout, };

package/bigint/bytes.d.ts

@@ -0,0 +1,2 @@
+export declare function toBytes(value: bigint, length?: number, le?: boolean): Uint8Array;
+export declare function fromBytes(buffer: Uint8Array, le?: boolean): bigint;

package/bigint/index.d.ts

@@ -0,0 +1,2 @@
+export * from './bytes';
+export * from './math';

package/bigint/math.d.ts

@@ -0,0 +1,10 @@
+export declare function bitLength(n: bigint): number;
+export declare function twoMultiplicity(n: bigint): bigint;
+export declare function min2(a: bigint, b: bigint): bigint;
+export declare function min(...args: Array<bigint>): bigint;
+export declare function max2(a: bigint, b: bigint): bigint;
+export declare function max(...args: Array<bigint>): bigint;
+export declare function abs(a: bigint): bigint;
+export declare function euclideanGcd(a: bigint, b: bigint): bigint;
+export declare function modPowBinary(base: bigint, exp: bigint, mod: bigint): bigint;
+export declare function modInv(a: bigint, n: bigint): bigint;

package/encoding/base64.d.ts

@@ -0,0 +1,6 @@
+export declare const lookup: Map<number, number>;
+export declare const encodeLookup: Map<number, number>;
+export declare function decode(data: string, url?: boolean): Uint8Array;
+export declare function encode(bytes: Uint8Array, url?: boolean): string;
+export declare function encodedLength(n: number): number;
+export declare function decodedLength(n: number): number;

package/encoding/hex.d.ts

@@ -0,0 +1,4 @@
+export declare function encode(buf: Uint8Array): string;
+export declare function decode(data: string): Uint8Array;
+export declare function encodedLength(n: number): number;
+export declare function decodedLength(n: number): number;

package/encoding/index.d.ts

@@ -0,0 +1,4 @@
+import * as base64 from "./base64";
+import * as hex from "./hex";
+import * as utf8 from "./utf8";
+export { base64, hex, utf8 };

package/encoding/utf8.d.ts

@@ -0,0 +1,3 @@
+export declare const encoder: TextEncoder;
+export declare const decoder: TextDecoder;
+export declare function encodedLength(data: string): number;

package/index.d.ts

@@ -0,0 +1,8 @@
+export * from './arrays';
+export * from './bigint';
+export * from './encoding';
+export * from './iterate';
+export * from './misc';
+export * from './async';
+export * from './structures';
+export * from './types';