seroval 0.9.0 → 0.10.2

package/src/core/cross/index.ts

@@ -0,0 +1,169 @@
+import { Feature } from '../compat';
+import { GLOBAL_CONTEXT_REFERENCES } from '../keys';
+import { serializeString } from '../string';
+// import type { SerovalNode } from '../types';
+import parseAsync from './async';
+import type {
+  CrossParserContextOptions,
+  CrossSerializerContext,
+} from './context';
+import {
+  createCrossParserContext,
+  createCrossSerializerContext,
+  createStreamingCrossParserContext,
+} from './context';
+import crossSerializeTree, { getRefExpr, resolvePatches } from './serialize';
+import crossParseStream from './stream';
+import parseSync from './sync';
+
+function finalize(
+  ctx: CrossSerializerContext,
+  scopeId: string | undefined,
+  id: number | undefined,
+  result: string,
+): string {
+  if (id == null) {
+    return result;
+  }
+  const patches = resolvePatches(ctx);
+  const ref = getRefExpr(id);
+  const params = scopeId == null ? '' : GLOBAL_CONTEXT_REFERENCES;
+  const mainBody = patches ? result + ',' + patches : result;
+  if (params === '') {
+    return patches ? '(' + mainBody + ref + ')' : mainBody;
+  }
+  const args = scopeId == null ? '()' : '(' + GLOBAL_CONTEXT_REFERENCES + '["' + serializeString(scopeId) + '"])';
+  const body = mainBody + (patches ? ref : '');
+  if (ctx.features & Feature.ArrowFunction) {
+    return '(' + params + '=>(' + body + '))' + args;
+  }
+  return '(function(' + params + '){return ' + body + '})' + args;
+}
+
+export function crossSerialize<T>(
+  source: T,
+  options?: CrossParserContextOptions,
+): string {
+  const ctx = createCrossParserContext(options);
+  const tree = parseSync(ctx, source);
+  const serial = createCrossSerializerContext({
+    features: ctx.features,
+  });
+  const result = crossSerializeTree(serial, tree);
+  return finalize(
+    serial,
+    ctx.scopeId,
+    tree.i,
+    result,
+  );
+}
+
+export async function crossSerializeAsync<T>(
+  source: T,
+  options?: CrossParserContextOptions,
+): Promise<string> {
+  const ctx = createCrossParserContext(options);
+  const tree = await parseAsync(ctx, source);
+  const serial = createCrossSerializerContext({
+    features: ctx.features,
+  });
+  const result = crossSerializeTree(serial, tree);
+  return finalize(
+    serial,
+    ctx.scopeId,
+    tree.i,
+    result,
+  );
+}
+
+// export interface SerovalCrossJSON {
+//   t: SerovalNode;
+//   f: number;
+// }
+
+// export function toCrossJSON<T>(
+//   source: T,
+//   options?: CrossParserContextOptions,
+// ): SerovalCrossJSON {
+//   const ctx = createCrossParserContext(options);
+//   return {
+//     t: parseSync(ctx, source),
+//     f: ctx.features,
+//   };
+// }
+
+// export async function toCrossJSONAsync<T>(
+//   source: T,
+//   options?: CrossParserContextOptions,
+// ): Promise<SerovalCrossJSON> {
+//   const ctx = createCrossParserContext(options);
+//   return {
+//     t: await parseAsync(ctx, source),
+//     f: ctx.features,
+//   };
+// }
+
+// export function compileCrossJSON(source: SerovalCrossJSON): string {
+//   const serial = createCrossSerializerContext({
+//     features: source.f,
+//   });
+//   const result = crossSerializeTree(serial, source.t);
+//   return finalize(
+//     serial,
+//     source.t.i,
+//     result,
+//   );
+// }
+
+// export function fromJSON<T>(source: SerovalJSON): T {
+//   const serial = createDeserializerContext({
+//     markedRefs: source.m,
+//   });
+//   return deserializeTree(serial, source.t) as T;
+// }
+
+export interface CrossSerializeStreamOptions extends CrossParserContextOptions {
+  onSerialize: (data: string, initial: boolean) => void;
+  onDone?: () => void;
+}
+
+export function crossSerializeStream<T>(
+  source: T,
+  options: CrossSerializeStreamOptions,
+): () => void {
+  const ctx = createStreamingCrossParserContext({
+    scopeId: options.scopeId,
+    refs: options.refs,
+    disabledFeatures: options.disabledFeatures,
+    onParse(node, initial) {
+      const serial = createCrossSerializerContext({
+        features: ctx.features,
+      });
+
+      options.onSerialize(
+        finalize(
+          serial,
+          ctx.scopeId,
+          node.i,
+          crossSerializeTree(serial, node),
+        ),
+        initial,
+      );
+    },
+    onDone: options.onDone,
+  });
+
+  ctx.onParse(crossParseStream(ctx, source), true);
+
+  if (ctx.pending <= 0) {
+    ctx.onDone();
+    ctx.alive = false;
+  }
+
+  return () => {
+    if (ctx.alive) {
+      ctx.alive = false;
+      ctx.onDone();
+    }
+  };
+}

package/src/core/cross/primitives.ts

@@ -0,0 +1,137 @@
+import assert from '../assert';
+import { Feature } from '../compat';
+import type { CrossParserContext } from './context';
+import type { BigIntTypedArrayValue, TypedArrayValue } from '../../types';
+import UnsupportedTypeError from '../UnsupportedTypeError';
+import { hasReferenceID } from '../reference';
+import type {
+  SerovalBigIntTypedArrayNode,
+  SerovalTypedArrayNode,
+  SerovalDataViewNode,
+  SerovalNode,
+  SerovalIndexedValueNode,
+  SerovalReferenceNode,
+  SerovalWKSymbolNode,
+} from '../types';
+import type { WellKnownSymbols } from '../constants';
+import { SerovalNodeType } from '../constants';
+import {
+  createIndexedValueNode,
+  createArrayBufferNode,
+  createWKSymbolNode,
+  createReferenceNode,
+} from '../base-primitives';
+
+export function serializeArrayBuffer(
+  ctx: CrossParserContext,
+  current: ArrayBuffer,
+): SerovalNode {
+  const id = ctx.refs.get(current);
+  if (id != null) {
+    return createIndexedValueNode(id);
+  }
+  const newID = ctx.refs.size;
+  ctx.refs.set(current, newID);
+  return createArrayBufferNode(newID, current);
+}
+
+export function createTypedArrayNode(
+  ctx: CrossParserContext,
+  id: number,
+  current: TypedArrayValue,
+): SerovalTypedArrayNode {
+  assert(ctx.features & Feature.TypedArray, new UnsupportedTypeError(current));
+  return {
+    t: SerovalNodeType.TypedArray,
+    i: id,
+    s: undefined,
+    l: current.length,
+    c: current.constructor.name,
+    m: undefined,
+    p: undefined,
+    e: undefined,
+    a: undefined,
+    f: serializeArrayBuffer(ctx, current.buffer),
+    b: current.byteOffset,
+    o: undefined,
+  };
+}
+
+const BIGINT_FLAG = Feature.BigIntTypedArray | Feature.BigInt;
+
+export function createBigIntTypedArrayNode(
+  ctx: CrossParserContext,
+  id: number,
+  current: BigIntTypedArrayValue,
+): SerovalBigIntTypedArrayNode {
+  assert(
+    (ctx.features & BIGINT_FLAG) === BIGINT_FLAG,
+    new UnsupportedTypeError(current),
+  );
+  return {
+    t: SerovalNodeType.BigIntTypedArray,
+    i: id,
+    s: undefined,
+    l: current.length,
+    c: current.constructor.name,
+    m: undefined,
+    p: undefined,
+    e: undefined,
+    a: undefined,
+    f: serializeArrayBuffer(ctx, current.buffer),
+    b: current.byteOffset,
+    o: undefined,
+  };
+}
+
+export function createDataViewNode(
+  ctx: CrossParserContext,
+  id: number,
+  current: DataView,
+): SerovalDataViewNode {
+  return {
+    t: SerovalNodeType.DataView,
+    i: id,
+    s: undefined,
+    l: current.byteLength,
+    c: undefined,
+    m: undefined,
+    p: undefined,
+    e: undefined,
+    a: undefined,
+    f: serializeArrayBuffer(ctx, current.buffer),
+    b: current.byteOffset,
+    o: undefined,
+  };
+}
+
+export function createSymbolNode(
+  ctx: CrossParserContext,
+  current: symbol,
+): SerovalIndexedValueNode | SerovalReferenceNode | SerovalWKSymbolNode {
+  const id = ctx.refs.get(current);
+  if (id != null) {
+    return createIndexedValueNode(id);
+  }
+  const newID = ctx.refs.size;
+  ctx.refs.set(current, newID);
+  if (hasReferenceID(current)) {
+    return createReferenceNode(newID, current);
+  }
+  return createWKSymbolNode(ctx, newID, current as WellKnownSymbols);
+}
+
+export function createFunctionNode(
+  ctx: CrossParserContext,
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  current: Function,
+): SerovalIndexedValueNode | SerovalReferenceNode {
+  assert(hasReferenceID(current), new Error('Cannot serialize function without reference ID.'));
+  const id = ctx.refs.get(current);
+  if (id != null) {
+    return createIndexedValueNode(id);
+  }
+  const newID = ctx.refs.size;
+  ctx.refs.set(current, newID);
+  return createReferenceNode(newID, current);
+}