seroval 0.11.6 → 0.12.1

package/src/core/cross/cross-parser.ts

@@ -0,0 +1,9 @@
+import type { BaseParserContextOptions } from '../parser-context';
+
+export interface CrossParserContextOptions extends BaseParserContextOptions {
+  refs?: Map<unknown, number>;
+}
+
+export interface CrossContextOptions {
+  scopeId?: string;
+}

package/src/core/cross/index.ts

@@ -1,79 +1,56 @@
-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;
+import type { CrossAsyncParserContextOptions } from './async';
+import AsyncCrossParserContext from './async';
+import type { CrossContextOptions } from './cross-parser';
+import CrossSerializerContext from './serialize';
+import type { CrossStreamParserContextOptions } from './stream';
+import StreamCrossParserContext from './stream';
+import type { CrossSyncParserContextOptions } from './sync';
+import SyncCrossParserContext from './sync';
+
+export interface CrossSerializeOptions
+  extends CrossSyncParserContextOptions, CrossContextOptions {
 }
 
 export function crossSerialize<T>(
   source: T,
-  options?: CrossParserContextOptions,
+  options: CrossSerializeOptions = {},
 ): string {
-  const ctx = createCrossParserContext(options);
-  const tree = parseSync(ctx, source);
-  const serial = createCrossSerializerContext({
+  const ctx = new SyncCrossParserContext({
+    plugins: options.plugins,
+    disabledFeatures: options.disabledFeatures,
+    refs: options.refs,
+  });
+  const tree = ctx.parse(source);
+  const serial = new CrossSerializerContext({
+    plugins: options.plugins,
     features: ctx.features,
+    scopeId: options.scopeId,
+    markedRefs: ctx.marked,
   });
-  const result = crossSerializeTree(serial, tree);
-  return finalize(
-    serial,
-    ctx.scopeId,
-    tree.i,
-    result,
-  );
+  return serial.serializeTop(tree);
+}
+
+export interface CrossSerializeAsyncOptions
+  extends CrossAsyncParserContextOptions, CrossContextOptions {
 }
 
 export async function crossSerializeAsync<T>(
   source: T,
-  options?: CrossParserContextOptions,
+  options: CrossSerializeAsyncOptions = {},
 ): Promise<string> {
-  const ctx = createCrossParserContext(options);
-  const tree = await parseAsync(ctx, source);
-  const serial = createCrossSerializerContext({
+  const ctx = new AsyncCrossParserContext({
+    plugins: options.plugins,
+    disabledFeatures: options.disabledFeatures,
+    refs: options.refs,
+  });
+  const tree = await ctx.parse(source);
+  const serial = new CrossSerializerContext({
+    plugins: options.plugins,
     features: ctx.features,
+    scopeId: options.scopeId,
+    markedRefs: ctx.marked,
   });
-  const result = crossSerializeTree(serial, tree);
-  return finalize(
-    serial,
-    ctx.scopeId,
-    tree.i,
-    result,
-  );
+  return serial.serializeTop(tree);
 }
 
 // export interface SerovalCrossJSON {
@@ -122,48 +99,49 @@ export async function crossSerializeAsync<T>(
 //   return deserializeTree(serial, source.t) as T;
 // }
 
-export interface CrossSerializeStreamOptions extends CrossParserContextOptions {
+export interface CrossSerializeStreamOptions
+  extends Omit<CrossStreamParserContextOptions, 'onParse'>, CrossContextOptions {
   onSerialize: (data: string, initial: boolean) => void;
-  onDone?: () => void;
 }
 
 export function crossSerializeStream<T>(
   source: T,
   options: CrossSerializeStreamOptions,
 ): () => void {
-  const ctx = createStreamingCrossParserContext({
-    scopeId: options.scopeId,
+  const ctx = new StreamCrossParserContext({
     refs: options.refs,
     disabledFeatures: options.disabledFeatures,
-    onParse(node, initial) {
-      const serial = createCrossSerializerContext({
+    onParse(node, initial): void {
+      const serial = new CrossSerializerContext({
+        plugins: options.plugins,
         features: ctx.features,
+        scopeId: options.scopeId,
+        markedRefs: ctx.marked,
       });
 
+      let serialized: string;
+
+      try {
+        serialized = serial.serializeTop(node);
+      } catch (err) {
+        if (options.onError) {
+          options.onError(err);
+        }
+        return;
+      }
+
       options.onSerialize(
-        finalize(
-          serial,
-          ctx.scopeId,
-          node.i,
-          crossSerializeTree(serial, node),
-        ),
+        serialized,
         initial,
       );
     },
+    onError: options.onError,
     onDone: options.onDone,
   });
 
-  ctx.onParse(crossParseStream(ctx, source), true);
-
-  if (ctx.pending <= 0) {
-    ctx.onDone();
-    ctx.alive = false;
-  }
+  ctx.start(source);
 
   return () => {
-    if (ctx.alive) {
-      ctx.alive = false;
-      ctx.onDone();
-    }
+    ctx.destroy();
   };
 }