@yume-chan/struct 0.0.19 → 0.0.21

package/src/sync-promise.ts

@@ -7,7 +7,7 @@ export interface SyncPromise<T> {
         onrejected?:
             | ((reason: any) => TResult2 | PromiseLike<TResult2>)
             | null
-            | undefined
+            | undefined,
     ): SyncPromise<TResult1 | TResult2>;
 
     valueOrPromise(): T | PromiseLike<T>;
@@ -55,13 +55,13 @@ export const SyncPromise: SyncPromiseStatic = {
 };
 
 class PendingSyncPromise<T> implements SyncPromise<T> {
-    private promise: PromiseLike<T>;
+    #promise: PromiseLike<T>;
 
-    public constructor(promise: PromiseLike<T>) {
-        this.promise = promise;
+    constructor(promise: PromiseLike<T>) {
+        this.#promise = promise;
     }
 
-    public then<TResult1 = T, TResult2 = never>(
+    then<TResult1 = T, TResult2 = never>(
         onfulfilled?:
             | ((value: T) => TResult1 | PromiseLike<TResult1>)
             | null
@@ -69,50 +69,50 @@ class PendingSyncPromise<T> implements SyncPromise<T> {
         onrejected?:
             | ((reason: any) => TResult2 | PromiseLike<TResult2>)
             | null
-            | undefined
+            | undefined,
     ) {
         return new PendingSyncPromise<TResult1 | TResult2>(
-            this.promise.then(onfulfilled, onrejected)
+            this.#promise.then(onfulfilled, onrejected),
         );
     }
 
-    public valueOrPromise(): T | PromiseLike<T> {
-        return this.promise;
+    valueOrPromise(): T | PromiseLike<T> {
+        return this.#promise;
     }
 }
 
 class ResolvedSyncPromise<T> implements SyncPromise<T> {
-    private value: T;
+    #value: T;
 
-    public constructor(value: T) {
-        this.value = value;
+    constructor(value: T) {
+        this.#value = value;
     }
 
-    public then<TResult1 = T>(
+    then<TResult1 = T>(
         onfulfilled?:
             | ((value: T) => TResult1 | PromiseLike<TResult1>)
             | null
-            | undefined
+            | undefined,
     ) {
         if (!onfulfilled) {
             return this as any;
         }
-        return SyncPromise.try(() => onfulfilled(this.value));
+        return SyncPromise.try(() => onfulfilled(this.#value));
     }
 
-    public valueOrPromise(): T | PromiseLike<T> {
-        return this.value;
+    valueOrPromise(): T | PromiseLike<T> {
+        return this.#value;
     }
 }
 
 class RejectedSyncPromise<T> implements SyncPromise<T> {
-    private reason: any;
+    #reason: any;
 
-    public constructor(reason: any) {
-        this.reason = reason;
+    constructor(reason: any) {
+        this.#reason = reason;
     }
 
-    public then<TResult1 = T, TResult2 = never>(
+    then<TResult1 = T, TResult2 = never>(
         onfulfilled?:
             | ((value: T) => TResult1 | PromiseLike<TResult1>)
             | null
@@ -120,15 +120,15 @@ class RejectedSyncPromise<T> implements SyncPromise<T> {
         onrejected?:
             | ((reason: any) => TResult2 | PromiseLike<TResult2>)
             | null
-            | undefined
+            | undefined,
     ) {
         if (!onrejected) {
             return this as any;
         }
-        return SyncPromise.try(() => onrejected(this.reason));
+        return SyncPromise.try(() => onrejected(this.#reason));
     }
 
-    public valueOrPromise(): T | PromiseLike<T> {
-        throw this.reason;
+    valueOrPromise(): T | PromiseLike<T> {
+        throw this.#reason;
     }
 }

package/src/types/bigint.ts

@@ -6,8 +6,8 @@ import {
 } from "@yume-chan/dataview-bigint-polyfill/esm/fallback.js";
 
 import type {
-    StructAsyncDeserializeStream,
-    StructDeserializeStream,
+    AsyncExactReadable,
+    ExactReadable,
     StructOptions,
     StructValue,
 } from "../basic/index.js";
@@ -18,95 +18,87 @@ import type { ValueOrPromise } from "../utils.js";
 type DataViewBigInt64Getter = (
     dataView: DataView,
     byteOffset: number,
-    littleEndian: boolean | undefined
+    littleEndian: boolean | undefined,
 ) => bigint;
 
 type DataViewBigInt64Setter = (
     dataView: DataView,
     byteOffset: number,
     value: bigint,
-    littleEndian: boolean | undefined
+    littleEndian: boolean | undefined,
 ) => void;
 
 export class BigIntFieldType {
-    public readonly TTypeScriptType!: bigint;
+    readonly TTypeScriptType!: bigint;
 
-    public readonly size: number;
+    readonly size: number;
 
-    public readonly getter: DataViewBigInt64Getter;
+    readonly getter: DataViewBigInt64Getter;
 
-    public readonly setter: DataViewBigInt64Setter;
+    readonly setter: DataViewBigInt64Setter;
 
-    public constructor(
+    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 Uint64 = new BigIntFieldType(
-        8,
-        getBigUint64,
-        setBigUint64
-    );
+    static readonly Int64 = new BigIntFieldType(8, getBigInt64, setBigInt64);
+
+    static readonly Uint64 = new BigIntFieldType(8, getBigUint64, setBigUint64);
 }
 
 export class BigIntFieldDefinition<
     TType extends BigIntFieldType = BigIntFieldType,
-    TTypeScriptType = TType["TTypeScriptType"]
+    TTypeScriptType = TType["TTypeScriptType"],
 > extends StructFieldDefinition<void, TTypeScriptType> {
-    public readonly type: TType;
+    readonly type: TType;
 
-    public constructor(type: TType, typescriptType?: TTypeScriptType) {
+    constructor(type: TType, typescriptType?: TTypeScriptType) {
         void typescriptType;
         super();
         this.type = type;
     }
 
-    public getSize(): number {
+    getSize(): number {
         return this.type.size;
     }
 
-    public create(
+    create(
         options: Readonly<StructOptions>,
         struct: StructValue,
-        value: TTypeScriptType
+        value: TTypeScriptType,
     ): BigIntFieldValue<this> {
         return new BigIntFieldValue(this, options, struct, value);
     }
 
-    public override deserialize(
+    override deserialize(
         options: Readonly<StructOptions>,
-        stream: StructDeserializeStream,
-        struct: StructValue
+        stream: ExactReadable,
+        struct: StructValue,
     ): BigIntFieldValue<this>;
-    public override deserialize(
+    override deserialize(
         options: Readonly<StructOptions>,
-        stream: StructAsyncDeserializeStream,
-        struct: StructValue
+        stream: AsyncExactReadable,
+        struct: StructValue,
     ): Promise<BigIntFieldValue<this>>;
-    public override deserialize(
+    override deserialize(
         options: Readonly<StructOptions>,
-        stream: StructDeserializeStream | StructAsyncDeserializeStream,
-        struct: StructValue
+        stream: ExactReadable | AsyncExactReadable,
+        struct: StructValue,
     ): ValueOrPromise<BigIntFieldValue<this>> {
         return SyncPromise.try(() => {
-            return stream.read(this.getSize());
+            return stream.readExactly(this.getSize());
         })
             .then((array) => {
                 const view = new DataView(
                     array.buffer,
                     array.byteOffset,
-                    array.byteLength
+                    array.byteLength,
                 );
                 const value = this.type.getter(view, 0, options.littleEndian);
                 return this.create(options, struct, value as any);
@@ -116,14 +108,14 @@ export class BigIntFieldDefinition<
 }
 
 export class BigIntFieldValue<
-    TDefinition extends BigIntFieldDefinition<BigIntFieldType, any>
+    TDefinition extends BigIntFieldDefinition<BigIntFieldType, any>,
 > extends StructFieldValue<TDefinition> {
-    public serialize(dataView: DataView, offset: number): void {
+    serialize(dataView: DataView, offset: number): void {
         this.definition.type.setter(
             dataView,
             offset,
             this.value,
-            this.options.littleEndian
+            this.options.littleEndian,
         );
     }
 }

package/src/types/buffer/base.ts

@@ -1,6 +1,6 @@
 import type {
-    StructAsyncDeserializeStream,
-    StructDeserializeStream,
+    AsyncExactReadable,
+    ExactReadable,
     StructOptions,
     StructValue,
 } from "../../basic/index.js";
@@ -20,9 +20,9 @@ import { decodeUtf8, encodeUtf8 } from "../../utils.js";
  */
 export abstract class BufferFieldSubType<
     TValue = unknown,
-    TTypeScriptType = TValue
+    TTypeScriptType = TValue,
 > {
-    public readonly TTypeScriptType!: TTypeScriptType;
+    readonly TTypeScriptType!: TTypeScriptType;
 
     /**
      * When implemented in derived classes, converts the type-specific `value` to an `Uint8Array`
@@ -30,10 +30,10 @@ export abstract class BufferFieldSubType<
      * This function should be "pure", i.e.,
      * same `value` should always be converted to `Uint8Array`s that have same content.
      */
-    public abstract toBuffer(value: TValue): Uint8Array;
+    abstract toBuffer(value: TValue): Uint8Array;
 
     /** When implemented in derived classes, converts the `Uint8Array` to a type-specific value */
-    public abstract toValue(array: Uint8Array): TValue;
+    abstract toValue(array: Uint8Array): TValue;
 
     /**
      * When implemented in derived classes, gets the size in byte of the type-specific `value`.
@@ -42,47 +42,47 @@ export abstract class BufferFieldSubType<
      * implementer can returns `-1`, so the caller will get its size by first converting it to
      * an `Uint8Array` (and cache the result).
      */
-    public abstract getSize(value: TValue): number;
+    abstract getSize(value: TValue): number;
 }
 
 /** An `BufferFieldSubType` that's actually an `Uint8Array` */
 export class Uint8ArrayBufferFieldSubType<
-    TTypeScriptType = Uint8Array
+    TTypeScriptType = Uint8Array,
 > extends BufferFieldSubType<Uint8Array, TTypeScriptType> {
-    public static readonly Instance = new Uint8ArrayBufferFieldSubType();
+    static readonly Instance = new Uint8ArrayBufferFieldSubType();
 
     protected constructor() {
         super();
     }
 
-    public toBuffer(value: Uint8Array): Uint8Array {
+    toBuffer(value: Uint8Array): Uint8Array {
         return value;
     }
 
-    public toValue(buffer: Uint8Array): Uint8Array {
+    toValue(buffer: Uint8Array): Uint8Array {
         return buffer;
     }
 
-    public getSize(value: Uint8Array): number {
+    getSize(value: Uint8Array): number {
         return value.byteLength;
     }
 }
 
 /** An `BufferFieldSubType` that converts between `Uint8Array` and `string` */
 export class StringBufferFieldSubType<
-    TTypeScriptType = string
+    TTypeScriptType = string,
 > extends BufferFieldSubType<string, TTypeScriptType> {
-    public static readonly Instance = new StringBufferFieldSubType();
+    static readonly Instance = new StringBufferFieldSubType();
 
-    public toBuffer(value: string): Uint8Array {
+    toBuffer(value: string): Uint8Array {
         return encodeUtf8(value);
     }
 
-    public toValue(array: Uint8Array): string {
+    toValue(array: Uint8Array): string {
         return decodeUtf8(array);
     }
 
-    public getSize(): number {
+    getSize(): number {
         // Return `-1`, so `BufferLikeFieldDefinition` will
         // convert this `value` into an `Uint8Array` (and cache the result),
         // Then get the size from that `Uint8Array`
@@ -99,11 +99,11 @@ export abstract class BufferLikeFieldDefinition<
     >,
     TOptions = void,
     TOmitInitKey extends PropertyKey = never,
-    TTypeScriptType = TType["TTypeScriptType"]
+    TTypeScriptType = TType["TTypeScriptType"],
 > extends StructFieldDefinition<TOptions, TTypeScriptType, TOmitInitKey> {
-    public readonly type: TType;
+    readonly type: TType;
 
-    public constructor(type: TType, options: TOptions) {
+    constructor(type: TType, options: TOptions) {
         super(options);
         this.type = type;
     }
@@ -116,36 +116,36 @@ export abstract class BufferLikeFieldDefinition<
     /**
      * When implemented in derived classes, creates a `StructFieldValue` for the current field definition.
      */
-    public create(
+    create(
         options: Readonly<StructOptions>,
         struct: StructValue,
         value: TType["TTypeScriptType"],
-        array?: Uint8Array
+        array?: Uint8Array,
     ): BufferLikeFieldValue<this> {
         return new BufferLikeFieldValue(this, options, struct, value, array);
     }
 
-    public override deserialize(
+    override deserialize(
         options: Readonly<StructOptions>,
-        stream: StructDeserializeStream,
-        struct: StructValue
+        stream: ExactReadable,
+        struct: StructValue,
     ): BufferLikeFieldValue<this>;
-    public override deserialize(
+    override deserialize(
         options: Readonly<StructOptions>,
-        stream: StructAsyncDeserializeStream,
-        struct: StructValue
+        stream: AsyncExactReadable,
+        struct: StructValue,
     ): Promise<BufferLikeFieldValue<this>>;
-    public override deserialize(
+    override deserialize(
         options: Readonly<StructOptions>,
-        stream: StructDeserializeStream | StructAsyncDeserializeStream,
-        struct: StructValue
+        stream: ExactReadable | AsyncExactReadable,
+        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);
+                return stream.readExactly(size);
             }
         })
             .then((array) => {
@@ -161,29 +161,29 @@ export class BufferLikeFieldValue<
         BufferFieldSubType<unknown, unknown>,
         any,
         any
-    >
+    >,
 > extends StructFieldValue<TDefinition> {
     protected array: Uint8Array | undefined;
 
-    public constructor(
+    constructor(
         definition: TDefinition,
         options: Readonly<StructOptions>,
         struct: StructValue,
         value: TDefinition["TValue"],
-        array?: Uint8Array
+        array?: Uint8Array,
     ) {
         super(definition, options, struct, value);
         this.array = array;
     }
 
-    public override set(value: TDefinition["TValue"]): void {
+    override set(value: TDefinition["TValue"]): void {
         super.set(value);
         // When value changes, clear the cached `array`
         // It will be lazily calculated in `serialize()`
         this.array = undefined;
     }
 
-    public serialize(dataView: DataView, offset: number): void {
+    serialize(dataView: DataView, offset: number): void {
         if (!this.array) {
             this.array = this.definition.type.toBuffer(this.value);
         }
@@ -191,7 +191,7 @@ export class BufferLikeFieldValue<
         new Uint8Array(
             dataView.buffer,
             dataView.byteOffset,
-            dataView.byteLength
+            dataView.byteLength,
         ).set(this.array, offset);
     }
 }

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

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

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

@@ -13,7 +13,7 @@ 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.
@@ -33,15 +33,16 @@ export interface VariableLengthBufferLikeFieldOptions<
 
 export class VariableLengthBufferLikeFieldDefinition<
     TType extends BufferFieldSubType = BufferFieldSubType,
-    TOptions extends VariableLengthBufferLikeFieldOptions = VariableLengthBufferLikeFieldOptions,
-    TTypeScriptType = TType["TTypeScriptType"]
+    TOptions extends
+        VariableLengthBufferLikeFieldOptions = VariableLengthBufferLikeFieldOptions,
+    TTypeScriptType = TType["TTypeScriptType"],
 > extends BufferLikeFieldDefinition<
     TType,
     TOptions,
     TOptions["lengthField"],
     TTypeScriptType
 > {
-    public getSize(): number {
+    getSize(): number {
         return 0;
     }
 
@@ -53,35 +54,36 @@ export class VariableLengthBufferLikeFieldDefinition<
         return value;
     }
 
-    public override create(
+    override create(
         options: Readonly<StructOptions>,
         struct: StructValue,
         value: TTypeScriptType,
-        array?: Uint8Array
+        array?: Uint8Array,
     ): VariableLengthBufferLikeStructFieldValue<this> {
         return new VariableLengthBufferLikeStructFieldValue(
             this,
             options,
             struct,
             value,
-            array
+            array,
         );
     }
 }
 
 export class VariableLengthBufferLikeStructFieldValue<
-    TDefinition extends VariableLengthBufferLikeFieldDefinition = VariableLengthBufferLikeFieldDefinition
+    TDefinition extends
+        VariableLengthBufferLikeFieldDefinition = VariableLengthBufferLikeFieldDefinition,
 > extends BufferLikeFieldValue<TDefinition> {
     protected length: number | undefined;
 
     protected lengthFieldValue: VariableLengthBufferLikeFieldLengthValue;
 
-    public constructor(
+    constructor(
         definition: TDefinition,
         options: Readonly<StructOptions>,
         struct: StructValue,
         value: TDefinition["TValue"],
-        array?: Uint8Array
+        array?: Uint8Array,
     ) {
         super(definition, options, struct, value, array);
 
@@ -95,12 +97,12 @@ export class VariableLengthBufferLikeStructFieldValue<
         const originalValue = struct.get(lengthField);
         this.lengthFieldValue = new VariableLengthBufferLikeFieldLengthValue(
             originalValue,
-            this
+            this,
         );
         struct.set(lengthField, this.lengthFieldValue);
     }
 
-    public override getSize() {
+    override getSize() {
         if (this.length === undefined) {
             this.length = this.definition.type.getSize(this.value);
             if (this.length === -1) {
@@ -112,7 +114,7 @@ export class VariableLengthBufferLikeStructFieldValue<
         return this.length;
     }
 
-    public override set(value: unknown) {
+    override set(value: unknown) {
         super.set(value);
         this.array = undefined;
         this.length = undefined;
@@ -129,38 +131,38 @@ export class VariableLengthBufferLikeFieldLengthValue extends StructFieldValue {
 
     protected bufferField: VariableLengthBufferLikeFieldValueLike;
 
-    public constructor(
+    constructor(
         originalField: StructFieldValue,
-        arrayBufferField: VariableLengthBufferLikeFieldValueLike
+        arrayBufferField: VariableLengthBufferLikeFieldValueLike,
     ) {
         super(
             originalField.definition,
             originalField.options,
             originalField.struct,
-            0
+            0,
         );
         this.originalField = originalField;
         this.bufferField = arrayBufferField;
     }
 
-    public override getSize() {
+    override getSize() {
         return this.originalField.getSize();
     }
 
-    public override get() {
+    override get() {
         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
+                this.bufferField.definition.options.lengthFieldRadix ?? 10,
             );
         }
 
         return value;
     }
 
-    public override set() {
+    override set() {
         // Ignore setting
         // It will always be in sync with the buffer size
     }