feat(types): Max size attribute. (#58)

Author: MierenManz

src/array/array.ts

@@ -1,8 +1,11 @@
 import { type Options, UnsizedType } from "../types/mod.ts";
 
 export class ArrayType<T> extends UnsizedType<T[]> {
+  override readonly maxSize: number | null;
+
   constructor(readonly type: UnsizedType<T>, readonly length: number) {
     super(type.byteAlignment);
+    this.maxSize = type.maxSize ? type.maxSize * length : null;
   }
 
   readPacked(dt: DataView, options: Options = { byteOffset: 0 }): T[] {

src/array/array_buffer_test.ts

@@ -9,6 +9,11 @@ Deno.test({
     dt.setUint16(0, 0xFF);
 
     const type = new ArrayBufferType(2);
+
+    await t.step("estimated size", () => {
+      assertEquals(type.maxSize, 2);
+    });
+
     await t.step("Read", () => {
       const newAb = type.read(dt);
       assertEquals(new Uint8Array(newAb), new Uint8Array(ab));

src/array/array_test.ts

@@ -9,6 +9,10 @@ Deno.test({
     const dt = new DataView(ab);
     const type = new ArrayType(u8, 2);
 
+    await t.step("estimated size", () => {
+      assertEquals(type.maxSize, 2);
+    });
+
     await t.step("Read", () => {
       dt.setUint16(0, 0xFFFF);
       const result = type.read(dt);

src/array/typed_array.ts

@@ -1,30 +1,30 @@
 import { type Options, SizedType } from "../types/mod.ts";
 
 type TypedArrays =
-  | Uint8Array
-  | Uint8ClampedArray
-  | Int8Array
-  | Uint16Array
-  | Int16Array
-  | Uint32Array
-  | Int32Array
-  | Float32Array
-  | Float64Array
-  | BigUint64Array
-  | BigInt64Array;
+  | Uint8Array<ArrayBufferLike>
+  | Uint8ClampedArray<ArrayBufferLike>
+  | Int8Array<ArrayBufferLike>
+  | Uint16Array<ArrayBufferLike>
+  | Int16Array<ArrayBufferLike>
+  | Uint32Array<ArrayBufferLike>
+  | Int32Array<ArrayBufferLike>
+  | Float32Array<ArrayBufferLike>
+  | Float64Array<ArrayBufferLike>
+  | BigUint64Array<ArrayBufferLike>
+  | BigInt64Array<ArrayBufferLike>;
 
-type TypedConstructors<T extends TypedArrays> = T extends Uint8Array
-  ? Uint8ArrayConstructor
-  : T extends Uint8ClampedArray ? Uint8ClampedArrayConstructor
-  : T extends Int8Array ? Int8ArrayConstructor
-  : T extends Uint16Array ? Uint16ArrayConstructor
-  : T extends Int16Array ? Int16ArrayConstructor
-  : T extends Uint32Array ? Uint32ArrayConstructor
-  : T extends Int32Array ? Int32ArrayConstructor
-  : T extends Float32Array ? Float32ArrayConstructor
-  : T extends Float64Array ? Float64ArrayConstructor
-  : T extends BigUint64Array ? BigUint64ArrayConstructor
-  : T extends BigInt64Array ? BigInt64ArrayConstructor
+type TypedConstructors<T extends TypedArrays> = T extends
+  Uint8Array<ArrayBufferLike> ? Uint8ArrayConstructor
+  : T extends Uint8ClampedArray<ArrayBufferLike> ? Uint8ClampedArrayConstructor
+  : T extends Int8Array<ArrayBufferLike> ? Int8ArrayConstructor
+  : T extends Uint16Array<ArrayBufferLike> ? Uint16ArrayConstructor
+  : T extends Int16Array<ArrayBufferLike> ? Int16ArrayConstructor
+  : T extends Uint32Array<ArrayBufferLike> ? Uint32ArrayConstructor
+  : T extends Int32Array<ArrayBufferLike> ? Int32ArrayConstructor
+  : T extends Float32Array<ArrayBufferLike> ? Float32ArrayConstructor
+  : T extends Float64Array<ArrayBufferLike> ? Float64ArrayConstructor
+  : T extends BigUint64Array<ArrayBufferLike> ? BigUint64ArrayConstructor
+  : T extends BigInt64Array<ArrayBufferLike> ? BigInt64ArrayConstructor
   : never;
 
 export class TypedArray<T extends TypedArrays> extends SizedType<T> {
@@ -40,8 +40,8 @@ export class TypedArray<T extends TypedArrays> extends SizedType<T> {
 
   readPacked(dt: DataView, options: Options = { byteOffset: 0 }): T {
     const value = new this.arrayConstructor(
-      dt.buffer,
       // @ts-expect-error:
+      dt.buffer,
       dt.byteOffset + options.byteOffset,
       this.length,
     ).slice() as T;
@@ -56,8 +56,8 @@ export class TypedArray<T extends TypedArrays> extends SizedType<T> {
     options: Options = { byteOffset: 0 },
   ): void {
     const view = new this.arrayConstructor(
-      dt.buffer,
       // @ts-expect-error:
+      dt.buffer,
       dt.byteOffset + options.byteOffset,
       this.length,
     );

src/array/typed_array_test.ts

@@ -9,6 +9,10 @@ Deno.test({
     const dt = new DataView(ab);
     const type = new Uint16ArrayType(1);
 
+    await t.step("estimated size", () => {
+      assertEquals(type.maxSize, 2);
+    });
+
     await t.step("Read", () => {
       dt.setUint16(0, 0xFFFF);
       const result = type.read(dt);

src/bitflags/bitflags16_test.ts

@@ -11,6 +11,10 @@ Deno.test({
       two: 2,
     });
 
+    await t.step("estimated size", () => {
+      assertEquals(type.maxSize, 2);
+    });
+
     await t.step("Read", () => {
       dt.setUint8(1, 0b01);
       const result = type.read(dt);

src/bitflags/bitflags32_test.ts

@@ -11,6 +11,10 @@ Deno.test({
       two: 2,
     });
 
+    await t.step("estimated size", () => {
+      assertEquals(type.maxSize, 4);
+    });
+
     await t.step("Read", () => {
       dt.setUint8(3, 0b01);
       const result = type.read(dt);

src/bitflags/bitflags64_test.ts

@@ -11,6 +11,10 @@ Deno.test({
       two: 2n,
     });
 
+    await t.step("estimated size", () => {
+      assertEquals(type.maxSize, 8);
+    });
+
     await t.step("Read", () => {
       dt.setUint8(7, 0b01);
       const result = type.read(dt);

src/bitflags/bitflags8_test.ts

@@ -11,6 +11,10 @@ Deno.test({
       two: 2,
     });
 
+    await t.step("estimated size", () => {
+      assertEquals(type.maxSize, 1);
+    });
+
     await t.step("Read", () => {
       dt.setUint8(0, 0b01);
       const result = type.read(dt);

src/compound/sized_struct_test.ts

@@ -9,6 +9,10 @@ Deno.test({
     const dt = new DataView(ab);
     const type = new SizedStruct({ byte: u8, word: u32le });
 
+    await t.step("estimated size", () => {
+      assertEquals(type.maxSize, 8);
+    });
+
     await t.step("Read", () => {
       dt.setUint8(0, 127);
       dt.setUint32(4, 255, true);

src/compound/struct.ts

@@ -1,5 +1,5 @@
 import { type InnerType, type Options, UnsizedType } from "../types/mod.ts";
-import { alignmentOf } from "../util.ts";
+import { align, alignmentOf } from "../util.ts";
 
 export class Struct<
   T extends Record<string, UnsizedType<unknown>>,
@@ -8,10 +8,17 @@ export class Struct<
   },
 > extends UnsizedType<V> {
   #record: Array<[string, UnsizedType<unknown>]>;
+  override readonly maxSize: number | null;
 
   constructor(input: T) {
     super(alignmentOf(input));
     this.#record = Object.entries(input);
+    this.maxSize = this.#record.every(([_, a]) => a.maxSize !== null)
+      ? this.#record.reduce(
+        (acc, [_, x]) => acc + align(Number(x.maxSize), this.byteAlignment),
+        0,
+      )
+      : null;
   }
 
   readPacked(dt: DataView, options: Options = { byteOffset: 0 }): V {

src/compound/struct_test.ts

@@ -9,6 +9,10 @@ Deno.test({
     const dt = new DataView(ab);
     const type = new Struct({ byte: u8, word: u32le });
 
+    await t.step("estimated size", () => {
+      assertEquals(type.maxSize, 8);
+    });
+
     await t.step("Read", () => {
       dt.setUint8(0, 127);
       dt.setUint32(4, 255, true);

src/compound/tagged_union.ts

@@ -5,7 +5,7 @@ import {
   UnsizedType,
   type ValueOf,
 } from "../types/mod.ts";
-import { alignmentOf } from "../util.ts";
+import { align, alignmentOf } from "../util.ts";
 
 type FindDiscriminant<V, D extends number | string> = (variant: V) => D;
 
@@ -22,6 +22,8 @@ export class TaggedUnion<
   #variantFinder: FindDiscriminant<V, Keys<T>>;
   #discriminant: UnsizedType<string | number>;
 
+  override maxSize: number | null;
+
   constructor(
     input: T,
     variantFinder: FindDiscriminant<V, Keys<T>>,
@@ -43,6 +45,13 @@ export class TaggedUnion<
     this.#record = input;
     this.#variantFinder = variantFinder;
     this.#discriminant = discriminant;
+    this.maxSize = Object.values(input).some((x) => x.maxSize === null)
+      ? null
+      : Object.values(input).reduce(
+        (acc: number, x) =>
+          Math.max(acc, align(x.maxSize as number, this.byteAlignment)),
+        0,
+      );
   }
 
   readPacked(dt: DataView, options: Options = { byteOffset: 0 }): V {

src/compound/tagged_union_test.ts

@@ -1,5 +1,5 @@
 import { TaggedUnion } from "./tagged_union.ts";
-import { u32le, u8 } from "../mod.ts";
+import { cstring, u32le, u8 } from "../mod.ts";
 import { assertEquals, assertThrows } from "../../test_deps.ts";
 
 Deno.test({
@@ -13,6 +13,21 @@ Deno.test({
       2: u8,
     }, (a) => a === 32 ? 0 : 1);
 
+    await t.step("estimate size", () => {
+      const type = new TaggedUnion({
+        0: u32le,
+        1: u8,
+        2: u8,
+      }, (a) => a === 32 ? 0 : 1);
+      assertEquals(type.maxSize, 4);
+
+      const unknownSizedType = new TaggedUnion({
+        0: cstring,
+      }, () => 0);
+
+      assertEquals(unknownSizedType.maxSize, null);
+    });
+
     await t.step("Read", () => {
       dt.setUint8(0, 1);
       dt.setUint8(1, 11);

src/compound/tuple.ts

@@ -1,16 +1,25 @@
 import { type InnerType, type Options, UnsizedType } from "../types/mod.ts";
-import { alignmentOf } from "../util.ts";
+import { align, alignmentOf } from "../util.ts";
 
 export class Tuple<
   T extends [...UnsizedType<unknown>[]],
   V extends [...unknown[]] = { [I in keyof T]: InnerType<T[I]> },
 > extends UnsizedType<V> {
   #tupleTypes: T;
   #length: number;
+  override maxSize: number | null;
+
   constructor(types: T) {
     super(alignmentOf(types));
     this.#tupleTypes = types;
     this.#length = types.length;
+
+    this.maxSize = types.every((a) => a.maxSize !== null)
+      ? types.reduce(
+        (acc, x) => acc + align(Number(x.maxSize), this.byteAlignment),
+        0,
+      )
+      : null;
   }
 
   readPacked(dt: DataView, options: Options = { byteOffset: 0 }): V {

src/compound/tuple_test.ts

@@ -9,6 +9,10 @@ Deno.test({
     const dt = new DataView(ab);
     const type = new Tuple([u8, u32le]);
 
+    await t.step("estimated size", () => {
+      assertEquals(type.maxSize, 8);
+    });
+
     await t.step("Read", () => {
       dt.setUint32(0, 127, true);
       dt.setUint32(4, 255, true);

src/compound/union.ts

@@ -5,7 +5,7 @@ import {
   UnsizedType,
   type ValueOf,
 } from "../types/mod.ts";
-import { alignmentOf } from "../util.ts";
+import { align, alignmentOf } from "../util.ts";
 
 type FindDiscriminant<V, D extends number> = (variant: V) => D;
 
@@ -20,13 +20,23 @@ export class Union<
   #variantFinder: FindDiscriminant<V, Keys<T>>;
   #discriminant = u8;
 
+  override maxSize: number | null;
+
   constructor(
     input: T,
     variantFinder: FindDiscriminant<V, Keys<T>>,
   ) {
     super(alignmentOf(input));
     this.#record = input;
     this.#variantFinder = variantFinder;
+
+    this.maxSize = Object.values(input).some((x) => x.maxSize === null)
+      ? null
+      : Object.values(input).reduce(
+        (acc: number, x) =>
+          Math.max(acc, align(x.maxSize as number, this.byteAlignment)),
+        0,
+      );
   }
 
   readPacked(dt: DataView, options: Options = { byteOffset: 0 }): V {

src/compound/union_test.ts

@@ -1,4 +1,4 @@
-import { u32le, u8 } from "../mod.ts";
+import { cstring, u32le, u8 } from "../mod.ts";
 import { assertEquals, assertThrows } from "../../test_deps.ts";
 import { Union } from "./union.ts";
 
@@ -13,6 +13,21 @@ Deno.test({
       2: u8,
     }, (a) => a === 32 ? 0 : 1);
 
+    await t.step("estimate size", () => {
+      const type = new Union({
+        0: u32le,
+        1: u8,
+        2: u8,
+      }, (a) => a === 32 ? 0 : 1);
+      assertEquals(type.maxSize, 4);
+
+      const unknownSizedType = new Union({
+        0: cstring,
+      }, () => 0);
+
+      assertEquals(unknownSizedType.maxSize, null);
+    });
+
     await t.step("Read", () => {
       dt.setUint8(0, 1);
       dt.setUint8(1, 11);

src/meta_types.ts

@@ -2,9 +2,12 @@ import type { Options } from "./mod.ts";
 import { SizedType } from "./types/mod.ts";
 
 export class Offset extends SizedType<null> {
+  override readonly maxSize: number | null;
+
   constructor(byteSize: number) {
     // Magic trick for flooring
     super(byteSize | 0, 1);
+    this.maxSize = 0;
   }
 
   override readPacked(