@yume-chan/struct 0.0.5 → 0.0.10

package/src/basic/definition.ts

@@ -1,69 +1,72 @@
-import type { StructDeserializationContext, StructOptions, StructSerializationContext } from './context';
-import type { FieldRuntimeValue } from './runtime-value';
-
-type ValueOrPromise<T> = T | Promise<T>;
-
-/**
- * A field definition is a bridge between its type and its runtime value.
- *
- * `Struct` record fields in a list of `FieldDefinition`s.
- *
- * When `Struct#create` or `Struct#deserialize` are called, each field's definition
- * crates its own type of `FieldRuntimeValue` to manage the field value in that `Struct` instance.
- *
- * One `FieldDefinition` can represents multiple similar types, just returns the corresponding
- * `FieldRuntimeValue` when `createValue` was called.
- *
- * @template TOptions TypeScript type of this definition's `options`.
- * @template TValueType TypeScript type of this field.
- * @template TOmitInit Optionally remove some fields from the init type. Should be a union of string literal types.
- */
-export abstract class FieldDefinition<
-    TOptions = void,
-    TValueType = unknown,
-    TOmitInit = never,
-    > {
-    public readonly options: TOptions;
-
-    /**
-     * When `T` is a type initiated `FieldDefinition`,
-     * use `T['valueType']` to retrieve its `TValueType` type parameter.
-     */
-    public readonly valueType!: TValueType;
-
-    /**
-     * When `T` is a type initiated `FieldDefinition`,
-     * use `T['omitInitType']` to retrieve its `TOmitInit` type parameter.
-     */
-    public readonly omitInitType!: TOmitInit;
-
-    public constructor(options: TOptions) {
-        this.options = options;
-    }
-
-    /**
-     * When implemented in derived classes, returns the size (or minimal size if it's dynamic) of this field.
-     *
-     * Actual size can be retrieved from `FieldRuntimeValue#getSize`
-     */
-    public abstract getSize(): number;
-
-    /**
-     * When implemented in derived classes, creates a `FieldRuntimeValue` by parsing the `context`.
-     */
-    public abstract deserialize(
-        options: Readonly<StructOptions>,
-        context: StructDeserializationContext,
-        object: any,
-    ): ValueOrPromise<FieldRuntimeValue<FieldDefinition<TOptions, TValueType, TOmitInit>>>;
-
-    /**
-     * When implemented in derived classes, creates a `FieldRuntimeValue` from a given `value`.
-     */
-    public abstract createValue(
-        options: Readonly<StructOptions>,
-        context: StructSerializationContext,
-        object: any,
-        value: TValueType,
-    ): FieldRuntimeValue<FieldDefinition<TOptions, TValueType, TOmitInit>>;
-}
+import type { StructAsyncDeserializeStream, StructDeserializeStream, StructOptions } from './context';
+import type { StructFieldValue } from './field-value';
+import type { StructValue } from './struct-value';
+
+/**
+ * A field definition is a bridge between its type and its runtime value.
+ *
+ * `Struct` record fields in a list of `StructFieldDefinition`s.
+ *
+ * When `Struct#create` or `Struct#deserialize` are called, each field's definition
+ * crates its own type of `StructFieldValue` to manage the field value in that `Struct` instance.
+ *
+ * One `StructFieldDefinition` can represents multiple similar types, just returns the corresponding
+ * `StructFieldValue` when `createValue` was called.
+ *
+ * @template TOptions TypeScript type of this definition's `options`.
+ * @template TValue TypeScript type of this field.
+ * @template TOmitInitKey Optionally remove some fields from the init type. Should be a union of string literal types.
+ */
+export abstract class StructFieldDefinition<
+    TOptions = void,
+    TValue = unknown,
+    TOmitInitKey extends PropertyKey = never,
+    > {
+    /**
+     * When `T` is a type initiated `StructFieldDefinition`,
+     * use `T['TValue']` to retrieve its `TValue` type parameter.
+     */
+    public readonly TValue!: TValue;
+
+    /**
+     * When `T` is a type initiated `StructFieldDefinition`,
+     * use `T['TOmitInitKey']` to retrieve its `TOmitInitKey` type parameter.
+     */
+    public readonly TOmitInitKey!: TOmitInitKey;
+
+    public readonly options: TOptions;
+
+    public constructor(options: TOptions) {
+        this.options = options;
+    }
+
+    /**
+     * When implemented in derived classes, returns the size (or minimal size if it's dynamic) of this field.
+     *
+     * Actual size can be retrieved from `StructFieldValue#getSize`
+     */
+    public abstract getSize(): number;
+
+    /**
+     * When implemented in derived classes, creates a `StructFieldValue` from a given `value`.
+     */
+    public abstract create(
+        options: Readonly<StructOptions>,
+        struct: StructValue,
+        value: TValue,
+    ): StructFieldValue<this>;
+
+    /**
+     * When implemented in derived classes, creates a `StructFieldValue` by parsing `context`.
+     */
+    public abstract deserialize(
+        options: Readonly<StructOptions>,
+        stream: StructDeserializeStream,
+        struct: StructValue,
+    ): StructFieldValue<this>;
+    public abstract deserialize(
+        options: Readonly<StructOptions>,
+        stream: StructAsyncDeserializeStream,
+        struct: StructValue,
+    ): Promise<StructFieldValue<this>>;
+}

package/src/basic/{runtime-value.ts → field-value.ts}

@@ -1,72 +1,67 @@
-import type { StructOptions, StructSerializationContext } from './context';
-import type { FieldDefinition } from './definition';
-
-/**
- * Field runtime value manages one field of one `Struct` instance.
- *
- * If one `FieldDefinition` needs to change other field's semantics
- * It can override other fields' `FieldRuntimeValue` in its own `FieldRuntimeValue`'s constructor
- */
-export abstract class FieldRuntimeValue<
-    TDefinition extends FieldDefinition<any, any, any> = FieldDefinition<any, any, any>
-    > {
-    /** Gets the definition associated with this runtime value */
-    public readonly definition: TDefinition;
-
-    /** Gets the options of the associated `Struct` */
-    public readonly options: Readonly<StructOptions>;
-
-    /** Gets the serialization context of the associated `Struct` instance */
-    public readonly context: StructSerializationContext;
-
-    /** Gets the associated `Struct` instance */
-    public readonly object: any;
-
-    protected value: TDefinition['valueType'];
-
-    public constructor(
-        definition: TDefinition,
-        options: Readonly<StructOptions>,
-        context: StructSerializationContext,
-        object: any,
-        value: TDefinition['valueType'],
-    ) {
-        this.definition = definition;
-        this.options = options;
-        this.context = context;
-        this.object = object;
-        this.value = value;
-    }
-
-    /**
-     * Gets the actual size of this field. By default, the return value of its `definition.getSize()`
-     *
-     * When overridden in derived classes, can have custom logic to calculate the actual size.
-     */
-    public getSize(): number {
-        return this.definition.getSize();
-    }
-
-    /**
-     * When implemented in derived classes, returns the current value of this field
-     */
-    public get(): TDefinition['valueType'] {
-        return this.value;
-    }
-
-    /**
-     * When implemented in derived classes, update the current value of this field
-     */
-    public set(value: TDefinition['valueType']): void {
-        this.value = value;
-    }
-
-    /**
-     * When implemented in derived classes, serializes this field into `dataView` at `offset`
-     */
-    public abstract serialize(
-        dataView: DataView,
-        offset: number,
-        context: StructSerializationContext
-    ): void;
-}
+import type { StructOptions } from './context';
+import type { StructFieldDefinition } from './definition';
+import type { StructValue } from './struct-value';
+
+/**
+ * Field runtime value manages one field of one `Struct` instance.
+ *
+ * If one `StructFieldDefinition` needs to change other field's semantics
+ * It can override other fields' `StructFieldValue` in its own `StructFieldValue`'s constructor
+ */
+export abstract class StructFieldValue<
+    TDefinition extends StructFieldDefinition<any, any, any> = StructFieldDefinition<any, any, any>
+    > {
+    /** Gets the definition associated with this runtime value */
+    public readonly definition: TDefinition;
+
+    /** Gets the options of the associated `Struct` */
+    public readonly options: Readonly<StructOptions>;
+
+    /** Gets the associated `Struct` instance */
+    public readonly struct: StructValue;
+
+    protected value: TDefinition['TValue'];
+
+    public constructor(
+        definition: TDefinition,
+        options: Readonly<StructOptions>,
+        struct: StructValue,
+        value: TDefinition['TValue'],
+    ) {
+        this.definition = definition;
+        this.options = options;
+        this.struct = struct;
+        this.value = value;
+    }
+
+    /**
+     * Gets size of this field. By default, it returns its `definition`'s size.
+     *
+     * When overridden in derived classes, can have custom logic to calculate the actual size.
+     */
+    public getSize(): number {
+        return this.definition.getSize();
+    }
+
+    /**
+     * When implemented in derived classes, returns the current value of this field
+     */
+    public get(): TDefinition['TValue'] {
+        return this.value;
+    }
+
+    /**
+     * When implemented in derived classes, update the current value of this field
+     */
+    public set(value: TDefinition['TValue']): void {
+        this.value = value;
+    }
+
+    /**
+     * When implemented in derived classes, serializes this field into `dataView` at `offset`
+     */
+    public abstract serialize(
+        dataView: DataView,
+        offset: number,
+    ): void;
+}

package/src/basic/index.ts

@@ -1,4 +1,4 @@
-export * from './context';
-export * from './definition';
-export * from './runtime-value';
-export * from './runtime-object';
+export * from './context';
+export * from './definition';
+export * from './field-value';
+export * from './struct-value';

package/src/basic/struct-value.ts

@@ -0,0 +1,39 @@
+import type { StructFieldValue } from './field-value';
+
+/**
+ * Manages the initialization process of a struct value
+ */
+export class StructValue {
+    /** @internal */ readonly fieldValues: Record<PropertyKey, StructFieldValue> = {};
+
+    /**
+     * Gets the result struct value object
+     */
+    public readonly value: Record<PropertyKey, unknown> = {};
+
+    /**
+     * Sets a `StructFieldValue` for `key`
+     *
+     * @param key The field name
+     * @param value The associated `StructFieldValue`
+     */
+    public set(key: PropertyKey, value: StructFieldValue): void {
+        this.fieldValues[key] = value;
+
+        Object.defineProperty(this.value, key, {
+            configurable: true,
+            enumerable: true,
+            get() { return value.get(); },
+            set(v) { value.set(v); },
+        });
+    }
+
+    /**
+     * Gets a previously `StructFieldValue` for `key`
+     *
+     * @param key The field name
+     */
+    public get(key: PropertyKey): StructFieldValue {
+        return this.fieldValues[key];
+    }
+}

package/src/index.ts

@@ -1,4 +1,5 @@
-export * from './basic';
-export * from './struct';
-export { Struct as default } from './struct';
-export * from './types';
+export * from './basic';
+export * from './struct';
+export { Struct as default } from './struct';
+export * from './types';
+export * from './utils';