@yume-chan/struct 0.0.24 → 2.0.0

package/src/index.ts

@@ -10,9 +10,14 @@ declare global {
     }
 }
 
-export * from "./basic/index.js";
+export * from "./bipedal.js";
+export * from "./buffer.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 { Struct as default } from "./struct.js";
-export * from "./sync-promise.js";
-export * from "./types/index.js";
+export * from "./types.js";
 export * from "./utils.js";

package/src/number.ts

@@ -0,0 +1,134 @@
+import type { MaybePromiseLike } from "@yume-chan/async";
+import {
+    getInt16,
+    getInt32,
+    getInt64,
+    getInt8,
+    getUint16,
+    getUint32,
+    getUint64,
+    setInt16,
+    setInt32,
+    setInt64,
+    setUint16,
+    setUint32,
+    setUint64,
+} from "@yume-chan/no-data-view";
+
+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, T> {
+    <const U>(infer?: U): Field<U, never, never, T>;
+}
+
+/* #__NO_SIDE_EFFECTS__ */
+function number<T>(
+    size: number,
+    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: NumberField<number> = number(
+    1,
+    (value, { buffer, index }) => {
+        buffer[index] = value;
+    },
+    function* (then, reader) {
+        const data = yield* then(reader.readExactly(1));
+        return data[0]!;
+    },
+);
+
+export const s8: NumberField<number> = number(
+    1,
+    (value, { buffer, index }) => {
+        buffer[index] = value;
+    },
+    function* (then, reader) {
+        const data = yield* then(reader.readExactly(1));
+        return getInt8(data, 0);
+    },
+);
+
+export const u16: NumberField<number> = number(
+    2,
+    (value, { buffer, index, littleEndian }) => {
+        setUint16(buffer, index, value, littleEndian);
+    },
+    function* (then, reader, { littleEndian }) {
+        const data = yield* then(reader.readExactly(2));
+        return getUint16(data, 0, littleEndian);
+    },
+);
+
+export const s16: NumberField<number> = number(
+    2,
+    (value, { buffer, index, littleEndian }) => {
+        setInt16(buffer, index, value, littleEndian);
+    },
+    function* (then, reader, { littleEndian }) {
+        const data = yield* then(reader.readExactly(2));
+        return getInt16(data, 0, littleEndian);
+    },
+);
+
+export const u32: NumberField<number> = number(
+    4,
+    (value, { buffer, index, littleEndian }) => {
+        setUint32(buffer, index, value, littleEndian);
+    },
+    function* (then, reader, { littleEndian }) {
+        const data = yield* then(reader.readExactly(4));
+        return getUint32(data, 0, littleEndian);
+    },
+);
+
+export const s32: NumberField<number> = number(
+    4,
+    (value, { buffer, index, littleEndian }) => {
+        setInt32(buffer, index, value, littleEndian);
+    },
+    function* (then, reader, { littleEndian }) {
+        const data = yield* then(reader.readExactly(4));
+        return getInt32(data, 0, littleEndian);
+    },
+);
+
+export const u64: NumberField<bigint> = number(
+    8,
+    (value, { buffer, index, littleEndian }) => {
+        setUint64(buffer, index, value, littleEndian);
+    },
+    function* (then, reader, { littleEndian }) {
+        const data = yield* then(reader.readExactly(8));
+        return getUint64(data, 0, littleEndian);
+    },
+);
+
+export const s64: NumberField<bigint> = number(
+    8,
+    (value, { buffer, index, littleEndian }) => {
+        setInt64(buffer, index, value, littleEndian);
+    },
+    function* (then, reader, { littleEndian }) {
+        const data = yield* then(reader.readExactly(8));
+        return getInt64(data, 0, littleEndian);
+    },
+);

package/src/{basic/stream.ts → readable.ts}

@@ -1,11 +1,10 @@
-import type { ValueOrPromise } from "../utils.js";
-
 // TODO: allow over reading (returning a `Uint8Array`, an `offset` and a `length`) to avoid copying
 
+import type { MaybePromiseLike } from "@yume-chan/async";
+
 export class ExactReadableEndedError extends Error {
     constructor() {
         super("ExactReadable ended");
-        Object.setPrototypeOf(this, new.target.prototype);
     }
 }
 
@@ -21,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;
 
@@ -30,5 +57,5 @@ export interface AsyncExactReadable {
      * The stream must return exactly `length` bytes or data. If that's not possible
      * (due to end of file or other error condition), it must throw an {@link ExactReadableEndedError}.
      */
-    readExactly(length: number): ValueOrPromise<Uint8Array>;
+    readExactly(length: number): MaybePromiseLike<Uint8Array>;
 }

package/src/string.ts

@@ -0,0 +1,41 @@
+import type { BufferLengthConverter } from "./buffer.js";
+import { buffer } from "./buffer.js";
+import type { Field } from "./field/index.js";
+import { decodeUtf8, encodeUtf8 } from "./utils.js";
+
+export interface String {
+    (length: number): Field<string, never, never> & {
+        as: <T>(infer: T) => Field<T, never, never>;
+    };
+
+    <K extends string>(
+        lengthField: K,
+    ): Field<string, K, Record<K, number>> & {
+        as: <T>(infer: T) => Field<T, K, Record<K, number>>;
+    };
+
+    <const K extends string, KT>(
+        length: BufferLengthConverter<K, KT>,
+    ): Field<string, K, Record<K, KT>> & {
+        as: <T>(infer: T) => Field<T, K, Record<K, KT>>;
+    };
+
+    <KOmitInit extends string, KS>(
+        length: Field<number, KOmitInit, KS>,
+    ): Field<string, KOmitInit, KS>;
+}
+
+// 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;
+}) as never;