@yorozu/utils 0.1.4 → 0.3.1

package/iterate/enumerate.d.ts

@@ -0,0 +1 @@
+export declare function enumerate<T>(iterable: Iterable<T>): IterableIterator<[number, T]>;

package/iterate/index.d.ts

@@ -0,0 +1 @@
+export * from './enumerate';

package/misc/assert.d.ts

@@ -0,0 +1,7 @@
+import { Brand } from '../types/brand';
+export declare function assert(condition: boolean, message?: unknown): asserts condition;
+export declare function assertHashKey<Obj extends object, Key extends string>(obj: Obj, key: Key): asserts obj is Obj & Record<Key, unknown>;
+export declare function unsafeCastType<T>(value: unknown): asserts value is T;
+export declare function assertNotNull<T>(value: T): asserts value is Exclude<T, null | undefined>;
+export declare function asNonNull<T>(value: null extends T ? T : undefined extends T ? T : Brand<"type is not nullable", "TypeError">): Exclude<T, null | undefined>;
+export declare function assertMatches(str: string, regex: RegExp): RegExpMatchArray;

package/misc/composer.d.ts

@@ -0,0 +1,4 @@
+export type Middleware<C, R = void> = (ctx: C, next: (ctx: C) => Promise<R>) => Promise<R>;
+export type ComposedMiddleware<C, R = void> = (ctx: C) => Promise<R>;
+export declare function composeMiddlewares<C, R = void>(middlewares: Array<Middleware<C, R>>, final: ComposedMiddleware<C, R>): ComposedMiddleware<C, R>;
+export declare function composeMiddlewares<C, R = void>(middlewares: Array<Middleware<C, R>>): Middleware<C, R>;

package/misc/guards.d.ts

@@ -0,0 +1,12 @@
+import { AnyFunction, Truthy } from '../types';
+export declare const isNotUndefined: <T>(val: T) => val is Exclude<T, undefined>;
+export declare const isNotNull: <T>(val: T) => val is Exclude<T, null>;
+export declare const isBoolean: (val: any) => val is boolean;
+export declare const isTruthy: <T>(val: T) => val is Truthy<T>;
+export declare const isFalsy: <T>(val: T) => val is Exclude<T, Truthy<T>>;
+export declare const isFunction: (val: any) => val is AnyFunction;
+export declare const isNumber: (val: any) => val is number;
+export declare const isString: (val: unknown) => val is string;
+export declare const isSymbol: (val: any) => val is symbol;
+export declare const isBigInt: (val: any) => val is bigint;
+export declare const isObject: (val: any) => val is object;

package/misc/index.d.ts

@@ -0,0 +1,6 @@
+export * from './assert';
+export * from './composer';
+export * from './guards';
+export * from './noop';
+export * from './objects';
+export * from './string';

package/misc/noop.d.ts

@@ -0,0 +1 @@
+export declare function noop(): void;

package/misc/objects.d.ts

@@ -0,0 +1,18 @@
+import { MaybeArray } from '../types';
+export declare function objectKeys<T extends object>(obj: T): Array<`${keyof T & (string | number | boolean | null | undefined)}`>;
+export declare function objectEntries<T extends object>(obj: T): Array<[keyof T, T[keyof T]]>;
+export declare function clearUndefinedInPlace<T extends object>(obj: T): void;
+export type MergeInsertions<T> = T extends object ? {
+    [K in keyof T]: MergeInsertions<T[K]>;
+} : T;
+export type DeepMerge<F, S> = MergeInsertions<{
+    [K in keyof F | keyof S]: K extends keyof S & keyof F ? DeepMerge<F[K], S[K]> : K extends keyof S ? S[K] : K extends keyof F ? F[K] : never;
+}>;
+export interface DeepMergeOptions {
+    undefined?: "replace" | "ignore";
+    properties?: "replace" | "ignore";
+    arrays?: "replace" | "ignore" | "merge";
+    objects?: "replace" | "ignore" | "merge";
+}
+export declare function deepMerge<T extends object = object>(into: T, from: MaybeArray<T>, options?: DeepMergeOptions): T;
+export declare function deepMerge<T extends object = object, S extends object = T>(into: T, from: MaybeArray<S>, options?: DeepMergeOptions): DeepMerge<T, S>;

package/misc/string.d.ts

@@ -0,0 +1,4 @@
+export declare function splitOnce(str: string, separator: string): [string, string];
+export declare function assertStartsWith<P extends string>(str: string, prefix: P): asserts str is `${P}${string}`;
+export declare function assertEndsWith<S extends string>(str: string, suffix: S): asserts str is `${string}${S}`;
+export { assertEndsWith as assertsEndsWith };

package/package.json

@@ -1,23 +1,21 @@
 {
     "name": "@yorozu/utils",
-    "version": "0.1.4",
     "type": "module",
-    "sideEffects": false,
-    "author": "inshinrei",
-    "license": "MIT",
+    "version": "0.3.1",
     "description": "quality of life",
-    "main": "lib/index.js",
-    "module": "lib/index.cjs",
-    "types": "lib/index.d.ts",
-    "files": [
-        "lib"
-    ],
-    "scripts": {
-        "test": "vitest",
-        "bench": "node benchmarks/main_bench.js",
-        "build": "tsup"
+    "license": "MIT",
+    "exports": {
+        ".": {
+            "import": {
+                "types": "./index.d.ts",
+                "default": "./index.js"
+            }
+        }
     },
-    "devDependencies": {
-        "tsup": "8.5.1"
+    "sideEffects": false,
+    "author": "inshinrei",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/inshinrei/yorozu.git"
     }
-}
+}

package/structures/_iterator.d.ts

@@ -0,0 +1,2 @@
+export declare function maybeWrapIterator<T>(iter: IterableIterator<T>): IterableIterator<T>;
+export declare function resetIteratorDetectionForTests(): void;

package/structures/custom-map.d.ts

@@ -0,0 +1,21 @@
+export declare class CustomMap<ExternalKey, InternalKey, V> implements Map<ExternalKey, V> {
+    readonly clear: Map<ExternalKey, V>["clear"];
+    protected _map: Map<InternalKey, V>;
+    protected _mapperTo: (key: ExternalKey) => InternalKey;
+    protected _mapperFrom: (key: InternalKey) => ExternalKey;
+    constructor(externalToInternal: (key: ExternalKey) => InternalKey, internalToExternal: (key: InternalKey) => ExternalKey);
+    get size(): number;
+    get [Symbol.toStringTag](): string;
+    getInternalMap(): Map<InternalKey, V>;
+    delete(key: ExternalKey): boolean;
+    forEach(cb: (value: V, key: ExternalKey, map: Map<ExternalKey, V>) => void, thisArg?: any): void;
+    get(key: ExternalKey): V | undefined;
+    has(key: ExternalKey): boolean;
+    set(key: ExternalKey, value: V): this;
+    getOrInsert(key: ExternalKey, value: V): ReturnType<Map<ExternalKey, V>["getOrInsert"]>;
+    getOrInsertComputed(key: ExternalKey, callback: (key: ExternalKey) => V): ReturnType<Map<ExternalKey, V>["getOrInsertComputed"]>;
+    entries(): ReturnType<Map<ExternalKey, V>["entries"]>;
+    keys(): ReturnType<Map<ExternalKey, V>["keys"]>;
+    values(): ReturnType<Map<ExternalKey, V>["values"]>;
+    [Symbol.iterator](): ReturnType<Map<ExternalKey, V>["entries"]>;
+}

package/structures/custom-set.d.ts

@@ -0,0 +1,25 @@
+export declare class CustomSet<ExternalKey, InternalKey> implements Set<ExternalKey> {
+    readonly clear: Set<ExternalKey>["clear"];
+    protected _set: Set<InternalKey>;
+    protected _mapperTo: (key: ExternalKey) => InternalKey;
+    protected _mapperFrom: (key: InternalKey) => ExternalKey;
+    constructor(externalToInternal: (key: ExternalKey) => InternalKey, internalToExternal: (key: InternalKey) => ExternalKey);
+    get size(): number;
+    get [Symbol.toStringTag](): string;
+    add(value: ExternalKey): this;
+    delete(value: ExternalKey): boolean;
+    forEach(cb: (value: ExternalKey, value2: ExternalKey, set: Set<ExternalKey>) => void, thisArg?: any): void;
+    has(value: ExternalKey): boolean;
+    entries(): ReturnType<Set<ExternalKey>["entries"]>;
+    keys(): ReturnType<Set<ExternalKey>["keys"]>;
+    values(): ReturnType<Set<ExternalKey>["values"]>;
+    union<U>(other: Set<U>): Set<ExternalKey | U>;
+    intersection<U>(other: Set<U>): Set<ExternalKey & U>;
+    difference<U>(other: ReadonlySetLike<ExternalKey & U>): Set<ExternalKey>;
+    symmetricDifference<U>(other: Set<U>): Set<ExternalKey | U>;
+    isSubsetOf(other: ReadonlySetLike<ExternalKey>): boolean;
+    isSupersetOf(other: Set<ExternalKey>): boolean;
+    isDisjointFrom(other: Set<ExternalKey>): boolean;
+    [Symbol.iterator](): ReturnType<Set<ExternalKey>["keys"]>;
+    getInternalSet(): Set<InternalKey>;
+}

package/structures/deque.d.ts

@@ -0,0 +1,34 @@
+export interface DequeOptions {
+    capacity?: number;
+}
+export declare class Deque<T> {
+    protected _list: Array<T | undefined>;
+    protected _head: number;
+    protected _tail: number;
+    protected _capacityMask: number;
+    protected _capacity?: number;
+    protected _size: number;
+    constructor(array?: ArrayLike<T>, options?: DequeOptions);
+    get length(): number;
+    isEmpty(): boolean;
+    at(index: number): T | undefined;
+    peekFront(): T | undefined;
+    peekBack(): T | undefined;
+    pushFront(item: T): number;
+    pushBack(item: T): number;
+    popFront(): T | undefined;
+    popBack(): T | undefined;
+    removeOne(idx: number): T | undefined;
+    removeBy(predicate: (item: T) => boolean): void;
+    clear(): void;
+    indexOf(item: T): number;
+    findIndex(predicate: (item: T) => boolean): number;
+    find(predicate: (item: T) => boolean): T | undefined;
+    includes(item: T): boolean;
+    toArray(): Array<T>;
+    [Symbol.iterator](): Iterator<T>;
+    protected _fromArray(array: ArrayLike<T>): void;
+    protected _growArray(): void;
+    protected _shrinkArray(): void;
+    protected _remove(idx: number): void;
+}

package/structures/index.d.ts

@@ -0,0 +1,5 @@
+export * from './custom-map';
+export * from './custom-set';
+export * from './deque';
+export * from './lru-map';
+export * from './lru-set';

package/structures/lru-map.d.ts

@@ -0,0 +1,15 @@
+export declare class LruMap<K, V> {
+    protected _capacity: number;
+    protected _map: Map<K, V>;
+    constructor(capacity: number, MapImpl?: new () => Map<K, V>);
+    get size(): number;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    set(key: K, value: V): void;
+    delete(key: K): void;
+    clear(): void;
+    [Symbol.iterator](): IterableIterator<[K, V]>;
+    entries(): IterableIterator<[K, V]>;
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V>;
+}

package/structures/lru-set.d.ts

@@ -0,0 +1,12 @@
+export declare class LruSet<T> {
+    protected _capacity: number;
+    protected _set: Set<T>;
+    constructor(capacity: number, SetImpl?: new () => Set<T>);
+    get size(): number;
+    add(value: T): void;
+    has(value: T): boolean;
+    delete(value: T): boolean;
+    clear(): void;
+    [Symbol.iterator](): IterableIterator<T>;
+    toArray(): Array<T>;
+}

package/types/brand.d.ts

@@ -0,0 +1,5 @@
+declare const brand: unique symbol;
+export type Brand<T, Name extends string> = T & {
+    [brand]: Name;
+};
+export {};

package/types/equal.d.ts

@@ -0,0 +1 @@
+export type TypesAreEqual<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;

package/types/error.d.ts

@@ -0,0 +1,6 @@
+export declare function unknownToError(err: unknown): Error;
+export declare class NotImplementedError extends Error {
+    constructor(message?: string, options?: ErrorOptions);
+}
+export declare function throwNotImplemented(message?: string, options?: ErrorOptions): never;
+export declare function throwUnreachable(): never;

package/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from './brand';
+export * from './equal';
+export * from './error';
+export * from './misc';
+export * from './unions';

package/types/misc.d.ts

@@ -0,0 +1,11 @@
+export type NoneToVoidFunction = () => void;
+export type AnyFunction = (...args: any[]) => any;
+export type AnyToVoidFunction = (...args: any[]) => void;
+export type AnyToNever<T> = any extends T ? never : T;
+export type MaybePromise<T> = Promise<T> | T;
+export type MaybeArray<T> = Array<T> | T;
+export type Values<T> = T[keyof T];
+export type Truthy<T> = T extends false | "" | 0 | null | undefined ? never : T;
+export type UnsafeMutate<T> = {
+    -readonly [P in keyof T]: T[P];
+};

package/types/unions.d.ts

@@ -0,0 +1,3 @@
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+export type LastOfUnion<U> = UnionToIntersection<U extends any ? () => U : never> extends () => infer R ? R : never;
+export type UnionToTuple<U, Acc extends Array<any> = [], L = LastOfUnion<U>> = [U] extends [never] ? Acc : UnionToTuple<Exclude<U, L>, [L, ...Acc]>;