seroval 0.15.0 → 1.0.0

package/src/core/cross/async.ts

@@ -2,7 +2,7 @@ import BaseAsyncParserContext from '../context/parser/async';
 import type { CrossParserContextOptions } from './parser';
 import type { SerovalMode } from '../plugin';
 
-export type CrossAsyncParserContextOptions = CrossParserContextOptions
+export type CrossAsyncParserContextOptions = CrossParserContextOptions;
 
 export default class CrossAsyncParserContext extends BaseAsyncParserContext {
   readonly mode: SerovalMode = 'cross';

package/src/core/cross/deserializer.ts

@@ -7,10 +7,7 @@ export type CrossDeserializerContextOptions = BaseDeserializerOptions;
 export default class CrossDeserializerContext extends BaseDeserializerContext {
   readonly mode: SerovalMode = 'cross';
 
-  assignIndexedValue<T>(
-    index: number,
-    value: T,
-  ): T {
+  assignIndexedValue<T>(index: number, value: T): T {
     if (!this.refs.has(index)) {
       this.refs.set(index, value);
     }

package/src/core/cross/index.ts

@@ -1,4 +1,4 @@
-import { getCrossReferenceHeader } from '../keys';
+import { resolvePlugins } from '../plugin';
 import type { SerovalNode } from '../types';
 import type { CrossAsyncParserContextOptions } from './async';
 import AsyncCrossParserContext from './async';
@@ -11,54 +11,52 @@ import StreamCrossParserContext from './stream';
 import type { CrossSyncParserContextOptions } from './sync';
 import SyncCrossParserContext from './sync';
 
-function insertCrossReferenceHeader(scopeId: string | undefined, value: string): string {
-  return '(' + getCrossReferenceHeader(scopeId) + ',' + value + ')';
-}
-
 export interface CrossSerializeOptions
-  extends CrossSyncParserContextOptions, CrossContextOptions {
-}
+  extends CrossSyncParserContextOptions,
+    CrossContextOptions {}
 
 export function crossSerialize<T>(
   source: T,
   options: CrossSerializeOptions = {},
 ): string {
+  const plugins = resolvePlugins(options.plugins);
   const ctx = new SyncCrossParserContext({
-    plugins: options.plugins,
+    plugins,
     disabledFeatures: options.disabledFeatures,
     refs: options.refs,
   });
   const tree = ctx.parse(source);
   const serial = new CrossSerializerContext({
-    plugins: options.plugins,
+    plugins,
     features: ctx.features,
     scopeId: options.scopeId,
     markedRefs: ctx.marked,
   });
-  return insertCrossReferenceHeader(options.scopeId, serial.serializeTop(tree));
+  return serial.serializeTop(tree);
 }
 
 export interface CrossSerializeAsyncOptions
-  extends CrossAsyncParserContextOptions, CrossContextOptions {
-}
+  extends CrossAsyncParserContextOptions,
+    CrossContextOptions {}
 
 export async function crossSerializeAsync<T>(
   source: T,
   options: CrossSerializeAsyncOptions = {},
 ): Promise<string> {
+  const plugins = resolvePlugins(options.plugins);
   const ctx = new AsyncCrossParserContext({
-    plugins: options.plugins,
+    plugins,
     disabledFeatures: options.disabledFeatures,
     refs: options.refs,
   });
   const tree = await ctx.parse(source);
   const serial = new CrossSerializerContext({
-    plugins: options.plugins,
+    plugins,
     features: ctx.features,
     scopeId: options.scopeId,
     markedRefs: ctx.marked,
   });
-  return insertCrossReferenceHeader(options.scopeId, serial.serializeTop(tree));
+  return serial.serializeTop(tree);
 }
 
 export type ToCrossJSONOptions = CrossParserContextOptions;
@@ -67,8 +65,9 @@ export function toCrossJSON<T>(
   source: T,
   options: CrossParserContextOptions = {},
 ): SerovalNode {
+  const plugins = resolvePlugins(options.plugins);
   const ctx = new SyncCrossParserContext({
-    plugins: options.plugins,
+    plugins,
     disabledFeatures: options.disabledFeatures,
     refs: options.refs,
   });
@@ -81,16 +80,18 @@ export async function toCrossJSONAsync<T>(
   source: T,
   options: CrossParserContextOptions = {},
 ): Promise<SerovalNode> {
+  const plugins = resolvePlugins(options.plugins);
   const ctx = new AsyncCrossParserContext({
-    plugins: options.plugins,
+    plugins,
     disabledFeatures: options.disabledFeatures,
     refs: options.refs,
   });
-  return ctx.parse(source);
+  return await ctx.parse(source);
 }
 
 export interface CrossSerializeStreamOptions
-  extends Omit<CrossStreamParserContextOptions, 'onParse'>, CrossContextOptions {
+  extends Omit<CrossStreamParserContextOptions, 'onParse'>,
+    CrossContextOptions {
   onSerialize: (data: string, initial: boolean) => void;
 }
 
@@ -98,13 +99,14 @@ export function crossSerializeStream<T>(
   source: T,
   options: CrossSerializeStreamOptions,
 ): () => void {
+  const plugins = resolvePlugins(options.plugins);
   const ctx = new StreamCrossParserContext({
-    plugins: options.plugins,
+    plugins,
     refs: options.refs,
     disabledFeatures: options.disabledFeatures,
     onParse(node, initial): void {
       const serial = new CrossSerializerContext({
-        plugins: options.plugins,
+        plugins,
         features: ctx.features,
         scopeId: options.scopeId,
         markedRefs: ctx.marked,
@@ -121,14 +123,7 @@ export function crossSerializeStream<T>(
         return;
       }
 
-      if (initial) {
-        serialized = insertCrossReferenceHeader(options.scopeId, serialized);
-      }
-
-      options.onSerialize(
-        serialized,
-        initial,
-      );
+      options.onSerialize(serialized, initial);
     },
     onError: options.onError,
     onDone: options.onDone,
@@ -147,8 +142,9 @@ export function toCrossJSONStream<T>(
   source: T,
   options: ToCrossJSONStreamOptions,
 ): () => void {
+  const plugins = resolvePlugins(options.plugins);
   const ctx = new StreamCrossParserContext({
-    plugins: options.plugins,
+    plugins,
     refs: options.refs,
     disabledFeatures: options.disabledFeatures,
     onParse: options.onParse,
@@ -169,8 +165,9 @@ export function fromCrossJSON<T>(
   source: SerovalNode,
   options: FromCrossJSONOptions,
 ): T {
+  const plugins = resolvePlugins(options.plugins);
   const ctx = new CrossDeserializerContext({
-    plugins: options.plugins,
+    plugins,
     refs: options.refs,
   });
   return ctx.deserialize(source) as T;

package/src/core/cross/parser.ts

@@ -1,6 +1,6 @@
 import type { BaseParserContextOptions } from '../context/parser';
 
-export type CrossParserContextOptions = BaseParserContextOptions
+export type CrossParserContextOptions = BaseParserContextOptions;
 
 export interface CrossContextOptions {
   scopeId?: string;

package/src/core/cross/serializer.ts

@@ -1,9 +1,5 @@
-import type {
-  SerovalNode,
-} from '../types';
-import {
-  GLOBAL_CONTEXT_REFERENCES,
-} from '../keys';
+import type { SerovalNode } from '../types';
+import { GLOBAL_CONTEXT_REFERENCES } from '../keys';
 import type { BaseSerializerContextOptions } from '../context/serializer';
 import BaseSerializerContext from '../context/serializer';
 import type { SerovalMode } from '../plugin';
@@ -11,8 +7,8 @@ import { serializeString } from '../string';
 import type { CrossContextOptions } from './parser';
 
 export interface CrossSerializerContextOptions
-  extends BaseSerializerContextOptions, CrossContextOptions {
-}
+  extends BaseSerializerContextOptions,
+    CrossContextOptions {}
 
 export default class CrossSerializerContext extends BaseSerializerContext {
   readonly mode: SerovalMode = 'cross';
@@ -24,35 +20,49 @@ export default class CrossSerializerContext extends BaseSerializerContext {
     this.scopeId = options.scopeId;
   }
 
-  getRefParam(id: number | string): string {
-    if (typeof id === 'string') {
-      return GLOBAL_CONTEXT_REFERENCES + '.' + id;
-    }
+  getRefParam(id: number): string {
     return GLOBAL_CONTEXT_REFERENCES + '[' + id + ']';
   }
 
-  protected assignIndexedValue(
-    index: number,
-    value: string,
-  ): string {
+  protected assignIndexedValue(index: number, value: string): string {
+    // In cross-reference, we have to assume that
+    // every reference are going to be referenced
+    // in the future, and so we need to store
+    // all of it into the reference array.
     return this.getRefParam(index) + '=' + value;
   }
 
   serializeTop(tree: SerovalNode): string {
+    // Get the serialized result
     const result = this.serialize(tree);
+    // If the node is a non-reference, return
+    // the result immediately
     const id = tree.i;
     if (id == null) {
       return result;
     }
+    // Get the patches
     const patches = this.resolvePatches();
+    // Get the variable that represents the root
     const ref = this.getRefParam(id);
+    // Parameters needed for scoping
     const params = this.scopeId == null ? '' : GLOBAL_CONTEXT_REFERENCES;
-    const mainBody = patches ? result + ',' + patches : result;
+    // If there are patches, append it after the result
+    const body = patches ? result + ',' + patches + ref : result;
+    // If there are no params, there's no need to generate a function
     if (params === '') {
-      return patches ? '(' + mainBody + ref + ')' : mainBody;
+      return patches ? '(' + body + ')' : body;
     }
-    const args = this.scopeId == null ? '()' : '(' + GLOBAL_CONTEXT_REFERENCES + '["' + serializeString(this.scopeId) + '"])';
-    const body = mainBody + (patches ? ref : '');
+    // Get the arguments for the IIFE
+    const args =
+      this.scopeId == null
+        ? '()'
+        : '(' +
+          GLOBAL_CONTEXT_REFERENCES +
+          '["' +
+          serializeString(this.scopeId) +
+          '"])';
+    // Create the IIFE
     return '(' + this.createFunction([params], body) + ')' + args;
   }
 }

package/src/core/cross/stream.ts

@@ -2,7 +2,7 @@ import type { BaseStreamParserContextOptions } from '../context/parser/stream';
 import BaseStreamParserContext from '../context/parser/stream';
 import type { SerovalMode } from '../plugin';
 
-export type CrossStreamParserContextOptions = BaseStreamParserContextOptions
+export type CrossStreamParserContextOptions = BaseStreamParserContextOptions;
 
 export default class CrossStreamParserContext extends BaseStreamParserContext {
   readonly mode: SerovalMode = 'cross';

package/src/core/cross/sync.ts

@@ -2,7 +2,7 @@ import BaseSyncParserContext from '../context/parser/sync';
 import type { SerovalMode } from '../plugin';
 import type { CrossParserContextOptions } from './parser';
 
-export type CrossSyncParserContextOptions = CrossParserContextOptions
+export type CrossSyncParserContextOptions = CrossParserContextOptions;
 
 export default class CrossSyncParserContext extends BaseSyncParserContext {
   readonly mode: SerovalMode = 'cross';

package/src/core/keys.ts

@@ -11,5 +11,7 @@ export function getCrossReferenceHeader(id?: string): string {
   if (id == null) {
     return `${GLOBAL_CONTEXT_R}=${GLOBAL_CONTEXT_R}||[]`;
   }
-  return `(${GLOBAL_CONTEXT_R}=${GLOBAL_CONTEXT_R}||{})["${serializeString(id)}"]=[]`;
+  return `(${GLOBAL_CONTEXT_R}=${GLOBAL_CONTEXT_R}||{})["${serializeString(
+    id,
+  )}"]=[]`;
 }

package/src/core/literals.ts

@@ -18,11 +18,25 @@ function createConstantNode(value: SerovalConstant): SerovalConstantNode {
   };
 }
 
-export const TRUE_NODE = createConstantNode(SerovalConstant.True);
-export const FALSE_NODE = createConstantNode(SerovalConstant.False);
-export const UNDEFINED_NODE = createConstantNode(SerovalConstant.Undefined);
-export const NULL_NODE = createConstantNode(SerovalConstant.Null);
-export const NEG_ZERO_NODE = createConstantNode(SerovalConstant.NegativeZero);
-export const INFINITY_NODE = createConstantNode(SerovalConstant.Infinity);
-export const NEG_INFINITY_NODE = createConstantNode(SerovalConstant.NegativeInfinity);
-export const NAN_NODE = createConstantNode(SerovalConstant.NaN);
+export const TRUE_NODE = /* @__PURE__ */ createConstantNode(
+  SerovalConstant.True,
+);
+export const FALSE_NODE = /* @__PURE__ */ createConstantNode(
+  SerovalConstant.False,
+);
+export const UNDEFINED_NODE = /* @__PURE__ */ createConstantNode(
+  SerovalConstant.Undefined,
+);
+export const NULL_NODE = /* @__PURE__ */ createConstantNode(
+  SerovalConstant.Null,
+);
+export const NEG_ZERO_NODE = /* @__PURE__ */ createConstantNode(
+  SerovalConstant.NegativeZero,
+);
+export const INFINITY_NODE = /* @__PURE__ */ createConstantNode(
+  SerovalConstant.Infinity,
+);
+export const NEG_INFINITY_NODE = /* @__PURE__ */ createConstantNode(
+  SerovalConstant.NegativeInfinity,
+);
+export const NAN_NODE = /* @__PURE__ */ createConstantNode(SerovalConstant.NaN);

package/src/core/plugin.ts

@@ -11,14 +11,24 @@ export interface PluginData {
 }
 
 export interface Plugin<Value, Node> {
+  /**
+   * A unique string that helps idenfity the plugin
+   */
   tag: string;
+  /**
+   * List of dependency plugins
+   */
+  extends?: Plugin<any, any>[];
+  /**
+   * Method to test if a value is an expected value of the plugin
+   * @param value
+   */
   test(value: unknown): boolean;
+  /**
+   * Parsing modes
+   */
   parse: {
-    sync?: (
-      value: Value,
-      ctx: BaseSyncParserContext,
-      data: PluginData,
-    ) => Node;
+    sync?: (value: Value, ctx: BaseSyncParserContext, data: PluginData) => Node;
     async?: (
       value: Value,
       ctx: BaseAsyncParserContext,
@@ -30,11 +40,13 @@ export interface Plugin<Value, Node> {
       data: PluginData,
     ) => Node;
   };
-  serialize(
-    node: Node,
-    ctx: BaseSerializerContext,
-    data: PluginData,
-  ): string;
+  /**
+   * Convert the parsed node into a JS string
+   */
+  serialize(node: Node, ctx: BaseSerializerContext, data: PluginData): string;
+  /**
+   * Convert the parsed node into its runtime equivalent.
+   */
   deserialize(
     node: Node,
     ctx: BaseDeserializerContext,
@@ -51,3 +63,29 @@ export function createPlugin<Value, Node>(
 export interface PluginAccessOptions {
   plugins?: Plugin<any, any>[];
 }
+
+function dedupePlugins(
+  deduped: Set<Plugin<any, any>>,
+  plugins: Plugin<any, any>[],
+): void {
+  for (let i = 0, len = plugins.length; i < len; i++) {
+    const current = plugins[i];
+    if (!deduped.has(current)) {
+      deduped.add(current);
+      if (current.extends) {
+        dedupePlugins(deduped, current.extends);
+      }
+    }
+  }
+}
+
+export function resolvePlugins(
+  plugins?: Plugin<any, any>[],
+): Plugin<any, any>[] | undefined {
+  if (plugins) {
+    const deduped = new Set<Plugin<any, any>>();
+    dedupePlugins(deduped, plugins);
+    return [...deduped];
+  }
+  return undefined;
+}

package/src/core/reference.ts

@@ -1,4 +1,3 @@
-/* eslint-disable no-restricted-globals */
 import assert from './utils/assert';
 import { REFERENCES_KEY } from './keys';
 
@@ -29,28 +28,28 @@ export function getReference<T>(id: string): T {
   return INV_REFERENCE.get(id) as T;
 }
 
-if (typeof globalThis !== undefined) {
+if (typeof globalThis !== 'undefined') {
   Object.defineProperty(globalThis, REFERENCES_KEY, {
     value: INV_REFERENCE,
     configurable: true,
     writable: false,
     enumerable: false,
   });
-} else if (typeof window !== undefined) {
+} else if (typeof window !== 'undefined') {
   Object.defineProperty(window, REFERENCES_KEY, {
     value: INV_REFERENCE,
     configurable: true,
     writable: false,
     enumerable: false,
   });
-} else if (typeof self !== undefined) {
+} else if (typeof self !== 'undefined') {
   Object.defineProperty(self, REFERENCES_KEY, {
     value: INV_REFERENCE,
     configurable: true,
     writable: false,
     enumerable: false,
   });
-} else if (typeof global !== undefined) {
+} else if (typeof global !== 'undefined') {
   Object.defineProperty(global, REFERENCES_KEY, {
     value: INV_REFERENCE,
     configurable: true,

package/src/core/special-reference.ts

@@ -1,29 +1,19 @@
-export const UNIVERSAL_SENTINEL = {};
-
 export const ITERATOR = {};
 
 export const ASYNC_ITERATOR = {};
 
 export const enum SpecialReference {
   MapSentinel = 0,
-  ReadableStream = 1,
-  PromiseConstructor = 2,
-  PromiseResolve = 3,
-  PromiseReject = 4,
-  ReadableStreamConstructor = 5,
-  ReadableStreamEnqueue = 6,
-  ReadableStreamError = 7,
-  ReadableStreamClose = 8,
+  PromiseConstructor = 1,
+  PromiseResolve = 2,
+  PromiseReject = 3,
+  StreamConstructor = 4,
 }
 
 export const SPECIAL_REFS: Record<SpecialReference, unknown> = {
   [SpecialReference.MapSentinel]: {},
-  [SpecialReference.ReadableStream]: {},
   [SpecialReference.PromiseConstructor]: {},
   [SpecialReference.PromiseResolve]: {},
   [SpecialReference.PromiseReject]: {},
-  [SpecialReference.ReadableStreamConstructor]: {},
-  [SpecialReference.ReadableStreamEnqueue]: {},
-  [SpecialReference.ReadableStreamError]: {},
-  [SpecialReference.ReadableStreamClose]: {},
+  [SpecialReference.StreamConstructor]: {},
 };