@cgtk/std 0.0.193 → 0.0.194

package/src/treemap.js

@@ -0,0 +1,71 @@
+import { before } from "./fn.js";
+import { isDefined } from "./checks.js";
+import { EMPTY } from "./constants.js";
+export const treemap = () => {
+    const nodes = new Set();
+    const parents = new Map();
+    const children = new Map();
+    let changed = false;
+    const update = () => {
+        const hasChanged = changed;
+        if (hasChanged) {
+            children.clear();
+            for (const k of nodes) {
+                const p = parents.get(k);
+                if (isDefined(p)) {
+                    if (!children.has(p))
+                        children.set(p, []);
+                    children.get(p).push(k);
+                }
+            }
+            changed = false;
+        }
+        return hasChanged;
+    };
+    const updated = before(update);
+    const getChildren = updated((key) => children.get(key) ?? EMPTY.LIST);
+    const parent = updated((key) => parents.get(key));
+    const roots = () => nodes.values().filter(k => !parents.has(k));
+    return {
+        set(node, parent) {
+            nodes.add(node);
+            if (isDefined(parent)) {
+                nodes.add(parent);
+                parents.set(node, parent);
+            }
+            changed = true;
+            return this;
+        },
+        delete(key) {
+            nodes.delete(key);
+            parents.delete(key);
+            changed = true;
+        },
+        get size() {
+            update();
+            return nodes.size;
+        },
+        parent,
+        children: getChildren,
+        roots,
+        ancestors: updated(function* (node) {
+            for (let cur = node; isDefined(cur); cur = parent(cur))
+                yield cur;
+        }),
+        dfs: updated(function* (root) {
+            const stack = [root];
+            for (let node; stack.length > 0;) {
+                yield node = stack.pop();
+                const items = getChildren(node);
+                for (let i = items.length - 1; i >= 0; i--)
+                    stack.push(items[i]);
+            }
+        }),
+        bfs: updated(function* (queue = [...roots()]) {
+            for (let node; queue.length > 0;) {
+                yield node = queue.shift();
+                queue.push(...getChildren(node));
+            }
+        })
+    };
+};

package/src/typedarray.d.ts

@@ -0,0 +1,31 @@
+import type { FnV, TypedArray, NumberArray, BufferType, Number } from "./types.js";
+export interface Constructor<T extends TypedArray> {
+    new (length: number): T;
+    new (buffer: BufferType<T> | ArrayBufferLike, byteOffset?: number, length?: number): T;
+    readonly BYTES_PER_ELEMENT: number;
+    of(...items: Number<T>[]): T;
+    from(arrayLike: ArrayLike<Number<T>>): T;
+}
+export type View<T extends TypedArray> = FnV<[BufferType<T>?, number?], T>;
+export declare const view: <T extends TypedArray>(type: Constructor<T>, length: number) => View<T>;
+export declare const u8: (length: number) => View<Uint8Array<ArrayBufferLike>>;
+export declare const u16: (length: number) => View<Uint16Array<ArrayBufferLike>>;
+export declare const u32: (length: number) => View<Uint32Array<ArrayBufferLike>>;
+export declare const u64: (length: number) => View<BigUint64Array<ArrayBufferLike>>;
+export declare const i8: (length: number) => View<Int8Array<ArrayBufferLike>>;
+export declare const i16: (length: number) => View<Int16Array<ArrayBufferLike>>;
+export declare const i32: (length: number) => View<Int32Array<ArrayBufferLike>>;
+export declare const i64: (length: number) => View<BigInt64Array<ArrayBufferLike>>;
+export declare const f16: (length: number) => View<Float16Array<ArrayBufferLike>>;
+export declare const f32: (length: number) => View<Float32Array<ArrayBufferLike>>;
+export declare const f64: (length: number) => View<Float64Array<ArrayBufferLike>>;
+export declare const UintArray: (n: number) => Uint8ArrayConstructor | Uint16ArrayConstructor | Uint32ArrayConstructor;
+export declare const ctor: <T extends TypedArray>(x: T) => Constructor<T>;
+export declare const emptyLike: <T extends TypedArray>(x: T) => T;
+export declare const set: <T extends TypedArray>(xs: T, x: ArrayLike<Number<T>> | T, i: number) => T;
+export declare const concat: <T extends TypedArray>(chunks: T[]) => T;
+export declare const iter: (size: number, stride?: number) => <T extends TypedArray>(data: T) => Generator<T>;
+export declare const tile: (n: number) => (out: TypedArray, x: TypedArray) => TypedArray;
+export declare const tileEvery: (m: number, n: number) => <T extends TypedArray>(xs: T, out?: T) => T;
+export declare const strided: <T extends TypedArray>(data: T, size: number, stride?: number, out?: T) => T;
+export declare const toFixed: (n: number, sep?: string) => (xs: NumberArray) => string;

package/src/typedarray.js

@@ -0,0 +1,39 @@
+import { bind } from "./fn.js";
+import { zmap, map as mapI, reduce } from "./iterable.js";
+import { push } from "./array.js";
+export const view = (type, length) => (buf = new ArrayBuffer(type.BYTES_PER_ELEMENT * length), offset = 0) => new type(buf, offset, length);
+export const u8 = bind((view), Uint8Array);
+export const u16 = bind((view), Uint16Array);
+export const u32 = bind((view), Uint32Array);
+export const u64 = bind((view), BigUint64Array);
+export const i8 = bind((view), Int8Array);
+export const i16 = bind((view), Int16Array);
+export const i32 = bind((view), Int32Array);
+export const i64 = bind((view), BigInt64Array);
+export const f16 = bind((view), Float16Array);
+export const f32 = bind((view), Float32Array);
+export const f64 = bind((view), Float64Array);
+export const UintArray = (n) => n < 256 ? Uint8Array : n < 65536 ? Uint16Array : Uint32Array;
+export const ctor = (x) => x.constructor;
+export const emptyLike = (x) => new (ctor(x))(x.length);
+export const set = (xs, x, i) => (xs.set(x, i), xs);
+export const concat = (chunks) => {
+    const out = new (ctor(chunks[0]))(chunks.reduce((a, x) => a + x.length, 0));
+    chunks.reduce((offset, chunk) => (out.set(chunk, offset), offset + chunk.length), 0);
+    return out;
+};
+export const iter = (size, stride = size) => function* (data) {
+    const C = ctor(data);
+    for (let i = 0, n = data.length; i < n - size + 1; i += stride) {
+        const offset = data.byteOffset + i * C.BYTES_PER_ELEMENT;
+        yield new C(data.buffer, offset, size);
+    }
+};
+export const tile = (n) => (out, x) => {
+    for (let i = 0; i < n; i++)
+        set(out, x, i * x.length);
+    return out;
+};
+export const tileEvery = (m, n) => (xs, out = new (ctor(xs))(xs.length * n)) => (zmap(tile(n))(iter(m * n)(out), iter(m)(xs)), out);
+export const strided = (data, size, stride = size, out = new (ctor(data))(data.length / size * stride)) => (iter(size)(data).forEach((p, i) => set(out, p, i * stride)), out);
+export const toFixed = (n, sep = ',') => (xs) => reduce((push), [])(mapI(x => x.toFixed(n))(Iterator.from(xs))).join(sep);

package/src/types.d.ts

@@ -0,0 +1,63 @@
+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

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

package/src/utils.d.ts

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,2 @@
+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

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

package/stream.d.ts

@@ -1,4 +1,4 @@
-import type { Fn } from "./types";
+import type { Fn } from "./types.js";
 export declare const readable: <T>(x: T) => ReadableStream<any>;
 export declare function iterate<T>(rs: ReadableStream<T>): AsyncGenerator<Awaited<T>, void, unknown>;
 export declare const map: <T, S>(f: Fn<T, S>) => TransformStream<T, S>;

package/stream.js

@@ -1,5 +1,5 @@
-import { push } from "./array";
-import { reduceA } from "./iterable";
+import { push } from "./array.js";
+import { reduceA } from "./iterable.js";
 export const readable = (x) => new ReadableStream({
     start: c => (c.enqueue(x), c.close())
 });

package/string.d.ts

@@ -1,4 +1,4 @@
-import type { Tuple } from "./types";
+import type { Tuple } from "./types.js";
 export declare const basename: (path: string) => string;
 export declare const dirname: (path: string) => string;
 export declare const splitext: (path: string) => Tuple<string, 2>;

package/string.js

@@ -1,5 +1,5 @@
-import { EMPTY } from "./constants";
-import { seek } from "./array";
+import { EMPTY } from "./constants.js";
+import { seek } from "./array.js";
 export const basename = (path) => path.split("/").at(-1) ?? "";
 export const dirname = (path) => {
     const parts = path.split("/");

package/struct.d.ts

@@ -1,5 +1,5 @@
-import type { TypedArray, Fn, NumberArray } from "./types";
-import type { Constructor } from "./typedarray";
+import type { TypedArray, Fn, NumberArray } from "./types.js";
+import type { Constructor } from "./typedarray.js";
 export interface Type {
     size: number;
     align: number;

package/struct.js

@@ -1,5 +1,5 @@
-import { align as _align } from "./math";
-import { isBigIntArray, isNumberArray } from "./checks";
+import { align as _align } from "./math.js";
+import { isBigIntArray, isNumberArray } from "./checks.js";
 const vec = (type) => (length = 1, align = type.BYTES_PER_ELEMENT) => ({
     type, align, length, size: type.BYTES_PER_ELEMENT * length,
 });

package/tree.d.ts

@@ -1,4 +1,4 @@
-import type { Fn, FnV, TPred, PredV } from './types';
+import type { Fn, FnV, TPred, PredV } from './types.js';
 export type Node<S, T = S> = T | Tree<S, T>;
 export type Tree<S, T = S> = [S, Node<S, T>[]];
 export declare const tree: <S, T = S>(value: S, children?: Node<S, T>[]) => Tree<S, T>;

package/tree.js

@@ -1,6 +1,6 @@
-import { identity } from './fn';
-import { EMPTY } from './constants';
-import { zip as zipI } from './iterable';
+import { identity } from './fn.js';
+import { EMPTY } from './constants.js';
+import { zip as zipI } from './iterable.js';
 export const tree = (value, children = []) => [value, children];
 export const isTree = (x) => Array.isArray(x) && x.length == 2 && Array.isArray(x[1]);
 export const children = (x, p = isTree) => p(x) ? x[1] : EMPTY.LIST;

package/treemap.d.ts

@@ -1,4 +1,4 @@
-import type { Maybe } from "./types";
+import type { Maybe } from "./types.js";
 export interface Treemap<T = number> {
     set(node: T, parent?: T): Treemap<T>;
     delete(key: T): void;

package/treemap.js

@@ -1,6 +1,6 @@
-import { before } from "./fn";
-import { isDefined } from "./checks";
-import { EMPTY } from "./constants";
+import { before } from "./fn.js";
+import { isDefined } from "./checks.js";
+import { EMPTY } from "./constants.js";
 export const treemap = () => {
     const nodes = new Set();
     const parents = new Map();

package/typedarray.d.ts

@@ -1,4 +1,4 @@
-import type { FnV, TypedArray, NumberArray, BufferType, Number } from "./types";
+import type { FnV, TypedArray, NumberArray, BufferType, Number } from "./types.js";
 export interface Constructor<T extends TypedArray> {
     new (length: number): T;
     new (buffer: BufferType<T> | ArrayBufferLike, byteOffset?: number, length?: number): T;

package/typedarray.js

@@ -1,6 +1,6 @@
-import { bind } from "./fn";
-import { zmap, map as mapI, reduce } from "./iterable";
-import { push } from "./array";
+import { bind } from "./fn.js";
+import { zmap, map as mapI, reduce } from "./iterable.js";
+import { push } from "./array.js";
 export const view = (type, length) => (buf = new ArrayBuffer(type.BYTES_PER_ELEMENT * length), offset = 0) => new type(buf, offset, length);
 export const u8 = bind((view), Uint8Array);
 export const u16 = bind((view), Uint16Array);

package/utils.d.ts

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

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

package/weak.d.ts

@@ -1,2 +1,2 @@
-import type { Fn, Maybe } from "./types";
+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/weak.js

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