@rotu/structview 0.6.1 → 0.7.1

package/esm/mod.js

@@ -0,0 +1,378 @@
+/**
+ * Strongly typed classes for accessing binary data in a structured way
+ * @module
+ */
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _a;
+const dataViewSymbol = Symbol.for("Struct.dataview");
+/**
+ * Get the underlying DataView of a struct
+ * @param struct
+ * @returns
+ */
+export function structDataView(struct) {
+    const result = struct[dataViewSymbol];
+    if (!(result instanceof DataView)) {
+        throw new TypeError("not a struct");
+    }
+    return struct[dataViewSymbol];
+}
+/**
+ * Helper method to create a view of a contiguous subregion of a Struct's memory
+ * @param struct
+ * @param start byte offset to start
+ * @param end byte offset of the end of the subrange
+ * @returns region of the given struct.
+ */
+function structBytes(struct, start, end) {
+    const dv = structDataView(struct);
+    start ??= 0;
+    end ??= dv.byteLength;
+    console.assert(start <= end);
+    console.assert(end <= dv.byteLength);
+    return new Uint8Array(dv.buffer, dv.byteOffset + start, end - start);
+}
+/**
+ * Define a descriptor based on a dataview of the struct
+ * @param fieldGetter function which, given a dataview, returns
+ * @returns
+ */
+export function fromDataView(fieldGetter) {
+    return {
+        enumerable: true,
+        get() {
+            const dv = this[dataViewSymbol];
+            return fieldGetter(dv);
+        },
+    };
+}
+/**
+ * Field for a 8-bit unsigned integer
+ */
+export function u8(fieldOffset) {
+    return {
+        enumerable: true,
+        get() {
+            return structDataView(this).getUint8(fieldOffset);
+        },
+        set(value) {
+            structDataView(this).setUint8(fieldOffset, value);
+        },
+    };
+}
+/**
+ * Field for a little-endian 16-bit unsigned integer
+ */
+export function u16(fieldOffset) {
+    return {
+        enumerable: true,
+        get() {
+            return structDataView(this).getUint16(fieldOffset, true);
+        },
+        set(value) {
+            structDataView(this).setUint16(fieldOffset, value, true);
+        },
+    };
+}
+/**
+ * Field for a little-endian 32-bit unsigned integer
+ */
+export function u32(fieldOffset) {
+    return {
+        enumerable: true,
+        get() {
+            return structDataView(this).getUint32(fieldOffset, true);
+        },
+        set(value) {
+            structDataView(this).setUint32(fieldOffset, value, true);
+        },
+    };
+}
+/**
+ * Field for a little-endian 64-bit unsigned integer
+ */
+export function u64(fieldOffset) {
+    return {
+        enumerable: true,
+        get() {
+            return structDataView(this).getBigUint64(fieldOffset, true);
+        },
+        set(value) {
+            structDataView(this).setBigUint64(fieldOffset, value, true);
+        },
+    };
+}
+/**
+ * Field for a little-endian 8-bit signed integer
+ */
+export function i8(fieldOffset) {
+    return {
+        enumerable: true,
+        get() {
+            return structDataView(this).getInt8(fieldOffset);
+        },
+        set(value) {
+            structDataView(this).setInt8(fieldOffset, value);
+        },
+    };
+}
+/**
+ * Field for a little-endian 16-bit signed integer
+ */
+export function i16(fieldOffset) {
+    return {
+        enumerable: true,
+        get() {
+            return structDataView(this).getInt16(fieldOffset, true);
+        },
+        set(value) {
+            structDataView(this).setInt16(fieldOffset, value, true);
+        },
+    };
+}
+/**
+ * Field for a little-endian 32-bit signed integer
+ */
+export function i32(fieldOffset) {
+    return {
+        enumerable: true,
+        get() {
+            return structDataView(this).getInt32(fieldOffset, true);
+        },
+        set(value) {
+            structDataView(this).setInt32(fieldOffset, value, true);
+        },
+    };
+}
+/**
+ * Field for a little-endian 64-bit signed integer
+ */
+export function i64(fieldOffset) {
+    return {
+        enumerable: true,
+        get() {
+            return structDataView(this).getBigInt64(fieldOffset, true);
+        },
+        set(value) {
+            structDataView(this).setBigInt64(fieldOffset, value, true);
+        },
+    };
+}
+/**
+ * Field for a little-endian 16-bit binary float (float16_t)
+ */
+export function f16(fieldOffset) {
+    if (typeof DataView.prototype.getFloat16 !== "function" ||
+        typeof DataView.prototype.setFloat16 !== "function") {
+        throw new TypeError("float16 is not supported in this environment");
+    }
+    return {
+        enumerable: true,
+        get() {
+            return structDataView(this).getFloat16(fieldOffset, true);
+        },
+        set(value) {
+            structDataView(this).setFloat16(fieldOffset, value, true);
+        },
+    };
+}
+/**
+ * Field for a little-endian 32-bit binary float (float32_t)
+ */
+export function f32(fieldOffset) {
+    return {
+        enumerable: true,
+        get() {
+            return structDataView(this).getFloat32(fieldOffset, true);
+        },
+        set(value) {
+            structDataView(this).setFloat32(fieldOffset, value, true);
+        },
+    };
+}
+/**
+ * Field for a little-endian 64-bit binary float (float64_t)
+ */
+export function f64(fieldOffset) {
+    return {
+        enumerable: true,
+        get() {
+            return structDataView(this).getFloat64(fieldOffset, true);
+        },
+        set(value) {
+            structDataView(this).setFloat64(fieldOffset, value, true);
+        },
+    };
+}
+/**
+ * Field for a UTF-8 fixed-length string
+ */
+export function string(fieldOffset, byteLength) {
+    const TEXT_DECODER = new TextDecoder();
+    const TEXT_ENCODER = new TextEncoder();
+    return {
+        enumerable: true,
+        get() {
+            const str = TEXT_DECODER.decode(structBytes(this, fieldOffset, fieldOffset + byteLength));
+            // trim all trailing null characters
+            return str.replace(/\0+$/, "");
+        },
+        set(value) {
+            const bytes = structBytes(this, fieldOffset, fieldOffset + byteLength);
+            bytes.fill(0);
+            TEXT_ENCODER.encodeInto(value, bytes);
+        },
+    };
+}
+/**
+ * Field for a boolean stored in a byte (0 = false, nonzero = true)
+ * True will be stored as 1
+ */
+export function bool(fieldOffset) {
+    return {
+        enumerable: true,
+        get() {
+            return Boolean(structDataView(this).getUint8(fieldOffset));
+        },
+        set(value) {
+            structDataView(this).setUint8(fieldOffset, value ? 1 : 0);
+        },
+    };
+}
+/**
+ * Field for an embedded struct
+ * @param ctor constructor for the inner struct
+ * @param byteOffset where the inner struct starts relative to the outer struct
+ * @param bytelength the length in bytes of the inner struct
+ * @returns property descriptor for a struct
+ */
+export function substruct(ctor, byteOffset, bytelength) {
+    return fromDataView(function (dv) {
+        const offset2 = dv.byteOffset + (byteOffset ?? 0);
+        const bytelength2 = bytelength ?? (dv.byteLength - (byteOffset ?? 0));
+        return Reflect.construct(ctor, [{
+                buffer: dv.buffer,
+                byteOffset: offset2,
+                byteLength: bytelength2,
+            }]);
+    });
+}
+/**
+ * Base class for a structured binary object
+ * Note there are no predeclared string-keyed properties - all property names are reserved for user-defined fields
+ */
+export class Struct {
+    get [(_a = dataViewSymbol, Symbol.toStringTag)]() {
+        return Struct.name;
+    }
+    static toDataView(o) {
+        return o[dataViewSymbol];
+    }
+    /**
+     * Create a new Struct
+     * @param arg options for creating the struct.
+     *  If options has a `.buffer` property, we will use that as the backing memory (e.g. any TypedArray or DataView).
+     *  If options has no `.buffer` property but has a `.byteLength`, we will allocate a new buffer for the object.
+     */
+    constructor(arg) {
+        Object.defineProperty(this, _a, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (typeof arg !== "object" || arg === null) {
+            throw new TypeError("Expected argument to be an object");
+        }
+        Object.preventExtensions(this);
+        if (arg.buffer) {
+            this[dataViewSymbol] = new DataView(arg.buffer, arg.byteOffset, arg.byteLength);
+        }
+        else if (typeof arg.byteLength === "number") {
+            this[dataViewSymbol] = new DataView(new ArrayBuffer(arg.byteLength + (arg.byteOffset ?? 0)), arg.byteOffset, arg.byteLength);
+        }
+        else {
+            throw new TypeError("Must provide either {buffer} or {byteLength}");
+        }
+    }
+}
+/**
+ * Subclass a type by adding the given property descriptors
+ * @param ctor constructor for the base class
+ * @param propertyDescriptors properties to add to subclass instances
+ * @returns A new class, inheriting from the base class, with the new property descriptors added
+ */
+function subclassWithProperties(ctor, propertyDescriptors) {
+    var _b;
+    return (_b = class extends ctor {
+        },
+        (() => {
+            Object.defineProperties(_b.prototype, propertyDescriptors);
+        })(),
+        _b);
+}
+/**
+ * Subclass struct by adding the given property descriptors
+ * @param propertyDescriptors properties to add to subclass instances
+ * @returns A new class, inheriting from `Struct`, with the new property descriptors added
+ */
+export function defineStruct(propertyDescriptors) {
+    return subclassWithProperties(Struct, propertyDescriptors);
+}
+/**
+ * Create a new struct subclass for an array of structs
+ * @param arrayOptions
+ * @returns A new class, inheriting from `Struct` whose elements are statically typed structs
+ */
+export function defineArray(arrayOptions) {
+    var _StructArray_struct, _StructArray_length, _StructArray_byteStride;
+    const { struct, byteStride, length } = arrayOptions;
+    class StructArray extends Struct {
+        constructor() {
+            super(...arguments);
+            _StructArray_struct.set(this, struct);
+            _StructArray_length.set(this, length);
+            _StructArray_byteStride.set(this, byteStride
+            /**
+             * Number of items in the array
+             */
+            );
+        }
+        /**
+         * Number of items in the array
+         */
+        get length() {
+            if (typeof __classPrivateFieldGet(this, _StructArray_length, "f") === "number") {
+                return __classPrivateFieldGet(this, _StructArray_length, "f");
+            }
+            return structDataView(this).byteLength / __classPrivateFieldGet(this, _StructArray_byteStride, "f");
+        }
+        /**
+         * A view of the item at the given index
+         * @param index
+         * @returns a new struct instance viewing the item at the given index
+         */
+        item(index) {
+            const ctor = __classPrivateFieldGet(this, _StructArray_struct, "f");
+            return new ctor(structBytes(this, __classPrivateFieldGet(this, _StructArray_byteStride, "f") * index, __classPrivateFieldGet(this, _StructArray_byteStride, "f") * (index + 1)));
+        }
+        /** @deprecated use item() instead */
+        element(index) {
+            return this.item(index);
+        }
+        /**
+         * Iterate over the items in the array
+         */
+        *[(_StructArray_struct = new WeakMap(), _StructArray_length = new WeakMap(), _StructArray_byteStride = new WeakMap(), Symbol.iterator)]() {
+            for (let i = 0; i < this.length; ++i) {
+                yield this.item(i);
+            }
+        }
+    }
+    // deno-lint-ignore no-explicit-any
+    return StructArray;
+}

package/esm/mod_test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod_test.d.ts","sourceRoot":"","sources":["../src/mod_test.ts"],"names":[],"mappings":""}

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/package.json

@@ -1,18 +1,25 @@
 {
   "name": "@rotu/structview",
-  "version": "0.6.1",
-  "homepage": "https://jsr.io/@rotu/structview",
-  "type": "module",
-  "dependencies": {},
+  "version": "0.7.1+dnt",
+  "description": "Read and write structured binary data with typesafe views",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rotu/structview"
+  },
+  "license": "MIT",
+  "module": "./esm/mod.js",
   "exports": {
     ".": {
-      "types": "./_dist/mod.d.ts",
-      "default": "./mod.js"
-    },
-    "./bigendian": {
-      "types": "./_dist/bigendian.d.ts",
-      "default": "./bigendian.js"
+      "import": "./esm/mod.js"
     }
   },
-  "_jsr_revision": 11
+  "scripts": {
+    "test": "node test_runner.js"
+  },
+  "devDependencies": {
+    "@types/node": "^20.9.0",
+    "picocolors": "^1.0.0",
+    "@deno/shim-deno": "~0.18.0"
+  },
+  "_generatedBy": "dnt@dev"
 }

package/.github/workflows/deno.yml

@@ -1,32 +0,0 @@
-name: Deno
-
-on:
-  push:
-    branches: ["main"]
-  pull_request:
-    branches: ["main"]
-
-permissions:
-  contents: read
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Setup repo
-        uses: actions/checkout@v4
-
-      - name: Setup Deno
-        uses: denoland/setup-deno@v2
-        with:
-          deno-version: vx.x.x
-
-      - name: Verify formatting
-        run: deno fmt --check
-
-      - name: Run linter
-        run: deno lint
-
-      - name: Run tests
-        run: deno test -A

package/.github/workflows/publish.yml

@@ -1,20 +0,0 @@
-name: Publish
-on:
-  push:
-    branches:
-      - main
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      id-token: write
-    steps:
-      - uses: actions/checkout@v4
-      - name: Setup Deno
-        uses: denoland/setup-deno@v2
-        with:
-          deno-version: vx.x.x
-      - name: Publish package
-        run: deno publish

package/.vscode/settings.json

@@ -1,4 +0,0 @@
-{
-  "deno.enable": true,
-  "editor.formatOnSaveMode": "file"
-}

package/_dist/bigendian.d.ts

@@ -1,32 +0,0 @@
-/**
- * Property descriptor factories for big-endian numbers
- * @module
- */ import { type StructPropertyDescriptor } from "./mod.js";
-/**
- * Field for a big-endian 16-bit unsigned integer
- */ export declare function u16be(fieldOffset: number): StructPropertyDescriptor<number>;
-/**
- * Field for a big-endian 32-bit unsigned integer
- */ export declare function u32be(fieldOffset: number): StructPropertyDescriptor<number>;
-/**
- * Field for a big-endian 64-bit unsigned integer
- */ export declare function u64be(fieldOffset: number): StructPropertyDescriptor<bigint>;
-/**
- * Field for a big-endian 16-bit signed integer
- */ export declare function i16be(fieldOffset: number): StructPropertyDescriptor<number>;
-/**
- * Field for a big-endian 32-bit signed integer
- */ export declare function i32be(fieldOffset: number): StructPropertyDescriptor<number>;
-/**
- * Field for a big-endian 64-bit signed integer
- */ export declare function i64be(fieldOffset: number): StructPropertyDescriptor<bigint>;
-/**
- * Field for a big-endian 16-bit binary float (float16_t)
- */ export declare function f16be(fieldOffset: number): StructPropertyDescriptor<number>;
-/**
- * Field for a big-endian 32-bit binary float (float32_t)
- */ export declare function f32be(fieldOffset: number): StructPropertyDescriptor<number>;
-/**
- * Field for a big-endian 64-bit binary float (float64_t)
- */ export declare function f64be(fieldOffset: number): StructPropertyDescriptor<number>;
-//# sourceMappingURL=bigendian.d.ts.map

package/_dist/bigendian.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bigendian.d.ts","sources":["../bigendian.ts"],"names":[],"mappings":"AAAA;;;CAGC,GAED,SAAyB,KAAK,wBAAwB,mBAAkB;AAExE;;CAEC,GACD,OAAO,iBAAS,MAAM,aAAa,MAAM,GAAG,yBAAyB,MAAM;AAW3E;;CAEC,GACD,OAAO,iBAAS,MAAM,aAAa,MAAM,GAAG,yBAAyB,MAAM;AAW3E;;CAEC,GACD,OAAO,iBAAS,MAAM,aAAa,MAAM,GAAG,yBAAyB,MAAM;AAW3E;;CAEC,GACD,OAAO,iBAAS,MAAM,aAAa,MAAM,GAAG,yBAAyB,MAAM;AAW3E;;CAEC,GACD,OAAO,iBAAS,MAAM,aAAa,MAAM,GAAG,yBAAyB,MAAM;AAW3E;;CAEC,GACD,OAAO,iBAAS,MAAM,aAAa,MAAM,GAAG,yBAAyB,MAAM;AAY3E;;CAEC,GACD,OAAO,iBAAS,MAAM,aAAa,MAAM,GAAG,yBAAyB,MAAM;AAY3E;;CAEC,GACD,OAAO,iBAAS,MAAM,aAAa,MAAM,GAAG,yBAAyB,MAAM;AAY3E;;CAEC,GACD,OAAO,iBAAS,MAAM,aAAa,MAAM,GAAG,yBAAyB,MAAM"}

package/_dist/mod.d.ts

@@ -1,135 +0,0 @@
-/**
- * Strongly typed classes for accessing binary data in a structured way
- * @module
- */ declare const dataViewSymbol: unique symbol;
-type AnyStruct = {
-  get [dataViewSymbol](): DataView;
-};
-type Constructor<T> = {
-  new(...args: any[]): T;
-};
-type SubclassWithProperties<Ctor extends Constructor<object>, Mixin> = {
-  [K in keyof Ctor]: Ctor[K];
-} & {
-  new(...args: ConstructorParameters<Ctor>): InstanceType<Ctor> & {
-    -readonly [K in keyof Mixin]: Mixin[K];
-  };
-};
-type TPropertyDescriptor<T> = {
-  enumerable?: boolean;
-  configurable?: boolean;
-  get?(): T;
-  set?(t: T): undefined;
-  value?: T;
-  writable?: boolean;
-};
-type MixinFromProps<Props extends object> = {
-  [K in keyof Props]: Props[K] extends TPropertyDescriptor<infer V> ? V : unknown;
-};
-/**
- * Get the underlying DataView of a struct
- * @param struct
- * @returns
- */ export declare function structDataView(struct: AnyStruct): DataView;
-/**
- * Type of a property descriptor for a struct
- */ export type StructPropertyDescriptor<T> = ThisType<AnyStruct> & TPropertyDescriptor<T>;
-/**
- * Define a descriptor based on a dataview of the struct
- * @param fieldGetter function which, given a dataview, returns
- * @returns
- */ export declare function fromDataView<Fn extends (dv: DataView) => unknown>(fieldGetter: Fn): StructPropertyDescriptor<ReturnType<Fn>>;
-/**
- * Field for a 8-bit unsigned integer
- */ export declare function u8(fieldOffset: number): StructPropertyDescriptor<number>;
-/**
- * Field for a little-endian 16-bit unsigned integer
- */ export declare function u16(fieldOffset: number): StructPropertyDescriptor<number>;
-/**
- * Field for a little-endian 32-bit unsigned integer
- */ export declare function u32(fieldOffset: number): StructPropertyDescriptor<number>;
-/**
- * Field for a little-endian 64-bit unsigned integer
- */ export declare function u64(fieldOffset: number): StructPropertyDescriptor<bigint>;
-/**
- * Field for a little-endian 8-bit signed integer
- */ export declare function i8(fieldOffset: number): StructPropertyDescriptor<number>;
-/**
- * Field for a little-endian 16-bit signed integer
- */ export declare function i16(fieldOffset: number): StructPropertyDescriptor<number>;
-/**
- * Field for a little-endian 32-bit signed integer
- */ export declare function i32(fieldOffset: number): StructPropertyDescriptor<number>;
-/**
- * Field for a little-endian 64-bit signed integer
- */ export declare function i64(fieldOffset: number): StructPropertyDescriptor<bigint>;
-/**
- * Field for a little-endian 16-bit binary float (float16_t)
- */ export declare function f16(fieldOffset: number): StructPropertyDescriptor<number>;
-/**
- * Field for a little-endian 32-bit binary float (float32_t)
- */ export declare function f32(fieldOffset: number): StructPropertyDescriptor<number>;
-/**
- * Field for a little-endian 64-bit binary float (float64_t)
- */ export declare function f64(fieldOffset: number): StructPropertyDescriptor<number>;
-/**
- * Field for a UTF-8 fixed-length string
- */ export declare function string(fieldOffset: number, byteLength: number): StructPropertyDescriptor<string>;
-/**
- * Field for a boolean stored in a byte (0 = false, nonzero = true)
- * True will be stored as 1
- */ export declare function bool(fieldOffset: number): StructPropertyDescriptor<boolean>;
-type StructConstructor<T extends object> = {
-  new(arg: {
-    buffer: ArrayBufferLike;
-    byteOffset?: number;
-    byteLength?: number;
-  }): T;
-};
-/**
- * Field for an embedded struct
- * @param ctor constructor for the inner struct
- * @param byteOffset where the inner struct starts relative to the outer struct
- * @param bytelength the length in bytes of the inner struct
- * @returns property descriptor for a struct
- */ export declare function substruct<T extends object>(ctor: StructConstructor<T>, byteOffset?: number, bytelength?: number): StructPropertyDescriptor<T>;
-/**
- * Base class for a structured binary object
- * Note there are no predeclared string-keyed properties - all property names are reserved for user-defined fields
- */ export declare class Struct {
-  [dataViewSymbol]: DataView;
-  static toDataView(o: Struct): DataView;
-  /**
-   * Create a new Struct
-   * @param arg options for creating the struct.
-   *  If options has a `.buffer` property, we will use that as the backing memory (e.g. any TypedArray or DataView).
-   *  If options has no `.buffer` property but has a `.byteLength`, we will allocate a new buffer for the object.
-   */ constructor(arg: {
-    buffer: ArrayBufferLike;
-    byteOffset?: number;
-    byteLength?: number;
-  } | {
-    buffer?: undefined;
-    byteOffset?: number;
-    byteLength: number;
-  });
-}
-/**
- * Subclass struct by adding the given property descriptors
- * @param propertyDescriptors properties to add to subclass instances
- * @returns A new class, inheriting from `Struct`, with the new property descriptors added
- */ export declare function defineStruct<const Props extends PropertyDescriptorMap>(propertyDescriptors: Props): SubclassWithProperties<typeof Struct, MixinFromProps<Props>>;
-/**
- * Create a new struct subclass for an array of structs
- * @param arrayOptions
- * @returns A new class, inheriting from `Struct` whose elements are statically typed structs
- */ export declare function defineArray<Ctor extends StructConstructor<object>>(arrayOptions: {
-  /** Constructor for an object view of each element*/ struct: Ctor;
-  /** Number of bytes between the start of consecutive elements */ byteStride: number;
-  /** Total number of elements in the array (not bytes). If omitted, the array length will depend on the size of its underlying buffer */ length?: number;
-}): StructConstructor<{
-  get length(): number;
-  element(i: number): InstanceType<Ctor>;
-  [i: number]: InstanceType<Ctor>;
-} & Iterable<InstanceType<Ctor>>>;
-//# sourceMappingURL=mod.d.ts.map

package/_dist/mod.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mod.d.ts","sources":["../mod.ts"],"names":[],"mappings":"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"}