@yume-chan/struct 0.0.23 → 0.0.24

package/src/sync-promise.ts

@@ -5,7 +5,7 @@ export interface SyncPromise<T> {
             | null
             | undefined,
         onrejected?:
-            | ((reason: any) => TResult2 | PromiseLike<TResult2>)
+            | ((reason: unknown) => TResult2 | PromiseLike<TResult2>)
             | null
             | undefined,
     ): SyncPromise<TResult1 | TResult2>;
@@ -14,7 +14,7 @@ export interface SyncPromise<T> {
 }
 
 interface SyncPromiseStatic {
-    reject<T = never>(reason?: any): SyncPromise<T>;
+    reject<T = never>(reason?: unknown): SyncPromise<T>;
 
     resolve(): SyncPromise<void>;
     resolve<T>(value: T | PromiseLike<T>): SyncPromise<T>;
@@ -23,7 +23,7 @@ interface SyncPromiseStatic {
 }
 
 export const SyncPromise: SyncPromiseStatic = {
-    reject<T = never>(reason?: any): SyncPromise<T> {
+    reject<T = never>(reason?: unknown): SyncPromise<T> {
         return new RejectedSyncPromise(reason);
     },
     resolve<T>(value?: T | PromiseLike<T>): SyncPromise<T> {
@@ -67,7 +67,7 @@ class PendingSyncPromise<T> implements SyncPromise<T> {
             | null
             | undefined,
         onrejected?:
-            | ((reason: any) => TResult2 | PromiseLike<TResult2>)
+            | ((reason: unknown) => TResult2 | PromiseLike<TResult2>)
             | null
             | undefined,
     ) {
@@ -95,7 +95,7 @@ class ResolvedSyncPromise<T> implements SyncPromise<T> {
             | undefined,
     ) {
         if (!onfulfilled) {
-            return this as any;
+            return this as never;
         }
         return SyncPromise.try(() => onfulfilled(this.#value));
     }
@@ -106,9 +106,9 @@ class ResolvedSyncPromise<T> implements SyncPromise<T> {
 }
 
 class RejectedSyncPromise<T> implements SyncPromise<T> {
-    #reason: any;
+    #reason: unknown;
 
-    constructor(reason: any) {
+    constructor(reason: unknown) {
         this.#reason = reason;
     }
 
@@ -118,12 +118,12 @@ class RejectedSyncPromise<T> implements SyncPromise<T> {
             | null
             | undefined,
         onrejected?:
-            | ((reason: any) => TResult2 | PromiseLike<TResult2>)
+            | ((reason: unknown) => TResult2 | PromiseLike<TResult2>)
             | null
             | undefined,
     ) {
         if (!onrejected) {
-            return this as any;
+            return this as never;
         }
         return SyncPromise.try(() => onrejected(this.#reason));
     }

package/src/types/bigint.ts

@@ -1,9 +1,9 @@
 import {
-    getBigInt64,
-    getBigUint64,
-    setBigInt64,
-    setBigUint64,
-} from "@yume-chan/dataview-bigint-polyfill/esm/fallback.js";
+    getInt64,
+    getUint64,
+    setInt64,
+    setUint64,
+} from "@yume-chan/no-data-view";
 
 import type {
     AsyncExactReadable,
@@ -15,57 +15,57 @@ import { StructFieldDefinition, StructFieldValue } from "../basic/index.js";
 import { SyncPromise } from "../sync-promise.js";
 import type { ValueOrPromise } from "../utils.js";
 
-type DataViewBigInt64Getter = (
-    dataView: DataView,
+export type BigIntDeserializer = (
+    array: Uint8Array,
     byteOffset: number,
-    littleEndian: boolean | undefined,
+    littleEndian: boolean,
 ) => bigint;
 
-type DataViewBigInt64Setter = (
-    dataView: DataView,
+export type BigIntSerializer = (
+    array: Uint8Array,
     byteOffset: number,
     value: bigint,
-    littleEndian: boolean | undefined,
+    littleEndian: boolean,
 ) => void;
 
-export class BigIntFieldType {
+export class BigIntFieldVariant {
     readonly TTypeScriptType!: bigint;
 
     readonly size: number;
 
-    readonly getter: DataViewBigInt64Getter;
+    readonly deserialize: BigIntDeserializer;
 
-    readonly setter: DataViewBigInt64Setter;
+    readonly serialize: BigIntSerializer;
 
     constructor(
         size: number,
-        getter: DataViewBigInt64Getter,
-        setter: DataViewBigInt64Setter,
+        deserialize: BigIntDeserializer,
+        serialize: BigIntSerializer,
     ) {
         this.size = size;
-        this.getter = getter;
-        this.setter = setter;
+        this.deserialize = deserialize;
+        this.serialize = serialize;
     }
 
-    static readonly Int64 = new BigIntFieldType(8, getBigInt64, setBigInt64);
+    static readonly Int64 = new BigIntFieldVariant(8, getInt64, setInt64);
 
-    static readonly Uint64 = new BigIntFieldType(8, getBigUint64, setBigUint64);
+    static readonly Uint64 = new BigIntFieldVariant(8, getUint64, setUint64);
 }
 
 export class BigIntFieldDefinition<
-    TType extends BigIntFieldType = BigIntFieldType,
-    TTypeScriptType = TType["TTypeScriptType"],
+    TVariant extends BigIntFieldVariant = BigIntFieldVariant,
+    TTypeScriptType = TVariant["TTypeScriptType"],
 > extends StructFieldDefinition<void, TTypeScriptType> {
-    readonly type: TType;
+    readonly variant: TVariant;
 
-    constructor(type: TType, typescriptType?: TTypeScriptType) {
+    constructor(variant: TVariant, typescriptType?: TTypeScriptType) {
         void typescriptType;
         super();
-        this.type = type;
+        this.variant = variant;
     }
 
     getSize(): number {
-        return this.type.size;
+        return this.variant.size;
     }
 
     create(
@@ -95,26 +95,29 @@ export class BigIntFieldDefinition<
             return stream.readExactly(this.getSize());
         })
             .then((array) => {
-                const view = new DataView(
-                    array.buffer,
-                    array.byteOffset,
-                    array.byteLength,
+                const value = this.variant.deserialize(
+                    array,
+                    0,
+                    options.littleEndian,
                 );
-                const value = this.type.getter(view, 0, options.littleEndian);
-                return this.create(options, struct, value as any);
+                return this.create(options, struct, value as never);
             })
             .valueOrPromise();
     }
 }
 
 export class BigIntFieldValue<
-    TDefinition extends BigIntFieldDefinition<BigIntFieldType, any>,
+    TDefinition extends BigIntFieldDefinition<BigIntFieldVariant, unknown>,
 > extends StructFieldValue<TDefinition> {
-    serialize(dataView: DataView, offset: number): void {
-        this.definition.type.setter(
-            dataView,
+    override serialize(
+        dataView: DataView,
+        array: Uint8Array,
+        offset: number,
+    ): void {
+        this.definition.variant.serialize(
+            array,
             offset,
-            this.value,
+            this.value as never,
             this.options.littleEndian,
         );
     }

package/src/types/buffer/base.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import type {
     AsyncExactReadable,
     ExactReadable,
@@ -10,46 +11,49 @@ import type { ValueOrPromise } from "../../utils.js";
 import { decodeUtf8, encodeUtf8 } from "../../utils.js";
 
 /**
- * Base class for all types that
- * can be converted from an `Uint8Array` when deserialized,
- * and need to be converted to an `Uint8Array` when serializing
+ * A converter for buffer-like fields.
+ * It converts `Uint8Array`s to custom-typed values when deserializing,
+ * and convert values back to `Uint8Array`s when serializing.
  *
- * @template TValue The actual TypeScript type of this type
- * @template TTypeScriptType Optional another type (should be compatible with `TType`)
- * specified by user when creating field definitions.
+ * @template TValue The type of the value that the converter converts to/from `Uint8Array`.
+ * @template TTypeScriptType Optionally another type to refine `TValue`.
+ * For example, `TValue` is `string`, and `TTypeScriptType` is `"foo" | "bar"`.
+ * `TValue` is specified by the developer when creating an converter implementation,
+ * `TTypeScriptType` is specified by the user when creating a field.
  */
-export abstract class BufferFieldSubType<
+export abstract class BufferFieldConverter<
     TValue = unknown,
     TTypeScriptType = TValue,
 > {
     readonly TTypeScriptType!: TTypeScriptType;
 
     /**
-     * When implemented in derived classes, converts the type-specific `value` to an `Uint8Array`
+     * When implemented in derived classes, converts the custom `value` to an `Uint8Array`
      *
      * This function should be "pure", i.e.,
      * same `value` should always be converted to `Uint8Array`s that have same content.
      */
     abstract toBuffer(value: TValue): Uint8Array;
 
-    /** When implemented in derived classes, converts the `Uint8Array` to a type-specific value */
+    /** When implemented in derived classes, converts the `Uint8Array` to a custom value */
     abstract toValue(array: Uint8Array): TValue;
 
     /**
-     * When implemented in derived classes, gets the size in byte of the type-specific `value`.
+     * When implemented in derived classes, gets the size in byte of the custom `value`.
      *
-     * If the size can't be calculated without first converting the `value` back to an `Uint8Array`,
-     * implementer can returns `-1`, so the caller will get its size by first converting it to
-     * an `Uint8Array` (and cache the result).
+     * If the size can't be determined without first converting the `value` back to an `Uint8Array`,
+     * the implementer should return `undefined`. In which case, the caller will call `toBuffer` to
+     * convert the value to a `Uint8Array`, then read the length of the `Uint8Array`. The caller can
+     * cache the result so the serialization process doesn't need to call `toBuffer` again.
      */
-    abstract getSize(value: TValue): number;
+    abstract getSize(value: TValue): number | undefined;
 }
 
-/** An `BufferFieldSubType` that's actually an `Uint8Array` */
-export class Uint8ArrayBufferFieldSubType<
+/** An identity converter, doesn't convert to anything else. */
+export class Uint8ArrayBufferFieldConverter<
     TTypeScriptType = Uint8Array,
-> extends BufferFieldSubType<Uint8Array, TTypeScriptType> {
-    static readonly Instance = new Uint8ArrayBufferFieldSubType();
+> extends BufferFieldConverter<Uint8Array, TTypeScriptType> {
+    static readonly Instance = new Uint8ArrayBufferFieldConverter();
 
     protected constructor() {
         super();
@@ -64,15 +68,15 @@ export class Uint8ArrayBufferFieldSubType<
     }
 
     getSize(value: Uint8Array): number {
-        return value.byteLength;
+        return value.length;
     }
 }
 
 /** An `BufferFieldSubType` that converts between `Uint8Array` and `string` */
-export class StringBufferFieldSubType<
+export class StringBufferFieldConverter<
     TTypeScriptType = string,
-> extends BufferFieldSubType<string, TTypeScriptType> {
-    static readonly Instance = new StringBufferFieldSubType();
+> extends BufferFieldConverter<string, TTypeScriptType> {
+    static readonly Instance = new StringBufferFieldConverter();
 
     toBuffer(value: string): Uint8Array {
         return encodeUtf8(value);
@@ -82,30 +86,29 @@ export class StringBufferFieldSubType<
         return decodeUtf8(array);
     }
 
-    getSize(): number {
-        // Return `-1`, so `BufferLikeFieldDefinition` will
-        // convert this `value` into an `Uint8Array` (and cache the result),
-        // Then get the size from that `Uint8Array`
-        return -1;
+    getSize(): number | undefined {
+        // See the note in `BufferFieldConverter.getSize`
+        return undefined;
     }
 }
 
 export const EMPTY_UINT8_ARRAY = new Uint8Array(0);
 
 export abstract class BufferLikeFieldDefinition<
-    TType extends BufferFieldSubType<any, any> = BufferFieldSubType<
+    TConverter extends BufferFieldConverter<
         unknown,
         unknown
-    >,
+    > = BufferFieldConverter<unknown, unknown>,
     TOptions = void,
     TOmitInitKey extends PropertyKey = never,
-    TTypeScriptType = TType["TTypeScriptType"],
+    TTypeScriptType = TConverter["TTypeScriptType"],
 > extends StructFieldDefinition<TOptions, TTypeScriptType, TOmitInitKey> {
-    readonly type: TType;
+    readonly converter: TConverter;
+    readonly TTypeScriptType!: TTypeScriptType;
 
-    constructor(type: TType, options: TOptions) {
+    constructor(converter: TConverter, options: TOptions) {
         super(options);
-        this.type = type;
+        this.converter = converter;
     }
 
     protected getDeserializeSize(struct: StructValue): number {
@@ -119,7 +122,7 @@ export abstract class BufferLikeFieldDefinition<
     create(
         options: Readonly<StructOptions>,
         struct: StructValue,
-        value: TType["TTypeScriptType"],
+        value: TTypeScriptType,
         array?: Uint8Array,
     ): BufferLikeFieldValue<this> {
         return new BufferLikeFieldValue(this, options, struct, value, array);
@@ -149,7 +152,7 @@ export abstract class BufferLikeFieldDefinition<
             }
         })
             .then((array) => {
-                const value = this.type.toValue(array);
+                const value = this.converter.toValue(array) as TTypeScriptType;
                 return this.create(options, struct, value, array);
             })
             .valueOrPromise();
@@ -158,7 +161,8 @@ export abstract class BufferLikeFieldDefinition<
 
 export class BufferLikeFieldValue<
     TDefinition extends BufferLikeFieldDefinition<
-        BufferFieldSubType<unknown, unknown>,
+        BufferFieldConverter<unknown, unknown>,
+        any,
         any,
         any
     >,
@@ -169,7 +173,7 @@ export class BufferLikeFieldValue<
         definition: TDefinition,
         options: Readonly<StructOptions>,
         struct: StructValue,
-        value: TDefinition["TValue"],
+        value: TDefinition["TTypeScriptType"],
         array?: Uint8Array,
     ) {
         super(definition, options, struct, value);
@@ -183,15 +187,12 @@ export class BufferLikeFieldValue<
         this.array = undefined;
     }
 
-    serialize(dataView: DataView, offset: number): void {
-        if (!this.array) {
-            this.array = this.definition.type.toBuffer(this.value);
-        }
-
-        new Uint8Array(
-            dataView.buffer,
-            dataView.byteOffset,
-            dataView.byteLength,
-        ).set(this.array, offset);
+    override serialize(
+        dataView: DataView,
+        array: Uint8Array,
+        offset: number,
+    ): void {
+        this.array ??= this.definition.converter.toBuffer(this.value);
+        array.set(this.array, offset);
     }
 }

package/src/types/buffer/fixed-length.ts

@@ -1,4 +1,4 @@
-import type { BufferFieldSubType } from "./base.js";
+import type { BufferFieldConverter } from "./base.js";
 import { BufferLikeFieldDefinition } from "./base.js";
 
 export interface FixedLengthBufferLikeFieldOptions {
@@ -6,11 +6,16 @@ export interface FixedLengthBufferLikeFieldOptions {
 }
 
 export class FixedLengthBufferLikeFieldDefinition<
-    TType extends BufferFieldSubType = BufferFieldSubType,
+    TConverter extends BufferFieldConverter = BufferFieldConverter,
     TOptions extends
         FixedLengthBufferLikeFieldOptions = FixedLengthBufferLikeFieldOptions,
-    TTypeScriptType = TType["TTypeScriptType"],
-> extends BufferLikeFieldDefinition<TType, TOptions, never, TTypeScriptType> {
+    TTypeScriptType = TConverter["TTypeScriptType"],
+> extends BufferLikeFieldDefinition<
+    TConverter,
+    TOptions,
+    never,
+    TTypeScriptType
+> {
     getSize(): number {
         return this.options.length;
     }

package/src/types/buffer/variable-length.ts

@@ -1,3 +1,6 @@
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
 import type {
     StructFieldDefinition,
     StructOptions,
@@ -6,13 +9,13 @@ import type {
 import { StructFieldValue } from "../../basic/index.js";
 import type { KeysOfType } from "../../utils.js";
 
-import type { BufferFieldSubType } from "./base.js";
+import type { BufferFieldConverter } from "./base.js";
 import { BufferLikeFieldDefinition, BufferLikeFieldValue } from "./base.js";
 
 export type LengthField<TFields> = KeysOfType<TFields, number | string>;
 
 export interface VariableLengthBufferLikeFieldOptions<
-    TFields = object,
+    TFields extends object = object,
     TLengthField extends LengthField<TFields> = any,
 > {
     /**
@@ -32,12 +35,12 @@ export interface VariableLengthBufferLikeFieldOptions<
 }
 
 export class VariableLengthBufferLikeFieldDefinition<
-    TType extends BufferFieldSubType = BufferFieldSubType,
+    TConverter extends BufferFieldConverter = BufferFieldConverter,
     TOptions extends
         VariableLengthBufferLikeFieldOptions = VariableLengthBufferLikeFieldOptions,
-    TTypeScriptType = TType["TTypeScriptType"],
+    TTypeScriptType = TConverter["TTypeScriptType"],
 > extends BufferLikeFieldDefinition<
-    TType,
+    TConverter,
     TOptions,
     TOptions["lengthField"],
     TTypeScriptType
@@ -88,11 +91,11 @@ export class VariableLengthBufferLikeStructFieldValue<
         super(definition, options, struct, value, array);
 
         if (array) {
-            this.length = array.byteLength;
+            this.length = array.length;
         }
 
         // Patch the associated length field.
-        const lengthField = this.definition.options.lengthField;
+        const lengthField = this.definition.options.lengthField as PropertyKey;
 
         const originalValue = struct.get(lengthField);
         this.lengthFieldValue = new VariableLengthBufferLikeFieldLengthValue(
@@ -102,13 +105,24 @@ export class VariableLengthBufferLikeStructFieldValue<
         struct.set(lengthField, this.lengthFieldValue);
     }
 
-    override getSize() {
+    #tryGetSize() {
+        const length = this.definition.converter.getSize(this.value);
+        if (length !== undefined && length < 0) {
+            throw new Error("Invalid length");
+        }
+        return length;
+    }
+
+    override getSize(): number {
         if (this.length === undefined) {
-            this.length = this.definition.type.getSize(this.value);
-            if (this.length === -1) {
-                this.array = this.definition.type.toBuffer(this.value);
-                this.length = this.array.byteLength;
-            }
+            // first try to get the size from the converter
+            this.length = this.#tryGetSize();
+        }
+
+        if (this.length === undefined) {
+            // The converter doesn't know the size, so convert the value to a buffer to get its size
+            this.array = this.definition.converter.toBuffer(this.value);
+            this.length = this.array.length;
         }
 
         return this.length;
@@ -123,39 +137,49 @@ export class VariableLengthBufferLikeStructFieldValue<
 
 // Not using `VariableLengthBufferLikeStructFieldValue` directly makes writing tests much easier...
 type VariableLengthBufferLikeFieldValueLike = StructFieldValue<
-    StructFieldDefinition<VariableLengthBufferLikeFieldOptions, any, any>
+    StructFieldDefinition<
+        VariableLengthBufferLikeFieldOptions<any, any>,
+        any,
+        any
+    >
 >;
 
-export class VariableLengthBufferLikeFieldLengthValue extends StructFieldValue {
-    protected originalField: StructFieldValue;
+export class VariableLengthBufferLikeFieldLengthValue extends StructFieldValue<
+    StructFieldDefinition<unknown, unknown, PropertyKey>
+> {
+    protected originalValue: StructFieldValue<
+        StructFieldDefinition<unknown, unknown, PropertyKey>
+    >;
 
-    protected bufferField: VariableLengthBufferLikeFieldValueLike;
+    protected bufferValue: VariableLengthBufferLikeFieldValueLike;
 
     constructor(
-        originalField: StructFieldValue,
-        arrayBufferField: VariableLengthBufferLikeFieldValueLike,
+        originalValue: StructFieldValue<
+            StructFieldDefinition<unknown, unknown, PropertyKey>
+        >,
+        bufferValue: VariableLengthBufferLikeFieldValueLike,
     ) {
         super(
-            originalField.definition,
-            originalField.options,
-            originalField.struct,
+            originalValue.definition,
+            originalValue.options,
+            originalValue.struct,
             0,
         );
-        this.originalField = originalField;
-        this.bufferField = arrayBufferField;
+        this.originalValue = originalValue;
+        this.bufferValue = bufferValue;
     }
 
     override getSize() {
-        return this.originalField.getSize();
+        return this.originalValue.getSize();
     }
 
     override get() {
-        let value: string | number = this.bufferField.getSize();
+        let value: string | number = this.bufferValue.getSize();
 
-        const originalValue = this.originalField.get();
+        const originalValue = this.originalValue.get();
         if (typeof originalValue === "string") {
             value = value.toString(
-                this.bufferField.definition.options.lengthFieldRadix ?? 10,
+                this.bufferValue.definition.options.lengthFieldRadix ?? 10,
             );
         }
 
@@ -167,8 +191,8 @@ export class VariableLengthBufferLikeFieldLengthValue extends StructFieldValue {
         // It will always be in sync with the buffer size
     }
 
-    serialize(dataView: DataView, offset: number) {
-        this.originalField.set(this.get());
-        this.originalField.serialize(dataView, offset);
+    serialize(dataView: DataView, array: Uint8Array, offset: number) {
+        this.originalValue.set(this.get());
+        this.originalValue.serialize(dataView, array, offset);
     }
 }