@cgtk/std 0.0.200 → 0.0.202

package/array.js

@@ -11,8 +11,8 @@ export const cap = (n, f) => xs => {
         f(xs);
     return xs;
 };
-export const sliding = (n, xs = []) => comp(scan((push), xs), cap(n, shift));
-export const dropping = (n, xs = []) => comp(scan((push), xs), cap(n, pop));
+export const sliding = (n, xs = []) => comp(scan(push, xs), cap(n, shift));
+export const dropping = (n, xs = []) => comp(scan(push, xs), cap(n, pop));
 export const tuple = (...xs) => xs;
 export const seek = (arr, vals, offset = 0) => {
     for (let i = offset, n = arr.length; i < n; i++)

package/checks.js

@@ -29,7 +29,7 @@ export const isclose = (a, b, eps = Number.EPSILON) => Math.abs(a - b) < eps;
 export const allclose = (a, b, eps) => a.length == b.length && a.every((x, i) => isclose(x, b[i], eps));
 export const equal = (a, b) => a == b;
 export const strictEqual = (a, b) => a === b;
-export const isDiffPrev = (eq = (strictEqual)) => comp(sliding(2), not(apply(eq)));
+export const isDiffPrev = (eq = strictEqual) => comp(sliding(2), not(apply(eq)));
 export const isLonger = (delta) => comp((x) => [performance.now(), x], sliding(2), (xs) => xs.length < 2 || xs[1][0] - xs[0][0] > delta);
 export const isFunction = (x) => typeof x === "function";
 export const isAborted = (signal) => () => signal.aborted;

package/dom.js

@@ -100,11 +100,11 @@ const NS = {
 };
 const tag = (ns, name) => document.createElementNS(NS[ns], name);
 export const h = new Proxy({}, ({
-    get: (_, name) => F.bind((element), tag("HTML", name))
+    get: (_, name) => F.bind(element, tag("HTML", name))
 }));
 export const s = new Proxy({}, {
-    get: (_, name) => F.bind((element), tag("SVG", name))
+    get: (_, name) => F.bind(element, tag("SVG", name))
 });
 export const m = new Proxy({}, {
-    get: (_, name) => F.bind((element), tag("MathML", name))
+    get: (_, name) => F.bind(element, tag("MathML", name))
 });

package/math.d.ts

@@ -30,7 +30,7 @@ export declare const logn: (n: number, x: number) => number;
 export declare const floordiv: (x: number, b: number) => number;
 export declare const zoom: (x: number, s: number, p: number) => number;
 export declare const align: (x: number, b: number) => number;
-export declare const sign11: (x: number) => 1 | -1;
+export declare const sign11: (x: number) => -1 | 1;
 export declare const nudge: (x: number, v?: number, eps?: number) => number;
 export declare const divCeil: (a: number, b: number) => number;
 export declare const trunc: (num: number, precision: number) => number;

package/package.json

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

package/port.js

@@ -6,7 +6,7 @@ import { promisify } from "./async.js";
 export const onMessages = (target, fs) => on(target, "message", ({ data: { type, payload } }) => (type in fs) && fs[type](payload));
 export const onMessage = (target, name, f) => on(target, "message", ({ data: { type, payload } }) => type == name && f(payload));
 export const messageSources = (worker) => new Proxy({}, {
-    get: (_, k) => bind((onMessage), worker, k)
+    get: (_, k) => bind(onMessage, worker, k)
 });
 export const postMessages = (port) => new Proxy({}, {
     get: (_, type) => (payload, options) => port.postMessage({ type, payload }, options)

package/schedule.d.ts

@@ -4,6 +4,7 @@ export declare const timeout: (ms?: number) => Reactive<void>;
 export declare const schedule: <T>(s: Reactive<T>) => <F extends FnV>(f: F) => FnV<Parameters<F>, Dispose>;
 export declare const debounce: <T>(sched?: Reactive<T>) => Reactive<T>;
 export declare const reset: <T>(sched?: Reactive<T>) => Reactive<T>;
-export declare const repeatedly: <T = number>(sched?: Reactive<T>) => (f: Fn<T, boolean | void>) => () => any;
+export declare const repeatedly: <T = number>(f: Fn<T>, sched?: Reactive<T>) => () => any;
+export declare const repeatedlyCounted: <T = number>(n: number, f: Fn<number>, sched?: Reactive<T>) => () => any;
 export declare const delayAfter: <F extends FnV<any>>(delta: number, n: number, f: F) => (x: any) => any;
 export declare const micro: <F extends FnV>(f: F) => (...xs: Parameters<F>) => (reason?: any) => void;

package/schedule.js

@@ -2,7 +2,7 @@ import { isUndefined, isDefined, counted } from './checks.js';
 import { comp, lazy, bind, apply, call, where, noop, abortable } from './fn.js';
 export const raf = f => bind(cancelAnimationFrame, requestAnimationFrame(f));
 export const timeout = (ms = 0) => f => bind(clearTimeout, setTimeout(f, ms));
-export const schedule = (s) => (f) => call(comp(apply(bind((lazy), f)), s));
+export const schedule = (s) => (f) => call(comp(apply(bind(lazy, f)), s));
 export const debounce = (sched = raf) => {
     let cancel;
     const stop = () => { if (isDefined(cancel))
@@ -22,13 +22,17 @@ export const reset = (sched = raf) => {
         return stop;
     };
 };
-export const repeatedly = (sched = raf) => (f) => {
+export const repeatedly = (f, sched = raf) => {
     let cancel;
     const g = (x) => { if (f(x) !== false)
         cancel = sched(g); };
     cancel = sched(g);
     return () => cancel();
 };
+export const repeatedlyCounted = (n, f, sched) => {
+    let i = 0;
+    return repeatedly(() => f(i) !== false && ++i < n, sched);
+};
 export const delayAfter = (delta, n, f) => where(counted(n), f, schedule(reset(timeout(delta)))(f));
 export const micro = (f) => (...xs) => abortable(signal => queueMicrotask(() => { if (!signal.aborted)
     f(...xs); }));

package/stream.js

@@ -23,4 +23,4 @@ export const tap = (start, t, flush) => new TransformStream({
     },
     flush
 });
-export const reduceArray = (stream, xs = []) => reduceA((push), xs)(iterate(stream));
+export const reduceArray = (stream, xs = []) => reduceA(push, xs)(iterate(stream));

package/string.js

@@ -10,7 +10,7 @@ export const dirname = (path) => {
 export const splitext = (path) => {
     const idx = path.lastIndexOf(".");
     if (idx == -1)
-        return [path, ""];
+        return [path, EMPTY.STR];
     return [path.slice(0, idx), path.slice(idx + 1)];
 };
 export const objectURL = (data, type) => URL.createObjectURL(new Blob([data], { type }));

package/typedarray.d.ts

@@ -19,7 +19,7 @@ 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 UintArray: (n: number) => Uint16ArrayConstructor | Uint32ArrayConstructor | Uint8ArrayConstructor;
 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;

package/typedarray.js

@@ -2,17 +2,17 @@ import { bind } from "./fn.js";
 import { zmap } from "./iterable.js";
 import { push, tuple } 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 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);
@@ -57,4 +57,4 @@ export const tile = (n) => (out, x) => {
 };
 export const tileEvery = (m, n) => (xs, out = new (ctor(xs))(xs.length * n)) => (zmap(tile(n))(iter(out, m * n), iter(xs, m)), out);
 export const strided = (data, size, stride = size, out = new (ctor(data))(data.length / size * stride)) => (iter(data, size).forEach((p, i) => set(out, p, i * stride)), out);
-export const toFixed = (n, sep = ',') => (xs) => Iterator.from(xs).map(x => x.toFixed(n)).reduce((push), []).join(sep);
+export const toFixed = (n, sep = ',') => (xs) => Iterator.from(xs).map(x => x.toFixed(n)).reduce(push, []).join(sep);