@cgtk/std 0.0.182 → 0.0.184

package/base64.d.ts

@@ -0,0 +1 @@
+export declare const decodeBytes: (str: string) => Uint8Array<ArrayBuffer>;

package/base64.js

@@ -0,0 +1,7 @@
+export const decodeBytes = (str) => {
+    const raw = atob(str), size = raw.length;
+    const res = new Uint8Array(size);
+    for (let i = 0; i < size; i++)
+        res[i] = raw.charCodeAt(i);
+    return res;
+};

package/iterable.d.ts

@@ -1,4 +1,5 @@
-import type { Fn, FnV, Indexed, Pred } from "./types.js";
+import type { Fn, FnV, Indexed, Pred } from "./types";
+export declare const next: <T>(xs: Iterator<T>) => T;
 export declare const repeat: (n: number) => <A>(x: A) => Iterator<A>;
 export declare const just: <T>(x: T) => IteratorObject<T>;
 export declare const enumerate: (n?: number) => <T>(x: T) => Indexed<T>;
@@ -17,7 +18,7 @@ export declare const flat: <T>(xs: IteratorObject<IteratorObject<T>>) => Iterato
 export declare const prepend: <A>(ys: IteratorObject<A>) => (xs: IteratorObject<A>) => Generator<A, void, unknown>;
 export declare const append: <A>(ys: IteratorObject<A>) => (xs: IteratorObject<A>) => Generator<A, void, unknown>;
 export declare const first: <T>(xs: IteratorObject<T>) => T | undefined;
-export declare const reduce: <T, S>(f: FnV<[S, T], S>, a: S) => (xs: IteratorObject<T>) => S;
+export declare const reduce: <T, S>(f: FnV<[S, T, number], S>, a: S) => (xs: IteratorObject<T>) => S;
 export declare const traverse: <T>(children: Fn<T, Iterable<T>>, f: Fn<T>) => Fn<T>;
 export declare const take: (n: number) => <T>(xs: IteratorObject<T>) => Generator<T>;
 export declare function arange(a: number, b?: number, s?: number): Generator<number, void, unknown>;

package/iterable.js

@@ -1,5 +1,11 @@
-import { pipe, comp, scan, apply, noop, identity, constantly } from "./fn.js";
-import { set } from "./map.js";
+import { assert, isDefined } from "./checks";
+import { pipe, comp, scan, apply, noop, identity, constantly } from "./fn";
+import { set } from "./map";
+export const next = (xs) => {
+    const { done, value } = xs.next();
+    assert(isDefined(done) && !done, "iterator done");
+    return value;
+};
 export const repeat = n => function* (x) { for (let i = 0; i < n; i++)
     yield x; };
 export const just = function* (x) { yield x; };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cgtk/std",
-  "version": "0.0.182",
+  "version": "0.0.184",
   "type": "module",
   "main": "./index.js",
   "exports": {
@@ -33,6 +33,7 @@
     "./basen": "./basen.js",
     "./struct": "./struct.js",
     "./buffer": "./buffer.js",
+    "./base64": "./base64.js",
     "./utils": "./utils.js"
   },
   "devDependencies": {

package/struct.d.ts

@@ -18,8 +18,9 @@ export declare const f32: Num<Float32Array<ArrayBufferLike>>;
 export declare const f64: Num<Float64Array<ArrayBufferLike>>;
 export declare const vec: <T extends TypedArray, N extends number>(t: Num<T>, length: N, align?: number, size?: number) => View<T>;
 export declare const array: <T>(type: View<T>, length: number, size?: number, align?: number) => View<T[]>;
-type Struct<T extends ReadonlyArray<readonly [string, View<any>]>> = View<{
+export type Fields = ReadonlyArray<readonly [string, View<unknown>]>;
+export type Struct<T extends Fields> = View<{
     [K in T[number] as K[0]]: K[1] extends Num<any> ? number : Inner<K[1]>;
 }>;
-export declare const struct: <T extends ReadonlyArray<readonly [string, View<any>]>>(fs: T) => Struct<T>;
+export declare const struct: <T extends Fields>(fs: T) => Struct<T>;
 export {};

package/struct.js

@@ -47,9 +47,8 @@ export const struct = (fs) => {
     const size = _align(offset, align);
     const f = ((buf = new ArrayBuffer(size), offset = 0) => {
         const res = {};
-        for (const [name, type] of Object.entries(fields)) {
+        for (const [name, type] of Object.entries(fields))
             Object.defineProperty(res, name, property(type(buf, offset + offsets[name])));
-        }
         return res;
     });
     f.size = size;

package/typedarray.d.ts

@@ -13,7 +13,7 @@ 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 set: <T extends TypedArray>(xs: T, x: 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;

package/typedarray.js

@@ -13,7 +13,7 @@ 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 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);