@yume-chan/struct 1.0.0 → 2.0.1

package/src/concat.ts

@@ -0,0 +1,78 @@
+import type { FieldsValue, Struct, StructFields } from "./struct.js";
+import { struct } from "./struct.js";
+
+type UnionToIntersection<U> = (
+    U extends unknown ? (x: U) => void : never
+) extends (x: infer I) => void
+    ? I
+    : never;
+
+type As<T, U> = T extends infer V extends U ? V : never;
+
+export type ConcatFields<
+    T extends Struct<
+        StructFields,
+        Record<PropertyKey, unknown> | undefined,
+        unknown
+    >[],
+> = As<UnionToIntersection<T[number]["fields"]>, StructFields>;
+
+type ConcatFieldValues<
+    T extends Struct<
+        StructFields,
+        Record<PropertyKey, unknown> | undefined,
+        unknown
+    >[],
+> = FieldsValue<ConcatFields<T>>;
+
+type ExtraToUnion<Extra extends Record<PropertyKey, unknown> | undefined> =
+    Extra extends undefined ? never : Extra;
+
+export type ConcatExtras<
+    T extends Struct<
+        StructFields,
+        Record<PropertyKey, unknown> | undefined,
+        unknown
+    >[],
+> = As<
+    UnionToIntersection<ExtraToUnion<T[number]["extra"]>>,
+    Record<PropertyKey, unknown>
+>;
+
+/* #__NO_SIDE_EFFECTS__ */
+export function concat<
+    T extends Struct<
+        StructFields,
+        Record<PropertyKey, unknown> | undefined,
+        unknown
+    >[],
+    PostDeserialize = ConcatFieldValues<T> & ConcatExtras<T>,
+>(
+    options: {
+        littleEndian: boolean;
+        postDeserialize?: (
+            this: ConcatFieldValues<T> & ConcatExtras<T>,
+            value: ConcatFieldValues<T> & ConcatExtras<T>,
+        ) => PostDeserialize;
+    },
+    ...structs: T
+): Struct<ConcatFields<T>, ConcatExtras<T>, PostDeserialize> {
+    return struct(
+        structs.reduce(
+            (fields, struct) => Object.assign(fields, struct.fields),
+            {},
+        ) as never,
+        {
+            littleEndian: options.littleEndian,
+            postDeserialize: options.postDeserialize,
+            extra: structs.reduce(
+                (extras, struct) =>
+                    Object.defineProperties(
+                        extras,
+                        Object.getOwnPropertyDescriptors(struct.extra),
+                    ),
+                {},
+            ) as never,
+        },
+    ) as never;
+}

package/src/extend.ts

@@ -0,0 +1,37 @@
+import type {
+    ExtraToIntersection,
+    FieldsValue,
+    Struct,
+    StructFields,
+} from "./struct.js";
+import { struct } from "./struct.js";
+
+/* #__NO_SIDE_EFFECTS__ */
+export function extend<
+    Base extends Struct<
+        StructFields,
+        Record<PropertyKey, unknown> | undefined,
+        unknown
+    >,
+    Fields extends StructFields,
+    PostDeserialize = FieldsValue<Base["fields"] & Fields> &
+        ExtraToIntersection<Base["extra"]>,
+>(
+    base: Base,
+    fields: Fields,
+    options?: {
+        littleEndian?: boolean | undefined;
+        postDeserialize?: (
+            this: FieldsValue<Base["fields"] & Fields> &
+                ExtraToIntersection<Base["extra"]>,
+            value: FieldsValue<Base["fields"] & Fields> &
+                ExtraToIntersection<Base["extra"]>,
+        ) => PostDeserialize;
+    },
+): Struct<Base["fields"] & Fields, Base["extra"], PostDeserialize> {
+    return struct(Object.assign({}, base.fields, fields), {
+        littleEndian: options?.littleEndian ?? base.littleEndian,
+        extra: base.extra as never,
+        postDeserialize: options?.postDeserialize,
+    }) as never;
+}

package/src/field/factory.ts

@@ -0,0 +1,64 @@
+import type { BipedalGenerator } from "../bipedal.js";
+import { bipedal } from "../bipedal.js";
+import type { AsyncExactReadable } from "../readable.js";
+
+import type {
+    ByobFieldSerializer,
+    DefaultFieldSerializer,
+} from "./serialize.js";
+import { byobFieldSerializer, defaultFieldSerializer } from "./serialize.js";
+import type { Field, FieldDeserializeContext, FieldOptions } from "./types.js";
+
+export type BipedalFieldDeserializer<T, D> = BipedalGenerator<
+    undefined,
+    T,
+    [reader: AsyncExactReadable, context: FieldDeserializeContext<D>]
+>;
+
+// eslint-disable-next-line @typescript-eslint/max-params
+function _field<T, OmitInit extends string, D, Raw = T>(
+    size: number,
+    type: "default",
+    serialize: DefaultFieldSerializer<Raw>,
+    deserialize: BipedalFieldDeserializer<T, D>,
+    options?: FieldOptions<T, OmitInit, D, Raw>,
+): Field<T, OmitInit, D, Raw>;
+// eslint-disable-next-line @typescript-eslint/max-params
+function _field<T, OmitInit extends string, D, Raw = T>(
+    size: number,
+    type: "byob",
+    serialize: ByobFieldSerializer<Raw>,
+    deserialize: BipedalFieldDeserializer<T, D>,
+    options?: FieldOptions<T, OmitInit, D, Raw>,
+): Field<T, OmitInit, D, Raw>;
+/* #__NO_SIDE_EFFECTS__ */
+// eslint-disable-next-line @typescript-eslint/max-params
+function _field<T, OmitInit extends string, D, Raw = T>(
+    size: number,
+    type: "default" | "byob",
+    serialize: DefaultFieldSerializer<Raw> | ByobFieldSerializer<Raw>,
+    deserialize: BipedalFieldDeserializer<T, D>,
+    options?: FieldOptions<T, OmitInit, D, Raw>,
+): Field<T, OmitInit, D, Raw> {
+    const field: Field<T, OmitInit, D, Raw> = {
+        size,
+        type: type,
+        serialize:
+            type === "default"
+                ? defaultFieldSerializer(
+                      serialize as DefaultFieldSerializer<Raw>,
+                  )
+                : byobFieldSerializer(
+                      size,
+                      serialize as ByobFieldSerializer<Raw>,
+                  ),
+        deserialize: bipedal(deserialize) as never,
+        omitInit: options?.omitInit,
+    };
+    if (options?.init) {
+        field.init = options.init;
+    }
+    return field;
+}
+
+export const field = _field;

package/src/field/index.ts

@@ -0,0 +1,3 @@
+export * from "./factory.js";
+export * from "./serialize.js";
+export * from "./types.js";

package/src/field/serialize.ts

@@ -0,0 +1,58 @@
+import type {
+    FieldByobSerializeContext,
+    FieldDefaultSerializeContext,
+    FieldSerializer,
+} from "./types.js";
+
+export type DefaultFieldSerializer<T> = (
+    source: T,
+    context: FieldDefaultSerializeContext,
+) => Uint8Array;
+
+/* Adapt default field serializer to universal field serializer */
+export function defaultFieldSerializer<T>(
+    serializer: DefaultFieldSerializer<T>,
+): FieldSerializer<T>["serialize"] {
+    return (
+        source,
+        context: FieldDefaultSerializeContext | FieldByobSerializeContext,
+    ): never => {
+        if ("buffer" in context) {
+            const buffer = serializer(source, context);
+            context.buffer.set(buffer, context.index);
+            return buffer.length as never;
+        } else {
+            return serializer(source, context) as never;
+        }
+    };
+}
+
+export type ByobFieldSerializer<T> = (
+    source: T,
+    context: FieldByobSerializeContext & { index: number },
+) => void;
+
+/* Adapt byob field serializer to universal field serializer */
+export function byobFieldSerializer<T>(
+    size: number,
+    serializer: ByobFieldSerializer<T>,
+): FieldSerializer<T>["serialize"] {
+    return (
+        source,
+        context: FieldDefaultSerializeContext | FieldByobSerializeContext,
+    ): never => {
+        if ("buffer" in context) {
+            context.index ??= 0;
+            serializer(source, context as never);
+            return size as never;
+        } else {
+            const buffer = new Uint8Array(size);
+            serializer(source, {
+                buffer,
+                index: 0,
+                littleEndian: context.littleEndian,
+            });
+            return buffer as never;
+        }
+    };
+}

package/src/field/types.ts

@@ -0,0 +1,48 @@
+import type { MaybePromiseLike } from "@yume-chan/async";
+
+import type { AsyncExactReadable, ExactReadable } from "../readable.js";
+
+export interface FieldDefaultSerializeContext {
+    littleEndian: boolean;
+}
+
+export interface FieldByobSerializeContext
+    extends FieldDefaultSerializeContext {
+    buffer: Uint8Array;
+    index?: number;
+}
+
+export interface FieldSerializer<T> {
+    type: "default" | "byob";
+    size: number;
+
+    serialize(source: T, context: FieldDefaultSerializeContext): Uint8Array;
+    serialize(source: T, context: FieldByobSerializeContext): number;
+}
+
+export interface Field<T, OmitInit extends string, D, Raw = T>
+    extends FieldSerializer<Raw>,
+        FieldDeserializer<T, D> {
+    omitInit: OmitInit | undefined;
+
+    init?(value: T, dependencies: D): Raw | undefined;
+}
+
+export interface FieldDeserializeContext<D> {
+    littleEndian: boolean;
+    dependencies: D;
+}
+
+export interface FieldDeserializer<T, D> {
+    deserialize(reader: ExactReadable, context: FieldDeserializeContext<D>): T;
+    deserialize(
+        reader: AsyncExactReadable,
+        context: FieldDeserializeContext<D>,
+    ): MaybePromiseLike<T>;
+}
+
+export interface FieldOptions<T, OmitInit extends string, D, Raw = T> {
+    omitInit?: OmitInit;
+    dependencies?: D;
+    init?: (value: T, dependencies: D) => Raw | undefined;
+}

package/src/index.ts

@@ -12,9 +12,12 @@ declare global {
 
 export * from "./bipedal.js";
 export * from "./buffer.js";
-export * from "./field.js";
+export * from "./concat.js";
+export * from "./extend.js";
+export * from "./field/index.js";
 export * from "./number.js";
 export * from "./readable.js";
 export * from "./string.js";
 export * from "./struct.js";
+export * from "./types.js";
 export * from "./utils.js";

package/src/number.ts

@@ -1,3 +1,4 @@
+import type { MaybePromiseLike } from "@yume-chan/async";
 import {
     getInt16,
     getInt32,
@@ -14,110 +15,120 @@ import {
     setUint64,
 } from "@yume-chan/no-data-view";
 
-import { bipedal } from "./bipedal.js";
-import type { Field } from "./field.js";
+import type {
+    Field,
+    FieldByobSerializeContext,
+    FieldDeserializeContext,
+} from "./field/index.js";
+import { field } from "./field/index.js";
+import type { AsyncExactReadable } from "./readable.js";
 
-export interface NumberField<T> extends Field<T, never, never> {
-    <const U>(infer?: U): Field<U, never, never>;
+export interface NumberField<T> extends Field<T, never, never, T> {
+    <const U>(infer?: U): Field<U, never, never, T>;
 }
 
 /* #__NO_SIDE_EFFECTS__ */
-function factory<T>(
+function number<T>(
     size: number,
-    serialize: Field<T, never, never>["serialize"],
-    deserialize: Field<T, never, never>["deserialize"],
-): NumberField<T> {
-    const result = () => result;
-    result.size = size;
-    result.serialize = serialize;
-    result.deserialize = deserialize;
-    return result as never;
+    serialize: (
+        source: T,
+        context: FieldByobSerializeContext & { index: number },
+    ) => void,
+    deserialize: (
+        then: <U>(value: MaybePromiseLike<U>) => Iterable<unknown, U, unknown>,
+        reader: AsyncExactReadable,
+        context: FieldDeserializeContext<never>,
+    ) => Generator<unknown, T, unknown>,
+) {
+    const fn: NumberField<T> = (() => fn) as never;
+    Object.assign(fn, field(size, "byob", serialize, deserialize));
+    return fn;
 }
 
-export const u8 = factory<number>(
+export const u8: NumberField<number> = number(
     1,
     (value, { buffer, index }) => {
         buffer[index] = value;
     },
-    bipedal(function* (then, { reader }) {
+    function* (then, reader) {
         const data = yield* then(reader.readExactly(1));
         return data[0]!;
-    }),
+    },
 );
 
-export const s8 = factory<number>(
+export const s8: NumberField<number> = number(
     1,
     (value, { buffer, index }) => {
         buffer[index] = value;
     },
-    bipedal(function* (then, { reader }) {
+    function* (then, reader) {
         const data = yield* then(reader.readExactly(1));
         return getInt8(data, 0);
-    }),
+    },
 );
 
-export const u16 = factory<number>(
+export const u16: NumberField<number> = number(
     2,
     (value, { buffer, index, littleEndian }) => {
         setUint16(buffer, index, value, littleEndian);
     },
-    bipedal(function* (then, { reader, littleEndian }) {
+    function* (then, reader, { littleEndian }) {
         const data = yield* then(reader.readExactly(2));
         return getUint16(data, 0, littleEndian);
-    }),
+    },
 );
 
-export const s16 = factory<number>(
+export const s16: NumberField<number> = number(
     2,
     (value, { buffer, index, littleEndian }) => {
         setInt16(buffer, index, value, littleEndian);
     },
-    bipedal(function* (then, { reader, littleEndian }) {
+    function* (then, reader, { littleEndian }) {
         const data = yield* then(reader.readExactly(2));
         return getInt16(data, 0, littleEndian);
-    }),
+    },
 );
 
-export const u32 = factory<number>(
+export const u32: NumberField<number> = number(
     4,
     (value, { buffer, index, littleEndian }) => {
         setUint32(buffer, index, value, littleEndian);
     },
-    bipedal(function* (then, { reader, littleEndian }) {
+    function* (then, reader, { littleEndian }) {
         const data = yield* then(reader.readExactly(4));
         return getUint32(data, 0, littleEndian);
-    }),
+    },
 );
 
-export const s32 = factory<number>(
+export const s32: NumberField<number> = number(
     4,
     (value, { buffer, index, littleEndian }) => {
         setInt32(buffer, index, value, littleEndian);
     },
-    bipedal(function* (then, { reader, littleEndian }) {
+    function* (then, reader, { littleEndian }) {
         const data = yield* then(reader.readExactly(4));
         return getInt32(data, 0, littleEndian);
-    }),
+    },
 );
 
-export const u64 = factory<bigint>(
+export const u64: NumberField<bigint> = number(
     8,
     (value, { buffer, index, littleEndian }) => {
         setUint64(buffer, index, value, littleEndian);
     },
-    bipedal(function* (then, { reader, littleEndian }) {
+    function* (then, reader, { littleEndian }) {
         const data = yield* then(reader.readExactly(8));
         return getUint64(data, 0, littleEndian);
-    }),
+    },
 );
 
-export const s64 = factory<bigint>(
+export const s64: NumberField<bigint> = number(
     8,
     (value, { buffer, index, littleEndian }) => {
         setInt64(buffer, index, value, littleEndian);
     },
-    bipedal(function* (then, { reader, littleEndian }) {
+    function* (then, reader, { littleEndian }) {
         const data = yield* then(reader.readExactly(8));
         return getInt64(data, 0, littleEndian);
-    }),
+    },
 );

package/src/readable.ts

@@ -20,6 +20,34 @@ export interface ExactReadable {
     readExactly(length: number): Uint8Array;
 }
 
+export class Uint8ArrayExactReadable implements ExactReadable {
+    #data: Uint8Array;
+    #position: number;
+
+    get position() {
+        return this.#position;
+    }
+
+    constructor(data: Uint8Array) {
+        this.#data = data;
+        this.#position = 0;
+    }
+
+    readExactly(length: number): Uint8Array {
+        if (this.#position + length > this.#data.length) {
+            throw new ExactReadableEndedError();
+        }
+
+        const result = this.#data.subarray(
+            this.#position,
+            this.#position + length,
+        );
+
+        this.#position += length;
+        return result;
+    }
+}
+
 export interface AsyncExactReadable {
     readonly position: number;
 

package/src/string.ts

@@ -1,6 +1,6 @@
 import type { BufferLengthConverter } from "./buffer.js";
 import { buffer } from "./buffer.js";
-import type { Field } from "./field.js";
+import type { Field } from "./field/index.js";
 import { decodeUtf8, encodeUtf8 } from "./utils.js";
 
 export interface String {
@@ -25,19 +25,17 @@ export interface String {
     ): Field<string, KOmitInit, KS>;
 }
 
-// Rollup doesn't support `/* #__NO_SIDE_EFFECTS__ */ export const a = () => {}
-/* #__NO_SIDE_EFFECTS__ */
-function _string(
+// Prettier will move the annotation and make it invalid
+// prettier-ignore
+export const string: String = (/* #__NO_SIDE_EFFECTS__ */ (
     lengthOrField: string | number | BufferLengthConverter<string, unknown>,
 ): Field<string, string, Record<string, unknown>> & {
     as: <T>(infer: T) => Field<T, string, Record<string, unknown>>;
-} {
+} => {
     const field = buffer(lengthOrField as never, {
         convert: decodeUtf8,
         back: encodeUtf8,
     });
     (field as never as { as: unknown }).as = () => field;
     return field as never;
-}
-
-export const string: String = _string as never;
+}) as never;