Added a maxSize property to some schemas.

packages/typed-binary/src/structure/array.ts

@@ -56,6 +56,18 @@ export class ArraySchema<TElement extends AnySchema> extends Schema<
     return array;
   }
 
+  /**
+   * Returns the maximum number of bytes this schema can take up.
+   *
+   * Returns `NaN` if the schema is unbounded. If you would like to know
+   * how many bytes a particular value encoding will take up, use `.measure(value)`.
+   *
+   * Alias for `.measure(MaxValue).size`
+   */
+  get maxSize(): number {
+    return this.elementSchema.measure(MaxValue).size * this.length;
+  }
+
   measure(
     values: ParseUnwrapped<TElement>[] | MaxValue,
     measurer: IMeasurer = new Measurer(),

packages/typed-binary/src/structure/baseTypes.ts

@@ -11,6 +11,13 @@ import { MaxValue, Schema } from './types';
 ////
 
 export class BoolSchema extends Schema<boolean> {
+  /**
+   * The maximum number of bytes this schema can take up.
+   *
+   * Alias for `.measure(MaxValue).size`
+   */
+  readonly maxSize = 1;
+
   read(input: ISerialInput): boolean {
     return input.readBool();
   }
@@ -57,6 +64,13 @@ export class StringSchema extends Schema<string> {
 ////
 
 export class ByteSchema extends Schema<number> {
+  /**
+   * The maximum number of bytes this schema can take up.
+   *
+   * Alias for `.measure(MaxValue).size`
+   */
+  readonly maxSize = 1;
+
   read(input: ISerialInput): number {
     return input.readByte();
   }
@@ -78,6 +92,13 @@ export class ByteSchema extends Schema<number> {
 ////
 
 export class Int32Schema extends Schema<number> {
+  /**
+   * The maximum number of bytes this schema can take up.
+   *
+   * Alias for `.measure(MaxValue).size`
+   */
+  readonly maxSize = 4;
+
   read(input: ISerialInput): number {
     return input.readInt32();
   }
@@ -99,6 +120,13 @@ export class Int32Schema extends Schema<number> {
 ////
 
 export class Uint32Schema extends Schema<number> {
+  /**
+   * The maximum number of bytes this schema can take up.
+   *
+   * Alias for `.measure(MaxValue).size`
+   */
+  readonly maxSize = 4;
+
   read(input: ISerialInput): number {
     return input.readUint32();
   }
@@ -120,6 +148,13 @@ export class Uint32Schema extends Schema<number> {
 ////
 
 export class Float32Schema extends Schema<number> {
+  /**
+   * The maximum number of bytes this schema can take up.
+   *
+   * Alias for `.measure(MaxValue).size`
+   */
+  readonly maxSize = 4;
+
   read(input: ISerialInput): number {
     return input.readFloat32();
   }

packages/typed-binary/src/structure/dynamicArray.ts

@@ -51,6 +51,18 @@ export class DynamicArraySchema<TElement extends AnySchema> extends Schema<
     return array;
   }
 
+  /**
+   * The maximum number of bytes this schema can take up.
+   *
+   * Is `NaN` if the schema is unbounded. If you would like to know
+   * how many bytes a particular value encoding will take up, use `.measure(value)`.
+   *
+   * Alias for `.measure(MaxValue).size`
+   */
+  get maxSize(): number {
+    return this.measure(MaxValue).size;
+  }
+
   measure(
     values: ParseUnwrapped<TElement>[] | typeof MaxValue,
     measurer: IMeasurer = new Measurer(),

packages/typed-binary/src/structure/keyed.ts

@@ -11,7 +11,7 @@ import {
   type IKeyedSchema,
   type IRefResolver,
   type ISchema,
-  type MaxValue,
+  MaxValue,
   type PropertyDescription,
   Ref,
   type Unwrap,
@@ -122,6 +122,18 @@ export class KeyedSchema<
     this.innerType.write(output, value);
   }
 
+  /**
+   * The maximum number of bytes this schema can take up.
+   *
+   * Is `NaN` if the schema is unbounded. If you would like to know
+   * how many bytes a particular value encoding will take up, use `.measure(value)`.
+   *
+   * Alias for `.measure(MaxValue).size`
+   */
+  get maxSize(): number {
+    return this.measure(MaxValue).size;
+  }
+
   measure(
     value: ParseUnwrapped<TInner> | typeof MaxValue,
     measurer: IMeasurer = new Measurer(),

packages/typed-binary/src/structure/object.ts

@@ -80,6 +80,24 @@ export class ObjectSchema<TProps extends Record<string, AnySchema>>
     return result;
   }
 
+  /**
+   * The maximum number of bytes this schema can take up.
+   *
+   * Is `NaN` if the schema is unbounded. If you would like to know
+   * how many bytes a particular value encoding will take up, use `.measure(value)`.
+   *
+   * Alias for `.measure(MaxValue).size`
+   */
+  get maxSize(): number {
+    const measurer = new Measurer();
+
+    for (const property of Object.values(this.properties)) {
+      property.measure(MaxValue, measurer);
+    }
+
+    return measurer.size;
+  }
+
   measure(
     value: ParseUnwrappedRecord<TProps> | typeof MaxValue,
     measurer: IMeasurer = new Measurer(),

packages/typed-binary/src/structure/optional.ts

@@ -8,7 +8,7 @@ import type { ParseUnwrapped } from '../utilityTypes';
 import {
   type AnySchema,
   type IRefResolver,
-  type MaxValue,
+  MaxValue,
   Schema,
   type Unwrap,
 } from './types';
@@ -52,6 +52,18 @@ export class OptionalSchema<TInner extends AnySchema> extends Schema<
     return undefined;
   }
 
+  /**
+   * The maximum number of bytes this schema can take up.
+   *
+   * Is `NaN` if the schema is unbounded. If you would like to know
+   * how many bytes a particular value encoding will take up, use `.measure(value)`.
+   *
+   * Alias for `.measure(MaxValue).size`
+   */
+  get maxSize(): number {
+    return this.measure(MaxValue).size;
+  }
+
   measure(
     value: ParseUnwrapped<TInner> | MaxValue | undefined,
     measurer: IMeasurer = new Measurer(),

packages/typed-binary/src/structure/tuple.ts

@@ -62,6 +62,18 @@ export class TupleSchema<
     return array;
   }
 
+  /**
+   * The maximum number of bytes this schema can take up.
+   *
+   * Is `NaN` if the schema is unbounded. If you would like to know
+   * how many bytes a particular value encoding will take up, use `.measure(value)`.
+   *
+   * Alias for `.measure(MaxValue).size`
+   */
+  get maxSize(): number {
+    return this.measure(MaxValue).size;
+  }
+
   measure(
     values: Parsed<UnwrapArray<TSequence>> | MaxValue,
     measurer: IMeasurer = new Measurer(),