@yume-chan/struct 0.0.13 → 0.0.16

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

@@ -1,156 +1,158 @@
-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,
-    > {
-    /**
-     * The name of the field that contains the length of the buffer.
-     *
-     * This field must be a `number` or `string` (can't be `bigint`) field.
-     */
-    lengthField: TLengthField;
-
-    /**
-     * If the `lengthField` refers to a string field,
-     * what radix to use when converting the string to a number.
-     *
-     * @default 10
-     */
-    lengthFieldRadix?: number;
-}
-
-export class VariableLengthBufferLikeFieldDefinition<
-    TType extends BufferFieldSubType = BufferFieldSubType,
-    TOptions extends VariableLengthBufferLikeFieldOptions = VariableLengthBufferLikeFieldOptions
-    > extends BufferLikeFieldDefinition<
-    TType,
-    TOptions,
-    TOptions['lengthField']
-    > {
-    public getSize(): number {
-        return 0;
-    }
-
-    protected override getDeserializeSize(struct: StructValue) {
-        let value = struct.value[this.options.lengthField] as number | string;
-        if (typeof value === 'string') {
-            value = Number.parseInt(value, this.options.lengthFieldRadix ?? 10);
-        }
-        return value;
-    }
-
-    public override create(
-        options: Readonly<StructOptions>,
-        struct: StructValue,
-        value: TType['TTypeScriptType'],
-        array?: Uint8Array
-    ): VariableLengthBufferLikeStructFieldValue<this> {
-        return new VariableLengthBufferLikeStructFieldValue(
-            this,
-            options,
-            struct,
-            value,
-            array,
-        );
-    }
-}
-
-export class VariableLengthBufferLikeStructFieldValue<
-    TDefinition extends VariableLengthBufferLikeFieldDefinition = VariableLengthBufferLikeFieldDefinition,
-    > extends BufferLikeFieldValue<TDefinition> {
-    protected length: number | undefined;
-
-    protected lengthFieldValue: VariableLengthBufferLikeFieldLengthValue;
-
-    public constructor(
-        definition: TDefinition,
-        options: Readonly<StructOptions>,
-        struct: StructValue,
-        value: TDefinition['TValue'],
-        array?: Uint8Array,
-    ) {
-        super(definition, options, struct, value, array);
-
-        if (array) {
-            this.length = array.byteLength;
-        }
-
-        // Patch the associated length field.
-        const lengthField = this.definition.options.lengthField;
-
-        const originalValue = struct.get(lengthField);
-        this.lengthFieldValue = new VariableLengthBufferLikeFieldLengthValue(
-            originalValue,
-            this,
-        );
-        struct.set(lengthField, this.lengthFieldValue);
-    }
-
-    public override getSize() {
-        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;
-            }
-        }
-
-        return this.length;
-    }
-
-    public override set(value: unknown) {
-        super.set(value);
-        this.array = undefined;
-        this.length = undefined;
-    }
-}
-
-// Not using `VariableLengthBufferLikeStructFieldValue` directly makes writing tests much easier...
-type VariableLengthBufferLikeFieldValueLike =
-    StructFieldValue<StructFieldDefinition<VariableLengthBufferLikeFieldOptions, any, any>>;
-
-export class VariableLengthBufferLikeFieldLengthValue
-    extends StructFieldValue {
-    protected originalField: StructFieldValue;
-
-    protected bufferField: VariableLengthBufferLikeFieldValueLike;
-
-    public constructor(
-        originalField: StructFieldValue,
-        arrayBufferField: VariableLengthBufferLikeFieldValueLike,
-    ) {
-        super(originalField.definition, originalField.options, originalField.struct, 0);
-        this.originalField = originalField;
-        this.bufferField = arrayBufferField;
-    }
-
-    public override getSize() {
-        return this.originalField.getSize();
-    }
-
-    public 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);
-        }
-
-        return value;
-    }
-
-    public override set() {
-        // Ignore setting
-        // 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);
-    }
-}
+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,
+    > {
+    /**
+     * The name of the field that contains the length of the buffer.
+     *
+     * This field must be a `number` or `string` (can't be `bigint`) field.
+     */
+    lengthField: TLengthField;
+
+    /**
+     * If the `lengthField` refers to a string field,
+     * what radix to use when converting the string to a number.
+     *
+     * @default 10
+     */
+    lengthFieldRadix?: number;
+}
+
+export class VariableLengthBufferLikeFieldDefinition<
+    TType extends BufferFieldSubType = BufferFieldSubType,
+    TOptions extends VariableLengthBufferLikeFieldOptions = VariableLengthBufferLikeFieldOptions,
+    TTypeScriptType = TType["TTypeScriptType"],
+    > extends BufferLikeFieldDefinition<
+    TType,
+    TOptions,
+    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') {
+            value = Number.parseInt(value, this.options.lengthFieldRadix ?? 10);
+        }
+        return value;
+    }
+
+    public override create(
+        options: Readonly<StructOptions>,
+        struct: StructValue,
+        value: TTypeScriptType,
+        array?: Uint8Array
+    ): VariableLengthBufferLikeStructFieldValue<this> {
+        return new VariableLengthBufferLikeStructFieldValue(
+            this,
+            options,
+            struct,
+            value,
+            array,
+        );
+    }
+}
+
+export class VariableLengthBufferLikeStructFieldValue<
+    TDefinition extends VariableLengthBufferLikeFieldDefinition = VariableLengthBufferLikeFieldDefinition,
+    > extends BufferLikeFieldValue<TDefinition> {
+    protected length: number | undefined;
+
+    protected lengthFieldValue: VariableLengthBufferLikeFieldLengthValue;
+
+    public constructor(
+        definition: TDefinition,
+        options: Readonly<StructOptions>,
+        struct: StructValue,
+        value: TDefinition['TValue'],
+        array?: Uint8Array,
+    ) {
+        super(definition, options, struct, value, array);
+
+        if (array) {
+            this.length = array.byteLength;
+        }
+
+        // Patch the associated length field.
+        const lengthField = this.definition.options.lengthField;
+
+        const originalValue = struct.get(lengthField);
+        this.lengthFieldValue = new VariableLengthBufferLikeFieldLengthValue(
+            originalValue,
+            this,
+        );
+        struct.set(lengthField, this.lengthFieldValue);
+    }
+
+    public override getSize() {
+        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;
+            }
+        }
+
+        return this.length;
+    }
+
+    public override set(value: unknown) {
+        super.set(value);
+        this.array = undefined;
+        this.length = undefined;
+    }
+}
+
+// Not using `VariableLengthBufferLikeStructFieldValue` directly makes writing tests much easier...
+type VariableLengthBufferLikeFieldValueLike =
+    StructFieldValue<StructFieldDefinition<VariableLengthBufferLikeFieldOptions, any, any>>;
+
+export class VariableLengthBufferLikeFieldLengthValue
+    extends StructFieldValue {
+    protected originalField: StructFieldValue;
+
+    protected bufferField: VariableLengthBufferLikeFieldValueLike;
+
+    public constructor(
+        originalField: StructFieldValue,
+        arrayBufferField: VariableLengthBufferLikeFieldValueLike,
+    ) {
+        super(originalField.definition, originalField.options, originalField.struct, 0);
+        this.originalField = originalField;
+        this.bufferField = arrayBufferField;
+    }
+
+    public override getSize() {
+        return this.originalField.getSize();
+    }
+
+    public 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);
+        }
+
+        return value;
+    }
+
+    public override set() {
+        // Ignore setting
+        // 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);
+    }
+}

package/src/types/index.ts

@@ -1,3 +1,3 @@
-export * from "./bigint.js";
-export * from "./buffer/index.js";
-export * from "./number.js";
+export * from "./bigint.js";
+export * from "./buffer/index.js";
+export * from "./number.js";

package/src/types/number.ts

@@ -1,115 +1,127 @@
-// cspell: ignore syncbird
-
-import { StructFieldDefinition, StructFieldValue, StructValue, type StructAsyncDeserializeStream, type StructDeserializeStream, type StructOptions } from '../basic/index.js';
-import { Syncbird } from "../syncbird.js";
-import type { ValueOrPromise } from "../utils.js";
-
-export type DataViewGetters =
-    { [TKey in keyof DataView]: TKey extends `get${string}` ? TKey : never }[keyof DataView];
-
-export type DataViewSetters =
-    { [TKey in keyof DataView]: TKey extends `set${string}` ? TKey : never }[keyof DataView];
-
-export class NumberFieldType {
-    public readonly TTypeScriptType!: number;
-
-    public readonly size: number;
-
-    public readonly dataViewGetter: DataViewGetters;
-
-    public readonly dataViewSetter: DataViewSetters;
-
-    public constructor(
-        size: number,
-        dataViewGetter: DataViewGetters,
-        dataViewSetter: DataViewSetters
-    ) {
-        this.size = size;
-        this.dataViewGetter = dataViewGetter;
-        this.dataViewSetter = dataViewSetter;
-    }
-
-    public static readonly Int8 = new NumberFieldType(1, 'getInt8', 'setInt8');
-
-    public static readonly Uint8 = new NumberFieldType(1, 'getUint8', 'setUint8');
-
-    public static readonly Int16 = new NumberFieldType(2, 'getInt16', 'setInt16');
-
-    public static readonly Uint16 = new NumberFieldType(2, 'getUint16', 'setUint16');
-
-    public static readonly Int32 = new NumberFieldType(4, 'getInt32', 'setInt32');
-
-    public static readonly Uint32 = new NumberFieldType(4, 'getUint32', 'setUint32');
-}
-
-export class NumberFieldDefinition<
-    TType extends NumberFieldType = NumberFieldType,
-    TTypeScriptType = TType["TTypeScriptType"],
-    > extends StructFieldDefinition<
-    void,
-    TTypeScriptType
-    > {
-    public readonly type: TType;
-
-    public constructor(type: TType, _typescriptType?: TTypeScriptType) {
-        super();
-        this.type = type;
-    }
-
-    public getSize(): number {
-        return this.type.size;
-    }
-
-    public create(
-        options: Readonly<StructOptions>,
-        struct: StructValue,
-        value: TTypeScriptType,
-    ): NumberFieldValue<this> {
-        return new NumberFieldValue(this, options, struct, value);
-    }
-
-    public override deserialize(
-        options: Readonly<StructOptions>,
-        stream: StructDeserializeStream,
-        struct: StructValue,
-    ): NumberFieldValue<this>;
-    public override deserialize(
-        options: Readonly<StructOptions>,
-        stream: StructAsyncDeserializeStream,
-        struct: StructValue,
-    ): Promise<NumberFieldValue<this>>;
-    public override deserialize(
-        options: Readonly<StructOptions>,
-        stream: StructDeserializeStream | StructAsyncDeserializeStream,
-        struct: StructValue,
-    ): ValueOrPromise<NumberFieldValue<this>> {
-        return Syncbird
-            .try(() => {
-                return stream.read(this.getSize());
-            })
-            .then(array => {
-                const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
-                const value = view[this.type.dataViewGetter](
-                    0,
-                    options.littleEndian
-                );
-                return this.create(options, struct, value as any);
-            })
-            .valueOrPromise();
-    }
-}
-
-export class NumberFieldValue<
-    TDefinition extends NumberFieldDefinition<NumberFieldType, any>,
-    > extends StructFieldValue<TDefinition> {
-    public serialize(dataView: DataView, offset: number): void {
-        // `setBigInt64` requires a `bigint` while others require `number`
-        // So `dataView[DataViewSetters]` requires `bigint & number`
-        // and that is, `never`
-        (dataView[this.definition.type.dataViewSetter] as any)(
-            offset,
-            this.value!,
-            this.options.littleEndian
-        );
-    }
-}
+import { StructFieldDefinition, StructFieldValue, StructValue, type StructAsyncDeserializeStream, type StructDeserializeStream, type StructOptions } from '../basic/index.js';
+import { SyncPromise } from "../sync-promise.js";
+import type { ValueOrPromise } from "../utils.js";
+
+type NumberTypeDeserializer = (array: Uint8Array, littleEndian: boolean) => number;
+
+const DESERIALIZERS: Record<number, NumberTypeDeserializer> = {
+    1: (array, littleEndian) =>
+        array[0]!,
+    2: (array, littleEndian) =>
+        ((array[1]! << 8) | array[0]!) * (littleEndian as any) |
+        ((array[0]! << 8) | array[1]!) * (!littleEndian as any),
+    4: (array, littleEndian) =>
+        ((array[3]! << 24) | (array[2]! << 16) | (array[1]! << 8) | array[0]!) * (littleEndian as any) |
+        ((array[0]! << 24) | (array[1]! << 16) | (array[2]! << 8) | array[3]!) * (!littleEndian as any),
+};
+
+export type DataViewSetters =
+    { [TKey in keyof DataView]: TKey extends `set${string}` ? TKey : never }[keyof DataView];
+
+export class NumberFieldType {
+    public readonly TTypeScriptType!: number;
+
+    public readonly signed: boolean;
+
+    public readonly size: number;
+
+    public readonly deserializer: NumberTypeDeserializer;
+    public readonly convertSign: (value: number) => number;
+
+    public readonly dataViewSetter: DataViewSetters;
+
+    public constructor(
+        size: number,
+        signed: boolean,
+        convertSign: (value: number) => number,
+        dataViewSetter: DataViewSetters
+    ) {
+        this.size = size;
+        this.signed = signed;
+        this.deserializer = DESERIALIZERS[size]!;
+        this.convertSign = convertSign;
+        this.dataViewSetter = dataViewSetter;
+    }
+
+    public static readonly Int8 = new NumberFieldType(1, true, value => value << 24 >> 24, 'setInt8');
+
+    public static readonly Uint8 = new NumberFieldType(1, false, value => value, 'setUint8');
+
+    public static readonly Int16 = new NumberFieldType(2, true, value => value << 16 >> 16, 'setInt16');
+
+    public static readonly Uint16 = new NumberFieldType(2, false, value => value, 'setUint16');
+
+    public static readonly Int32 = new NumberFieldType(4, true, value => value, 'setInt32');
+
+    public static readonly Uint32 = new NumberFieldType(4, false, value => value >>> 0, 'setUint32');
+}
+
+export class NumberFieldDefinition<
+    TType extends NumberFieldType = NumberFieldType,
+    TTypeScriptType = TType["TTypeScriptType"],
+    > extends StructFieldDefinition<
+    void,
+    TTypeScriptType
+    > {
+    public readonly type: TType;
+
+    public constructor(type: TType, _typescriptType?: TTypeScriptType) {
+        super();
+        this.type = type;
+    }
+
+    public getSize(): number {
+        return this.type.size;
+    }
+
+    public create(
+        options: Readonly<StructOptions>,
+        struct: StructValue,
+        value: TTypeScriptType,
+    ): NumberFieldValue<this> {
+        return new NumberFieldValue(this, options, struct, value);
+    }
+
+    public override deserialize(
+        options: Readonly<StructOptions>,
+        stream: StructDeserializeStream,
+        struct: StructValue,
+    ): NumberFieldValue<this>;
+    public override deserialize(
+        options: Readonly<StructOptions>,
+        stream: StructAsyncDeserializeStream,
+        struct: StructValue,
+    ): Promise<NumberFieldValue<this>>;
+    public override deserialize(
+        options: Readonly<StructOptions>,
+        stream: StructDeserializeStream | StructAsyncDeserializeStream,
+        struct: StructValue,
+    ): ValueOrPromise<NumberFieldValue<this>> {
+        return SyncPromise
+            .try(() => {
+                return stream.read(this.getSize());
+            })
+            .then(array => {
+                let value: number;
+                value = this.type.deserializer(array, options.littleEndian);
+                value = this.type.convertSign(value);
+                return this.create(options, struct, value as any);
+            })
+            .valueOrPromise();
+    }
+}
+
+export class NumberFieldValue<
+    TDefinition extends NumberFieldDefinition<NumberFieldType, any>,
+    > extends StructFieldValue<TDefinition> {
+    public serialize(dataView: DataView, offset: number): void {
+        // `setBigInt64` requires a `bigint` while others require `number`
+        // So `dataView[DataViewSetters]` requires `bigint & number`
+        // and that is, `never`
+        (dataView[this.definition.type.dataViewSetter] as any)(
+            offset,
+            this.value!,
+            this.options.littleEndian
+        );
+    }
+}