seroval 1.3.2 → 1.4.1

package/src/core/reference.ts

@@ -1,63 +0,0 @@
-import {
-  SerovalMissingReferenceError,
-  SerovalMissingReferenceForIdError,
-} from '..';
-import { REFERENCES_KEY } from './keys';
-import assert from './utils/assert';
-
-const REFERENCE = new Map<unknown, string>();
-const INV_REFERENCE = new Map<string, unknown>();
-
-export function createReference<T>(id: string, value: T): T {
-  REFERENCE.set(value, id);
-  INV_REFERENCE.set(id, value);
-  return value;
-}
-
-export function hasReferenceID<T>(value: T): boolean {
-  return REFERENCE.has(value);
-}
-
-export function hasReference(id: string): boolean {
-  return INV_REFERENCE.has(id);
-}
-
-export function getReferenceID<T>(value: T): string {
-  assert(hasReferenceID(value), new SerovalMissingReferenceError(value));
-  return REFERENCE.get(value)!;
-}
-
-export function getReference<T>(id: string): T {
-  assert(hasReference(id), new SerovalMissingReferenceForIdError(id));
-  return INV_REFERENCE.get(id) as T;
-}
-
-if (typeof globalThis !== 'undefined') {
-  Object.defineProperty(globalThis, REFERENCES_KEY, {
-    value: INV_REFERENCE,
-    configurable: true,
-    writable: false,
-    enumerable: false,
-  });
-} else if (typeof window !== 'undefined') {
-  Object.defineProperty(window, REFERENCES_KEY, {
-    value: INV_REFERENCE,
-    configurable: true,
-    writable: false,
-    enumerable: false,
-  });
-} else if (typeof self !== 'undefined') {
-  Object.defineProperty(self, REFERENCES_KEY, {
-    value: INV_REFERENCE,
-    configurable: true,
-    writable: false,
-    enumerable: false,
-  });
-} else if (typeof global !== 'undefined') {
-  Object.defineProperty(global, REFERENCES_KEY, {
-    value: INV_REFERENCE,
-    configurable: true,
-    writable: false,
-    enumerable: false,
-  });
-}

package/src/core/special-reference.ts

@@ -1,114 +0,0 @@
-import { createEffectfulFunction, createFunction } from './function-string';
-
-export const ITERATOR = {};
-
-export const ASYNC_ITERATOR = {};
-
-export const enum SpecialReference {
-  MapSentinel = 0,
-  PromiseConstructor = 1,
-  PromiseSuccess = 2,
-  PromiseFailure = 3,
-  StreamConstructor = 4,
-}
-
-/**
- * Placeholder references
- */
-export const SPECIAL_REFS: Record<SpecialReference, unknown> = {
-  [SpecialReference.MapSentinel]: {},
-  [SpecialReference.PromiseConstructor]: {},
-  [SpecialReference.PromiseSuccess]: {},
-  [SpecialReference.PromiseFailure]: {},
-  [SpecialReference.StreamConstructor]: {},
-};
-
-function serializePromiseConstructor(features: number): string {
-  return createFunction(
-    features,
-    ['r'],
-    '(r.p=new Promise(' +
-      createEffectfulFunction(features, ['s', 'f'], 'r.s=s,r.f=f') +
-      '))',
-  );
-}
-
-function serializePromiseSuccess(features: number): string {
-  return createEffectfulFunction(
-    features,
-    ['r', 'd'],
-    'r.s(d),r.p.s=1,r.p.v=d',
-  );
-}
-
-function serializePromiseFailure(features: number): string {
-  return createEffectfulFunction(
-    features,
-    ['r', 'd'],
-    'r.f(d),r.p.s=2,r.p.v=d',
-  );
-}
-
-function serializeStreamConstructor(features: number): string {
-  return createFunction(
-    features,
-    ['b', 'a', 's', 'l', 'p', 'f', 'e', 'n'],
-    '(b=[],a=!0,s=!1,l=[],p=0,f=' +
-      createEffectfulFunction(
-        features,
-        ['v', 'm', 'x'],
-        'for(x=0;x<p;x++)l[x]&&l[x][m](v)',
-      ) +
-      ',n=' +
-      createEffectfulFunction(
-        features,
-        ['o', 'x', 'z', 'c'],
-        'for(x=0,z=b.length;x<z;x++)(c=b[x],(!a&&x===z-1)?o[s?"return":"throw"](c):o.next(c))',
-      ) +
-      ',e=' +
-      createFunction(
-        features,
-        ['o', 't'],
-        '(a&&(l[t=p++]=o),n(o),' +
-          createEffectfulFunction(features, [], 'a&&(l[t]=void 0)') +
-          ')',
-      ) +
-      ',{__SEROVAL_STREAM__:!0,on:' +
-      createFunction(features, ['o'], 'e(o)') +
-      ',next:' +
-      createEffectfulFunction(features, ['v'], 'a&&(b.push(v),f(v,"next"))') +
-      ',throw:' +
-      createEffectfulFunction(
-        features,
-        ['v'],
-        'a&&(b.push(v),f(v,"throw"),a=s=!1,l.length=0)',
-      ) +
-      ',return:' +
-      createEffectfulFunction(
-        features,
-        ['v'],
-        'a&&(b.push(v),f(v,"return"),a=!1,s=!0,l.length=0)',
-      ) +
-      '})',
-  );
-}
-
-export function serializeSpecialReferenceValue(
-  features: number,
-  ref: SpecialReference,
-): string {
-  switch (ref) {
-    case SpecialReference.MapSentinel:
-      return '[]';
-    case SpecialReference.PromiseConstructor:
-      return serializePromiseConstructor(features);
-    case SpecialReference.PromiseSuccess:
-      return serializePromiseSuccess(features);
-    case SpecialReference.PromiseFailure:
-      return serializePromiseFailure(features);
-    case SpecialReference.StreamConstructor:
-      return serializeStreamConstructor(features);
-    default:
-      return '';
-  }
-}

package/src/core/stream.ts

@@ -1,205 +0,0 @@
-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 = true;
-
-  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 && !alive) {
-          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,84 +0,0 @@
-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;
-  }
-}
-
-// Written by https://github.com/DylanPiercey and is distributed under the MIT license.
-// Creates a JavaScript double quoted string and escapes all characters
-// not listed as DoubleStringCharacters on
-// Also includes "<" to escape "</script>" and "\" to avoid invalid escapes in the output.
-// http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.4
-export function serializeString(str: string): string {
-  let result = '';
-  let lastPos = 0;
-  let replacement: string | undefined;
-  for (let i = 0, len = str.length; i < len; i++) {
-    replacement = serializeChar(str[i]);
-    if (replacement) {
-      result += str.slice(lastPos, i) + replacement;
-      lastPos = i + 1;
-    }
-  }
-  if (lastPos === 0) {
-    result = str;
-  } else {
-    result += str.slice(lastPos);
-  }
-  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(
-    /(\\\\|\\"|\\n|\\r|\\b|\\t|\\f|\\u2028|\\u2029|\\x3C)/g,
-    deserializeReplacer,
-  );
-}

package/src/core/tree/async.ts

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

package/src/core/tree/deserializer.ts

@@ -1,26 +0,0 @@
-import type { BaseDeserializerOptions } from '../context/deserializer';
-import BaseDeserializerContext from '../context/deserializer';
-import type { SerovalMode } from '../plugin';
-
-export interface VanillaDeserializerContextOptions
-  extends Omit<BaseDeserializerOptions, 'refs'> {
-  markedRefs: number[] | Set<number>;
-}
-
-export default class VanillaDeserializerContext extends BaseDeserializerContext {
-  readonly mode: SerovalMode = 'vanilla';
-
-  marked: Set<number>;
-
-  constructor(options: VanillaDeserializerContextOptions) {
-    super(options);
-    this.marked = new Set(options.markedRefs);
-  }
-
-  assignIndexedValue<T>(index: number, value: T): T {
-    if (this.marked.has(index)) {
-      this.refs.set(index, value);
-    }
-    return value;
-  }
-}

package/src/core/tree/index.ts

@@ -1,111 +0,0 @@
-import { type PluginAccessOptions, resolvePlugins } from '../plugin';
-import type { SerovalNode } from '../types';
-import type { AsyncParserContextOptions } from './async';
-import AsyncParserContext from './async';
-import VanillaDeserializerContext from './deserializer';
-import VanillaSerializerContext from './serializer';
-import type { SyncParserContextOptions } from './sync';
-import SyncParserContext from './sync';
-
-export function serialize<T>(
-  source: T,
-  options: SyncParserContextOptions = {},
-): string {
-  const plugins = resolvePlugins(options.plugins);
-  const ctx = new SyncParserContext({
-    plugins,
-    disabledFeatures: options.disabledFeatures,
-  });
-  const tree = ctx.parseTop(source);
-  const serial = new VanillaSerializerContext({
-    plugins,
-    features: ctx.features,
-    markedRefs: ctx.marked,
-  });
-  return serial.serializeTop(tree);
-}
-
-export async function serializeAsync<T>(
-  source: T,
-  options: AsyncParserContextOptions = {},
-): Promise<string> {
-  const plugins = resolvePlugins(options.plugins);
-  const ctx = new AsyncParserContext({
-    plugins,
-    disabledFeatures: options.disabledFeatures,
-  });
-  const tree = await ctx.parseTop(source);
-  const serial = new VanillaSerializerContext({
-    plugins,
-    features: ctx.features,
-    markedRefs: ctx.marked,
-  });
-  return serial.serializeTop(tree);
-}
-
-export function deserialize<T>(source: string): T {
-  return (0, eval)(source) as T;
-}
-
-export interface SerovalJSON {
-  t: SerovalNode;
-  f: number;
-  m: number[];
-}
-
-export function toJSON<T>(
-  source: T,
-  options: SyncParserContextOptions = {},
-): SerovalJSON {
-  const plugins = resolvePlugins(options.plugins);
-  const ctx = new SyncParserContext({
-    plugins,
-    disabledFeatures: options.disabledFeatures,
-  });
-  return {
-    t: ctx.parseTop(source),
-    f: ctx.features,
-    m: Array.from(ctx.marked),
-  };
-}
-
-export async function toJSONAsync<T>(
-  source: T,
-  options: AsyncParserContextOptions = {},
-): Promise<SerovalJSON> {
-  const plugins = resolvePlugins(options.plugins);
-  const ctx = new AsyncParserContext({
-    plugins,
-    disabledFeatures: options.disabledFeatures,
-  });
-  return {
-    t: await ctx.parseTop(source),
-    f: ctx.features,
-    m: Array.from(ctx.marked),
-  };
-}
-
-export function compileJSON(
-  source: SerovalJSON,
-  options: PluginAccessOptions = {},
-): string {
-  const plugins = resolvePlugins(options.plugins);
-  const ctx = new VanillaSerializerContext({
-    plugins,
-    features: source.f,
-    markedRefs: source.m,
-  });
-  return ctx.serializeTop(source.t);
-}
-
-export function fromJSON<T>(
-  source: SerovalJSON,
-  options: PluginAccessOptions = {},
-): T {
-  const plugins = resolvePlugins(options.plugins);
-  const ctx = new VanillaDeserializerContext({
-    plugins,
-    markedRefs: source.m,
-  });
-  return ctx.deserializeTop(source.t) as T;
-}

package/src/core/tree/serializer.ts

@@ -1,98 +0,0 @@
-import { SerovalNodeType } from '../constants';
-import type { BaseSerializerContextOptions } from '../context/serializer';
-import BaseSerializerContext from '../context/serializer';
-import { SerovalUnsupportedNodeError } from '../errors';
-import type { SerovalMode } from '../plugin';
-import type {
-  SerovalNode,
-  SerovalPromiseConstructorNode,
-  SerovalPromiseRejectNode,
-  SerovalPromiseResolveNode,
-} from '../types';
-import getIdentifier from '../utils/get-identifier';
-
-export type VanillaSerializerContextOptions = BaseSerializerContextOptions;
-
-export default class VanillaSerializerContext extends BaseSerializerContext {
-  readonly mode: SerovalMode = 'vanilla';
-
-  /**
-   * Map tree refs to actual refs
-   * @private
-   */
-  valid = new Map<number, number>();
-
-  /**
-   * Variables
-   * @private
-   */
-  vars: string[] = [];
-
-  /**
-   * Creates the reference param (identifier) from the given reference ID
-   * Calling this function means the value has been referenced somewhere
-   */
-  getRefParam(index: number): string {
-    /**
-     * Creates a new reference ID from a given reference ID
-     * This new reference ID means that the reference itself
-     * has been referenced at least once, and is used to generate
-     * the variables
-     */
-    let actualIndex = this.valid.get(index);
-    if (actualIndex == null) {
-      actualIndex = this.valid.size;
-      this.valid.set(index, actualIndex);
-    }
-    let identifier = this.vars[actualIndex];
-    if (identifier == null) {
-      identifier = getIdentifier(actualIndex);
-      this.vars[actualIndex] = identifier;
-    }
-    return identifier;
-  }
-
-  protected assignIndexedValue(index: number, value: string): string {
-    if (this.isMarked(index)) {
-      return this.getRefParam(index) + '=' + value;
-    }
-    return value;
-  }
-
-  protected serializePromiseConstructor(
-    node: SerovalPromiseConstructorNode,
-  ): string {
-    throw new SerovalUnsupportedNodeError(node);
-  }
-
-  protected serializePromiseResolve(node: SerovalPromiseResolveNode): string {
-    throw new SerovalUnsupportedNodeError(node);
-  }
-
-  protected serializePromiseReject(node: SerovalPromiseRejectNode): string {
-    throw new SerovalUnsupportedNodeError(node);
-  }
-
-  serializeTop(tree: SerovalNode): string {
-    const result = this.serialize(tree);
-    // Shared references detected
-    if (tree.i != null && this.vars.length) {
-      const patches = this.resolvePatches();
-      let body = result;
-      if (patches) {
-        // Get (or create) a ref from the source
-        const index = this.getRefParam(tree.i);
-        body = result + ',' + patches + index;
-        if (!result.startsWith(index + '=')) {
-          body = index + '=' + body;
-        }
-        body = '(' + body + ')';
-      }
-      return '(' + this.createFunction(this.vars, body) + ')()';
-    }
-    if (tree.t === SerovalNodeType.Object) {
-      return '(' + result + ')';
-    }
-    return result;
-  }
-}