@yume-chan/struct 0.0.24 → 2.0.0

package/src/types/bigint.ts

@@ -1,124 +0,0 @@
-import {
-    getInt64,
-    getUint64,
-    setInt64,
-    setUint64,
-} from "@yume-chan/no-data-view";
-
-import type {
-    AsyncExactReadable,
-    ExactReadable,
-    StructOptions,
-    StructValue,
-} from "../basic/index.js";
-import { StructFieldDefinition, StructFieldValue } from "../basic/index.js";
-import { SyncPromise } from "../sync-promise.js";
-import type { ValueOrPromise } from "../utils.js";
-
-export type BigIntDeserializer = (
-    array: Uint8Array,
-    byteOffset: number,
-    littleEndian: boolean,
-) => bigint;
-
-export type BigIntSerializer = (
-    array: Uint8Array,
-    byteOffset: number,
-    value: bigint,
-    littleEndian: boolean,
-) => void;
-
-export class BigIntFieldVariant {
-    readonly TTypeScriptType!: bigint;
-
-    readonly size: number;
-
-    readonly deserialize: BigIntDeserializer;
-
-    readonly serialize: BigIntSerializer;
-
-    constructor(
-        size: number,
-        deserialize: BigIntDeserializer,
-        serialize: BigIntSerializer,
-    ) {
-        this.size = size;
-        this.deserialize = deserialize;
-        this.serialize = serialize;
-    }
-
-    static readonly Int64 = new BigIntFieldVariant(8, getInt64, setInt64);
-
-    static readonly Uint64 = new BigIntFieldVariant(8, getUint64, setUint64);
-}
-
-export class BigIntFieldDefinition<
-    TVariant extends BigIntFieldVariant = BigIntFieldVariant,
-    TTypeScriptType = TVariant["TTypeScriptType"],
-> extends StructFieldDefinition<void, TTypeScriptType> {
-    readonly variant: TVariant;
-
-    constructor(variant: TVariant, typescriptType?: TTypeScriptType) {
-        void typescriptType;
-        super();
-        this.variant = variant;
-    }
-
-    getSize(): number {
-        return this.variant.size;
-    }
-
-    create(
-        options: Readonly<StructOptions>,
-        struct: StructValue,
-        value: TTypeScriptType,
-    ): BigIntFieldValue<this> {
-        return new BigIntFieldValue(this, options, struct, value);
-    }
-
-    override deserialize(
-        options: Readonly<StructOptions>,
-        stream: ExactReadable,
-        struct: StructValue,
-    ): BigIntFieldValue<this>;
-    override deserialize(
-        options: Readonly<StructOptions>,
-        stream: AsyncExactReadable,
-        struct: StructValue,
-    ): Promise<BigIntFieldValue<this>>;
-    override deserialize(
-        options: Readonly<StructOptions>,
-        stream: ExactReadable | AsyncExactReadable,
-        struct: StructValue,
-    ): ValueOrPromise<BigIntFieldValue<this>> {
-        return SyncPromise.try(() => {
-            return stream.readExactly(this.getSize());
-        })
-            .then((array) => {
-                const value = this.variant.deserialize(
-                    array,
-                    0,
-                    options.littleEndian,
-                );
-                return this.create(options, struct, value as never);
-            })
-            .valueOrPromise();
-    }
-}
-
-export class BigIntFieldValue<
-    TDefinition extends BigIntFieldDefinition<BigIntFieldVariant, unknown>,
-> extends StructFieldValue<TDefinition> {
-    override serialize(
-        dataView: DataView,
-        array: Uint8Array,
-        offset: number,
-    ): void {
-        this.definition.variant.serialize(
-            array,
-            offset,
-            this.value as never,
-            this.options.littleEndian,
-        );
-    }
-}

package/src/types/buffer/base.ts

@@ -1,198 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import type {
-    AsyncExactReadable,
-    ExactReadable,
-    StructOptions,
-    StructValue,
-} from "../../basic/index.js";
-import { StructFieldDefinition, StructFieldValue } from "../../basic/index.js";
-import { SyncPromise } from "../../sync-promise.js";
-import type { ValueOrPromise } from "../../utils.js";
-import { decodeUtf8, encodeUtf8 } from "../../utils.js";
-
-/**
- * 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 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 BufferFieldConverter<
-    TValue = unknown,
-    TTypeScriptType = TValue,
-> {
-    readonly TTypeScriptType!: TTypeScriptType;
-
-    /**
-     * 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 custom value */
-    abstract toValue(array: Uint8Array): TValue;
-
-    /**
-     * When implemented in derived classes, gets the size in byte of the custom `value`.
-     *
-     * 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 | undefined;
-}
-
-/** An identity converter, doesn't convert to anything else. */
-export class Uint8ArrayBufferFieldConverter<
-    TTypeScriptType = Uint8Array,
-> extends BufferFieldConverter<Uint8Array, TTypeScriptType> {
-    static readonly Instance = new Uint8ArrayBufferFieldConverter();
-
-    protected constructor() {
-        super();
-    }
-
-    toBuffer(value: Uint8Array): Uint8Array {
-        return value;
-    }
-
-    toValue(buffer: Uint8Array): Uint8Array {
-        return buffer;
-    }
-
-    getSize(value: Uint8Array): number {
-        return value.length;
-    }
-}
-
-/** An `BufferFieldSubType` that converts between `Uint8Array` and `string` */
-export class StringBufferFieldConverter<
-    TTypeScriptType = string,
-> extends BufferFieldConverter<string, TTypeScriptType> {
-    static readonly Instance = new StringBufferFieldConverter();
-
-    toBuffer(value: string): Uint8Array {
-        return encodeUtf8(value);
-    }
-
-    toValue(array: Uint8Array): string {
-        return decodeUtf8(array);
-    }
-
-    getSize(): number | undefined {
-        // See the note in `BufferFieldConverter.getSize`
-        return undefined;
-    }
-}
-
-export const EMPTY_UINT8_ARRAY = new Uint8Array(0);
-
-export abstract class BufferLikeFieldDefinition<
-    TConverter extends BufferFieldConverter<
-        unknown,
-        unknown
-    > = BufferFieldConverter<unknown, unknown>,
-    TOptions = void,
-    TOmitInitKey extends PropertyKey = never,
-    TTypeScriptType = TConverter["TTypeScriptType"],
-> extends StructFieldDefinition<TOptions, TTypeScriptType, TOmitInitKey> {
-    readonly converter: TConverter;
-    readonly TTypeScriptType!: TTypeScriptType;
-
-    constructor(converter: TConverter, options: TOptions) {
-        super(options);
-        this.converter = converter;
-    }
-
-    protected getDeserializeSize(struct: StructValue): number {
-        void struct;
-        return this.getSize();
-    }
-
-    /**
-     * When implemented in derived classes, creates a `StructFieldValue` for the current field definition.
-     */
-    create(
-        options: Readonly<StructOptions>,
-        struct: StructValue,
-        value: TTypeScriptType,
-        array?: Uint8Array,
-    ): BufferLikeFieldValue<this> {
-        return new BufferLikeFieldValue(this, options, struct, value, array);
-    }
-
-    override deserialize(
-        options: Readonly<StructOptions>,
-        stream: ExactReadable,
-        struct: StructValue,
-    ): BufferLikeFieldValue<this>;
-    override deserialize(
-        options: Readonly<StructOptions>,
-        stream: AsyncExactReadable,
-        struct: StructValue,
-    ): Promise<BufferLikeFieldValue<this>>;
-    override deserialize(
-        options: Readonly<StructOptions>,
-        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.readExactly(size);
-            }
-        })
-            .then((array) => {
-                const value = this.converter.toValue(array) as TTypeScriptType;
-                return this.create(options, struct, value, array);
-            })
-            .valueOrPromise();
-    }
-}
-
-export class BufferLikeFieldValue<
-    TDefinition extends BufferLikeFieldDefinition<
-        BufferFieldConverter<unknown, unknown>,
-        any,
-        any,
-        any
-    >,
-> extends StructFieldValue<TDefinition> {
-    protected array: Uint8Array | undefined;
-
-    constructor(
-        definition: TDefinition,
-        options: Readonly<StructOptions>,
-        struct: StructValue,
-        value: TDefinition["TTypeScriptType"],
-        array?: Uint8Array,
-    ) {
-        super(definition, options, struct, value);
-        this.array = array;
-    }
-
-    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;
-    }
-
-    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,22 +0,0 @@
-import type { BufferFieldConverter } from "./base.js";
-import { BufferLikeFieldDefinition } from "./base.js";
-
-export interface FixedLengthBufferLikeFieldOptions {
-    length: number;
-}
-
-export class FixedLengthBufferLikeFieldDefinition<
-    TConverter extends BufferFieldConverter = BufferFieldConverter,
-    TOptions extends
-        FixedLengthBufferLikeFieldOptions = FixedLengthBufferLikeFieldOptions,
-    TTypeScriptType = TConverter["TTypeScriptType"],
-> extends BufferLikeFieldDefinition<
-    TConverter,
-    TOptions,
-    never,
-    TTypeScriptType
-> {
-    getSize(): number {
-        return this.options.length;
-    }
-}

package/src/types/buffer/index.ts

@@ -1,3 +0,0 @@
-export * from "./base.js";
-export * from "./fixed-length.js";
-export * from "./variable-length.js";

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

@@ -1,198 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
-import type {
-    StructFieldDefinition,
-    StructOptions,
-    StructValue,
-} from "../../basic/index.js";
-import { StructFieldValue } from "../../basic/index.js";
-import type { KeysOfType } from "../../utils.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 extends object = 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<
-    TConverter extends BufferFieldConverter = BufferFieldConverter,
-    TOptions extends
-        VariableLengthBufferLikeFieldOptions = VariableLengthBufferLikeFieldOptions,
-    TTypeScriptType = TConverter["TTypeScriptType"],
-> extends BufferLikeFieldDefinition<
-    TConverter,
-    TOptions,
-    TOptions["lengthField"],
-    TTypeScriptType
-> {
-    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;
-    }
-
-    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;
-
-    constructor(
-        definition: TDefinition,
-        options: Readonly<StructOptions>,
-        struct: StructValue,
-        value: TDefinition["TValue"],
-        array?: Uint8Array,
-    ) {
-        super(definition, options, struct, value, array);
-
-        if (array) {
-            this.length = array.length;
-        }
-
-        // Patch the associated length field.
-        const lengthField = this.definition.options.lengthField as PropertyKey;
-
-        const originalValue = struct.get(lengthField);
-        this.lengthFieldValue = new VariableLengthBufferLikeFieldLengthValue(
-            originalValue,
-            this,
-        );
-        struct.set(lengthField, this.lengthFieldValue);
-    }
-
-    #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) {
-            // 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;
-    }
-
-    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>,
-        any,
-        any
-    >
->;
-
-export class VariableLengthBufferLikeFieldLengthValue extends StructFieldValue<
-    StructFieldDefinition<unknown, unknown, PropertyKey>
-> {
-    protected originalValue: StructFieldValue<
-        StructFieldDefinition<unknown, unknown, PropertyKey>
-    >;
-
-    protected bufferValue: VariableLengthBufferLikeFieldValueLike;
-
-    constructor(
-        originalValue: StructFieldValue<
-            StructFieldDefinition<unknown, unknown, PropertyKey>
-        >,
-        bufferValue: VariableLengthBufferLikeFieldValueLike,
-    ) {
-        super(
-            originalValue.definition,
-            originalValue.options,
-            originalValue.struct,
-            0,
-        );
-        this.originalValue = originalValue;
-        this.bufferValue = bufferValue;
-    }
-
-    override getSize() {
-        return this.originalValue.getSize();
-    }
-
-    override get() {
-        let value: string | number = this.bufferValue.getSize();
-
-        const originalValue = this.originalValue.get();
-        if (typeof originalValue === "string") {
-            value = value.toString(
-                this.bufferValue.definition.options.lengthFieldRadix ?? 10,
-            );
-        }
-
-        return value;
-    }
-
-    override set() {
-        // Ignore setting
-        // It will always be in sync with the buffer size
-    }
-
-    serialize(dataView: DataView, array: Uint8Array, offset: number) {
-        this.originalValue.set(this.get());
-        this.originalValue.serialize(dataView, array, offset);
-    }
-}

package/src/types/index.ts

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