@cgtk/std 0.0.185 → 0.0.187

package/types.d.ts

@@ -1,6 +1,5 @@
-export type Key = string | number | symbol;
 export interface RecordOf<T> {
-    [id: string | number | symbol]: T;
+    [id: PropertyKey]: T;
 }
 export type ValueOf<T> = T[keyof T];
 export type Tuple<T, N extends number, R extends T[] = []> = R['length'] extends N ? R : Tuple<T, N, [T, ...R]>;
@@ -8,24 +7,39 @@ export type Elements<A extends readonly unknown[]> = A extends readonly (infer T
 export type MaybeFirst<T extends unknown[], S = void> = T extends {
     length: 0;
 } ? S : T[0];
-export type Fn<T = any, R = any> = (x: T) => R;
-export type FnP<T = any, R = any> = (x: T) => Promise<R>;
 export type FnV<T extends any[] = any[], R = any> = (...x: T) => R;
+export type Fn<T = any, R = any> = FnV<[T], R>;
+export type FnP<T = any, R = any> = (x: T) => Promise<R>;
+export type Fns<T> = {
+    [k in keyof T]: Fn<T[k]>;
+};
 export type FnF = <F extends FnV>(f: F) => (...xs: Parameters<F>) => ReturnType<F>;
-export type Reactive<T = unknown> = Fn<Fn<T>, Fn<void>>;
+export type Dispose = Fn<void>;
+export type Reactive<T = unknown, R = any> = Fn<Fn<T, R>, Dispose>;
+export type Resource<T> = Reactive<T, Dispose | void>;
 export type Constantly<T> = () => T;
 export type FirstParam<F extends FnV> = MaybeFirst<Parameters<F>>;
-export type Nullable<T> = T | null;
+export type MaybePromise<T = unknown> = T | PromiseLike<T>;
 export type Last<T extends any[]> = T extends [...any, infer Rest] ? Rest : never;
 export type Tail<T extends any[]> = T extends [any, ...(infer Rest)] ? Rest : never;
+export type Push<T extends any[], V> = [...T, V];
 export type Pop<T extends any[]> = T extends [...infer head, any] ? head : never;
 export type MinusOne<T extends number, A extends any[] = []> = A['length'] extends T ? Pop<A>['length'] : MinusOne<T, [...A, 0]>;
 export type Take<N extends number, T extends any[], R extends any[] = []> = R['length'] extends N ? R : Take<N, Tail<T>, [...R, T[0]]>;
 export type Skip<N extends number, T extends any[]> = N extends 0 ? T : Skip<MinusOne<N>, Tail<T>>;
-export type TypedArray = Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array | Float32Array | Float64Array;
-export type TypedArrayConstructor = Uint8ArrayConstructor | Uint8ClampedArrayConstructor | Uint16ArrayConstructor | Uint32ArrayConstructor | Int8ArrayConstructor | Int16ArrayConstructor | Int32ArrayConstructor | Float32ArrayConstructor | Float64ArrayConstructor;
-export type UintArray = Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array;
-export type IntArray = Int8Array | Int16Array | Int32Array;
+export type Range<N extends number, Acc extends number[] = []> = Acc['length'] extends N ? Acc[number] : Range<N, [...Acc, Acc['length']]>;
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+export type LastOf<T> = UnionToIntersection<T extends any ? (x: T) => void : never> extends (x: infer L) => void ? L : never;
+export type UnionToTuple<T> = [T] extends [never] ? [] : Push<UnionToTuple<Exclude<T, LastOf<T>>>, LastOf<T>>;
+export type Entry<K extends PropertyKey, V> = [K, V];
+export type Entries<T> = {
+    [K in keyof T]: Entry<K, T[K]>;
+}[keyof T];
+export type EntriesTuple<T, K extends UnionToTuple<keyof T> = UnionToTuple<keyof T>> = {
+    [I in keyof K]: K[I] extends keyof T ? [K[I], T[K[I]]] : never;
+};
+export type TypedArray<T extends ArrayBufferLike = ArrayBufferLike> = Uint8Array<T> | Uint16Array<T> | Uint32Array<T> | Int8Array<T> | Int16Array<T> | Int32Array<T> | Float16Array<T> | Float32Array<T> | Float64Array<T>;
+export type BufferType<T extends TypedArray> = T extends TypedArray<infer S> ? S : never;
 export type Numbers = Array<number> | TypedArray;
 export type Eq<A, B = A> = FnV<[A, B], boolean>;
 export type Pred<T> = Fn<T, boolean>;
@@ -40,3 +54,9 @@ export type Partials<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 export type KeyMap<T extends string> = {
     [K in T]: Extract<K, T>;
 };
+export interface BufferView<T extends ArrayBufferLike = ArrayBufferLike> {
+    readonly buffer: T;
+    readonly byteLength: number;
+    readonly byteOffset: number;
+}
+export {};

package/utils.d.ts

@@ -1,4 +1,4 @@
-import type { Tuple } from "./types.js";
+import type { Tuple } from "./types";
 export declare function toposort(nodes: number[]): Generator<number | undefined, void, unknown>;
 export declare const hex2rgb: (hex: string) => number[];
 export declare const rgb2hex: (rgb: Tuple<number, 3>) => string;

package/utils.js

@@ -1,4 +1,4 @@
-import { assert } from "./checks.js";
+import { assert } from "./checks";
 export function* toposort(nodes) {
     const n = nodes.length;
     const queue = [], children = new Map();

package/weak.d.ts

@@ -1,2 +1,2 @@
-import type { Fn, Optional } from "./types.js";
+import type { Fn, Optional } from "./types";
 export declare const deref: <T extends WeakKey, F extends Fn<T>>(r: WeakRef<T>, f: F) => Optional<ReturnType<F>>;

package/weak.js

@@ -1,4 +1,4 @@
-import { isDefined } from "./checks.js";
+import { isDefined } from "./checks";
 export const deref = (r, f) => {
     const x = r.deref();
     return isDefined(x) ? f(x) : undefined;