@cgtk/std 0.0.192 → 0.0.194

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("/");
@@ -26,3 +26,4 @@ export const readLine = (delims = new Set([0x0A])) => {
         return n > 0 ? dec(data.subarray(offset, n + 1)) : EMPTY.STR;
     };
 };
+export const DATA_URL = /^data:(?<mime>[\w/\-\+]+)?(;(?<params>[\w\-]+\=[^;,\s]+)*)?(;(?<encoding>base64))?,(?<data>.*)$/;

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,10 +1,10 @@
-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>;
 export declare const isTree: <S, T = S>(x: Node<S, T>) => x is Tree<S, T>;
-export declare const children: <S, T = S>(p?: TPred<Tree<S, T>, Node<S, T>>) => (x: Node<S, T>) => Node<S, T>[];
-export declare const value: <S, T = S>(p?: TPred<Tree<S, T>, Node<S, T>>) => (x: Node<S, T>) => S | T;
+export declare const children: <S, T = S>(x: Node<S, T>, p?: TPred<Tree<S, T>, Node<S, T>>) => Node<S, T>[];
+export declare const value: <S, T = S>(x: Node<S, T>, p?: TPred<Tree<S, T>, Node<S, T>>) => S | T;
 export declare const transform: <S, T = S, A = Tree<S, T>, B = Node<S, T>, C = void>(node: FnV<[Tree<S, T>, Fn<C, Fn<Node<S, T>>>, C], A>, leaf: FnV<[T, C], B>, p?: TPred<Tree<S, T>>) => Fn<C, Fn<Node<S, T>, A | B>>;
 export declare const map: <S, T = S, U = S, V = T, C = void>(parent: FnV<[S, C], U>, child: FnV<[T, C], V>, update?: FnV<[C, S], C>, p?: TPred<Tree<S, T>>) => Fn<C, Fn<Node<S, T>, Node<U, V>>>;
 export declare const filter: <S, T = S, C = void>(ps: PredV<[Node<S, T>, C]>, update?: FnV<[C, S], C>, p?: TPred<Tree<S, T>>) => Fn<C, Fn<Node<S, T>, T | Tree<S, T>>>;

package/tree.js

@@ -1,10 +1,10 @@
-import { identity } from './fn';
-import { EMPTY } from './constants';
-import { zip as zipI } from './iterable';
-export const tree = (value, children = EMPTY.LIST) => [value, children];
+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 = (p = isTree) => (x) => p(x) ? x[1] : EMPTY.LIST;
-export const value = (p = isTree) => (x) => p(x) ? x[0] : x;
+export const children = (x, p = isTree) => p(x) ? x[1] : EMPTY.LIST;
+export const value = (x, p = isTree) => 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;
@@ -13,13 +13,11 @@ export const map = (parent, child, update = identity, p = isTree) => transform((
 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 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)]);
+            res.push([value(a), value(b)]);
         else if ((isTree(a) && isTree(a)))
-            res.push([[va(a), vb(b)], zip(ca(a), cb(b))]);
+            res.push([[value(a), value(b)], zip(children(a), children(b))]);
         else
             throw new Error("[tree] a and b should be both tree or node");
     }

package/treemap.d.ts

@@ -1,13 +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>;
+import type { Maybe } from "./types.js";
+export interface Treemap<T = number> {
+    set(node: T, parent?: T): Treemap<T>;
+    delete(key: T): void;
+    parent(key: T): Maybe<T>;
+    size: number;
+    children(key: T): T[];
+    roots(): IteratorObject<T>;
+    ancestors(node: T): IteratorObject<T>;
+    dfs(root: T): IteratorObject<T>;
+    bfs(): IteratorObject<T>;
 }
+export declare const treemap: <T = number>() => Treemap<T>;

package/treemap.js

@@ -1,68 +1,71 @@
-import { isUndefined } from "./checks";
-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;
+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 (!isUndefined(p)) {
+                if (isDefined(p)) {
                     if (!children.has(p))
                         children.set(p, []);
                     children.get(p).push(k);
                 }
             }
-            this.changed = false;
+            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));
-        }
-    }
-}
+        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/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/types.d.ts

@@ -2,6 +2,8 @@ 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 {
@@ -16,7 +18,6 @@ export type Fns<T> = {
 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 Resource<T> = Reactive<T, Dispose | void>;
 export type Constantly<T> = () => T;
 export type FirstParam<F extends FnV> = MaybeFirst<Parameters<F>>;
 export type MaybePromise<T = unknown> = T | PromiseLike<T>;
@@ -50,7 +51,7 @@ 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 Maybe<T> = T | undefined;
 export type Indexed<T> = [number, T];
 export type Required<T, K extends keyof T> = T & {
     [P in K]-?: T[P];
@@ -59,9 +60,4 @@ 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";
+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, Optional } from "./types";
-export declare const deref: <T extends WeakKey, F extends Fn<T>>(r: WeakRef<T>, f: F) => Optional<ReturnType<F>>;
+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;