@yume-chan/struct 0.0.5 → 0.0.10

package/src/syncbird.ts

@@ -0,0 +1,53 @@
+import Bluebird from 'bluebird';
+
+type Resolvable<R> = R | PromiseLike<R>;
+
+export interface Syncbird<R> extends Bluebird<R> {
+    valueOrPromise(): R | PromiseLike<R>;
+
+    then<U>(onFulfill?: (value: R) => Resolvable<U>, onReject?: (error: any) => Resolvable<U>): Syncbird<U>; // For simpler signature help.
+    then<TResult1 = R, TResult2 = never>(
+        onfulfilled?: ((value: R) => Resolvable<TResult1>) | null,
+        onrejected?: ((reason: any) => Resolvable<TResult2>) | null
+    ): Syncbird<TResult1 | TResult2>;
+}
+
+interface SyncbirdStatic {
+    /**
+     * Create a promise that is resolved with the given `value`. If `value` is a thenable or promise, the returned promise will assume its state.
+     */
+    resolve(): Syncbird<void>;
+    resolve<R>(value: Resolvable<R>): Syncbird<R>;
+
+    try<R>(fn: () => Resolvable<R>): Syncbird<R>;
+    attempt<R>(fn: () => Resolvable<R>): Syncbird<R>;
+
+    new <R>(callback: (resolve: (thenableOrResult?: Resolvable<R>) => void, reject: (error?: any) => void, onCancel?: (callback: () => void) => void) => void): Syncbird<R>;
+}
+
+export const Syncbird: SyncbirdStatic = Bluebird.getNewLibraryCopy() as any;
+
+const _then = Bluebird.prototype.then;
+Syncbird.prototype.then = function <T, TResult1 = T, TResult2 = never>(
+    this: Bluebird<T>,
+    onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null,
+    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null
+): Syncbird<TResult1 | TResult2> {
+    if (this.isFulfilled()) {
+        if (!onfulfilled) {
+            return this as unknown as Syncbird<TResult1>;
+        } else {
+            return Syncbird.resolve(onfulfilled(this.value())) as Syncbird<TResult1 | TResult2>;
+        }
+    } else {
+        return _then.call(this, onfulfilled, onrejected) as Syncbird<TResult1 | TResult2>;
+    }
+};
+
+(Syncbird.prototype as any).valueOrPromise = function <T>(this: Bluebird<T>): T | PromiseLike<T> {
+    if (this.isFulfilled()) {
+        return this.value();
+    } else {
+        return this as Promise<T>;
+    }
+};

package/src/types/array-buffer.ts

@@ -1,171 +1,194 @@
-import { FieldDefinition, FieldRuntimeValue, StructDeserializationContext, StructOptions, StructSerializationContext } from '../basic';
-
-/**
- * Base class for all types that
- * can be converted from an ArrayBuffer when deserialized,
- * and need to be converted to an ArrayBuffer when serializing
- *
- * @template TType The actual TypeScript type of this type
- * @template TTypeScriptType Optional another type (should be compatible with `TType`)
- * specified by user when creating field definitions.
- */
-export abstract class ArrayBufferLikeFieldType<TType = unknown, TTypeScriptType = TType> {
-    public readonly valueType!: TTypeScriptType;
-
-    /**
-     * When implemented in derived classes, converts the type-specific `value` to an `ArrayBuffer`
-     *
-     * This function should be "pure", i.e.,
-     * same `value` should always be converted to `ArrayBuffer`s that have same content.
-     */
-    public abstract toArrayBuffer(value: TType, context: StructSerializationContext): ArrayBuffer;
-
-    /** When implemented in derived classes, converts the `ArrayBuffer` to a type-specific value */
-    public abstract fromArrayBuffer(arrayBuffer: ArrayBuffer, context: StructDeserializationContext): TType;
-
-    /**
-     * When implemented in derived classes, gets the size in byte of the type-specific `value`.
-     *
-     * If the size can't be calculated without first converting the `value` back to an `ArrayBuffer`,
-     * implementer should returns `-1` so the caller will get its size by first converting it to
-     * an `ArrayBuffer` (and cache the result).
-     */
-    public abstract getSize(value: TType): number;
-}
-
-/** An ArrayBufferLike type that's actually an `ArrayBuffer` */
-export class ArrayBufferFieldType extends ArrayBufferLikeFieldType<ArrayBuffer> {
-    public static readonly instance = new ArrayBufferFieldType();
-
-    protected constructor() {
-        super();
-    }
-
-    public toArrayBuffer(value: ArrayBuffer): ArrayBuffer {
-        return value;
-    }
-
-    public fromArrayBuffer(arrayBuffer: ArrayBuffer): ArrayBuffer {
-        return arrayBuffer;
-    }
-
-    public getSize(value: ArrayBuffer): number {
-        return value.byteLength;
-    }
-}
-
-/** Am ArrayBufferLike type that converts to/from the `ArrayBuffer` from/to a `Uint8ClampedArray` */
-export class Uint8ClampedArrayFieldType
-    extends ArrayBufferLikeFieldType<Uint8ClampedArray, Uint8ClampedArray> {
-    public static readonly instance = new Uint8ClampedArrayFieldType();
-
-    protected constructor() {
-        super();
-    }
-
-    public toArrayBuffer(value: Uint8ClampedArray): ArrayBuffer {
-        return value.buffer;
-    }
-
-    public fromArrayBuffer(arrayBuffer: ArrayBuffer): Uint8ClampedArray {
-        return new Uint8ClampedArray(arrayBuffer);
-    }
-
-    public getSize(value: Uint8ClampedArray): number {
-        return value.byteLength;
-    }
-}
-
-/** Am ArrayBufferLike type that converts to/from the `ArrayBuffer` from/to a `string` */
-export class StringFieldType<TTypeScriptType = string>
-    extends ArrayBufferLikeFieldType<string, TTypeScriptType> {
-    public static readonly instance = new StringFieldType();
-
-    public toArrayBuffer(value: string, context: StructSerializationContext): ArrayBuffer {
-        return context.encodeUtf8(value);
-    }
-
-    public fromArrayBuffer(arrayBuffer: ArrayBuffer, context: StructDeserializationContext): string {
-        return context.decodeUtf8(arrayBuffer);
-    }
-
-    public getSize(): number {
-        // Return `-1`, so `ArrayBufferLikeFieldDefinition` will
-        // convert this `value` into an `ArrayBuffer` (and cache the result),
-        // Then get the size from that `ArrayBuffer`
-        return -1;
-    }
-}
-
-const EmptyArrayBuffer = new ArrayBuffer(0);
-
-export abstract class ArrayBufferLikeFieldDefinition<
-    TType extends ArrayBufferLikeFieldType = ArrayBufferLikeFieldType,
-    TOptions = void,
-    TOmitInit = never,
-    > extends FieldDefinition<
-    TOptions,
-    TType['valueType'],
-    TOmitInit
-    >{
-    public readonly type: TType;
-
-    public constructor(type: TType, options: TOptions) {
-        super(options);
-        this.type = type;
-    }
-
-    protected getDeserializeSize(object: any): number {
-        return this.getSize();
-    }
-
-    public async deserialize(
-        options: Readonly<StructOptions>,
-        context: StructDeserializationContext,
-        object: any,
-    ): Promise<ArrayBufferLikeFieldRuntimeValue<ArrayBufferLikeFieldDefinition<TType, TOptions, TOmitInit>>> {
-        const size = this.getDeserializeSize(object);
-
-        let arrayBuffer: ArrayBuffer;
-        if (size === 0) {
-            arrayBuffer = EmptyArrayBuffer;
-        } else {
-            arrayBuffer = await context.read(size);
-        }
-
-        const value = this.type.fromArrayBuffer(arrayBuffer, context);
-        const runtimeValue = this.createValue(options, context, object, value);
-        runtimeValue.arrayBuffer = arrayBuffer;
-        return runtimeValue;
-    }
-
-    /**
-     * When implemented in derived classes, creates a `FieldRuntimeValue` for the current field definition.
-     */
-    public abstract createValue(
-        options: Readonly<StructOptions>,
-        context: StructSerializationContext,
-        object: any,
-        value: TType['valueType'],
-    ): ArrayBufferLikeFieldRuntimeValue<ArrayBufferLikeFieldDefinition<TType, TOptions, TOmitInit>>;
-}
-
-export class ArrayBufferLikeFieldRuntimeValue<
-    TDefinition extends ArrayBufferLikeFieldDefinition<any, any, any>,
-    > extends FieldRuntimeValue<TDefinition> {
-    public arrayBuffer: ArrayBuffer | undefined;
-
-    public set(value: TDefinition['valueType']): void {
-        super.set(value);
-        this.arrayBuffer = undefined;
-    }
-
-    public serialize(dataView: DataView, offset: number, context: StructSerializationContext): void {
-        if (!this.arrayBuffer) {
-            this.arrayBuffer = this.definition.type.toArrayBuffer(this.value, context);
-        }
-
-        new Uint8Array(dataView.buffer)
-            .set(new Uint8Array(this.arrayBuffer!), offset);
-    }
-}
+import { StructAsyncDeserializeStream, StructDeserializeStream, StructFieldDefinition, StructFieldValue, StructOptions, StructValue } from '../basic';
+import { Syncbird } from "../syncbird";
+import { decodeUtf8, encodeUtf8, ValueOrPromise } from "../utils";
+
+/**
+ * Base class for all types that
+ * can be converted from an ArrayBuffer when deserialized,
+ * and need to be converted to an ArrayBuffer when serializing
+ *
+ * @template TValue The actual TypeScript type of this type
+ * @template TTypeScriptType Optional another type (should be compatible with `TType`)
+ * specified by user when creating field definitions.
+ */
+export abstract class ArrayBufferLikeFieldType<TValue = unknown, TTypeScriptType = TValue> {
+    public readonly TTypeScriptType!: TTypeScriptType;
+
+    /**
+     * When implemented in derived classes, converts the type-specific `value` to an `ArrayBuffer`
+     *
+     * This function should be "pure", i.e.,
+     * same `value` should always be converted to `ArrayBuffer`s that have same content.
+     */
+    public abstract toArrayBuffer(value: TValue): ArrayBuffer;
+
+    /** When implemented in derived classes, converts the `ArrayBuffer` to a type-specific value */
+    public abstract fromArrayBuffer(arrayBuffer: ArrayBuffer): TValue;
+
+    /**
+     * When implemented in derived classes, gets the size in byte of the type-specific `value`.
+     *
+     * If the size can't be calculated without first converting the `value` back to an `ArrayBuffer`,
+     * implementer should returns `-1` so the caller will get its size by first converting it to
+     * an `ArrayBuffer` (and cache the result).
+     */
+    public abstract getSize(value: TValue): number;
+}
+
+/** An ArrayBufferLike type that's actually an `ArrayBuffer` */
+export class ArrayBufferFieldType extends ArrayBufferLikeFieldType<ArrayBuffer> {
+    public static readonly instance = new ArrayBufferFieldType();
+
+    protected constructor() {
+        super();
+    }
+
+    public toArrayBuffer(value: ArrayBuffer): ArrayBuffer {
+        return value;
+    }
+
+    public fromArrayBuffer(arrayBuffer: ArrayBuffer): ArrayBuffer {
+        return arrayBuffer;
+    }
+
+    public getSize(value: ArrayBuffer): number {
+        return value.byteLength;
+    }
+}
+
+/** Am ArrayBufferLike type that converts between `ArrayBuffer` and `Uint8ClampedArray` */
+export class Uint8ClampedArrayFieldType
+    extends ArrayBufferLikeFieldType<Uint8ClampedArray, Uint8ClampedArray> {
+    public static readonly instance = new Uint8ClampedArrayFieldType();
+
+    protected constructor() {
+        super();
+    }
+
+    public toArrayBuffer(value: Uint8ClampedArray): ArrayBuffer {
+        return value.buffer;
+    }
+
+    public fromArrayBuffer(arrayBuffer: ArrayBuffer): Uint8ClampedArray {
+        return new Uint8ClampedArray(arrayBuffer);
+    }
+
+    public getSize(value: Uint8ClampedArray): number {
+        return value.byteLength;
+    }
+}
+
+/** An ArrayBufferLike type that converts between `ArrayBuffer` and `string` */
+export class StringFieldType<TTypeScriptType = string>
+    extends ArrayBufferLikeFieldType<string, TTypeScriptType> {
+    public static readonly instance = new StringFieldType();
+
+    public toArrayBuffer(value: string): ArrayBuffer {
+        return encodeUtf8(value);
+    }
+
+    public fromArrayBuffer(arrayBuffer: ArrayBuffer): string {
+        return decodeUtf8(arrayBuffer);
+    }
+
+    public getSize(): number {
+        // Return `-1`, so `ArrayBufferLikeFieldDefinition` will
+        // convert this `value` into an `ArrayBuffer` (and cache the result),
+        // Then get the size from that `ArrayBuffer`
+        return -1;
+    }
+}
+
+const EmptyArrayBuffer = new ArrayBuffer(0);
+
+export abstract class ArrayBufferLikeFieldDefinition<
+    TType extends ArrayBufferLikeFieldType<any, any> = ArrayBufferLikeFieldType<unknown, unknown>,
+    TOptions = void,
+    TOmitInitKey extends PropertyKey = never,
+    > extends StructFieldDefinition<
+    TOptions,
+    TType['TTypeScriptType'],
+    TOmitInitKey
+    >{
+    public readonly type: TType;
+
+    public constructor(type: TType, options: TOptions) {
+        super(options);
+        this.type = type;
+    }
+
+    protected getDeserializeSize(struct: StructValue): number {
+        return this.getSize();
+    }
+
+    /**
+     * When implemented in derived classes, creates a `StructFieldValue` for the current field definition.
+     */
+    public create(
+        options: Readonly<StructOptions>,
+        struct: StructValue,
+        value: TType['TTypeScriptType'],
+        arrayBuffer?: ArrayBuffer,
+    ): ArrayBufferLikeFieldValue<this> {
+        return new ArrayBufferLikeFieldValue(this, options, struct, value, arrayBuffer);
+    }
+
+    public override deserialize(
+        options: Readonly<StructOptions>,
+        stream: StructDeserializeStream,
+        struct: StructValue,
+    ): ArrayBufferLikeFieldValue<this>;
+    public override deserialize(
+        options: Readonly<StructOptions>,
+        stream: StructAsyncDeserializeStream,
+        struct: StructValue,
+    ): Promise<ArrayBufferLikeFieldValue<this>>;
+    public override deserialize(
+        options: Readonly<StructOptions>,
+        stream: StructDeserializeStream | StructAsyncDeserializeStream,
+        struct: StructValue,
+    ): ValueOrPromise<ArrayBufferLikeFieldValue<this>> {
+        return Syncbird.try(() => {
+            const size = this.getDeserializeSize(struct);
+            if (size === 0) {
+                return EmptyArrayBuffer;
+            } else {
+                return stream.read(size);
+            }
+        }).then(arrayBuffer => {
+            const value = this.type.fromArrayBuffer(arrayBuffer);
+            return this.create(options, struct, value, arrayBuffer);
+        }).valueOrPromise();
+    }
+}
+
+export class ArrayBufferLikeFieldValue<
+    TDefinition extends ArrayBufferLikeFieldDefinition<ArrayBufferLikeFieldType<unknown, unknown>, any, any>,
+    > extends StructFieldValue<TDefinition> {
+    protected arrayBuffer: ArrayBuffer | undefined;
+
+    public constructor(
+        definition: TDefinition,
+        options: Readonly<StructOptions>,
+        struct: StructValue,
+        value: TDefinition['TValue'],
+        arrayBuffer?: ArrayBuffer,
+    ) {
+        super(definition, options, struct, value);
+        this.arrayBuffer = arrayBuffer;
+    }
+
+    public override set(value: TDefinition['TValue']): void {
+        super.set(value);
+        this.arrayBuffer = undefined;
+    }
+
+    public serialize(dataView: DataView, offset: number): void {
+        if (!this.arrayBuffer) {
+            this.arrayBuffer = this.definition.type.toArrayBuffer(this.value);
+        }
+
+        new Uint8Array(dataView.buffer)
+            .set(new Uint8Array(this.arrayBuffer), offset);
+    }
+}

package/src/types/fixed-length-array-buffer.ts

@@ -1,27 +1,17 @@
-import { StructOptions, StructSerializationContext } from '../basic';
-import { ArrayBufferLikeFieldDefinition, ArrayBufferLikeFieldRuntimeValue, ArrayBufferLikeFieldType } from './array-buffer';
-
-export interface FixedLengthArrayBufferLikeFieldOptions {
-    length: number;
-}
-
-export class FixedLengthArrayBufferLikeFieldDefinition<
-    TType extends ArrayBufferLikeFieldType = ArrayBufferLikeFieldType,
-    TOptions extends FixedLengthArrayBufferLikeFieldOptions = FixedLengthArrayBufferLikeFieldOptions,
-    > extends ArrayBufferLikeFieldDefinition<
-    TType,
-    TOptions
-    > {
-    public getSize(): number {
-        return this.options.length;
-    }
-
-    public createValue(
-        options: Readonly<StructOptions>,
-        context: StructSerializationContext,
-        object: any,
-        value: TType['valueType']
-    ): ArrayBufferLikeFieldRuntimeValue<FixedLengthArrayBufferLikeFieldDefinition<TType, TOptions>> {
-        return new ArrayBufferLikeFieldRuntimeValue(this, options, context, object, value);
-    }
-};
+import { ArrayBufferLikeFieldDefinition, ArrayBufferLikeFieldType } from './array-buffer';
+
+export interface FixedLengthArrayBufferLikeFieldOptions {
+    length: number;
+}
+
+export class FixedLengthArrayBufferLikeFieldDefinition<
+    TType extends ArrayBufferLikeFieldType = ArrayBufferLikeFieldType,
+    TOptions extends FixedLengthArrayBufferLikeFieldOptions = FixedLengthArrayBufferLikeFieldOptions,
+    > extends ArrayBufferLikeFieldDefinition<
+    TType,
+    TOptions
+    > {
+    public getSize(): number {
+        return this.options.length;
+    }
+};

package/src/types/index.ts

@@ -1,5 +1,4 @@
-export * from './array-buffer';
-export * from './fixed-length-array-buffer';
-export * from './number';
-export * from './utils';
-export * from './variable-length-array-buffer';
+export * from './array-buffer';
+export * from './fixed-length-array-buffer';
+export * from './number';
+export * from './variable-length-array-buffer';