@cgtk/std 0.0.189 → 0.0.191

package/array.d.ts

@@ -1,4 +1,4 @@
-import type { Fn, Tuple, Numbers } from "./types";
+import type { Fn, Tuple } from "./types";
 export declare const empty: <T>() => T[];
 export declare const push: <T>(xs: T[], x: T) => T[];
 export declare const unshift: <T>(xs: T[], x: T) => T[];
@@ -11,4 +11,4 @@ export declare const retain: <T>(n: number, xs?: T[]) => (x: T) => T[];
 export declare const tuple: <T, N extends number>(...xs: T[] & {
     length: N;
 }) => Tuple<T, N>;
-export declare const seek: <T>(arr: T[] | Numbers, vals: Set<T | number>, offset?: number) => number;
+export declare const seek: <T>(arr: ArrayLike<T>, vals: Set<T | number>, offset?: number) => number;

package/checks.d.ts

@@ -1,5 +1,7 @@
-import type { TypedArray, Pred, TPred, Optional, Numbers } from "./types";
+import type { TypedArray, NumberArray, BigIntArray, Pred, TPred, Optional } from "./types";
 export declare const isTypedArray: (x: any) => x is TypedArray;
+export declare const isNumberArray: (x: any) => x is NumberArray;
+export declare const isBigIntArray: (x: any) => x is BigIntArray;
 export declare const isUndefined: (x: any) => x is undefined;
 export declare const isNull: (x: any) => x is null;
 export declare const isDefined: <T>(x: Optional<T>) => x is T;
@@ -8,10 +10,11 @@ export declare function assertType<T>(x: any, pred: TPred<T>, msg: string): asse
 export declare const isObject: TPred<Object>;
 export declare const isString: TPred<string>;
 export declare const isNumber: TPred<number>;
+export declare const isBigInt: TPred<bigint>;
 export declare const isPositive: Pred<number>;
 export declare const isTs: <T>(p: TPred<T>) => TPred<T[]>;
 export declare const isclose: (a: number, b: number, eps?: number) => boolean;
-export declare const allclose: (a: Numbers, b: Numbers, eps?: number) => boolean;
+export declare const allclose: (a: Array<number> | NumberArray, b: Array<number> | NumberArray, eps?: number) => boolean;
 export declare const equal: <T>(a: T, b?: T) => boolean;
 export declare const strictEqual: <T>(a: T, b?: T) => boolean;
 export declare const isDiffPrev: <T>(eq?: (a: T, b?: T | undefined) => boolean) => Pred<T>;

package/checks.js

@@ -3,7 +3,13 @@ import { retain } from "./array";
 export const isTypedArray = (x) => x && (x instanceof Uint8Array || x instanceof Uint8ClampedArray ||
     x instanceof Uint16Array || x instanceof Uint32Array ||
     x instanceof Int8Array || x instanceof Int16Array || x instanceof Int32Array ||
-    x instanceof Float32Array || x instanceof Float64Array);
+    x instanceof Float16Array || x instanceof Float32Array || x instanceof Float64Array ||
+    x instanceof BigUint64Array || x instanceof BigInt64Array);
+export const isNumberArray = (x) => x && (x instanceof Uint8Array || x instanceof Uint8ClampedArray ||
+    x instanceof Uint16Array || x instanceof Uint32Array ||
+    x instanceof Int8Array || x instanceof Int16Array || x instanceof Int32Array ||
+    x instanceof Float16Array || x instanceof Float32Array || x instanceof Float64Array);
+export const isBigIntArray = (x) => x && (x instanceof BigUint64Array || x instanceof BigInt64Array);
 export const isUndefined = (x) => x === undefined;
 export const isNull = (x) => x === null;
 export const isDefined = (x) => !isUndefined(x);
@@ -15,6 +21,7 @@ export function assertType(x, pred, msg) { assert(pred(x), msg); }
 export const isObject = (x) => x !== null && typeof x === "object";
 export const isString = (x) => typeof x === "string";
 export const isNumber = (x) => typeof x === 'number';
+export const isBigInt = (x) => typeof x === "bigint";
 export const isPositive = (x) => x > 0;
 export const isTs = (p) => and(Array.isArray, (xs) => xs.every(p));
 export const isclose = (a, b, eps = Number.EPSILON) => Math.abs(a - b) < eps;

package/number.d.ts

@@ -1,3 +1,4 @@
 export declare const add: (a: number, x: number) => number;
+export declare const toFixed: (x: number | bigint, n?: number) => string | bigint;
 export declare const toFixedMax: (x: number, n?: number) => string;
 export declare const roundTo: (x: number, n: number) => number;

package/number.js

@@ -1,4 +1,6 @@
+import { isBigInt } from "./checks";
 export const add = (a, x) => a + x;
+export const toFixed = (x, n = 0) => isBigInt(x) ? x : x.toFixed(n);
 export const toFixedMax = (x, n = 0) => {
     const y = Number(x.toFixed(n));
     return `${Math.sign(y) == -1 ? '-' : ''}${Math.abs(y)}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cgtk/std",
-  "version": "0.0.189",
+  "version": "0.0.191",
   "type": "module",
   "main": "./index.js",
   "exports": {

package/struct.d.ts

@@ -1,10 +1,10 @@
-import type { TypedArray, BigIntArray, Fn } from "./types";
+import type { TypedArray, Fn } from "./types";
 import type { Constructor } from "./typedarray";
 export interface Type {
     size: number;
     align: number;
 }
-export type Vec<T extends TypedArray | BigIntArray, N extends number> = Type & {
+export type Vec<T extends TypedArray, N extends number> = Type & {
     length: N;
     type: Constructor<T>;
 };
@@ -36,7 +36,7 @@ export type Struct<T extends ReadonlyArray<Field<any>>> = Type & {
 export declare const isStruct: (t: any) => t is Struct<any>;
 export declare const struct: <T extends ReadonlyArray<Field<any>>>(fs: T, align?: number, offset?: number) => Struct<T>;
 export type View<T extends Type> = T extends Vec<infer C, any> ? C : T extends Array<infer S> ? View<S>[] : T extends Struct<infer F> ? {
-    [K in F[number] as K[0]]: K[1] extends Vec<infer C, infer N> ? (N extends 1 ? number : C) : View<K[1]>;
+    [K in F[number] as K[0]]: K[1] extends Vec<infer C, infer N> ? (N extends 1 ? (C extends TypedArray ? number : bigint) : C) : View<K[1]>;
 } : never;
 export declare const view: <T extends Vec<any, any> | Array<any> | Struct<any>>(t: T, buf?: ArrayBufferLike, offset?: number) => View<T>;
 export {};

package/struct.js

@@ -1,5 +1,5 @@
 import { align as _align } from "./math";
-import { isTypedArray } from "./checks";
+import { isTypedArray, isBigIntArray } from "./checks";
 const vec = (type) => (length = 1, align = type.BYTES_PER_ELEMENT) => ({
     type, align, length, size: type.BYTES_PER_ELEMENT * length,
 });
@@ -42,7 +42,7 @@ export const struct = (fs, align = 0, offset = 0) => {
 };
 const property = (value) => ({
     enumerable: true,
-    ...(isTypedArray(value) && value.length == 1 ? {
+    ...((isTypedArray(value) || isBigIntArray(value)) && value.length == 1 ? {
         get: () => value[0],
         set: (x) => value[0] = x,
     } : { value })

package/typedarray.d.ts

@@ -1,31 +1,31 @@
-import type { Fn, FnV, TypedArray, BigIntArray, BufferType, Numbers } from "./types";
-export interface Constructor<T extends TypedArray | BigIntArray> {
+import type { FnV, TypedArray, NumberArray, BufferType, Number } from "./types";
+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[] | bigint[]): T;
-    from(arrayLike: ArrayLike<number | bigint>): T;
+    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: Numbers, i: number) => 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 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, stride?: number, out?: T) => T;
-export declare const toFixed: (n: number, sep?: string) => (xs: TypedArray) => string;
+export declare const toFixed: (n: number, sep?: string) => (xs: NumberArray) => string;

package/typedarray.js

@@ -5,9 +5,11 @@ export const view = (type, length) => (buf = new ArrayBuffer(type.BYTES_PER_ELEM
 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);
@@ -29,17 +31,9 @@ export const iter = (size, stride = size) => function* (data) {
 };
 export const tile = (n) => (out, x) => {
     for (let i = 0; i < n; i++)
-        out.set(x, i * x.length);
+        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) => out.set(p, i * stride)), out);
-export const map = (it, f) => (data, out = emptyLike(data)) => (zmap(f)(it(out), it(data)), out);
-export const unweld = (data, indices, size, stride = size, out = new (ctor(data))(indices.length * stride)) => {
-    indices.forEach((i, j) => {
-        for (let k = 0; k < size; k++)
-            out[j * stride + k] = data[i * size + k];
-    });
-    return 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/types.d.ts

@@ -38,10 +38,14 @@ export type Entries<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 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 BufferType<T extends TypedArray | BigIntArray> = T extends TypedArray<infer S> ? S : T extends BigIntArray<infer S> ? S : never;
-export type Numbers = Array<number> | TypedArray;
+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>;