@cgtk/std 0.0.194 → 0.0.195

package/src/types.d.ts

@@ -1,63 +0,0 @@
-export interface RecordOf<T> {
-    [id: PropertyKey]: T;
-}
-export type ValueOf<T> = T[keyof T];
-export type Structure<T> = T | readonly Structure<T>[] | RecordOf<Structure<T>>;
-export type Optional<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>> & Partial<Pick<T, K>>;
-export type Tuple<T, N extends number, R extends T[] = []> = R['length'] extends N ? R : Tuple<T, N, [T, ...R]>;
-export type Elements<A extends readonly unknown[]> = A extends readonly (infer T)[] ? T : never;
-export type MaybeFirst<T extends unknown[], S = void> = T extends {
-    length: 0;
-} ? S : T[0];
-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 Dispose = Fn<void>;
-export type Reactive<T = unknown, R = any> = Fn<Fn<T, R>, Dispose>;
-export type Constantly<T> = () => T;
-export type FirstParam<F extends FnV> = MaybeFirst<Parameters<F>>;
-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 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 UintArray<T extends ArrayBufferLike = ArrayBufferLike> = Uint8Array<T> | Uint16Array<T> | Uint32Array<T>;
-export type IntArray<T extends ArrayBufferLike = ArrayBufferLike> = Int8Array<T> | Int16Array<T> | Int32Array<T>;
-export type FloatArray<T extends ArrayBufferLike = ArrayBufferLike> = Float16Array<T> | Float32Array<T> | Float64Array<T>;
-export type BigIntArray<T extends ArrayBufferLike = ArrayBufferLike> = BigUint64Array<T> | BigInt64Array<T>;
-export type NumberArray<T extends ArrayBufferLike = ArrayBufferLike> = UintArray<T> | IntArray<T> | FloatArray<T>;
-export type TypedArray<T extends ArrayBufferLike = ArrayBufferLike> = NumberArray | BigIntArray<T>;
-export type Number<T extends TypedArray> = T extends NumberArray ? number : bigint;
-export type BufferType<T extends TypedArray> = T extends TypedArray<infer S> ? S : never;
-export type Eq<A, B = A> = FnV<[A, B], boolean>;
-export type Pred<T> = Fn<T, boolean>;
-export type PredV<T extends any[]> = FnV<T, boolean>;
-export type TPred<T extends S, S = any> = (x: S) => x is T;
-export type Maybe<T> = T | undefined;
-export type Indexed<T> = [number, T];
-export type Required<T, K extends keyof T> = T & {
-    [P in K]-?: T[P];
-};
-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 {};

package/src/types.js

@@ -1 +0,0 @@
-export {};

package/src/utils.d.ts

@@ -1,4 +0,0 @@
-import type { Tuple } from "./types.js";
-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/src/utils.js

@@ -1,30 +0,0 @@
-import { assert } from "./checks.js";
-export function* toposort(nodes) {
-    const n = nodes.length;
-    const queue = [], children = new Map();
-    nodes.forEach((p, i) => {
-        if (p < 0)
-            queue.push(i);
-        else {
-            assert(p < n, `[toposort] Invalid parent: ${p}`);
-            if (!children.has(p))
-                children.set(p, []);
-            children.get(p).push(i);
-        }
-    });
-    while (queue.length > 0) {
-        const p = queue.shift();
-        yield p;
-        if (children.has(p)) {
-            queue.push(...children.get(p));
-            children.delete(p);
-        }
-    }
-}
-export const hex2rgb = (hex) => {
-    const r = parseInt(hex.slice(1, 3), 16);
-    const g = parseInt(hex.slice(3, 5), 16);
-    const b = parseInt(hex.slice(5, 7), 16);
-    return [r, g, b];
-};
-export const rgb2hex = (rgb) => "#" + rgb.map(x => Math.round(x).toString(16).padStart(2, '0')).join("");

package/src/weak.d.ts

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

package/src/weak.js

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