seroval 0.15.0 → 1.0.0

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();
+      },
+    };
+  };
+}

package/src/core/string.ts

@@ -1,16 +1,27 @@
 export function serializeChar(str: string): string | undefined {
   switch (str) {
-    case '"': return '\\"';
-    case '\\': return '\\\\';
-    case '\n': return '\\n';
-    case '\r': return '\\r';
-    case '\b': return '\\b';
-    case '\t': return '\\t';
-    case '\f': return '\\f';
-    case '<': return '\\x3C';
-    case '\u2028': return '\\u2028';
-    case '\u2029': return '\\u2029';
-    default: return undefined;
+    case '"':
+      return '\\"';
+    case '\\':
+      return '\\\\';
+    case '\n':
+      return '\\n';
+    case '\r':
+      return '\\r';
+    case '\b':
+      return '\\b';
+    case '\t':
+      return '\\t';
+    case '\f':
+      return '\\f';
+    case '<':
+      return '\\x3C';
+    case '\u2028':
+      return '\\u2028';
+    case '\u2029':
+      return '\\u2029';
+    default:
+      return undefined;
   }
 }
 
@@ -38,16 +49,36 @@ export function serializeString(str: string): string {
   return result;
 }
 
+function deserializeReplacer(str: string): string {
+  switch (str) {
+    case '\\\\':
+      return '\\';
+    case '\\"':
+      return '"';
+    case '\\n':
+      return '\n';
+    case '\\r':
+      return '\r';
+    case '\\b':
+      return '\b';
+    case '\\t':
+      return '\t';
+    case '\\f':
+      return '\f';
+    case '\\x3C':
+      return '\x3C';
+    case '\\u2028':
+      return '\u2028';
+    case '\\u2029':
+      return '\u2029';
+    default:
+      return str;
+  }
+}
+
 export function deserializeString(str: string): string {
-  return str
-    .replace(/\\"/g, '"')
-    .replace(/\\\\/g, '\\')
-    .replace(/\\n/g, '\n')
-    .replace(/\\r/g, '\r')
-    .replace(/\\b/g, '\b')
-    .replace(/\\t/g, '\t')
-    .replace(/\\f/g, '\f')
-    .replace(/\\x3C/g, '<')
-    .replace(/\\u2028/g, '\u2028')
-    .replace(/\\u2029/g, '\u2029');
+  return str.replace(
+    /(\\\\|\\"|\\n|\\r|\\b|\\t|\\f|\\u2028|\\u2029|\\x3C)/g,
+    deserializeReplacer,
+  );
 }

package/src/core/tree/async.ts

@@ -2,7 +2,7 @@ import BaseAsyncParserContext from '../context/parser/async';
 import type { BaseParserContextOptions } from '../context/parser';
 import type { SerovalMode } from '../plugin';
 
-export type AsyncParserContextOptions = Omit<BaseParserContextOptions, 'refs'>
+export type AsyncParserContextOptions = Omit<BaseParserContextOptions, 'refs'>;
 
 export default class AsyncParserContext extends BaseAsyncParserContext {
   readonly mode: SerovalMode = 'vanilla';

package/src/core/tree/deserializer.ts

@@ -2,7 +2,8 @@ import BaseDeserializerContext from '../context/deserializer';
 import type { BaseDeserializerOptions } from '../context/deserializer';
 import type { SerovalMode } from '../plugin';
 
-export interface VanillaDeserializerContextOptions extends Omit<BaseDeserializerOptions, 'refs'> {
+export interface VanillaDeserializerContextOptions
+  extends Omit<BaseDeserializerOptions, 'refs'> {
   markedRefs: number[] | Set<number>;
 }
 
@@ -12,17 +13,11 @@ export default class VanillaDeserializerContext extends BaseDeserializerContext
   marked: Set<number>;
 
   constructor(options: VanillaDeserializerContextOptions) {
-    super({
-      plugins: options.plugins,
-      refs: undefined,
-    });
+    super(options);
     this.marked = new Set(options.markedRefs);
   }
 
-  assignIndexedValue<T>(
-    index: number,
-    value: T,
-  ): T {
+  assignIndexedValue<T>(index: number, value: T): T {
     if (this.marked.has(index)) {
       this.refs.set(index, value);
     }

package/src/core/tree/index.ts

@@ -1,4 +1,4 @@
-import type { PluginAccessOptions } from '../plugin';
+import { resolvePlugins, type PluginAccessOptions } from '../plugin';
 import type { SerovalNode } from '../types';
 import type { AsyncParserContextOptions } from './async';
 import AsyncParserContext from './async';
@@ -11,13 +11,14 @@ export function serialize<T>(
   source: T,
   options: SyncParserContextOptions = {},
 ): string {
+  const plugins = resolvePlugins(options.plugins);
   const ctx = new SyncParserContext({
-    plugins: options.plugins,
+    plugins,
     disabledFeatures: options.disabledFeatures,
   });
   const tree = ctx.parse(source);
   const serial = new VanillaSerializerContext({
-    plugins: options.plugins,
+    plugins,
     features: ctx.features,
     markedRefs: ctx.marked,
   });
@@ -28,13 +29,14 @@ export async function serializeAsync<T>(
   source: T,
   options: AsyncParserContextOptions = {},
 ): Promise<string> {
+  const plugins = resolvePlugins(options.plugins);
   const ctx = new AsyncParserContext({
-    plugins: options.plugins,
+    plugins,
     disabledFeatures: options.disabledFeatures,
   });
   const tree = await ctx.parse(source);
   const serial = new VanillaSerializerContext({
-    plugins: options.plugins,
+    plugins,
     features: ctx.features,
     markedRefs: ctx.marked,
   });
@@ -42,7 +44,6 @@ export async function serializeAsync<T>(
 }
 
 export function deserialize<T>(source: string): T {
-  // eslint-disable-next-line no-eval
   return (0, eval)(source) as T;
 }
 
@@ -56,8 +57,9 @@ export function toJSON<T>(
   source: T,
   options: SyncParserContextOptions = {},
 ): SerovalJSON {
+  const plugins = resolvePlugins(options.plugins);
   const ctx = new SyncParserContext({
-    plugins: options.plugins,
+    plugins,
     disabledFeatures: options.disabledFeatures,
   });
   return {
@@ -71,8 +73,9 @@ export async function toJSONAsync<T>(
   source: T,
   options: AsyncParserContextOptions = {},
 ): Promise<SerovalJSON> {
+  const plugins = resolvePlugins(options.plugins);
   const ctx = new AsyncParserContext({
-    plugins: options.plugins,
+    plugins,
     disabledFeatures: options.disabledFeatures,
   });
   return {
@@ -83,8 +86,9 @@ export async function toJSONAsync<T>(
 }
 
 export function compileJSON(source: SerovalJSON, options: PluginAccessOptions = {}): string {
+  const plugins = resolvePlugins(options.plugins);
   const ctx = new VanillaSerializerContext({
-    plugins: options.plugins,
+    plugins,
     features: source.f,
     markedRefs: source.m,
   });
@@ -92,8 +96,9 @@ export function compileJSON(source: SerovalJSON, options: PluginAccessOptions =
 }
 
 export function fromJSON<T>(source: SerovalJSON, options: PluginAccessOptions = {}): T {
+  const plugins = resolvePlugins(options.plugins);
   const ctx = new VanillaDeserializerContext({
-    plugins: options.plugins,
+    plugins,
     markedRefs: source.m,
   });
   return ctx.deserialize(source.t) as T;

package/src/core/tree/serializer.ts

@@ -3,10 +3,6 @@ import type {
   SerovalPromiseConstructorNode,
   SerovalPromiseRejectNode,
   SerovalPromiseResolveNode,
-  SerovalReadableStreamCloseNode,
-  SerovalReadableStreamConstructorNode,
-  SerovalReadableStreamEnqueueNode,
-  SerovalReadableStreamErrorNode,
 } from '../types';
 import type { BaseSerializerContextOptions } from '../context/serializer';
 import BaseSerializerContext from '../context/serializer';
@@ -14,7 +10,7 @@ import getIdentifier from '../utils/get-identifier';
 import type { SerovalMode } from '../plugin';
 import { SerovalNodeType } from '../constants';
 
-export type VanillaSerializerContextOptions = BaseSerializerContextOptions
+export type VanillaSerializerContextOptions = BaseSerializerContextOptions;
 
 export default class VanillaSerializerContext extends BaseSerializerContext {
   readonly mode: SerovalMode = 'vanilla';
@@ -23,7 +19,7 @@ export default class VanillaSerializerContext extends BaseSerializerContext {
    * Map tree refs to actual refs
    * @private
    */
-  valid = new Map<number | string, number>();
+  valid = new Map<number, number>();
 
   /**
    * Variables
@@ -31,20 +27,11 @@ export default class VanillaSerializerContext extends BaseSerializerContext {
    */
   vars: string[] = [];
 
-  /**
-   * Increments the number of references the referenced value has
-   */
-  markRef(
-    current: number,
-  ): void {
-    this.marked.add(current);
-  }
-
   /**
    * Creates the reference param (identifier) from the given reference ID
    * Calling this function means the value has been referenced somewhere
    */
-  getRefParam(index: number | string): string {
+  getRefParam(index: number): string {
     /**
      * Creates a new reference ID from a given reference ID
      * This new reference ID means that the reference itself
@@ -64,10 +51,7 @@ export default class VanillaSerializerContext extends BaseSerializerContext {
     return identifier;
   }
 
-  protected assignIndexedValue(
-    index: number,
-    value: string,
-  ): string {
+  protected assignIndexedValue(index: number, value: string): string {
     if (this.isMarked(index)) {
       return this.getRefParam(index) + '=' + value;
     }
@@ -80,39 +64,11 @@ export default class VanillaSerializerContext extends BaseSerializerContext {
     throw new Error('Unsupported node type "' + node.t + '".');
   }
 
-  protected serializePromiseResolve(
-    node: SerovalPromiseResolveNode,
-  ): string {
-    throw new Error('Unsupported node type "' + node.t + '".');
-  }
-
-  protected serializePromiseReject(
-    node: SerovalPromiseRejectNode,
-  ): string {
+  protected serializePromiseResolve(node: SerovalPromiseResolveNode): string {
     throw new Error('Unsupported node type "' + node.t + '".');
   }
 
-  protected serializeReadableStreamConstructor(
-    node: SerovalReadableStreamConstructorNode,
-  ): string {
-    throw new Error('Unsupported node type "' + node.t + '".');
-  }
-
-  protected serializeReadableStreamEnqueue(
-    node: SerovalReadableStreamEnqueueNode,
-  ): string {
-    throw new Error('Unsupported node type "' + node.t + '".');
-  }
-
-  protected serializeReadableStreamError(
-    node: SerovalReadableStreamErrorNode,
-  ): string {
-    throw new Error('Unsupported node type "' + node.t + '".');
-  }
-
-  protected serializeReadableStreamClose(
-    node: SerovalReadableStreamCloseNode,
-  ): string {
+  protected serializePromiseReject(node: SerovalPromiseRejectNode): string {
     throw new Error('Unsupported node type "' + node.t + '".');
   }