@thi.ng/soa 0.4.87 → 0.4.88

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2023-12-09T19:12:04Z
+- **Last updated**: 2023-12-11T10:07:09Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.

package/aos.js

@@ -2,64 +2,31 @@ import { SIZEOF } from "@thi.ng/api/typedarray";
 import { align } from "@thi.ng/binary/align";
 import { SOA } from "./soa.js";
 import { prepareSpec } from "./utils.js";
-/**
- * Constructs SOA instance from given attrib specs and optional
- * ArrayBuffer (w/ optional start address / byte offset, which MUST be
- * properly pre-aligned). The resulting layout will be an underlying
- * interleaved AOS buffer with each attrib configured to map that same
- * array buffer relative to the given `byteOffset` (default: 0). If no
- * array buffer is given, a properly sized one will be created.
- *
- * First computes attrib offsets, alignments and the overall struct
- * size, then configures buffer views and strides for each attrib. This
- * is to ensure each attrib is correctly mapped in its buffer view (e.g.
- * float values need to be aligned to 4-byte boundaries). The overall
- * inter-struct packing/stride length is dependent on the largest attrib
- * type used. E.g. the following specs will cause a stride length of 16
- * bytes between each resulting SOA element, even though the actual
- * struct size is only 13 bytes:
- *
- * @example
- * ```ts
- * aos(
- *   1024,
- *   {
- *     a: { type: "u16", size: 1 }, // 2 bytes, align 2, offset 0
- *     b: { type: "f32", size: 2 }, // 8 bytes, align 4, offset 4
- *     c: { type: "u8", size: 1 },  // 1 byte,  align 1, offset 12
- *   }
- * );
- * ```
- *
- * @param num -
- * @param specs -
- * @param buf -
- * @param byteOffset -
- */
-export const aos = (num, specs, buf, byteOffset = 0) => {
-    let total = 0;
-    let maxSize = 0;
-    const offsets = {};
-    const soaSpecs = {};
-    for (let id in specs) {
-        const spec = prepareSpec(specs[id]);
-        const tsize = SIZEOF[spec.type];
-        maxSize = Math.max(maxSize, tsize);
-        // align field to type size
-        total = align(total, tsize);
-        offsets[id] = total;
-        total += tsize * spec.size;
-        soaSpecs[id] = spec;
-    }
-    // align total struct size to largest type
-    total = align(total, maxSize);
-    buf = buf || new ArrayBuffer(total * num + byteOffset);
-    for (let id in soaSpecs) {
-        const spec = soaSpecs[id];
-        const tsize = SIZEOF[spec.type];
-        spec.stride = total / tsize;
-        spec.buf = buf;
-        spec.byteOffset = byteOffset + offsets[id];
-    }
-    return new SOA(num, soaSpecs);
+const aos = (num, specs, buf, byteOffset = 0) => {
+  let total = 0;
+  let maxSize = 0;
+  const offsets = {};
+  const soaSpecs = {};
+  for (let id in specs) {
+    const spec = prepareSpec(specs[id]);
+    const tsize = SIZEOF[spec.type];
+    maxSize = Math.max(maxSize, tsize);
+    total = align(total, tsize);
+    offsets[id] = total;
+    total += tsize * spec.size;
+    soaSpecs[id] = spec;
+  }
+  total = align(total, maxSize);
+  buf = buf || new ArrayBuffer(total * num + byteOffset);
+  for (let id in soaSpecs) {
+    const spec = soaSpecs[id];
+    const tsize = SIZEOF[spec.type];
+    spec.stride = total / tsize;
+    spec.buf = buf;
+    spec.byteOffset = byteOffset + offsets[id];
+  }
+  return new SOA(num, soaSpecs);
+};
+export {
+  aos
 };

package/api.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/soa",
-  "version": "0.4.87",
+  "version": "0.4.88",
   "description": "SOA & AOS memory mapped structured views with optional & extensible serialization",
   "type": "module",
   "module": "./index.js",
@@ -24,7 +24,9 @@
   "author": "Karsten Schmidt (https://thi.ng)",
   "license": "Apache-2.0",
   "scripts": {
-    "build": "yarn clean && tsc --declaration",
+    "build": "yarn build:esbuild && yarn build:decl",
+    "build:decl": "tsc --declaration --emitDeclarationOnly",
+    "build:esbuild": "esbuild --format=esm --platform=neutral --target=es2022 --tsconfig=tsconfig.json --outdir=. src/**/*.ts",
     "clean": "rimraf --glob '*.js' '*.d.ts' '*.map' doc",
     "doc": "typedoc --excludePrivate --excludeInternal --out doc src/index.ts",
     "doc:ae": "mkdir -p .ae/doc .ae/temp && api-extractor run --local --verbose",
@@ -33,15 +35,16 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.9.11",
-    "@thi.ng/binary": "^3.3.40",
-    "@thi.ng/errors": "^2.4.5",
-    "@thi.ng/transducers-binary": "^2.1.81",
-    "@thi.ng/vectors": "^7.8.8"
+    "@thi.ng/api": "^8.9.12",
+    "@thi.ng/binary": "^3.4.0",
+    "@thi.ng/errors": "^2.4.6",
+    "@thi.ng/transducers-binary": "^2.1.82",
+    "@thi.ng/vectors": "^7.8.9"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.38.3",
-    "@thi.ng/equiv": "^2.1.36",
+    "@thi.ng/equiv": "^2.1.37",
+    "esbuild": "^0.19.8",
     "rimraf": "^5.0.5",
     "tools": "^0.0.1",
     "typedoc": "^0.25.4",
@@ -103,5 +106,5 @@
     "status": "alpha",
     "year": 2019
   },
-  "gitHead": "25f2ac8ff795a432a930119661b364d4d93b59a0\n"
+  "gitHead": "5e7bafedfc3d53bc131469a28de31dd8e5b4a3ff\n"
 }

package/serialize.js

@@ -1,61 +1,52 @@
 import { identity } from "@thi.ng/api/fn";
 import { assert } from "@thi.ng/errors/assert";
 import { utf8Decode, utf8Encode } from "@thi.ng/transducers-binary/utf8";
-/**
- * Identity serializer pair (no op).
- */
-export const ident = {
-    decode: identity,
-    encode: identity,
+const ident = {
+  decode: identity,
+  encode: identity
 };
-/**
- * Serializer pair for scalars.
- */
-export const scalar = {
-    decode: (v) => v[0],
-    encode: (x) => [x],
+const scalar = {
+  decode: (v) => v[0],
+  encode: (x) => [x]
 };
 const toUTF8 = utf8Decode();
-/**
- * Zero-terminated UTF-8 string serializer pair for given max length
- * (incl. final \0 char).
- *
- * {@link SerializerPair.encode} throws error if resulting byte sequence
- * is larger than configured `maxLen`.
- *
- * @param maxLen -
- */
-export const utf8z = (maxLen) => ({
-    decode: (v) => {
-        let acc = "";
-        const xf = toUTF8([null, null, (_, x) => (acc += x)])[2];
-        for (let i = 0, n = v.length; i < n; i++) {
-            const c = v[i];
-            if (c === 0)
-                break;
-            xf(acc, c);
-        }
-        return acc;
-    },
-    encode: (v) => {
-        const bytes = [...utf8Encode(v), 0];
-        assert(bytes.length <= maxLen, `string too large: "${v}"`);
-        return bytes;
-    },
+const utf8z = (maxLen) => ({
+  decode: (v) => {
+    let acc = "";
+    const xf = toUTF8([null, null, (_, x) => acc += x])[2];
+    for (let i = 0, n = v.length; i < n; i++) {
+      const c = v[i];
+      if (c === 0)
+        break;
+      xf(acc, c);
+    }
+    return acc;
+  },
+  encode: (v) => {
+    const bytes = [...utf8Encode(v), 0];
+    assert(bytes.length <= maxLen, `string too large: "${v}"`);
+    return bytes;
+  }
 });
-export const serializer = (specs) => ({
-    decode(tuple) {
-        const res = {};
-        for (let id in tuple) {
-            res[id] = specs[id].decode(tuple[id]);
-        }
-        return res;
-    },
-    encode: (tuple) => {
-        const res = {};
-        for (let id in tuple) {
-            res[id] = specs[id].encode(tuple[id]);
-        }
-        return res;
-    },
+const serializer = (specs) => ({
+  decode(tuple) {
+    const res = {};
+    for (let id in tuple) {
+      res[id] = specs[id].decode(tuple[id]);
+    }
+    return res;
+  },
+  encode: (tuple) => {
+    const res = {};
+    for (let id in tuple) {
+      res[id] = specs[id].encode(tuple[id]);
+    }
+    return res;
+  }
 });
+export {
+  ident,
+  scalar,
+  serializer,
+  utf8z
+};

package/soa.js

@@ -2,159 +2,163 @@ import { SIZEOF, typedArray } from "@thi.ng/api/typedarray";
 import { assert } from "@thi.ng/errors/assert";
 import { ensureIndex } from "@thi.ng/errors/out-of-bounds";
 import { prepareSpec } from "./utils.js";
-export class SOA {
-    length;
-    buffers;
-    specs;
-    constructor(num, specs) {
-        this.length = num;
-        this.buffers = {};
-        this.specs = {};
-        this.addSpecs(specs);
-    }
-    keys() {
-        return Object.keys(this.specs);
-    }
-    *values(from = 0, to = this.length) {
-        ensureIndex(from, 0, this.length);
-        ensureIndex(to, from, this.length + 1);
-        for (; from < to; from++) {
-            yield this.indexUnsafe(from);
-        }
-    }
-    attribValues(id, from = 0, to = this.length) {
-        this.ensureAttrib(id);
-        ensureIndex(from, 0, this.length);
-        ensureIndex(to, from, this.length + 1);
-        let { size, stride, type } = this.specs[id];
-        const buf = this.buffers[id].buffer;
-        stride *= SIZEOF[type];
-        from *= stride;
-        to *= stride;
-        const res = [];
-        for (; from < to; from += stride) {
-            res.push(typedArray(type, buf, from, size));
-        }
-        return res;
-    }
-    attribValue(id, i) {
-        this.ensureAttrib(id);
-        ensureIndex(i, 0, this.length);
-        return this.attribValueUnsafe(id, i);
-    }
-    attribValueUnsafe(id, i) {
-        const spec = this.specs[id];
-        i *= spec.stride;
-        return this.buffers[id].subarray(i, i + spec.size);
-    }
-    setAttribValue(id, i, val) {
-        this.ensureAttrib(id);
-        ensureIndex(i, 0, this.length);
-        const spec = this.specs[id];
-        assert(val.length <= spec.size, `${id} value too large`);
-        this.buffers[id].set(val, i * spec.stride);
-    }
-    setAttribValueUnsafe(id, i, val) {
-        this.buffers[id].set(val, i * this.specs[id].stride);
-        return this;
-    }
-    setAttribValues(id, vals, from = 0) {
-        this.ensureAttrib(id);
-        ensureIndex(from, 0, this.length);
-        const buf = this.buffers[id];
-        const stride = this.specs[id].stride;
-        const end = this.length * stride;
-        let i = from * stride;
-        for (let v of vals) {
-            buf.set(v, i);
-            i += stride;
-            if (i >= end)
-                break;
-        }
-        return this;
-    }
-    index(i, ids) {
-        ensureIndex(i, 0, this.length);
-        return this.indexUnsafe(i, ids);
-    }
-    indexUnsafe(i, ids) {
-        const res = {};
-        if (ids) {
-            for (let i = ids.length; i-- > 0;) {
-                const id = ids[i];
-                res[id] = this.attribValueUnsafe(id, i);
-            }
-        }
-        else {
-            for (let id in this.specs) {
-                res[id] = this.attribValueUnsafe(id, i);
-            }
+class SOA {
+  length;
+  buffers;
+  specs;
+  constructor(num, specs) {
+    this.length = num;
+    this.buffers = {};
+    this.specs = {};
+    this.addSpecs(specs);
+  }
+  keys() {
+    return Object.keys(this.specs);
+  }
+  *values(from = 0, to = this.length) {
+    ensureIndex(from, 0, this.length);
+    ensureIndex(to, from, this.length + 1);
+    for (; from < to; from++) {
+      yield this.indexUnsafe(from);
+    }
+  }
+  attribValues(id, from = 0, to = this.length) {
+    this.ensureAttrib(id);
+    ensureIndex(from, 0, this.length);
+    ensureIndex(to, from, this.length + 1);
+    let { size, stride, type } = this.specs[id];
+    const buf = this.buffers[id].buffer;
+    stride *= SIZEOF[type];
+    from *= stride;
+    to *= stride;
+    const res = [];
+    for (; from < to; from += stride) {
+      res.push(typedArray(type, buf, from, size));
+    }
+    return res;
+  }
+  attribValue(id, i) {
+    this.ensureAttrib(id);
+    ensureIndex(i, 0, this.length);
+    return this.attribValueUnsafe(id, i);
+  }
+  attribValueUnsafe(id, i) {
+    const spec = this.specs[id];
+    i *= spec.stride;
+    return this.buffers[id].subarray(i, i + spec.size);
+  }
+  setAttribValue(id, i, val) {
+    this.ensureAttrib(id);
+    ensureIndex(i, 0, this.length);
+    const spec = this.specs[id];
+    assert(val.length <= spec.size, `${id} value too large`);
+    this.buffers[id].set(val, i * spec.stride);
+  }
+  setAttribValueUnsafe(id, i, val) {
+    this.buffers[id].set(val, i * this.specs[id].stride);
+    return this;
+  }
+  setAttribValues(id, vals, from = 0) {
+    this.ensureAttrib(id);
+    ensureIndex(from, 0, this.length);
+    const buf = this.buffers[id];
+    const stride = this.specs[id].stride;
+    const end = this.length * stride;
+    let i = from * stride;
+    for (let v of vals) {
+      buf.set(v, i);
+      i += stride;
+      if (i >= end)
+        break;
+    }
+    return this;
+  }
+  index(i, ids) {
+    ensureIndex(i, 0, this.length);
+    return this.indexUnsafe(i, ids);
+  }
+  indexUnsafe(i, ids) {
+    const res = {};
+    if (ids) {
+      for (let i2 = ids.length; i2-- > 0; ) {
+        const id = ids[i2];
+        res[id] = this.attribValueUnsafe(id, i2);
+      }
+    } else {
+      for (let id in this.specs) {
+        res[id] = this.attribValueUnsafe(id, i);
+      }
+    }
+    return res;
+  }
+  setIndex(i, vals) {
+    ensureIndex(i, 0, this.length);
+    for (let id in vals) {
+      this.setAttribValue(id, i, vals[id]);
+    }
+    return this;
+  }
+  setIndexUnsafe(i, vals) {
+    for (let id in vals) {
+      this.setAttribValueUnsafe(id, i, vals[id]);
+    }
+    return this;
+  }
+  setValues(vals, from = 0) {
+    for (let id in vals) {
+      this.setAttribValues(id, vals[id], from);
+    }
+    return this;
+  }
+  copyTo(dest, ids, destFrom = 0, srcFrom = 0, srcTo = this.length) {
+    ensureIndex(srcFrom, 0, this.length);
+    ensureIndex(srcTo, srcFrom, this.length + 1);
+    const num = srcTo - srcFrom;
+    ensureIndex(destFrom, 0, dest.length);
+    ensureIndex(destFrom + num, destFrom, dest.length + 1);
+    ids = ids || Object.keys(this.specs);
+    for (let k = ids.length; k-- > 0; ) {
+      const id = ids[k];
+      for (let i = srcFrom, j = destFrom; i < srcTo; i++, j++) {
+        dest.setAttribValueUnsafe(id, j, this.attribValueUnsafe(id, i));
+      }
+    }
+    return dest;
+  }
+  addSpecs(specs) {
+    const num = this.length;
+    for (let id in specs) {
+      assert(!this.specs[id], `attrib ${id} already exists`);
+      const spec = prepareSpec(specs[id]);
+      this.validateSpec(id, spec);
+      const { stride, default: defVal } = spec;
+      const buffer = spec.buf ? typedArray(spec.type, spec.buf, spec.byteOffset || 0) : typedArray(spec.type, num * stride);
+      if (defVal) {
+        for (let i = 0; i < num; i++) {
+          buffer.set(defVal, i * stride);
         }
-        return res;
-    }
-    setIndex(i, vals) {
-        ensureIndex(i, 0, this.length);
-        for (let id in vals) {
-            this.setAttribValue(id, i, vals[id]);
-        }
-        return this;
-    }
-    setIndexUnsafe(i, vals) {
-        for (let id in vals) {
-            this.setAttribValueUnsafe(id, i, vals[id]);
-        }
-        return this;
-    }
-    setValues(vals, from = 0) {
-        for (let id in vals) {
-            this.setAttribValues(id, vals[id], from);
-        }
-        return this;
-    }
-    copyTo(dest, ids, destFrom = 0, srcFrom = 0, srcTo = this.length) {
-        ensureIndex(srcFrom, 0, this.length);
-        ensureIndex(srcTo, srcFrom, this.length + 1);
-        const num = srcTo - srcFrom;
-        ensureIndex(destFrom, 0, dest.length);
-        ensureIndex(destFrom + num, destFrom, dest.length + 1);
-        ids = ids || Object.keys(this.specs);
-        for (let k = ids.length; k-- > 0;) {
-            const id = ids[k];
-            for (let i = srcFrom, j = destFrom; i < srcTo; i++, j++) {
-                dest.setAttribValueUnsafe(id, j, this.attribValueUnsafe(id, i));
-            }
-        }
-        return dest;
-    }
-    addSpecs(specs) {
-        const num = this.length;
-        for (let id in specs) {
-            assert(!this.specs[id], `attrib ${id} already exists`);
-            const spec = prepareSpec(specs[id]);
-            this.validateSpec(id, spec);
-            const { stride, default: defVal } = spec;
-            const buffer = spec.buf
-                ? typedArray(spec.type, spec.buf, spec.byteOffset || 0)
-                : typedArray(spec.type, num * stride);
-            if (defVal) {
-                for (let i = 0; i < num; i++) {
-                    buffer.set(defVal, i * stride);
-                }
-            }
-            this.specs[id] = spec;
-            this.buffers[id] = buffer;
-        }
-    }
-    validateSpec(id, spec) {
-        assert(spec.stride >= spec.size, `${id} illegal stride`);
-        assert(!spec.buf ||
-            spec.buf.byteLength >=
-                ((this.length - 1) * spec.stride + spec.size) *
-                    SIZEOF[spec.type], `${id} buffer too small`);
-        assert(spec.default === undefined || spec.default.length === spec.size, `illegal default value for ${id}, expected size: ${spec.size}`);
-    }
-    ensureAttrib(id) {
-        assert(!!this.specs[id], `invalid attrib ${id}`);
-    }
+      }
+      this.specs[id] = spec;
+      this.buffers[id] = buffer;
+    }
+  }
+  validateSpec(id, spec) {
+    assert(spec.stride >= spec.size, `${id} illegal stride`);
+    assert(
+      !spec.buf || spec.buf.byteLength >= ((this.length - 1) * spec.stride + spec.size) * SIZEOF[spec.type],
+      `${id} buffer too small`
+    );
+    assert(
+      spec.default === void 0 || spec.default.length === spec.size,
+      `illegal default value for ${id}, expected size: ${spec.size}`
+    );
+  }
+  ensureAttrib(id) {
+    assert(!!this.specs[id], `invalid attrib ${id}`);
+  }
 }
-export const soa = (num, specs) => new SOA(num, specs);
+const soa = (num, specs) => new SOA(num, specs);
+export {
+  SOA,
+  soa
+};

package/utils.js

@@ -1,5 +1,8 @@
-export const prepareSpec = (spec) => {
-    spec = { type: "f32", size: 1, ...spec };
-    !spec.stride && (spec.stride = spec.size);
-    return spec;
+const prepareSpec = (spec) => {
+  spec = { type: "f32", size: 1, ...spec };
+  !spec.stride && (spec.stride = spec.size);
+  return spec;
+};
+export {
+  prepareSpec
 };