seroval 0.11.6 → 0.12.0

package/src/core/tree/index.ts

@@ -1,93 +1,44 @@
-import { Feature } from '../compat';
-import { SerovalNodeType } from '../constants';
+import type { PluginAccessOptions } from '../plugin';
 import type { SerovalNode } from '../types';
-import parseAsync from './async';
-import type {
-  ParserOptions,
-  SerializerContext,
-} from './context';
-import {
-  createDeserializerContext,
-  createParserContext,
-  createSerializerContext,
-  getRefParam,
-} from './context';
-import deserializeTree from './deserialize';
-import serializeTree, { resolvePatches } from './serialize';
-import parseSync from './sync';
-
-function finalize(
-  ctx: SerializerContext,
-  rootID: number | undefined,
-  isObject: boolean,
-  result: string,
-): string {
-  // Shared references detected
-  if (rootID != null && ctx.vars.length) {
-    const patches = resolvePatches(ctx);
-    let body = result;
-    if (patches) {
-      // Get (or create) a ref from the source
-      const index = getRefParam(ctx, rootID);
-      body = result + ',' + patches + index;
-      if (!result.startsWith(index + '=')) {
-        body = index + '=' + body;
-      }
-    }
-    let params = ctx.vars.length > 1
-      ? ctx.vars.join(',')
-      : ctx.vars[0];
-    // Source is probably already assigned
-    if (ctx.features & Feature.ArrowFunction) {
-      params = ctx.vars.length > 1 || ctx.vars.length === 0
-        ? '(' + params + ')'
-        : params;
-      return '(' + params + '=>(' + body + '))()';
-    }
-    return '(function(' + params + '){return ' + body + '})()';
-  }
-  if (isObject) {
-    return '(' + result + ')';
-  }
-  return result;
-}
+import type { AsyncParserContextOptions } from './async';
+import AsyncParserContext from './async';
+import VanillaDeserializerContext from './deserialize';
+import VanillaSerializerContext from './serialize';
+import type { SyncParserContextOptions } from './sync';
+import SyncParserContext from './sync';
 
 export function serialize<T>(
   source: T,
-  options?: Partial<ParserOptions>,
+  options: SyncParserContextOptions = {},
 ): string {
-  const ctx = createParserContext(options);
-  const tree = parseSync(ctx, source);
-  const serial = createSerializerContext({
-    markedRefs: ctx.reference.marked,
+  const ctx = new SyncParserContext({
+    plugins: options.plugins,
+    disabledFeatures: options.disabledFeatures,
+  });
+  const tree = ctx.parse(source);
+  const serial = new VanillaSerializerContext({
+    plugins: options.plugins,
     features: ctx.features,
+    markedRefs: ctx.marked,
   });
-  const result = serializeTree(serial, tree);
-  return finalize(
-    serial,
-    tree.i,
-    tree.t === SerovalNodeType.Object,
-    result,
-  );
+  return serial.serializeTop(tree);
 }
 
 export async function serializeAsync<T>(
   source: T,
-  options?: Partial<ParserOptions>,
+  options: AsyncParserContextOptions = {},
 ): Promise<string> {
-  const ctx = createParserContext(options);
-  const tree = await parseAsync(ctx, source);
-  const serial = createSerializerContext({
-    markedRefs: ctx.reference.marked,
+  const ctx = new AsyncParserContext({
+    plugins: options.plugins,
+    disabledFeatures: options.disabledFeatures,
+  });
+  const tree = await ctx.parse(source);
+  const serial = new VanillaSerializerContext({
+    plugins: options.plugins,
     features: ctx.features,
+    markedRefs: ctx.marked,
   });
-  const result = serializeTree(serial, tree);
-  return finalize(
-    serial,
-    tree.i,
-    tree.t === SerovalNodeType.Object,
-    result,
-  );
+  return serial.serializeTop(tree);
 }
 
 export function deserialize<T>(source: string): T {
@@ -103,40 +54,47 @@ export interface SerovalJSON {
 
 export function toJSON<T>(
   source: T,
-  options?: Partial<ParserOptions>,
+  options: SyncParserContextOptions = {},
 ): SerovalJSON {
-  const ctx = createParserContext(options);
+  const ctx = new SyncParserContext({
+    plugins: options.plugins,
+    disabledFeatures: options.disabledFeatures,
+  });
   return {
-    t: parseSync(ctx, source),
+    t: ctx.parse(source),
     f: ctx.features,
-    m: Array.from(ctx.reference.marked),
+    m: Array.from(ctx.marked),
   };
 }
 
 export async function toJSONAsync<T>(
   source: T,
-  options?: Partial<ParserOptions>,
+  options: AsyncParserContextOptions = {},
 ): Promise<SerovalJSON> {
-  const ctx = createParserContext(options);
+  const ctx = new AsyncParserContext({
+    plugins: options.plugins,
+    disabledFeatures: options.disabledFeatures,
+  });
   return {
-    t: await parseAsync(ctx, source),
+    t: await ctx.parse(source),
     f: ctx.features,
-    m: Array.from(ctx.reference.marked),
+    m: Array.from(ctx.marked),
   };
 }
 
-export function compileJSON(source: SerovalJSON): string {
-  const serial = createSerializerContext({
+export function compileJSON(source: SerovalJSON, options: PluginAccessOptions = {}): string {
+  const ctx = new VanillaSerializerContext({
+    plugins: options.plugins,
     features: source.f,
     markedRefs: source.m,
   });
-  const result = serializeTree(serial, source.t);
-  return finalize(serial, source.t.i, source.t.i === SerovalNodeType.Object, result);
+  return ctx.serializeTop(source.t);
 }
 
-export function fromJSON<T>(source: SerovalJSON): T {
-  const serial = createDeserializerContext({
+export function fromJSON<T>(source: SerovalJSON, options: PluginAccessOptions = {}): T {
+  const ctx = new VanillaDeserializerContext({
+    plugins: options.plugins,
     markedRefs: source.m,
   });
-  return deserializeTree(serial, source.t) as T;
+  return ctx.deserialize(source.t) as T;
 }

package/src/core/tree/parser.ts

@@ -0,0 +1,45 @@
+import { createIndexedValueNode, createReferenceNode } from '../base-primitives';
+import { hasReferenceID } from '../reference';
+import type { SerovalIndexedValueNode, SerovalReferenceNode } from '../types';
+
+function createIndexedValue<T>(
+  ids: Map<unknown, number>,
+  marked: Set<number>,
+  current: T,
+): number {
+  const ref = ids.get(current);
+  if (ref == null) {
+    const id = ids.size;
+    ids.set(current, id);
+    return id;
+  }
+  marked.add(ref);
+  return ref;
+}
+
+export function getVanillaReference<T>(
+  ids: Map<unknown, number>,
+  marked: Set<number>,
+  current: T,
+): number | SerovalIndexedValueNode | SerovalReferenceNode {
+  const id = createIndexedValue(ids, marked, current);
+  if (marked.has(id)) {
+    return createIndexedValueNode(id);
+  }
+  if (hasReferenceID(current)) {
+    return createReferenceNode(id, current);
+  }
+  return id;
+}
+
+export function getStrictVanillaReference<T>(
+  ids: Map<unknown, number>,
+  marked: Set<number>,
+  current: T,
+): SerovalIndexedValueNode | SerovalReferenceNode {
+  const id = createIndexedValue(ids, marked, current);
+  if (marked.has(id)) {
+    return createIndexedValueNode(id);
+  }
+  return createReferenceNode(id, current);
+}