@yume-chan/struct 1.0.0 → 2.0.0

package/esm/types.d.ts

@@ -0,0 +1,20 @@
+import type { MaybePromiseLike } from "@yume-chan/async";
+import type { FieldByobSerializeContext, FieldDeserializer, FieldSerializer } from "./field/index.js";
+import type { AsyncExactReadable, ExactReadable } from "./readable.js";
+export type StructSerializeContext = Omit<FieldByobSerializeContext, "littleEndian">;
+export interface StructSerializer<T> extends FieldSerializer<T> {
+    type: "byob";
+    size: number;
+    serialize(source: T): Uint8Array;
+    serialize(source: T, buffer: Uint8Array): number;
+    serialize(source: T, context: StructSerializeContext): number;
+}
+export type StructInit<T extends StructSerializer<unknown>> = T extends StructSerializer<infer U> ? U : never;
+export interface StructDeserializer<T> extends FieldDeserializer<T, never> {
+    size: number;
+    deserialize(reader: ExactReadable): T;
+    deserialize(reader: AsyncExactReadable): MaybePromiseLike<T>;
+}
+export type StructValue<T extends StructDeserializer<unknown>> = T extends StructDeserializer<infer P> ? P : never;
+export type StructLike<T> = StructSerializer<T> & StructDeserializer<T>;
+//# sourceMappingURL=types.d.ts.map

package/esm/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEzD,OAAO,KAAK,EACR,yBAAyB,EACzB,iBAAiB,EACjB,eAAe,EAClB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEvE,MAAM,MAAM,sBAAsB,GAAG,IAAI,CACrC,yBAAyB,EACzB,cAAc,CACjB,CAAC;AAEF,MAAM,WAAW,gBAAgB,CAAC,CAAC,CAAE,SAAQ,eAAe,CAAC,CAAC,CAAC;IAC3D,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IAEb,SAAS,CAAC,MAAM,EAAE,CAAC,GAAG,UAAU,CAAC;IACjC,SAAS,CAAC,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,UAAU,GAAG,MAAM,CAAC;IACjD,SAAS,CAAC,MAAM,EAAE,CAAC,EAAE,OAAO,EAAE,sBAAsB,GAAG,MAAM,CAAC;CACjE;AAED,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,gBAAgB,CAAC,OAAO,CAAC,IACtD,CAAC,SAAS,gBAAgB,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAEpD,MAAM,WAAW,kBAAkB,CAAC,CAAC,CAAE,SAAQ,iBAAiB,CAAC,CAAC,EAAE,KAAK,CAAC;IACtE,IAAI,EAAE,MAAM,CAAC;IAEb,WAAW,CAAC,MAAM,EAAE,aAAa,GAAG,CAAC,CAAC;IACtC,WAAW,CAAC,MAAM,EAAE,kBAAkB,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAAC;CAChE;AAED,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,kBAAkB,CAAC,OAAO,CAAC,IACzD,CAAC,SAAS,kBAAkB,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAEtD,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,gBAAgB,CAAC,CAAC,CAAC,GAAG,kBAAkB,CAAC,CAAC,CAAC,CAAC"}

package/esm/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/esm/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yume-chan/struct",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "C-style structure serializer and deserializer.",
   "keywords": [
     "structure",
@@ -29,15 +29,15 @@
   "sideEffects": false,
   "dependencies": {
     "@yume-chan/async": "^4.0.2",
-    "@yume-chan/no-data-view": "^1.0.0"
+    "@yume-chan/no-data-view": "^2.0.0"
   },
   "devDependencies": {
-    "@types/node": "^22.10.0",
-    "prettier": "^3.4.1",
-    "typescript": "^5.7.2",
-    "@yume-chan/tsconfig": "^1.0.0",
+    "@types/node": "^22.13.10",
+    "prettier": "^3.5.3",
+    "typescript": "^5.8.2",
+    "@yume-chan/test-runner": "^1.0.0",
     "@yume-chan/eslint-config": "^1.0.0",
-    "@yume-chan/test-runner": "^1.0.0"
+    "@yume-chan/tsconfig": "^1.0.0"
   },
   "scripts": {
     "build": "tsc -b tsconfig.build.json",

package/src/bipedal.ts

@@ -20,18 +20,22 @@ function advance<T>(
     }
 }
 
+export type BipedalGenerator<This, T, A extends unknown[]> = (
+    this: This,
+    then: <U>(value: MaybePromiseLike<U>) => Iterable<unknown, U, unknown>,
+    ...args: A
+) => Generator<unknown, T, unknown>;
+
+/* #__NO_SIDE_EFFECTS__ */
 export function bipedal<This, T, A extends unknown[]>(
-    fn: (
-        this: This,
-        then: <U>(value: U | PromiseLike<U>) => Iterable<unknown, U, unknown>,
-        ...args: A
-    ) => Generator<unknown, T, unknown>,
+    fn: BipedalGenerator<This, T, A>,
+    bindThis?: This,
 ): { (this: This, ...args: A): MaybePromiseLike<T> } {
-    return function (this: This, ...args: A) {
+    function result(this: This, ...args: A): MaybePromiseLike<T> {
         const iterator = fn.call(
             this,
             function* <U>(
-                value: U | PromiseLike<U>,
+                value: MaybePromiseLike<U>,
             ): Generator<
                 PromiseLike<U>,
                 U,
@@ -51,5 +55,11 @@ export function bipedal<This, T, A extends unknown[]>(
             ...args,
         ) as never;
         return advance(iterator, undefined);
-    };
+    }
+
+    if (bindThis) {
+        return result.bind(bindThis);
+    } else {
+        return result;
+    }
 }

package/src/buffer.ts

@@ -1,5 +1,7 @@
-import { bipedal } from "./bipedal.js";
-import type { Field } from "./field.js";
+import type { Field } from "./field/index.js";
+import { field } from "./field/index.js";
+
+export const EmptyUint8Array = new Uint8Array(0);
 
 export interface Converter<From, To> {
     convert: (value: From) => To;
@@ -11,244 +13,306 @@ export interface BufferLengthConverter<K, KT> extends Converter<KT, number> {
 }
 
 export interface BufferLike {
-    (length: number): Field<Uint8Array, never, never>;
+    (length: number): Field<Uint8Array, never, never, Uint8Array>;
     <U>(
         length: number,
         converter: Converter<Uint8Array, U>,
-    ): Field<U, never, never>;
+    ): Field<U, never, never, Uint8Array>;
 
-    <K extends string>(lengthField: K): Field<Uint8Array, K, Record<K, number>>;
+    <K extends string>(
+        lengthField: K,
+    ): Field<Uint8Array, K, Record<K, number>, Uint8Array>;
     <K extends string, U>(
         lengthField: K,
         converter: Converter<Uint8Array, U>,
-    ): Field<U, K, Record<K, number>>;
+    ): Field<U, K, Record<K, number>, Uint8Array>;
 
     <K extends string, KT>(
         length: BufferLengthConverter<K, KT>,
-    ): Field<Uint8Array, K, Record<K, KT>>;
+    ): Field<Uint8Array, K, Record<K, KT>, Uint8Array>;
     <K extends string, KT, U>(
         length: BufferLengthConverter<K, KT>,
         converter: Converter<Uint8Array, U>,
-    ): Field<U, K, Record<K, KT>>;
+    ): Field<U, K, Record<K, KT>, Uint8Array>;
 
-    <KOmitInit extends string, KS>(
-        length: Field<number, KOmitInit, KS>,
-    ): Field<Uint8Array, KOmitInit, KS>;
-    <KOmitInit extends string, KS, U>(
-        length: Field<number, KOmitInit, KS>,
+    <LengthOmitInit extends string, LengthDependencies>(
+        length: Field<number, LengthOmitInit, LengthDependencies, number>,
+    ): Field<Uint8Array, LengthOmitInit, LengthDependencies, Uint8Array>;
+    <LengthOmitInit extends string, LengthDependencies, U>(
+        length: Field<number, LengthOmitInit, LengthDependencies, number>,
         converter: Converter<Uint8Array, U>,
-    ): Field<U, KOmitInit, KS>;
+    ): Field<U, LengthOmitInit, LengthDependencies, Uint8Array>;
 }
 
-export const EmptyUint8Array = new Uint8Array(0);
+function _buffer(length: number): Field<Uint8Array, never, never, Uint8Array>;
+function _buffer<U>(
+    length: number,
+    converter: Converter<Uint8Array, U>,
+): Field<U, never, never, Uint8Array>;
 
-export const buffer: BufferLike = function (
+function _buffer<K extends string>(
+    lengthField: K,
+): Field<Uint8Array, K, Record<K, number>, Uint8Array>;
+function _buffer<K extends string, U>(
+    lengthField: K,
+    converter: Converter<Uint8Array, U>,
+): Field<U, K, Record<K, number>, Uint8Array>;
+
+function _buffer<K extends string, KT>(
+    length: BufferLengthConverter<K, KT>,
+): Field<Uint8Array, K, Record<K, KT>, Uint8Array>;
+function _buffer<K extends string, KT, U>(
+    length: BufferLengthConverter<K, KT>,
+    converter: Converter<Uint8Array, U>,
+): Field<U, K, Record<K, KT>, Uint8Array>;
+
+function _buffer<LengthOmitInit extends string, LengthDependencies>(
+    length: Field<number, LengthOmitInit, LengthDependencies, number>,
+): Field<Uint8Array, LengthOmitInit, LengthDependencies, Uint8Array>;
+function _buffer<LengthOmitInit extends string, LengthDependencies, U>(
+    length: Field<number, LengthOmitInit, LengthDependencies, number>,
+    converter: Converter<Uint8Array, U>,
+): Field<U, LengthOmitInit, LengthDependencies, Uint8Array>;
+
+/* #__NO_SIDE_EFFECTS__ */
+function _buffer(
     lengthOrField:
         | string
         | number
-        | Field<number, never, unknown>
+        | Field<number, string, unknown, number>
         | BufferLengthConverter<string, unknown>,
     converter?: Converter<Uint8Array, unknown>,
-): Field<unknown, string, Record<string, unknown>> {
+): Field<unknown, string, Record<string, unknown>, Uint8Array> {
+    // Fixed length
     if (typeof lengthOrField === "number") {
         if (converter) {
             if (lengthOrField === 0) {
-                return {
-                    size: 0,
-                    serialize: () => {},
-                    deserialize: () => converter.convert(EmptyUint8Array),
-                };
+                return field(
+                    0,
+                    "byob",
+                    () => {},
+                    // eslint-disable-next-line require-yield
+                    function* () {
+                        return converter.convert(EmptyUint8Array);
+                    },
+                );
             }
 
-            return {
-                size: lengthOrField,
-                serialize: (value, { buffer, index }) => {
-                    buffer.set(
-                        converter.back(value).slice(0, lengthOrField),
-                        index,
-                    );
+            return field(
+                0,
+                "byob",
+                (value, { buffer, index }) => {
+                    buffer.set(value.slice(0, lengthOrField), index);
                 },
-                deserialize: bipedal(function* (then, { reader }) {
+                function* (then, reader) {
                     const array = yield* then(
                         reader.readExactly(lengthOrField),
                     );
                     return converter.convert(array);
-                }),
-            };
+                },
+                {
+                    init(value) {
+                        return converter.back(value);
+                    },
+                },
+            );
         }
 
         if (lengthOrField === 0) {
-            return {
-                size: 0,
-                serialize: () => {},
-                deserialize: () => EmptyUint8Array,
-            };
+            return field(
+                0,
+                "byob",
+                () => {},
+                // eslint-disable-next-line require-yield
+                function* () {
+                    return EmptyUint8Array;
+                },
+            );
         }
 
-        return {
-            size: lengthOrField,
-            serialize: (value, { buffer, index }) => {
-                buffer.set(
-                    (value as Uint8Array).slice(0, lengthOrField),
-                    index,
-                );
+        return field(
+            0,
+            "byob",
+            (value, { buffer, index }) => {
+                buffer.set(value.slice(0, lengthOrField), index);
+            },
+            // eslint-disable-next-line require-yield
+            function* (_then, reader) {
+                return reader.readExactly(lengthOrField);
             },
-            deserialize: ({ reader }) => reader.readExactly(lengthOrField),
-        };
+        );
     }
 
-    // Some Field type might be `function`s
+    // Declare length field
+    // Some field types are `function`s
     if (
         (typeof lengthOrField === "object" ||
             typeof lengthOrField === "function") &&
         "serialize" in lengthOrField
     ) {
         if (converter) {
-            return {
-                size: 0,
-                dynamicSize(value) {
-                    const array = converter.back(value);
-                    const lengthFieldSize =
-                        lengthOrField.dynamicSize?.(array.length) ??
-                        lengthOrField.size;
-                    return lengthFieldSize + array.length;
-                },
-                serialize(value, context) {
-                    const array = converter.back(value);
-                    const lengthFieldSize =
-                        lengthOrField.dynamicSize?.(array.length) ??
-                        lengthOrField.size;
-                    lengthOrField.serialize(array.length, context);
-                    context.buffer.set(array, context.index + lengthFieldSize);
+            return field(
+                lengthOrField.size,
+                "default",
+                (value, { littleEndian }) => {
+                    if (lengthOrField.type === "default") {
+                        const lengthBuffer = lengthOrField.serialize(
+                            value.length,
+                            { littleEndian },
+                        );
+                        const result = new Uint8Array(
+                            lengthBuffer.length + value.length,
+                        );
+                        result.set(lengthBuffer, 0);
+                        result.set(value, lengthBuffer.length);
+                        return result;
+                    } else {
+                        const result = new Uint8Array(
+                            lengthOrField.size + value.length,
+                        );
+                        lengthOrField.serialize(value.length, {
+                            buffer: result,
+                            index: 0,
+                            littleEndian,
+                        });
+                        result.set(value, lengthOrField.size);
+                        return result;
+                    }
                 },
-                deserialize: bipedal(function* (then, context) {
+                function* (then, reader, context) {
                     const length = yield* then(
-                        lengthOrField.deserialize(context),
-                    );
-                    const array = yield* then(
-                        context.reader.readExactly(length),
+                        lengthOrField.deserialize(reader, context),
                     );
+                    const array = yield* then(reader.readExactly(length));
                     return converter.convert(array);
-                }),
-            };
+                },
+                {
+                    init(value) {
+                        return converter.back(value);
+                    },
+                },
+            );
         }
 
-        return {
-            size: 0,
-            dynamicSize(value) {
-                const lengthFieldSize =
-                    lengthOrField.dynamicSize?.((value as Uint8Array).length) ??
-                    lengthOrField.size;
-                return lengthFieldSize + (value as Uint8Array).length;
+        return field(
+            lengthOrField.size,
+            "default",
+            (value, { littleEndian }) => {
+                if (lengthOrField.type === "default") {
+                    const lengthBuffer = lengthOrField.serialize(value.length, {
+                        littleEndian,
+                    });
+                    const result = new Uint8Array(
+                        lengthBuffer.length + value.length,
+                    );
+                    result.set(lengthBuffer, 0);
+                    result.set(value, lengthBuffer.length);
+                    return result;
+                } else {
+                    const result = new Uint8Array(
+                        lengthOrField.size + value.length,
+                    );
+                    lengthOrField.serialize(value.length, {
+                        buffer: result,
+                        index: 0,
+                        littleEndian,
+                    });
+                    result.set(value, lengthOrField.size);
+                    return result;
+                }
             },
-            serialize(value, context) {
-                const lengthFieldSize =
-                    lengthOrField.dynamicSize?.((value as Uint8Array).length) ??
-                    lengthOrField.size;
-                lengthOrField.serialize((value as Uint8Array).length, context);
-                context.buffer.set(
-                    value as Uint8Array,
-                    context.index + lengthFieldSize,
+            function* (then, reader, context) {
+                const length = yield* then(
+                    lengthOrField.deserialize(reader, context),
                 );
+                return yield* then(reader.readExactly(length));
             },
-            deserialize: bipedal(function* (then, context) {
-                const length = yield* then(lengthOrField.deserialize(context));
-                return context.reader.readExactly(length);
-            }),
-        };
+        );
     }
 
+    // Reference exiting length field
     if (typeof lengthOrField === "string") {
         if (converter) {
-            return {
-                size: 0,
-                preSerialize: (value, runtimeStruct) => {
-                    runtimeStruct[lengthOrField] = converter.back(value).length;
-                },
-                dynamicSize: (value) => {
-                    return converter.back(value).length;
-                },
-                serialize: (value, { buffer, index }) => {
-                    buffer.set(converter.back(value), index);
-                },
-                deserialize: bipedal(function* (
-                    then,
-                    { reader, runtimeStruct },
-                ) {
-                    const length = runtimeStruct[lengthOrField] as number;
+            return field(
+                0,
+                "default",
+                (source) => source,
+                // eslint-disable-next-line require-yield
+                function* (_then, reader, { dependencies }) {
+                    const length = dependencies[lengthOrField] as number;
                     if (length === 0) {
-                        return converter.convert(EmptyUint8Array);
+                        return EmptyUint8Array;
                     }
 
-                    const value = yield* then(reader.readExactly(length));
-                    return converter.convert(value);
-                }),
-            };
+                    return reader.readExactly(length);
+                },
+                {
+                    init(value, dependencies) {
+                        const array = converter.back(value);
+                        dependencies[lengthOrField] = array.length;
+                        return array;
+                    },
+                },
+            );
         }
 
-        return {
-            size: 0,
-            preSerialize: (value, runtimeStruct) => {
-                runtimeStruct[lengthOrField] = (value as Uint8Array).length;
-            },
-            dynamicSize: (value) => {
-                return (value as Uint8Array).length;
-            },
-            serialize: (value, { buffer, index }) => {
-                buffer.set(value as Uint8Array, index);
-            },
-            deserialize: ({ reader, runtimeStruct }) => {
-                const length = runtimeStruct[lengthOrField] as number;
+        return field(
+            0,
+            "default",
+            (source) => source,
+            // eslint-disable-next-line require-yield
+            function* (_then, reader, { dependencies }) {
+                const length = dependencies[lengthOrField] as number;
                 if (length === 0) {
                     return EmptyUint8Array;
                 }
 
                 return reader.readExactly(length);
             },
-        };
+            {
+                init(value, dependencies) {
+                    dependencies[lengthOrField] = (value as Uint8Array).length;
+                    return undefined;
+                },
+            },
+        );
     }
 
+    // Reference existing length field + converter
     if (converter) {
-        return {
-            size: 0,
-            preSerialize: (value, runtimeStruct) => {
-                const length = converter.back(value).length;
-                runtimeStruct[lengthOrField.field] = lengthOrField.back(length);
-            },
-            dynamicSize: (value) => {
-                return converter.back(value).length;
-            },
-            serialize: (value, { buffer, index }) => {
-                buffer.set(converter.back(value), index);
-            },
-            deserialize: bipedal(function* (then, { reader, runtimeStruct }) {
-                const rawLength = runtimeStruct[lengthOrField.field];
+        return field(
+            0,
+            "default",
+            (source) => source,
+            // eslint-disable-next-line require-yield
+            function* (_then, reader, { dependencies }) {
+                const rawLength = dependencies[lengthOrField.field];
                 const length = lengthOrField.convert(rawLength);
                 if (length === 0) {
-                    return converter.convert(EmptyUint8Array);
+                    return EmptyUint8Array;
                 }
 
-                const value = yield* then(reader.readExactly(length));
-                return converter.convert(value);
-            }),
-        };
+                return reader.readExactly(length);
+            },
+            {
+                init(value, dependencies) {
+                    const array = converter.back(value);
+                    dependencies[lengthOrField.field] = lengthOrField.back(
+                        array.length,
+                    );
+                    return array;
+                },
+            },
+        );
     }
 
-    return {
-        size: 0,
-        preSerialize: (value, runtimeStruct) => {
-            runtimeStruct[lengthOrField.field] = lengthOrField.back(
-                (value as Uint8Array).length,
-            );
-        },
-        dynamicSize: (value) => {
-            return (value as Uint8Array).length;
-        },
-        serialize: (value, { buffer, index }) => {
-            buffer.set(value as Uint8Array, index);
-        },
-        deserialize: ({ reader, runtimeStruct }) => {
-            const rawLength = runtimeStruct[lengthOrField.field];
+    return field(
+        0,
+        "default",
+        (source) => source,
+        // eslint-disable-next-line require-yield
+        function* (_then, reader, { dependencies }) {
+            const rawLength = dependencies[lengthOrField.field];
             const length = lengthOrField.convert(rawLength);
             if (length === 0) {
                 return EmptyUint8Array;
@@ -256,5 +320,15 @@ export const buffer: BufferLike = function (
 
             return reader.readExactly(length);
         },
-    };
-} as never;
+        {
+            init(value, dependencies) {
+                dependencies[lengthOrField.field] = lengthOrField.back(
+                    (value as Uint8Array).length,
+                );
+                return undefined;
+            },
+        },
+    );
+}
+
+export const buffer = _buffer;