seroval 0.15.1 → 1.0.2

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,3 +1,4 @@
+import { resolvePlugins } from '../plugin';
 import type { SerovalNode } from '../types';
 import type { CrossAsyncParserContextOptions } from './async';
 import AsyncCrossParserContext from './async';
@@ -11,21 +12,22 @@ import type { CrossSyncParserContextOptions } from './sync';
 import SyncCrossParserContext from './sync';
 
 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,
@@ -34,21 +36,22 @@ export function crossSerialize<T>(
 }
 
 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,
@@ -62,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,
   });
@@ -76,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;
 }
 
@@ -93,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,
@@ -116,10 +123,7 @@ export function crossSerializeStream<T>(
         return;
       }
 
-      options.onSerialize(
-        serialized,
-        initial,
-      );
+      options.onSerialize(serialized, initial);
     },
     onError: options.onError,
     onDone: options.onDone,
@@ -138,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,
@@ -160,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]: {},
 };

package/src/core/stream.ts

@@ -0,0 +1,205 @@
+import type { Deferred } from './utils/deferred';
+import { createDeferred } from './utils/deferred';
+
+interface StreamListener<T> {
+  next(value: T): void;
+  throw(value: unknown): void;
+  return(value: T): void;
+}
+
+export interface Stream<T> {
+  __SEROVAL_STREAM__: true;
+
+  on(listener: StreamListener<T>): () => void;
+
+  next(value: T): void;
+  throw(value: unknown): void;
+  return(value: T): void;
+}
+
+export function isStream<T>(value: object): value is Stream<T> {
+  return '__SEROVAL_STREAM__' in value;
+}
+
+export function createStream<T>(): Stream<T> {
+  const listeners = new Set<StreamListener<T>>();
+  const buffer: unknown[] = [];
+  let alive = true;
+  let success = false;
+
+  function flushNext(value: T): void {
+    for (const listener of listeners.keys()) {
+      listener.next(value);
+    }
+  }
+
+  function flushThrow(value: unknown): void {
+    for (const listener of listeners.keys()) {
+      listener.throw(value);
+    }
+  }
+
+  function flushReturn(value: T): void {
+    for (const listener of listeners.keys()) {
+      listener.return(value);
+    }
+  }
+
+  return {
+    __SEROVAL_STREAM__: true,
+    on(listener: StreamListener<T>): () => void {
+      if (alive) {
+        listeners.add(listener);
+      }
+      for (let i = 0, len = buffer.length; i < len; i++) {
+        const value = buffer[i];
+        if (i === len - 1) {
+          if (success) {
+            listener.return(value as T);
+          } else {
+            listener.throw(value);
+          }
+        } else {
+          listener.next(value as T);
+        }
+      }
+      return () => {
+        if (alive) {
+          listeners.delete(listener);
+        }
+      };
+    },
+    next(value): void {
+      if (alive) {
+        buffer.push(value);
+        flushNext(value);
+      }
+    },
+    throw(value): void {
+      if (alive) {
+        buffer.push(value);
+        flushThrow(value);
+        alive = false;
+        success = false;
+        listeners.clear();
+      }
+    },
+    return(value): void {
+      if (alive) {
+        buffer.push(value);
+        flushReturn(value);
+        alive = false;
+        success = true;
+        listeners.clear();
+      }
+    },
+  };
+}
+
+export function createStreamFromAsyncIterable<T>(
+  iterable: AsyncIterable<T>,
+): Stream<T> {
+  const stream = createStream<T>();
+
+  const iterator = iterable[Symbol.asyncIterator]();
+
+  async function push(): Promise<void> {
+    try {
+      const value = await iterator.next();
+      if (value.done) {
+        stream.return(value.value as T);
+      } else {
+        stream.next(value.value);
+        await push();
+      }
+    } catch (error) {
+      stream.throw(error);
+    }
+  }
+
+  push().catch(() => {
+    // no-op
+  });
+
+  return stream;
+}
+
+export function streamToAsyncIterable<T>(
+  stream: Stream<T>,
+): () => AsyncIterableIterator<T> {
+  return (): AsyncIterableIterator<T> => {
+    const buffer: T[] = [];
+    const pending: Deferred[] = [];
+    let count = 0;
+    let doneAt = -1;
+    let isThrow = false;
+
+    function resolveAll(): void {
+      for (let i = 0, len = pending.length; i < len; i++) {
+        pending[i].resolve({ done: true, value: undefined });
+      }
+    }
+
+    stream.on({
+      next(value) {
+        const current = pending.shift();
+        if (current) {
+          current.resolve({ done: false, value });
+        }
+        buffer.push(value);
+      },
+      throw(value) {
+        const current = pending.shift();
+        if (current) {
+          current.reject(value);
+        }
+        resolveAll();
+        doneAt = buffer.length;
+        buffer.push(value as T);
+        isThrow = true;
+      },
+      return(value) {
+        const current = pending.shift();
+        if (current) {
+          current.resolve({ done: true, value });
+        }
+        resolveAll();
+        doneAt = buffer.length;
+        buffer.push(value);
+      },
+    });
+
+    function finalize() {
+      const current = count++;
+      const value = buffer[current];
+      if (current !== doneAt) {
+        return { done: false, value };
+      }
+      if (isThrow) {
+        throw value;
+      }
+      return { done: true, value };
+    }
+
+    return {
+      [Symbol.asyncIterator](): AsyncIterableIterator<T> {
+        return this;
+      },
+      async next(): Promise<IteratorResult<T>> {
+        if (doneAt === -1) {
+          const current = count++;
+          if (current >= buffer.length) {
+            const deferred = createDeferred();
+            pending.push(deferred);
+            return (await deferred.promise) as Promise<IteratorResult<T>>;
+          }
+          return { done: false, value: buffer[current] };
+        }
+        if (count > doneAt) {
+          return { done: true, value: undefined };
+        }
+        return finalize();
+      },
+    };
+  };
+}