@yume-chan/struct 0.0.16 → 0.0.18

package/src/sync-promise.ts

@@ -1,7 +1,13 @@
 export interface SyncPromise<T> {
     then<TResult1 = T, TResult2 = never>(
-        onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null | undefined,
-        onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined
+        onfulfilled?:
+            | ((value: T) => TResult1 | PromiseLike<TResult1>)
+            | null
+            | undefined,
+        onrejected?:
+            | ((reason: any) => TResult2 | PromiseLike<TResult2>)
+            | null
+            | undefined
     ): SyncPromise<TResult1 | TResult2>;
 
     valueOrPromise(): T | PromiseLike<T>;
@@ -22,9 +28,9 @@ export const SyncPromise: SyncPromiseStatic = {
     },
     resolve<T>(value?: T | PromiseLike<T>): SyncPromise<T> {
         if (
-            typeof value === 'object' &&
+            typeof value === "object" &&
             value !== null &&
-            typeof (value as PromiseLike<T>).then === 'function'
+            typeof (value as PromiseLike<T>).then === "function"
         ) {
             if (
                 value instanceof PendingSyncPromise ||
@@ -45,7 +51,7 @@ export const SyncPromise: SyncPromiseStatic = {
         } catch (e) {
             return SyncPromise.reject(e);
         }
-    }
+    },
 };
 
 class PendingSyncPromise<T> implements SyncPromise<T> {
@@ -56,8 +62,14 @@ class PendingSyncPromise<T> implements SyncPromise<T> {
     }
 
     public then<TResult1 = T, TResult2 = never>(
-        onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null | undefined,
-        onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined
+        onfulfilled?:
+            | ((value: T) => TResult1 | PromiseLike<TResult1>)
+            | null
+            | undefined,
+        onrejected?:
+            | ((reason: any) => TResult2 | PromiseLike<TResult2>)
+            | null
+            | undefined
     ) {
         return new PendingSyncPromise<TResult1 | TResult2>(
             this.promise.then(onfulfilled, onrejected)
@@ -76,9 +88,11 @@ class ResolvedSyncPromise<T> implements SyncPromise<T> {
         this.value = value;
     }
 
-    public then<TResult1 = T, TResult2 = never>(
-        onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null | undefined,
-        onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined
+    public then<TResult1 = T>(
+        onfulfilled?:
+            | ((value: T) => TResult1 | PromiseLike<TResult1>)
+            | null
+            | undefined
     ) {
         if (!onfulfilled) {
             return this as any;
@@ -99,8 +113,14 @@ class RejectedSyncPromise<T> implements SyncPromise<T> {
     }
 
     public then<TResult1 = T, TResult2 = never>(
-        onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null | undefined,
-        onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined
+        onfulfilled?:
+            | ((value: T) => TResult1 | PromiseLike<TResult1>)
+            | null
+            | undefined,
+        onrejected?:
+            | ((reason: any) => TResult2 | PromiseLike<TResult2>)
+            | null
+            | undefined
     ) {
         if (!onrejected) {
             return this as any;

package/src/types/bigint.ts

@@ -1,11 +1,33 @@
-import { getBigInt64, getBigUint64, setBigInt64, setBigUint64 } from '@yume-chan/dataview-bigint-polyfill/esm/fallback.js';
-import { StructFieldDefinition, StructFieldValue, StructValue, type StructAsyncDeserializeStream, type StructDeserializeStream, type StructOptions } from "../basic/index.js";
+import {
+    getBigInt64,
+    getBigUint64,
+    setBigInt64,
+    setBigUint64,
+} from "@yume-chan/dataview-bigint-polyfill/esm/fallback.js";
+
+import {
+    StructFieldDefinition,
+    StructFieldValue,
+    type StructAsyncDeserializeStream,
+    type StructDeserializeStream,
+    type StructOptions,
+    type StructValue,
+} from "../basic/index.js";
 import { SyncPromise } from "../sync-promise.js";
-import type { ValueOrPromise } from "../utils.js";
+import { type ValueOrPromise } from "../utils.js";
 
-type DataViewBigInt64Getter = (dataView: DataView, byteOffset: number, littleEndian: boolean | undefined) => bigint;
+type DataViewBigInt64Getter = (
+    dataView: DataView,
+    byteOffset: number,
+    littleEndian: boolean | undefined
+) => bigint;
 
-type DataViewBigInt64Setter = (dataView: DataView, byteOffset: number, value: bigint, littleEndian: boolean | undefined) => void;
+type DataViewBigInt64Setter = (
+    dataView: DataView,
+    byteOffset: number,
+    value: bigint,
+    littleEndian: boolean | undefined
+) => void;
 
 export class BigIntFieldType {
     public readonly TTypeScriptType!: bigint;
@@ -19,28 +41,34 @@ export class BigIntFieldType {
     public constructor(
         size: number,
         getter: DataViewBigInt64Getter,
-        setter: DataViewBigInt64Setter,
+        setter: DataViewBigInt64Setter
     ) {
         this.size = size;
         this.getter = getter;
         this.setter = setter;
     }
 
-    public static readonly Int64 = new BigIntFieldType(8, getBigInt64, setBigInt64);
+    public static readonly Int64 = new BigIntFieldType(
+        8,
+        getBigInt64,
+        setBigInt64
+    );
 
-    public static readonly Uint64 = new BigIntFieldType(8, getBigUint64, setBigUint64);
+    public static readonly Uint64 = new BigIntFieldType(
+        8,
+        getBigUint64,
+        setBigUint64
+    );
 }
 
 export class BigIntFieldDefinition<
     TType extends BigIntFieldType = BigIntFieldType,
-    TTypeScriptType = TType["TTypeScriptType"],
-    > extends StructFieldDefinition<
-    void,
-    TTypeScriptType
-    > {
+    TTypeScriptType = TType["TTypeScriptType"]
+> extends StructFieldDefinition<void, TTypeScriptType> {
     public readonly type: TType;
 
-    public constructor(type: TType, _typescriptType?: TTypeScriptType) {
+    public constructor(type: TType, typescriptType?: TTypeScriptType) {
+        void typescriptType;
         super();
         this.type = type;
     }
@@ -52,7 +80,7 @@ export class BigIntFieldDefinition<
     public create(
         options: Readonly<StructOptions>,
         struct: StructValue,
-        value: TTypeScriptType,
+        value: TTypeScriptType
     ): BigIntFieldValue<this> {
         return new BigIntFieldValue(this, options, struct, value);
     }
@@ -60,29 +88,28 @@ export class BigIntFieldDefinition<
     public override deserialize(
         options: Readonly<StructOptions>,
         stream: StructDeserializeStream,
-        struct: StructValue,
+        struct: StructValue
     ): BigIntFieldValue<this>;
     public override deserialize(
         options: Readonly<StructOptions>,
         stream: StructAsyncDeserializeStream,
-        struct: StructValue,
+        struct: StructValue
     ): Promise<BigIntFieldValue<this>>;
     public override deserialize(
         options: Readonly<StructOptions>,
         stream: StructDeserializeStream | StructAsyncDeserializeStream,
-        struct: StructValue,
+        struct: StructValue
     ): ValueOrPromise<BigIntFieldValue<this>> {
-        return SyncPromise
-            .try(() => {
-                return stream.read(this.getSize());
-            })
-            .then(array => {
-                const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
-                const value = this.type.getter(
-                    view,
-                    0,
-                    options.littleEndian
+        return SyncPromise.try(() => {
+            return stream.read(this.getSize());
+        })
+            .then((array) => {
+                const view = new DataView(
+                    array.buffer,
+                    array.byteOffset,
+                    array.byteLength
                 );
+                const value = this.type.getter(view, 0, options.littleEndian);
                 return this.create(options, struct, value as any);
             })
             .valueOrPromise();
@@ -90,13 +117,13 @@ export class BigIntFieldDefinition<
 }
 
 export class BigIntFieldValue<
-    TDefinition extends BigIntFieldDefinition<BigIntFieldType, any>,
-    > extends StructFieldValue<TDefinition> {
+    TDefinition extends BigIntFieldDefinition<BigIntFieldType, any>
+> extends StructFieldValue<TDefinition> {
     public serialize(dataView: DataView, offset: number): void {
         this.definition.type.setter(
             dataView,
             offset,
-            this.value!,
+            this.value,
             this.options.littleEndian
         );
     }

package/src/types/buffer/base.ts

@@ -1,4 +1,11 @@
-import { StructFieldDefinition, StructFieldValue, StructValue, type StructAsyncDeserializeStream, type StructDeserializeStream, type StructOptions } from '../../basic/index.js';
+import {
+    StructFieldDefinition,
+    StructFieldValue,
+    type StructAsyncDeserializeStream,
+    type StructDeserializeStream,
+    type StructOptions,
+    type StructValue,
+} from "../../basic/index.js";
 import { SyncPromise } from "../../sync-promise.js";
 import { decodeUtf8, encodeUtf8, type ValueOrPromise } from "../../utils.js";
 
@@ -11,7 +18,10 @@ import { decodeUtf8, encodeUtf8, type ValueOrPromise } from "../../utils.js";
  * @template TTypeScriptType Optional another type (should be compatible with `TType`)
  * specified by user when creating field definitions.
  */
-export abstract class BufferFieldSubType<TValue = unknown, TTypeScriptType = TValue> {
+export abstract class BufferFieldSubType<
+    TValue = unknown,
+    TTypeScriptType = TValue
+> {
     public readonly TTypeScriptType!: TTypeScriptType;
 
     /**
@@ -36,8 +46,9 @@ export abstract class BufferFieldSubType<TValue = unknown, TTypeScriptType = TVa
 }
 
 /** An `BufferFieldSubType` that's actually an `Uint8Array` */
-export class Uint8ArrayBufferFieldSubType<TTypeScriptType = Uint8Array>
-    extends BufferFieldSubType<Uint8Array, TTypeScriptType> {
+export class Uint8ArrayBufferFieldSubType<
+    TTypeScriptType = Uint8Array
+> extends BufferFieldSubType<Uint8Array, TTypeScriptType> {
     public static readonly Instance = new Uint8ArrayBufferFieldSubType();
 
     protected constructor() {
@@ -58,8 +69,9 @@ export class Uint8ArrayBufferFieldSubType<TTypeScriptType = Uint8Array>
 }
 
 /** An `BufferFieldSubType` that converts between `Uint8Array` and `string` */
-export class StringBufferFieldSubType<TTypeScriptType = string>
-    extends BufferFieldSubType<string, TTypeScriptType> {
+export class StringBufferFieldSubType<
+    TTypeScriptType = string
+> extends BufferFieldSubType<string, TTypeScriptType> {
     public static readonly Instance = new StringBufferFieldSubType();
 
     public toBuffer(value: string): Uint8Array {
@@ -81,15 +93,14 @@ export class StringBufferFieldSubType<TTypeScriptType = string>
 export const EMPTY_UINT8_ARRAY = new Uint8Array(0);
 
 export abstract class BufferLikeFieldDefinition<
-    TType extends BufferFieldSubType<any, any> = BufferFieldSubType<unknown, unknown>,
+    TType extends BufferFieldSubType<any, any> = BufferFieldSubType<
+        unknown,
+        unknown
+    >,
     TOptions = void,
     TOmitInitKey extends PropertyKey = never,
-    TTypeScriptType = TType["TTypeScriptType"],
-    > extends StructFieldDefinition<
-    TOptions,
-    TTypeScriptType,
-    TOmitInitKey
-    >{
+    TTypeScriptType = TType["TTypeScriptType"]
+> extends StructFieldDefinition<TOptions, TTypeScriptType, TOmitInitKey> {
     public readonly type: TType;
 
     public constructor(type: TType, options: TOptions) {
@@ -98,6 +109,7 @@ export abstract class BufferLikeFieldDefinition<
     }
 
     protected getDeserializeSize(struct: StructValue): number {
+        void struct;
         return this.getSize();
     }
 
@@ -107,8 +119,8 @@ export abstract class BufferLikeFieldDefinition<
     public create(
         options: Readonly<StructOptions>,
         struct: StructValue,
-        value: TType['TTypeScriptType'],
-        array?: Uint8Array,
+        value: TType["TTypeScriptType"],
+        array?: Uint8Array
     ): BufferLikeFieldValue<this> {
         return new BufferLikeFieldValue(this, options, struct, value, array);
     }
@@ -116,28 +128,27 @@ export abstract class BufferLikeFieldDefinition<
     public override deserialize(
         options: Readonly<StructOptions>,
         stream: StructDeserializeStream,
-        struct: StructValue,
+        struct: StructValue
     ): BufferLikeFieldValue<this>;
     public override deserialize(
         options: Readonly<StructOptions>,
         stream: StructAsyncDeserializeStream,
-        struct: StructValue,
+        struct: StructValue
     ): Promise<BufferLikeFieldValue<this>>;
     public override deserialize(
         options: Readonly<StructOptions>,
         stream: StructDeserializeStream | StructAsyncDeserializeStream,
-        struct: StructValue,
+        struct: StructValue
     ): ValueOrPromise<BufferLikeFieldValue<this>> {
-        return SyncPromise
-            .try(() => {
-                const size = this.getDeserializeSize(struct);
-                if (size === 0) {
-                    return EMPTY_UINT8_ARRAY;
-                } else {
-                    return stream.read(size);
-                }
-            })
-            .then(array => {
+        return SyncPromise.try(() => {
+            const size = this.getDeserializeSize(struct);
+            if (size === 0) {
+                return EMPTY_UINT8_ARRAY;
+            } else {
+                return stream.read(size);
+            }
+        })
+            .then((array) => {
                 const value = this.type.toValue(array);
                 return this.create(options, struct, value, array);
             })
@@ -146,22 +157,26 @@ export abstract class BufferLikeFieldDefinition<
 }
 
 export class BufferLikeFieldValue<
-    TDefinition extends BufferLikeFieldDefinition<BufferFieldSubType<unknown, unknown>, any, any>,
-    > extends StructFieldValue<TDefinition> {
+    TDefinition extends BufferLikeFieldDefinition<
+        BufferFieldSubType<unknown, unknown>,
+        any,
+        any
+    >
+> extends StructFieldValue<TDefinition> {
     protected array: Uint8Array | undefined;
 
     public constructor(
         definition: TDefinition,
         options: Readonly<StructOptions>,
         struct: StructValue,
-        value: TDefinition['TValue'],
-        array?: Uint8Array,
+        value: TDefinition["TValue"],
+        array?: Uint8Array
     ) {
         super(definition, options, struct, value);
         this.array = array;
     }
 
-    public override set(value: TDefinition['TValue']): void {
+    public override set(value: TDefinition["TValue"]): void {
         super.set(value);
         // When value changes, clear the cached `array`
         // It will be lazily calculated in `serialize()`
@@ -173,7 +188,10 @@ export class BufferLikeFieldValue<
             this.array = this.definition.type.toBuffer(this.value);
         }
 
-        new Uint8Array(dataView.buffer, dataView.byteOffset, dataView.byteLength)
-            .set(this.array, offset);
+        new Uint8Array(
+            dataView.buffer,
+            dataView.byteOffset,
+            dataView.byteLength
+        ).set(this.array, offset);
     }
 }

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

@@ -7,14 +7,9 @@ export interface FixedLengthBufferLikeFieldOptions {
 export class FixedLengthBufferLikeFieldDefinition<
     TType extends BufferFieldSubType = BufferFieldSubType,
     TOptions extends FixedLengthBufferLikeFieldOptions = FixedLengthBufferLikeFieldOptions,
-    TTypeScriptType = TType["TTypeScriptType"],
-    > extends BufferLikeFieldDefinition<
-    TType,
-    TOptions,
-    never,
-    TTypeScriptType
-    > {
+    TTypeScriptType = TType["TTypeScriptType"]
+> extends BufferLikeFieldDefinition<TType, TOptions, never, TTypeScriptType> {
     public getSize(): number {
         return this.options.length;
     }
-};
+}

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

@@ -1,13 +1,23 @@
-import { StructFieldValue, type StructFieldDefinition, type StructOptions, type StructValue } from '../../basic/index.js';
-import type { KeysOfType } from '../../utils.js';
-import { BufferLikeFieldDefinition, BufferLikeFieldValue, type BufferFieldSubType } from './base.js';
+import {
+    StructFieldValue,
+    type StructFieldDefinition,
+    type StructOptions,
+    type StructValue,
+} from "../../basic/index.js";
+import { type KeysOfType } from "../../utils.js";
+
+import {
+    BufferLikeFieldDefinition,
+    BufferLikeFieldValue,
+    type BufferFieldSubType,
+} from "./base.js";
 
 export type LengthField<TFields> = KeysOfType<TFields, number | string>;
 
 export interface VariableLengthBufferLikeFieldOptions<
     TFields = object,
-    TLengthField extends LengthField<TFields> = any,
-    > {
+    TLengthField extends LengthField<TFields> = any
+> {
     /**
      * The name of the field that contains the length of the buffer.
      *
@@ -27,20 +37,20 @@ export interface VariableLengthBufferLikeFieldOptions<
 export class VariableLengthBufferLikeFieldDefinition<
     TType extends BufferFieldSubType = BufferFieldSubType,
     TOptions extends VariableLengthBufferLikeFieldOptions = VariableLengthBufferLikeFieldOptions,
-    TTypeScriptType = TType["TTypeScriptType"],
-    > extends BufferLikeFieldDefinition<
+    TTypeScriptType = TType["TTypeScriptType"]
+> extends BufferLikeFieldDefinition<
     TType,
     TOptions,
-    TOptions['lengthField'],
+    TOptions["lengthField"],
     TTypeScriptType
-    > {
+> {
     public getSize(): number {
         return 0;
     }
 
     protected override getDeserializeSize(struct: StructValue) {
         let value = struct.value[this.options.lengthField] as number | string;
-        if (typeof value === 'string') {
+        if (typeof value === "string") {
             value = Number.parseInt(value, this.options.lengthFieldRadix ?? 10);
         }
         return value;
@@ -57,14 +67,14 @@ export class VariableLengthBufferLikeFieldDefinition<
             options,
             struct,
             value,
-            array,
+            array
         );
     }
 }
 
 export class VariableLengthBufferLikeStructFieldValue<
-    TDefinition extends VariableLengthBufferLikeFieldDefinition = VariableLengthBufferLikeFieldDefinition,
-    > extends BufferLikeFieldValue<TDefinition> {
+    TDefinition extends VariableLengthBufferLikeFieldDefinition = VariableLengthBufferLikeFieldDefinition
+> extends BufferLikeFieldValue<TDefinition> {
     protected length: number | undefined;
 
     protected lengthFieldValue: VariableLengthBufferLikeFieldLengthValue;
@@ -73,8 +83,8 @@ export class VariableLengthBufferLikeStructFieldValue<
         definition: TDefinition,
         options: Readonly<StructOptions>,
         struct: StructValue,
-        value: TDefinition['TValue'],
-        array?: Uint8Array,
+        value: TDefinition["TValue"],
+        array?: Uint8Array
     ) {
         super(definition, options, struct, value, array);
 
@@ -88,7 +98,7 @@ export class VariableLengthBufferLikeStructFieldValue<
         const originalValue = struct.get(lengthField);
         this.lengthFieldValue = new VariableLengthBufferLikeFieldLengthValue(
             originalValue,
-            this,
+            this
         );
         struct.set(lengthField, this.lengthFieldValue);
     }
@@ -113,20 +123,25 @@ export class VariableLengthBufferLikeStructFieldValue<
 }
 
 // Not using `VariableLengthBufferLikeStructFieldValue` directly makes writing tests much easier...
-type VariableLengthBufferLikeFieldValueLike =
-    StructFieldValue<StructFieldDefinition<VariableLengthBufferLikeFieldOptions, any, any>>;
+type VariableLengthBufferLikeFieldValueLike = StructFieldValue<
+    StructFieldDefinition<VariableLengthBufferLikeFieldOptions, any, any>
+>;
 
-export class VariableLengthBufferLikeFieldLengthValue
-    extends StructFieldValue {
+export class VariableLengthBufferLikeFieldLengthValue extends StructFieldValue {
     protected originalField: StructFieldValue;
 
     protected bufferField: VariableLengthBufferLikeFieldValueLike;
 
     public constructor(
         originalField: StructFieldValue,
-        arrayBufferField: VariableLengthBufferLikeFieldValueLike,
+        arrayBufferField: VariableLengthBufferLikeFieldValueLike
     ) {
-        super(originalField.definition, originalField.options, originalField.struct, 0);
+        super(
+            originalField.definition,
+            originalField.options,
+            originalField.struct,
+            0
+        );
         this.originalField = originalField;
         this.bufferField = arrayBufferField;
     }
@@ -139,8 +154,10 @@ export class VariableLengthBufferLikeFieldLengthValue
         let value: string | number = this.bufferField.getSize();
 
         const originalValue = this.originalField.get();
-        if (typeof originalValue === 'string') {
-            value = value.toString(this.bufferField.definition.options.lengthFieldRadix ?? 10);
+        if (typeof originalValue === "string") {
+            value = value.toString(
+                this.bufferField.definition.options.lengthFieldRadix ?? 10
+            );
         }
 
         return value;