@cgtk/std 0.0.182

package/tree.js

@@ -0,0 +1,33 @@
+import { identity } from './fn.js';
+import { EMPTY } from './constants.js';
+import { isString } from './checks.js';
+import { zip as zipI } from './iterable.js';
+export const tree = (value, children = EMPTY.LIST) => [value, children];
+export const isTree = (x) => Array.isArray(x) && x.length == 2 && Array.isArray(x[1]);
+export const children = (p = isTree) => (x) => p(x) ? x[1] : EMPTY.LIST;
+export const value = (p = isTree) => (x) => p(x) ? x[0] : x;
+export const transform = (node, leaf, p = isTree) => {
+    const f = (c) => (x) => p(x) ? node(x, f, c) : leaf(x, c);
+    return f;
+};
+export const map = (parent, child, update = identity, p = isTree) => transform((x, f, c) => tree(parent(x[0], c), x[1].map(f(update(c, x[0])))), child, p);
+export const filter = (ps, update = identity, p = isTree) => transform((x, f, c) => tree(x[0], x[1].filter(x => ps(x, c)).map(f(update(c, x[0])))), identity, p);
+export const toggleChildren = (g, update = identity, p = isTree) => transform((x, f, c) => tree(x[0], g(x, c) ? x[1].map(f(update(c, x[0]))) : EMPTY.LIST), identity, p);
+export const asObject = (items, f = identity, update = identity, context = "") => Object.fromEntries(items.map((x) => isString(x) ? [x, f(x, context)] : [x[0], {
+        value: f(x[0], context),
+        children: asObject(x[1], f, update, update(context, x[0]))
+    }]));
+export const zip = (na, nb) => {
+    const res = [];
+    const va = value(), vb = value();
+    const ca = children(), cb = children();
+    for (const [a, b] of zipI(Iterator.from(na), Iterator.from(nb))) {
+        if (!isTree(a) && !isTree(a))
+            res.push([va(a), vb(b)]);
+        else if ((isTree(a) && isTree(a)))
+            res.push([[va(a), vb(b)], zip(ca(a), cb(b))]);
+        else
+            throw new Error("[tree] a and b should be both tree or node");
+    }
+    return res;
+};

package/treemap.d.ts

@@ -0,0 +1,13 @@
+export declare class Treemap<T = number> {
+    #private;
+    static from<T>(iter: Iterable<[T, T?]>): Treemap<T>;
+    nodes: Set<T>;
+    parents: Map<T, T>;
+    changed: boolean;
+    add(node: T, parent?: T): T;
+    remove(key: T): void;
+    parent(key: T): T | undefined;
+    get size(): number;
+    children(key: T): T[] | undefined;
+    [Symbol.iterator](): Generator<NonNullable<T>, void, unknown>;
+}

package/treemap.js

@@ -0,0 +1,68 @@
+import { isUndefined } from "./checks.js";
+export class Treemap {
+    static from(iter) {
+        const tree = new Treemap();
+        for (const [n, p] of iter)
+            tree.add(n, p);
+        return tree;
+    }
+    nodes = new Set();
+    parents = new Map();
+    #children = new Map();
+    changed = false;
+    add(node, parent) {
+        const { nodes, parents } = this;
+        nodes.add(node);
+        if (!isUndefined(parent))
+            parents.set(node, parent);
+        this.changed = true;
+        return node;
+    }
+    remove(key) {
+        const { nodes, parents } = this;
+        nodes.delete(key);
+        parents.delete(key);
+        this.changed = true;
+    }
+    #update() {
+        const changed = this.changed;
+        if (changed) {
+            const { nodes, parents } = this;
+            const children = this.#children;
+            children.clear();
+            for (const k of nodes) {
+                const p = parents.get(k);
+                if (!isUndefined(p)) {
+                    if (!children.has(p))
+                        children.set(p, []);
+                    children.get(p).push(k);
+                }
+            }
+            this.changed = false;
+        }
+        return changed;
+    }
+    parent(key) {
+        this.#update();
+        return this.parents.get(key);
+    }
+    get size() {
+        this.#update();
+        return this.nodes.size;
+    }
+    children(key) {
+        this.#update();
+        return this.#children.get(key);
+    }
+    *[Symbol.iterator]() {
+        this.#update();
+        const { nodes, parents } = this;
+        const queue = [], children = this.#children;
+        nodes.forEach(k => !parents.has(k) && queue.push(k));
+        for (let node; queue.length > 0;) {
+            yield node = queue.shift();
+            if (children.has(node))
+                queue.push(...children.get(node));
+        }
+    }
+}

package/typedarray.d.ts

@@ -0,0 +1,23 @@
+import type { Fn, FnV, TypedArray, Numbers } from "./types";
+export type Constructor<T extends TypedArray> = T extends Uint8Array ? Uint8ArrayConstructor : T extends Uint8ClampedArray ? Uint8ClampedArrayConstructor : T extends Uint16Array ? Uint16ArrayConstructor : T extends Uint32Array ? Uint32ArrayConstructor : T extends Int8Array ? Int8ArrayConstructor : T extends Int16Array ? Int16ArrayConstructor : T extends Int32Array ? Int32ArrayConstructor : T extends Float32Array ? Float32ArrayConstructor : T extends Float64Array ? Float64ArrayConstructor : never;
+export type View<T extends TypedArray> = FnV<[ArrayBuffer?, 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 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 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, v: Numbers, 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 map: <T extends TypedArray>(it: Fn<T, IteratorObject<T>>, f: FnV<[T, T]>) => (data: T, out?: T) => T;
+export declare const unweld: <T extends TypedArray>(data: T, indices: Numbers, size: number, out?: T) => T;
+export declare const toFixed: (n: number, sep?: string) => (xs: TypedArray) => string;

package/typedarray.js

@@ -0,0 +1,44 @@
+import { bind } from "./fn";
+import { zmap, map as mapI, reduce } from "./iterable";
+import { push } from "./array";
+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 i8 = bind((view), Int8Array);
+export const i16 = bind((view), Int16Array);
+export const i32 = bind((view), Int32Array);
+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, v, i) => (xs.set(v, 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;
+        // https://github.com/microsoft/TypeScript/pull/59417
+        yield new C(data.buffer, offset, size);
+    }
+};
+export const tile = (n) => (out, x) => {
+    for (let i = 0; i < n; i++)
+        out.set(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 map = (it, f) => (data, out = emptyLike(data)) => (zmap(f)(it(out), it(data)), out);
+export const unweld = (data, indices, size, out = new (ctor(data))(indices.length * size)) => {
+    indices.forEach((i, j) => {
+        for (let k = 0; k < size; k++)
+            out[j * size + k] = data[i * size + k];
+    });
+    return out;
+};
+export const toFixed = (n, sep = ',') => (xs) => reduce((push), [])(mapI(x => x.toFixed(n))(Iterator.from(xs))).join(sep);

package/types.d.ts

@@ -0,0 +1,42 @@
+export type Key = string | number | symbol;
+export interface RecordOf<T> {
+    [id: string | number | symbol]: 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]>;
+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 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 FnF = <F extends FnV>(f: F) => (...xs: Parameters<F>) => ReturnType<F>;
+export type Reactive<T = unknown> = Fn<Fn<T>, Fn<void>>;
+export type Constantly<T> = () => T;
+export type FirstParam<F extends FnV> = MaybeFirst<Parameters<F>>;
+export type Nullable<T> = T | null;
+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 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 Numbers = Array<number> | TypedArray;
+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 Optional<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>;
+};

package/types.js

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

package/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/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/weak.d.ts

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

package/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;
+};