seroval 1.4.0 → 1.4.1

package/src/core/context/deserializer.ts

@@ -1,646 +0,0 @@
-import {
-  CONSTANT_VAL,
-  ERROR_CONSTRUCTOR,
-  SerovalNodeType,
-  SerovalObjectFlags,
-  SYMBOL_REF,
-} from '../constants';
-import {
-  ARRAY_BUFFER_CONSTRUCTOR,
-  PROMISE_CONSTRUCTOR,
-  type PromiseConstructorResolver,
-} from '../constructors';
-import {
-  SerovalDeserializationError,
-  SerovalMissingInstanceError,
-  SerovalMissingPluginError,
-  SerovalUnsupportedNodeError,
-} from '../errors';
-import type { PluginAccessOptions } from '../plugin';
-import { SerovalMode } from '../plugin';
-import { getReference } from '../reference';
-import type { Stream } from '../stream';
-import { createStream, streamToAsyncIterable } from '../stream';
-import { deserializeString } from '../string';
-import type {
-  SerovalAggregateErrorNode,
-  SerovalArrayBufferNode,
-  SerovalArrayNode,
-  SerovalAsyncIteratorFactoryInstanceNode,
-  SerovalAsyncIteratorFactoryNode,
-  SerovalBigIntTypedArrayNode,
-  SerovalBoxedNode,
-  SerovalDataViewNode,
-  SerovalDateNode,
-  SerovalErrorNode,
-  SerovalIteratorFactoryInstanceNode,
-  SerovalIteratorFactoryNode,
-  SerovalMapNode,
-  SerovalNode,
-  SerovalNullConstructorNode,
-  SerovalObjectNode,
-  SerovalObjectRecordKey,
-  SerovalObjectRecordNode,
-  SerovalPluginNode,
-  SerovalPromiseConstructorNode,
-  SerovalPromiseNode,
-  SerovalPromiseRejectNode,
-  SerovalPromiseResolveNode,
-  SerovalReferenceNode,
-  SerovalRegExpNode,
-  SerovalSetNode,
-  SerovalStreamConstructorNode,
-  SerovalStreamNextNode,
-  SerovalStreamReturnNode,
-  SerovalStreamThrowNode,
-  SerovalTypedArrayNode,
-} from '../types';
-import type { Sequence } from '../utils/iterator-to-sequence';
-import { sequenceToIterator } from '../utils/iterator-to-sequence';
-import type {
-  BigIntTypedArrayValue,
-  TypedArrayValue,
-} from '../utils/typed-array';
-import { getTypedArrayConstructor } from '../utils/typed-array';
-
-function applyObjectFlag(obj: unknown, flag: SerovalObjectFlags): unknown {
-  switch (flag) {
-    case SerovalObjectFlags.Frozen:
-      return Object.freeze(obj);
-    case SerovalObjectFlags.NonExtensible:
-      return Object.preventExtensions(obj);
-    case SerovalObjectFlags.Sealed:
-      return Object.seal(obj);
-    default:
-      return obj;
-  }
-}
-
-type AssignableValue = AggregateError | Error | Iterable<unknown>;
-type AssignableNode = SerovalAggregateErrorNode | SerovalErrorNode;
-
-export interface BaseDeserializerContextOptions extends PluginAccessOptions {
-  refs?: Map<number, unknown>;
-}
-
-export interface BaseDeserializerContext extends PluginAccessOptions {
-  readonly mode: SerovalMode;
-  /**
-   * Mapping ids to values
-   */
-  refs: Map<number, unknown>;
-}
-
-export function createBaseDeserializerContext(
-  mode: SerovalMode,
-  options: BaseDeserializerContextOptions,
-): BaseDeserializerContext {
-  return {
-    mode,
-    plugins: options.plugins,
-    refs: options.refs || new Map(),
-  };
-}
-
-export interface VanillaDeserializerContextOptions
-  extends Omit<BaseDeserializerContextOptions, 'refs'> {
-  markedRefs: number[] | Set<number>;
-}
-
-export interface VanillaDeserializerState {
-  marked: Set<number>;
-}
-
-export interface VanillaDeserializerContext {
-  mode: SerovalMode.Vanilla;
-  base: BaseDeserializerContext;
-  child: DeserializePluginContext | undefined;
-  state: VanillaDeserializerState;
-}
-
-export function createVanillaDeserializerContext(
-  options: VanillaDeserializerContextOptions,
-): VanillaDeserializerContext {
-  return {
-    mode: SerovalMode.Vanilla,
-    base: createBaseDeserializerContext(SerovalMode.Vanilla, options),
-    child: undefined,
-    state: {
-      marked: new Set(options.markedRefs),
-    },
-  };
-}
-
-export interface CrossDeserializerContext {
-  mode: SerovalMode.Cross;
-  base: BaseDeserializerContext;
-  child: DeserializePluginContext | undefined;
-}
-
-export type CrossDeserializerContextOptions = BaseDeserializerContextOptions;
-
-export function createCrossDeserializerContext(
-  options: CrossDeserializerContextOptions,
-): CrossDeserializerContext {
-  return {
-    mode: SerovalMode.Cross,
-    base: createBaseDeserializerContext(SerovalMode.Cross, options),
-    child: undefined,
-  };
-}
-
-type DeserializerContext =
-  | VanillaDeserializerContext
-  | CrossDeserializerContext;
-
-export class DeserializePluginContext {
-  constructor(private _p: DeserializerContext) {}
-
-  deserialize<T>(node: SerovalNode): T {
-    return deserialize(this._p, node) as T;
-  }
-}
-
-function assignIndexedValueVanilla<T>(
-  ctx: VanillaDeserializerContext,
-  id: number,
-  value: T,
-): T {
-  if (ctx.state.marked.has(id)) {
-    ctx.base.refs.set(id, value);
-  }
-  return value;
-}
-
-function assignIndexedValueCross<T>(
-  ctx: CrossDeserializerContext,
-  id: number,
-  value: T,
-): T {
-  if (!ctx.base.refs.has(id)) {
-    ctx.base.refs.set(id, value);
-  }
-  return value;
-}
-
-function assignIndexedValue<T>(
-  ctx: DeserializerContext,
-  id: number,
-  value: T,
-): T {
-  return ctx.mode === SerovalMode.Vanilla
-    ? assignIndexedValueVanilla(ctx, id, value)
-    : assignIndexedValueCross(ctx, id, value);
-}
-
-function deserializeReference(
-  ctx: DeserializerContext,
-  node: SerovalReferenceNode,
-): unknown {
-  return assignIndexedValue(
-    ctx,
-    node.i,
-    getReference(deserializeString(node.s)),
-  );
-}
-
-function deserializeArray(
-  ctx: DeserializerContext,
-  node: SerovalArrayNode,
-): unknown[] {
-  const len = node.l;
-  const result: unknown[] = assignIndexedValue(
-    ctx,
-    node.i,
-    new Array<unknown>(len),
-  );
-  let item: SerovalNode | undefined;
-  for (let i = 0; i < len; i++) {
-    item = node.a[i];
-    if (item) {
-      result[i] = deserialize(ctx, item);
-    }
-  }
-  applyObjectFlag(result, node.o);
-  return result;
-}
-
-function deserializeProperties(
-  ctx: DeserializerContext,
-  node: SerovalObjectRecordNode,
-  result: Record<string | symbol, unknown>,
-): Record<string | symbol, unknown> {
-  const len = node.s;
-  if (len) {
-    const keys = node.k;
-    const vals = node.v;
-    for (let i = 0, key: SerovalObjectRecordKey; i < len; i++) {
-      key = keys[i];
-      if (typeof key === 'string') {
-        result[deserializeString(key)] = deserialize(ctx, vals[i]);
-      } else {
-        result[deserialize(ctx, key) as symbol] = deserialize(ctx, vals[i]);
-      }
-    }
-  }
-  return result;
-}
-
-function deserializeObject(
-  ctx: DeserializerContext,
-  node: SerovalObjectNode | SerovalNullConstructorNode,
-): Record<string, unknown> {
-  const result = assignIndexedValue(
-    ctx,
-    node.i,
-    (node.t === SerovalNodeType.Object ? {} : Object.create(null)) as Record<
-      string,
-      unknown
-    >,
-  );
-  deserializeProperties(ctx, node.p, result);
-  applyObjectFlag(result, node.o);
-  return result;
-}
-
-function deserializeDate(
-  ctx: DeserializerContext,
-  node: SerovalDateNode,
-): Date {
-  return assignIndexedValue(ctx, node.i, new Date(node.s));
-}
-
-function deserializeRegExp(
-  ctx: DeserializerContext,
-  node: SerovalRegExpNode,
-): RegExp {
-  return assignIndexedValue(
-    ctx,
-    node.i,
-    new RegExp(deserializeString(node.c), node.m),
-  );
-}
-
-function deserializeSet(
-  ctx: DeserializerContext,
-  node: SerovalSetNode,
-): Set<unknown> {
-  const result = assignIndexedValue(ctx, node.i, new Set<unknown>());
-  const items = node.a;
-  for (let i = 0, len = node.l; i < len; i++) {
-    result.add(deserialize(ctx, items[i]));
-  }
-  return result;
-}
-
-function deserializeMap(
-  ctx: DeserializerContext,
-  node: SerovalMapNode,
-): Map<unknown, unknown> {
-  const result = assignIndexedValue(ctx, node.i, new Map<unknown, unknown>());
-  const keys = node.e.k;
-  const vals = node.e.v;
-  for (let i = 0, len = node.e.s; i < len; i++) {
-    result.set(deserialize(ctx, keys[i]), deserialize(ctx, vals[i]));
-  }
-  return result;
-}
-
-function deserializeArrayBuffer(
-  ctx: DeserializerContext,
-  node: SerovalArrayBufferNode,
-): ArrayBuffer {
-  const result = assignIndexedValue(
-    ctx,
-    node.i,
-    ARRAY_BUFFER_CONSTRUCTOR(node.l, deserializeString(node.s)),
-  );
-  return result;
-}
-
-function deserializeTypedArray(
-  ctx: DeserializerContext,
-  node: SerovalTypedArrayNode | SerovalBigIntTypedArrayNode,
-): TypedArrayValue | BigIntTypedArrayValue {
-  const construct = getTypedArrayConstructor(node.c) as Int8ArrayConstructor;
-  const source = deserialize(ctx, node.f) as ArrayBuffer;
-  const result = assignIndexedValue(
-    ctx,
-    node.i,
-    new construct(source, node.b, node.l),
-  );
-  return result;
-}
-
-function deserializeDataView(
-  ctx: DeserializerContext,
-  node: SerovalDataViewNode,
-): DataView {
-  const source = deserialize(ctx, node.f) as ArrayBuffer;
-  const result = assignIndexedValue(
-    ctx,
-    node.i,
-    new DataView(source, node.b, node.l),
-  );
-  return result;
-}
-
-function deserializeDictionary<T extends AssignableValue>(
-  ctx: DeserializerContext,
-  node: AssignableNode,
-  result: T,
-): T {
-  if (node.p) {
-    const fields = deserializeProperties(ctx, node.p, {});
-    Object.assign(result, fields);
-  }
-  return result;
-}
-
-function deserializeAggregateError(
-  ctx: DeserializerContext,
-  node: SerovalAggregateErrorNode,
-): AggregateError {
-  // Serialize the required arguments
-  const result = assignIndexedValue(
-    ctx,
-    node.i,
-    new AggregateError([], deserializeString(node.m)),
-  );
-  // `AggregateError` might've been extended
-  // either through class or custom properties
-  // Make sure to assign extra properties
-  return deserializeDictionary(ctx, node, result);
-}
-
-function deserializeError(
-  ctx: DeserializerContext,
-  node: SerovalErrorNode,
-): Error {
-  const construct = ERROR_CONSTRUCTOR[node.s];
-  const result = assignIndexedValue(
-    ctx,
-    node.i,
-    new construct(deserializeString(node.m)),
-  );
-  return deserializeDictionary(ctx, node, result);
-}
-
-function deserializePromise(
-  ctx: DeserializerContext,
-  node: SerovalPromiseNode,
-): Promise<unknown> {
-  const deferred = PROMISE_CONSTRUCTOR();
-  const result = assignIndexedValue(ctx, node.i, deferred.p);
-  const deserialized = deserialize(ctx, node.f);
-  if (node.s) {
-    deferred.s(deserialized);
-  } else {
-    deferred.f(deserialized);
-  }
-  return result;
-}
-
-function deserializeBoxed(
-  ctx: DeserializerContext,
-  node: SerovalBoxedNode,
-): unknown {
-  // biome-ignore lint/style/useConsistentBuiltinInstantiation: intended
-  return assignIndexedValue(ctx, node.i, Object(deserialize(ctx, node.f)));
-}
-
-function deserializePlugin(
-  ctx: DeserializerContext,
-  node: SerovalPluginNode,
-): unknown {
-  const currentPlugins = ctx.base.plugins;
-  if (currentPlugins) {
-    const tag = deserializeString(node.c);
-    for (let i = 0, len = currentPlugins.length; i < len; i++) {
-      const plugin = currentPlugins[i];
-      if (plugin.tag === tag) {
-        if (ctx.child == null) {
-          ctx.child = new DeserializePluginContext(ctx);
-        }
-        return assignIndexedValue(
-          ctx,
-          node.i,
-          plugin.deserialize(node.s, ctx.child, {
-            id: node.i,
-          }),
-        );
-      }
-    }
-  }
-  throw new SerovalMissingPluginError(node.c);
-}
-
-function deserializePromiseConstructor(
-  ctx: DeserializerContext,
-  node: SerovalPromiseConstructorNode,
-): unknown {
-  return assignIndexedValue(
-    ctx,
-    node.i,
-    assignIndexedValue(ctx, node.s, PROMISE_CONSTRUCTOR()).p,
-  );
-}
-
-function deserializePromiseResolve(
-  ctx: DeserializerContext,
-  node: SerovalPromiseResolveNode,
-): unknown {
-  const deferred = ctx.base.refs.get(node.i) as
-    | PromiseConstructorResolver
-    | undefined;
-  if (deferred) {
-    deferred.s(deserialize(ctx, node.a[1]));
-    return undefined;
-  }
-  throw new SerovalMissingInstanceError('Promise');
-}
-
-function deserializePromiseReject(
-  ctx: DeserializerContext,
-  node: SerovalPromiseRejectNode,
-): unknown {
-  const deferred = ctx.base.refs.get(node.i) as
-    | PromiseConstructorResolver
-    | undefined;
-  if (deferred) {
-    deferred.f(deserialize(ctx, node.a[1]));
-    return undefined;
-  }
-  throw new SerovalMissingInstanceError('Promise');
-}
-
-function deserializeIteratorFactoryInstance(
-  ctx: DeserializerContext,
-  node: SerovalIteratorFactoryInstanceNode,
-): unknown {
-  deserialize(ctx, node.a[0]);
-  const source = deserialize(ctx, node.a[1]);
-  return sequenceToIterator(source as Sequence);
-}
-
-function deserializeAsyncIteratorFactoryInstance(
-  ctx: DeserializerContext,
-  node: SerovalAsyncIteratorFactoryInstanceNode,
-): unknown {
-  deserialize(ctx, node.a[0]);
-  const source = deserialize(ctx, node.a[1]);
-  return streamToAsyncIterable(source as Stream<any>);
-}
-
-function deserializeStreamConstructor(
-  ctx: DeserializerContext,
-  node: SerovalStreamConstructorNode,
-): unknown {
-  const result = assignIndexedValue(ctx, node.i, createStream());
-  const len = node.a.length;
-  if (len) {
-    for (let i = 0; i < len; i++) {
-      deserialize(ctx, node.a[i]);
-    }
-  }
-  return result;
-}
-
-function deserializeStreamNext(
-  ctx: DeserializerContext,
-  node: SerovalStreamNextNode,
-): unknown {
-  const deferred = ctx.base.refs.get(node.i) as Stream<unknown> | undefined;
-  if (deferred) {
-    deferred.next(deserialize(ctx, node.f));
-    return undefined;
-  }
-  throw new SerovalMissingInstanceError('Stream');
-}
-
-function deserializeStreamThrow(
-  ctx: DeserializerContext,
-  node: SerovalStreamThrowNode,
-): unknown {
-  const deferred = ctx.base.refs.get(node.i) as Stream<unknown> | undefined;
-  if (deferred) {
-    deferred.throw(deserialize(ctx, node.f));
-    return undefined;
-  }
-  throw new SerovalMissingInstanceError('Stream');
-}
-
-function deserializeStreamReturn(
-  ctx: DeserializerContext,
-  node: SerovalStreamReturnNode,
-): unknown {
-  const deferred = ctx.base.refs.get(node.i) as Stream<unknown> | undefined;
-  if (deferred) {
-    deferred.return(deserialize(ctx, node.f));
-    return undefined;
-  }
-  throw new SerovalMissingInstanceError('Stream');
-}
-
-function deserializeIteratorFactory(
-  ctx: DeserializerContext,
-  node: SerovalIteratorFactoryNode,
-): unknown {
-  deserialize(ctx, node.f);
-  return undefined;
-}
-
-function deserializeAsyncIteratorFactory(
-  ctx: DeserializerContext,
-  node: SerovalAsyncIteratorFactoryNode,
-): unknown {
-  deserialize(ctx, node.a[1]);
-  return undefined;
-}
-export function deserialize(
-  ctx: DeserializerContext,
-  node: SerovalNode,
-): unknown {
-  switch (node.t) {
-    case SerovalNodeType.Constant:
-      return CONSTANT_VAL[node.s];
-    case SerovalNodeType.Number:
-      return node.s;
-    case SerovalNodeType.String:
-      return deserializeString(node.s);
-    case SerovalNodeType.BigInt:
-      return BigInt(node.s);
-    case SerovalNodeType.IndexedValue:
-      return ctx.base.refs.get(node.i);
-    case SerovalNodeType.Reference:
-      return deserializeReference(ctx, node);
-    case SerovalNodeType.Array:
-      return deserializeArray(ctx, node);
-    case SerovalNodeType.Object:
-    case SerovalNodeType.NullConstructor:
-      return deserializeObject(ctx, node);
-    case SerovalNodeType.Date:
-      return deserializeDate(ctx, node);
-    case SerovalNodeType.RegExp:
-      return deserializeRegExp(ctx, node);
-    case SerovalNodeType.Set:
-      return deserializeSet(ctx, node);
-    case SerovalNodeType.Map:
-      return deserializeMap(ctx, node);
-    case SerovalNodeType.ArrayBuffer:
-      return deserializeArrayBuffer(ctx, node);
-    case SerovalNodeType.BigIntTypedArray:
-    case SerovalNodeType.TypedArray:
-      return deserializeTypedArray(ctx, node);
-    case SerovalNodeType.DataView:
-      return deserializeDataView(ctx, node);
-    case SerovalNodeType.AggregateError:
-      return deserializeAggregateError(ctx, node);
-    case SerovalNodeType.Error:
-      return deserializeError(ctx, node);
-    case SerovalNodeType.Promise:
-      return deserializePromise(ctx, node);
-    case SerovalNodeType.WKSymbol:
-      return SYMBOL_REF[node.s];
-    case SerovalNodeType.Boxed:
-      return deserializeBoxed(ctx, node);
-    case SerovalNodeType.Plugin:
-      return deserializePlugin(ctx, node);
-    case SerovalNodeType.PromiseConstructor:
-      return deserializePromiseConstructor(ctx, node);
-    case SerovalNodeType.PromiseSuccess:
-      return deserializePromiseResolve(ctx, node);
-    case SerovalNodeType.PromiseFailure:
-      return deserializePromiseReject(ctx, node);
-    case SerovalNodeType.IteratorFactoryInstance:
-      return deserializeIteratorFactoryInstance(ctx, node);
-    case SerovalNodeType.AsyncIteratorFactoryInstance:
-      return deserializeAsyncIteratorFactoryInstance(ctx, node);
-    case SerovalNodeType.StreamConstructor:
-      return deserializeStreamConstructor(ctx, node);
-    case SerovalNodeType.StreamNext:
-      return deserializeStreamNext(ctx, node);
-    case SerovalNodeType.StreamThrow:
-      return deserializeStreamThrow(ctx, node);
-    case SerovalNodeType.StreamReturn:
-      return deserializeStreamReturn(ctx, node);
-    case SerovalNodeType.IteratorFactory:
-      return deserializeIteratorFactory(ctx, node);
-    case SerovalNodeType.AsyncIteratorFactory:
-      return deserializeAsyncIteratorFactory(ctx, node);
-    // case SerovalNodeType.SpecialReference:
-    default:
-      throw new SerovalUnsupportedNodeError(node);
-  }
-}
-
-export function deserializeTop(
-  ctx: DeserializerContext,
-  node: SerovalNode,
-): unknown {
-  try {
-    return deserialize(ctx, node);
-  } catch (error) {
-    throw new SerovalDeserializationError(error);
-  }
-}