@rotu/structview 0.6.1

package/.github/workflows/deno.yml

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,20 @@
+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

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

package/README.md

@@ -0,0 +1,86 @@
+# structview
+
+The point of this package is provide the ability to manipulate binary structured
+data in a typesafe, declarative, object-oriented way.
+
+1. Read and write binary-structured data with the same declaration
+2. Single source of truth - changes to logical view are immediately reflected in
+   the underlying binary structure and vice versa.
+3. Written in TypeScript, written FOR JavaScript. Declaring a struct allows full
+   type inference; no separate type declaration required!
+4. Clean object format. No risk of your struct field names colliding with
+   implementation details. Type inference won't show excessive properties.
+
+[![JSR](https://jsr.io/badges/@rotu/structview)](https://jsr.io/@rotu/structview)
+
+# example
+
+This example is pure JavaScript, but note that all property access is fully
+typechecked.
+
+```js
+import {
+  defineArray,
+  defineStruct,
+  f32,
+  string,
+  substruct,
+  u8,
+} from "@rotu/structview"
+
+// defineStruct returns a new class, which can be extended with custom getters, setters, and methods
+// it's recommended to always extend even if you have no additional members, so you can benefit from declaration hoisting.
+class Version extends defineStruct({
+  major: u8(0),
+  minor: u8(1),
+  patch: u8(2),
+}) {
+  asString() {
+    // Struct fields are exposed as properties. They can be destructured like any other js object
+    const { major, minor, patch } = this
+    return `${major}.${minor}.${patch}`
+  }
+}
+
+class ProductInfo extends defineStruct({
+  version: substruct(Version, 0, 3),
+  product: string(4, 12),
+}) {}
+
+const bytes = new Uint8Array(16)
+const info = new ProductInfo(bytes)
+
+info.product = "Widget"
+// Basic object assignment and destructuring just works
+Object.assign(info.version, { major: 1, minor: 42, patch: 1 })
+
+// Object writes are saved in the underlying buffer
+console.log(
+  "encoded hex:",
+  bytes.toHex(),
+)
+
+console.log(`${info.product} v${info.version.asString()}`)
+
+// You can compose structs into arrays
+class Dish extends defineStruct({
+  price: f32(0),
+  name: string(4, 12),
+}) {}
+
+class Menu extends defineArray({
+  struct: Dish,
+  byteStride: 16,
+  length: 3,
+}) {}
+
+const myMenu = new Menu({ byteLength: 48 })
+Object.assign(myMenu.element(0), { name: "garden salad", price: 4 })
+Object.assign(myMenu.element(1), { name: "soup du jour", price: 2.5 })
+Object.assign(myMenu.element(2), { name: "fries", price: 2.25 })
+
+// and arrays are iterable
+for (const dish of myMenu) {
+  console.log(`${dish.name} costs \$${dish.price}`)
+}
+```

package/_dist/bigendian.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,135 @@
+/**
+ * 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

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

package/bigendian.js

@@ -0,0 +1,122 @@
+/**
+ * Property descriptor factories for big-endian numbers
+ * @module
+ */ import { structDataView } from "./mod.js";
+/**
+ * Field for a big-endian 16-bit unsigned integer
+ */ export function u16be(fieldOffset) {
+  return {
+    enumerable: true,
+    get () {
+      return structDataView(this).getUint16(fieldOffset, false);
+    },
+    set (value) {
+      structDataView(this).setUint16(fieldOffset, value, false);
+    }
+  };
+}
+/**
+ * Field for a big-endian 32-bit unsigned integer
+ */ export function u32be(fieldOffset) {
+  return {
+    enumerable: true,
+    get () {
+      return structDataView(this).getUint32(fieldOffset, false);
+    },
+    set (value) {
+      structDataView(this).setUint32(fieldOffset, value, false);
+    }
+  };
+}
+/**
+ * Field for a big-endian 64-bit unsigned integer
+ */ export function u64be(fieldOffset) {
+  return {
+    enumerable: true,
+    get () {
+      return structDataView(this).getBigUint64(fieldOffset, false);
+    },
+    set (value) {
+      structDataView(this).setBigUint64(fieldOffset, value, false);
+    }
+  };
+}
+/**
+ * Field for a big-endian 16-bit signed integer
+ */ export function i16be(fieldOffset) {
+  return {
+    enumerable: true,
+    get () {
+      return structDataView(this).getInt16(fieldOffset, false);
+    },
+    set (value) {
+      structDataView(this).setInt16(fieldOffset, value, false);
+    }
+  };
+}
+/**
+ * Field for a big-endian 32-bit signed integer
+ */ export function i32be(fieldOffset) {
+  return {
+    enumerable: true,
+    get () {
+      return structDataView(this).getInt32(fieldOffset, false);
+    },
+    set (value) {
+      structDataView(this).setInt32(fieldOffset, value, false);
+    }
+  };
+}
+/**
+ * Field for a big-endian 64-bit signed integer
+ */ export function i64be(fieldOffset) {
+  return {
+    enumerable: true,
+    get () {
+      return structDataView(this).getBigInt64(fieldOffset, false);
+    },
+    set (value) {
+      structDataView(this).setBigInt64(fieldOffset, value, false);
+    }
+  };
+}
+/**
+ * Field for a big-endian 16-bit binary float (float16_t)
+ */ export function f16be(fieldOffset) {
+  return {
+    enumerable: true,
+    get () {
+      return structDataView(this).getFloat16(fieldOffset, false);
+    },
+    set (value) {
+      structDataView(this).setFloat16(fieldOffset, value, false);
+    }
+  };
+}
+/**
+ * Field for a big-endian 32-bit binary float (float32_t)
+ */ export function f32be(fieldOffset) {
+  return {
+    enumerable: true,
+    get () {
+      return structDataView(this).getFloat32(fieldOffset, false);
+    },
+    set (value) {
+      structDataView(this).setFloat32(fieldOffset, value, false);
+    }
+  };
+}
+/**
+ * Field for a big-endian 64-bit binary float (float64_t)
+ */ export function f64be(fieldOffset) {
+  return {
+    enumerable: true,
+    get () {
+      return structDataView(this).getFloat64(fieldOffset, false);
+    },
+    set (value) {
+      structDataView(this).setFloat64(fieldOffset, value, false);
+    }
+  };
+}
+//# sourceMappingURL=bigendian.js.map

package/bigendian.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bigendian.js","sources":["./bigendian.ts"],"names":[],"mappings":"AAAA;;;CAGC,GAED,SAAS,cAAc,mBAAiD;AAExE;;CAEC,GACD,OAAO,SAAS,MAAM,WAAmB;EACvC,OAAO;IACL,YAAY;IACZ;MACE,OAAO,eAAe,IAAI,EAAE,SAAS,CAAC,aAAa;IACrD;IACA,KAAI,KAAK;MACP,eAAe,IAAI,EAAE,SAAS,CAAC,aAAa,OAAO;IACrD;EACF;AACF;AACA;;CAEC,GACD,OAAO,SAAS,MAAM,WAAmB;EACvC,OAAO;IACL,YAAY;IACZ;MACE,OAAO,eAAe,IAAI,EAAE,SAAS,CAAC,aAAa;IACrD;IACA,KAAI,KAAK;MACP,eAAe,IAAI,EAAE,SAAS,CAAC,aAAa,OAAO;IACrD;EACF;AACF;AACA;;CAEC,GACD,OAAO,SAAS,MAAM,WAAmB;EACvC,OAAO;IACL,YAAY;IACZ;MACE,OAAO,eAAe,IAAI,EAAE,YAAY,CAAC,aAAa;IACxD;IACA,KAAI,KAAK;MACP,eAAe,IAAI,EAAE,YAAY,CAAC,aAAa,OAAO;IACxD;EACF;AACF;AACA;;CAEC,GACD,OAAO,SAAS,MAAM,WAAmB;EACvC,OAAO;IACL,YAAY;IACZ;MACE,OAAO,eAAe,IAAI,EAAE,QAAQ,CAAC,aAAa;IACpD;IACA,KAAI,KAAK;MACP,eAAe,IAAI,EAAE,QAAQ,CAAC,aAAa,OAAO;IACpD;EACF;AACF;AACA;;CAEC,GACD,OAAO,SAAS,MAAM,WAAmB;EACvC,OAAO;IACL,YAAY;IACZ;MACE,OAAO,eAAe,IAAI,EAAE,QAAQ,CAAC,aAAa;IACpD;IACA,KAAI,KAAK;MACP,eAAe,IAAI,EAAE,QAAQ,CAAC,aAAa,OAAO;IACpD;EACF;AACF;AACA;;CAEC,GACD,OAAO,SAAS,MAAM,WAAmB;EACvC,OAAO;IACL,YAAY;IACZ;MACE,OAAO,eAAe,IAAI,EAAE,WAAW,CAAC,aAAa;IACvD;IACA,KAAI,KAAK;MACP,eAAe,IAAI,EAAE,WAAW,CAAC,aAAa,OAAO;IACvD;EACF;AACF;AAEA;;CAEC,GACD,OAAO,SAAS,MAAM,WAAmB;EACvC,OAAO;IACL,YAAY;IACZ;MACE,OAAO,eAAe,IAAI,EAAE,UAAU,CAAC,aAAa;IACtD;IACA,KAAI,KAAK;MACP,eAAe,IAAI,EAAE,UAAU,CAAC,aAAa,OAAO;IACtD;EACF;AACF;AAEA;;CAEC,GACD,OAAO,SAAS,MAAM,WAAmB;EACvC,OAAO;IACL,YAAY;IACZ;MACE,OAAO,eAAe,IAAI,EAAE,UAAU,CAAC,aAAa;IACtD;IACA,KAAI,KAAK;MACP,eAAe,IAAI,EAAE,UAAU,CAAC,aAAa,OAAO;IACtD;EACF;AACF;AAEA;;CAEC,GACD,OAAO,SAAS,MAAM,WAAmB;EACvC,OAAO;IACL,YAAY;IACZ;MACE,OAAO,eAAe,IAAI,EAAE,UAAU,CAAC,aAAa;IACtD;IACA,KAAI,KAAK;MACP,eAAe,IAAI,EAAE,UAAU,CAAC,aAAa,OAAO;IACtD;EACF;AACF"}

package/bigendian.ts

@@ -0,0 +1,136 @@
+/**
+ * Property descriptor factories for big-endian numbers
+ * @module
+ */
+
+import { structDataView, type StructPropertyDescriptor } from "./mod.js"
+
+/**
+ * Field for a big-endian 16-bit unsigned integer
+ */
+export function u16be(fieldOffset: number): StructPropertyDescriptor<number> {
+  return {
+    enumerable: true,
+    get() {
+      return structDataView(this).getUint16(fieldOffset, false)
+    },
+    set(value) {
+      structDataView(this).setUint16(fieldOffset, value, false)
+    },
+  }
+}
+/**
+ * Field for a big-endian 32-bit unsigned integer
+ */
+export function u32be(fieldOffset: number): StructPropertyDescriptor<number> {
+  return {
+    enumerable: true,
+    get() {
+      return structDataView(this).getUint32(fieldOffset, false)
+    },
+    set(value) {
+      structDataView(this).setUint32(fieldOffset, value, false)
+    },
+  }
+}
+/**
+ * Field for a big-endian 64-bit unsigned integer
+ */
+export function u64be(fieldOffset: number): StructPropertyDescriptor<bigint> {
+  return {
+    enumerable: true,
+    get() {
+      return structDataView(this).getBigUint64(fieldOffset, false)
+    },
+    set(value) {
+      structDataView(this).setBigUint64(fieldOffset, value, false)
+    },
+  }
+}
+/**
+ * Field for a big-endian 16-bit signed integer
+ */
+export function i16be(fieldOffset: number): StructPropertyDescriptor<number> {
+  return {
+    enumerable: true,
+    get() {
+      return structDataView(this).getInt16(fieldOffset, false)
+    },
+    set(value) {
+      structDataView(this).setInt16(fieldOffset, value, false)
+    },
+  }
+}
+/**
+ * Field for a big-endian 32-bit signed integer
+ */
+export function i32be(fieldOffset: number): StructPropertyDescriptor<number> {
+  return {
+    enumerable: true,
+    get() {
+      return structDataView(this).getInt32(fieldOffset, false)
+    },
+    set(value) {
+      structDataView(this).setInt32(fieldOffset, value, false)
+    },
+  }
+}
+/**
+ * Field for a big-endian 64-bit signed integer
+ */
+export function i64be(fieldOffset: number): StructPropertyDescriptor<bigint> {
+  return {
+    enumerable: true,
+    get() {
+      return structDataView(this).getBigInt64(fieldOffset, false)
+    },
+    set(value) {
+      structDataView(this).setBigInt64(fieldOffset, value, false)
+    },
+  }
+}
+
+/**
+ * Field for a big-endian 16-bit binary float (float16_t)
+ */
+export function f16be(fieldOffset: number): StructPropertyDescriptor<number> {
+  return {
+    enumerable: true,
+    get() {
+      return structDataView(this).getFloat16(fieldOffset, false)
+    },
+    set(value) {
+      structDataView(this).setFloat16(fieldOffset, value, false)
+    },
+  }
+}
+
+/**
+ * Field for a big-endian 32-bit binary float (float32_t)
+ */
+export function f32be(fieldOffset: number): StructPropertyDescriptor<number> {
+  return {
+    enumerable: true,
+    get() {
+      return structDataView(this).getFloat32(fieldOffset, false)
+    },
+    set(value) {
+      structDataView(this).setFloat32(fieldOffset, value, false)
+    },
+  }
+}
+
+/**
+ * Field for a big-endian 64-bit binary float (float64_t)
+ */
+export function f64be(fieldOffset: number): StructPropertyDescriptor<number> {
+  return {
+    enumerable: true,
+    get() {
+      return structDataView(this).getFloat64(fieldOffset, false)
+    },
+    set(value) {
+      structDataView(this).setFloat64(fieldOffset, value, false)
+    },
+  }
+}

package/bigendian_test.ts

@@ -0,0 +1,70 @@
+import {
+  f16be,
+  f32be,
+  f64be,
+  i16be,
+  i32be,
+  i64be,
+  u16be,
+  u32be,
+  u64be,
+} from "./bigendian.ts"
+import { defineStruct, i16, i32, i64, u16, u32, u64 } from "./mod.ts"
+
+import { assertEquals } from "jsr:@std/assert@1"
+
+Deno.test("integers", () => {
+  const buf = new Uint8Array(16)
+  const Integers = defineStruct({
+    as_i16: i16(1),
+    as_i32: i32(1),
+    as_i64: i64(1),
+    as_u16: u16(1),
+    as_u32: u32(1),
+    as_u64: u64(1),
+
+    as_i16be: i16be(1),
+    as_i32be: i32be(1),
+    as_i64be: i64be(1),
+    as_u16be: u16be(1),
+    as_u32be: u32be(1),
+    as_u64be: u64be(1),
+  })
+  const b = new Integers(buf)
+  b.as_i16be = 0x0102
+  assertEquals(b.as_i16be, 0x0102)
+  assertEquals(b.as_i16, 0x0201)
+  assertEquals(b.as_u16be, 0x0102)
+  assertEquals(b.as_u16, 0x0201)
+
+  b.as_i32be = 0x01020304
+  assertEquals(b.as_i32be, 0x01020304)
+  assertEquals(b.as_i32, 0x04030201)
+  assertEquals(b.as_u32be, 0x01020304)
+  assertEquals(b.as_u32, 0x04030201)
+
+  b.as_i64be = 0x0102030405060708n
+  assertEquals(b.as_i64be, 0x0102030405060708n)
+  assertEquals(b.as_i64, 0x0807060504030201n)
+  assertEquals(b.as_u64be, 0x0102030405060708n)
+  assertEquals(b.as_u64, 0x0807060504030201n)
+})
+
+Deno.test("floats", () => {
+  const Floats = defineStruct({
+    f16: f16be(0),
+    f32: f32be(4),
+    f64: f64be(8),
+  })
+  const bytes = new Uint8Array(16)
+  const v = new Floats(bytes)
+  assertEquals(v.f16, 0)
+  assertEquals(v.f32, 0)
+  assertEquals(v.f64, 0)
+  v.f16 = 1 / 3
+  v.f32 = 1 / 3
+  v.f64 = 1 / 3
+  assertEquals(v.f16, Math.f16round(1 / 3))
+  assertEquals(v.f32, Math.fround(1 / 3))
+  assertEquals(v.f64, 1 / 3)
+})

package/deno.json

@@ -0,0 +1,18 @@
+{
+  "name": "@rotu/structview",
+  "version": "0.6.1",
+  "license": "MIT",
+  "tasks": {
+    "dev": "deno test --watch"
+  },
+  "fmt": {
+    "semiColons": false
+  },
+  "imports": {
+    "@std/assert": "jsr:@std/assert@1"
+  },
+  "exports": {
+    ".": "./mod.ts",
+    "./bigendian": "./bigendian.ts"
+  }
+}