seroval 0.8.0 → 0.10.1

package/src/index.ts

@@ -1,21 +1,4 @@
-/* eslint-disable no-await-in-loop */
-import { Feature } from './compat';
-import type {
-  SerializationContext,
-  Options,
-} from './context';
-import {
-  getRefParam,
-  createParserContext,
-  createSerializationContext,
-  getRootID,
-} from './context';
-import parseSync from './tree/sync';
-import parseAsync from './tree/async';
-import deserializeTree from './tree/deserialize';
-import serializeTree, { resolvePatches } from './tree/serialize';
-import type { SerovalNode } from './tree/types';
-import { SerovalNodeType } from './tree/types';
+import { serialize } from './core/tree';
 
 export type {
   AsyncServerValue,
@@ -25,131 +8,14 @@ export type {
   SemiPrimitiveValue,
   ErrorValue,
 } from './types';
-export { Feature } from './compat';
+export { Feature } from './core/compat';
+export { createReference } from './core/reference';
 
-function finalize(
-  ctx: SerializationContext,
-  rootID: number,
-  isObject: boolean,
-  result: string,
-): string {
-  // Shared references detected
-  if (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;
-}
+export * from './core/tree';
+export * from './core/cross';
 
-export function serialize<T>(
-  source: T,
-  options?: Partial<Options>,
-): string {
-  const ctx = createParserContext(options);
-  const tree = parseSync(ctx, source);
-  const serial = createSerializationContext(ctx);
-  const result = serializeTree(serial, tree);
-  return finalize(
-    serial,
-    getRootID(ctx, source),
-    tree.t === SerovalNodeType.Object,
-    result,
-  );
-}
+export { CROSS_REFERENCE_HEADER } from './core/keys';
 
-export async function serializeAsync<T>(
-  source: T,
-  options?: Partial<Options>,
-): Promise<string> {
-  const ctx = createParserContext(options);
-  const tree = await parseAsync(ctx, source);
-  const serial = createSerializationContext(ctx);
-  const result = serializeTree(serial, tree);
-  return finalize(
-    serial,
-    getRootID(ctx, source),
-    tree.t === SerovalNodeType.Object,
-    result,
-  );
-}
-
-export function deserialize<T>(source: string): T {
-  // eslint-disable-next-line no-eval
-  return (0, eval)(source) as T;
-}
-
-export interface SerovalJSON {
-  t: SerovalNode;
-  r: number;
-  f: number;
-  m: number[];
-}
-
-export function toJSON<T>(
-  source: T,
-  options?: Partial<Options>,
-): SerovalJSON {
-  const ctx = createParserContext(options);
-  return {
-    t: parseSync(ctx, source),
-    r: getRootID(ctx, source),
-    f: ctx.features,
-    m: Array.from(ctx.markedRefs),
-  };
-}
-
-export async function toJSONAsync<T>(
-  source: T,
-  options?: Partial<Options>,
-): Promise<SerovalJSON> {
-  const ctx = createParserContext(options);
-  return {
-    t: await parseAsync(ctx, source),
-    r: getRootID(ctx, source),
-    f: ctx.features,
-    m: Array.from(ctx.markedRefs),
-  };
-}
-
-export function compileJSON(source: SerovalJSON): string {
-  const serial = createSerializationContext({
-    features: source.f,
-    markedRefs: source.m,
-  });
-  const result = serializeTree(serial, source.t);
-  return finalize(serial, source.r, source.t.i === SerovalNodeType.Object, result);
-}
-
-export function fromJSON<T>(source: SerovalJSON): T {
-  const serial = createSerializationContext({
-    features: source.f,
-    markedRefs: source.m,
-  });
-  return deserializeTree(serial, source.t) as T;
-}
+export { default as Serializer } from './core/Serializer';
 
 export default serialize;
-
-export { createReference } from './tree/reference';

package/src/types.ts

@@ -1,4 +1,4 @@
-import type { WellKnownSymbols } from './tree/symbols';
+import type { WellKnownSymbols } from './core/constants';
 
 // Values that are non-recursive
 export type PrimitiveValue =

package/dist/types/context.d.ts

@@ -1,61 +0,0 @@
-interface IndexAssignment {
-    t: 'index';
-    s: string;
-    k: undefined;
-    v: string;
-}
-interface SetAssignment {
-    t: 'set';
-    s: string;
-    k: string;
-    v: string;
-}
-interface AddAssignment {
-    t: 'add';
-    s: string;
-    k: undefined;
-    v: string;
-}
-interface AppendAssignment {
-    t: 'append';
-    s: string;
-    k: string;
-    v: string;
-}
-export type Assignment = IndexAssignment | AddAssignment | SetAssignment | AppendAssignment;
-export interface ParserContext {
-    refs: Map<unknown, number>;
-    markedRefs: Set<number>;
-    features: number;
-}
-export interface SerializationContext {
-    stack: number[];
-    validRefs: (number | undefined)[];
-    refSize: number;
-    markedRefs: Set<number>;
-    vars: (string | undefined)[];
-    assignments: Assignment[];
-    features: number;
-    valueMap: Map<number, unknown>;
-}
-export interface Options {
-    disabledFeatures: number;
-}
-export declare function createParserContext(options?: Partial<Options>): ParserContext;
-export interface SerializationOptions {
-    markedRefs: number[] | Set<number>;
-    features: number;
-}
-export declare function createSerializationContext(options: SerializationOptions): SerializationContext;
-/**
- * Increments the number of references the referenced value has
- */
-export declare function markRef(ctx: ParserContext | SerializationContext, current: number): void;
-/**
- * Creates the reference param (identifier) from the given reference ID
- * Calling this function means the value has been referenced somewhere
- */
-export declare function getRefParam(ctx: SerializationContext, index: number): string;
-export declare function getRootID<T>(ctx: ParserContext, current: T): number;
-export declare function createIndexedValue<T>(ctx: ParserContext, current: T): number;
-export {};

package/dist/types/tree/async.d.ts

@@ -1,3 +0,0 @@
-import type { ParserContext } from '../context';
-import type { SerovalNode } from './types';
-export default function parseAsync<T>(ctx: ParserContext, current: T): Promise<SerovalNode>;

package/dist/types/tree/deserialize.d.ts

@@ -1,3 +0,0 @@
-import type { SerializationContext } from '../context';
-import type { SerovalNode } from './types';
-export default function deserializeTree(ctx: SerializationContext, node: SerovalNode): unknown;

package/dist/types/tree/primitives.d.ts

@@ -1,19 +0,0 @@
-import type { ParserContext } from '../context';
-import type { BigIntTypedArrayValue, TypedArrayValue } from '../types';
-import type { WellKnownSymbols } from './symbols';
-import type { SerovalBigIntNode, SerovalBigIntTypedArrayNode, SerovalDateNode, SerovalIndexedValueNode, SerovalRegExpNode, SerovalStringNode, SerovalTypedArrayNode, SerovalWKSymbolNode, SerovalReferenceNode, SerovalArrayBufferNode, SerovalDataViewNode, SerovalNode } from './types';
-export declare function createNumberNode(value: number): SerovalNode;
-export declare function createStringNode(value: string): SerovalStringNode;
-export declare function createBigIntNode(ctx: ParserContext, current: bigint): SerovalBigIntNode;
-export declare function createIndexedValueNode(id: number): SerovalIndexedValueNode;
-export declare function createDateNode(id: number, current: Date): SerovalDateNode;
-export declare function createRegExpNode(id: number, current: RegExp): SerovalRegExpNode;
-export declare function createArrayBufferNode(id: number, current: ArrayBuffer): SerovalArrayBufferNode;
-export declare function serializeArrayBuffer(ctx: ParserContext, current: ArrayBuffer): SerovalNode;
-export declare function createTypedArrayNode(ctx: ParserContext, id: number, current: TypedArrayValue): SerovalTypedArrayNode;
-export declare function createBigIntTypedArrayNode(ctx: ParserContext, id: number, current: BigIntTypedArrayValue): SerovalBigIntTypedArrayNode;
-export declare function createWKSymbolNode(ctx: ParserContext, id: number, current: WellKnownSymbols): SerovalWKSymbolNode;
-export declare function createReferenceNode<T>(id: number, ref: T): SerovalReferenceNode;
-export declare function createDataViewNode(ctx: ParserContext, id: number, current: DataView): SerovalDataViewNode;
-export declare function createSymbolNode(ctx: ParserContext, current: symbol): SerovalNode;
-export declare function createFunctionNode(ctx: ParserContext, current: Function): SerovalNode;

package/dist/types/tree/serialize.d.ts

@@ -1,4 +0,0 @@
-import type { SerializationContext } from '../context';
-import type { SerovalNode } from './types';
-export declare function resolvePatches(ctx: SerializationContext): string | undefined;
-export default function serializeTree(ctx: SerializationContext, node: SerovalNode): string;

package/dist/types/tree/symbols.d.ts

@@ -1,33 +0,0 @@
-export declare const enum Symbols {
-    AsyncIterator = 0,
-    HasInstance = 1,
-    IsConcatSpreadable = 2,
-    Iterator = 3,
-    Match = 4,
-    MatchAll = 5,
-    Replace = 6,
-    Search = 7,
-    Species = 8,
-    Split = 9,
-    ToPrimitive = 10,
-    ToStringTag = 11,
-    Unscopables = 12
-}
-export declare const SYMBOL_STRING: Record<Symbols, string>;
-export declare const INV_SYMBOL_REF: {
-    [Symbol.asyncIterator]: Symbols;
-    [Symbol.hasInstance]: Symbols;
-    [Symbol.isConcatSpreadable]: Symbols;
-    [Symbol.iterator]: Symbols;
-    [Symbol.match]: Symbols;
-    [Symbol.matchAll]: Symbols;
-    [Symbol.replace]: Symbols;
-    [Symbol.search]: Symbols;
-    [Symbol.species]: Symbols;
-    [Symbol.split]: Symbols;
-    [Symbol.toPrimitive]: Symbols;
-    [Symbol.toStringTag]: Symbols;
-    [Symbol.unscopables]: Symbols;
-};
-export type WellKnownSymbols = keyof typeof INV_SYMBOL_REF;
-export declare const SYMBOL_REF: Record<Symbols, WellKnownSymbols>;

package/dist/types/tree/sync.d.ts

@@ -1,3 +0,0 @@
-import type { ParserContext } from '../context';
-import type { SerovalNode } from './types';
-export default function parseSync<T>(ctx: ParserContext, current: T): SerovalNode;

package/dist/types/tree/web-api.d.ts

@@ -1,6 +0,0 @@
-import type { ParserContext } from '../context';
-import type { SerovalBlobNode, SerovalFileNode, SerovalURLNode, SerovalURLSearchParamsNode } from './types';
-export declare function createURLNode(ctx: ParserContext, id: number, current: URL): SerovalURLNode;
-export declare function createURLSearchParamsNode(ctx: ParserContext, id: number, current: URLSearchParams): SerovalURLSearchParamsNode;
-export declare function createBlobNode(ctx: ParserContext, id: number, current: Blob): Promise<SerovalBlobNode>;
-export declare function createFileNode(ctx: ParserContext, id: number, current: File): Promise<SerovalFileNode>;

package/src/context.ts

@@ -1,154 +0,0 @@
-import { ALL_ENABLED } from './compat';
-import getIdentifier from './get-identifier';
-
-interface IndexAssignment {
-  t: 'index';
-  s: string;
-  k: undefined;
-  v: string;
-}
-
-interface SetAssignment {
-  t: 'set';
-  s: string;
-  k: string;
-  v: string;
-}
-
-interface AddAssignment {
-  t: 'add';
-  s: string;
-  k: undefined;
-  v: string;
-}
-
-interface AppendAssignment {
-  t: 'append';
-  s: string;
-  k: string;
-  v: string;
-}
-
-// Array of assignments to be done (used for recursion)
-export type Assignment =
-  | IndexAssignment
-  | AddAssignment
-  | SetAssignment
-  | AppendAssignment;
-
-export interface ParserContext {
-  refs: Map<unknown, number>;
-  markedRefs: Set<number>;
-  features: number;
-}
-
-export interface SerializationContext {
-  stack: number[];
-  // Map tree refs to actual refs
-  validRefs: (number | undefined)[];
-  refSize: number;
-  // Refs that are...referenced
-  markedRefs: Set<number>;
-  // Variables
-  vars: (string | undefined)[];
-  // Array of assignments to be done (used for recursion)
-  assignments: Assignment[];
-  // Supported features
-  features: number;
-
-  valueMap: Map<number, unknown>;
-}
-
-export interface Options {
-  disabledFeatures: number;
-}
-
-const DEFAULT_OPTIONS: Options = {
-  disabledFeatures: 0,
-};
-
-export function createParserContext(options: Partial<Options> = {}): ParserContext {
-  // eslint-disable-next-line prefer-object-spread
-  const result = Object.assign({}, DEFAULT_OPTIONS, options);
-  return {
-    markedRefs: new Set(),
-    refs: new Map(),
-    features: ALL_ENABLED ^ result.disabledFeatures,
-  };
-}
-
-export interface SerializationOptions {
-  markedRefs: number[] | Set<number>;
-  features: number;
-}
-
-export function createSerializationContext(options: SerializationOptions): SerializationContext {
-  return {
-    stack: [],
-    vars: [],
-    assignments: [],
-    validRefs: [],
-    refSize: 0,
-    features: options.features,
-    markedRefs: new Set(options.markedRefs),
-    valueMap: new Map(),
-  };
-}
-
-/**
- * Increments the number of references the referenced value has
- */
-export function markRef(
-  ctx: ParserContext | SerializationContext,
-  current: number,
-): void {
-  ctx.markedRefs.add(current);
-}
-/**
- * Creates the reference param (identifier) from the given reference ID
- * Calling this function means the value has been referenced somewhere
- */
-export function getRefParam(ctx: SerializationContext, 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 = ctx.validRefs[index];
-  if (actualIndex == null) {
-    actualIndex = ctx.refSize++;
-    ctx.validRefs[index] = actualIndex;
-  }
-  let identifier = ctx.vars[actualIndex];
-  if (identifier == null) {
-    identifier = getIdentifier(actualIndex);
-    ctx.vars[actualIndex] = identifier;
-  }
-  return identifier;
-}
-
-export function getRootID<T>(
-  ctx: ParserContext,
-  current: T,
-): number {
-  const ref = ctx.refs.get(current);
-  if (ref == null) {
-    return ctx.refs.size;
-  }
-  return ref;
-}
-
-export function createIndexedValue<T>(
-  ctx: ParserContext,
-  current: T,
-): number {
-  const ref = ctx.refs.get(current);
-  if (ref == null) {
-    const id = ctx.refs.size;
-    ctx.refs.set(current, id);
-    return id;
-  }
-  markRef(ctx, ref);
-  return ref;
-}

package/src/tree/constants.ts

@@ -1,72 +0,0 @@
-import type { SerovalConstantNode } from './types';
-import { SerovalConstant, SerovalNodeType } from './types';
-
-function createConstantNode(value: SerovalConstant): SerovalConstantNode {
-  return {
-    t: SerovalNodeType.Constant,
-    i: undefined,
-    s: value,
-    l: undefined,
-    c: undefined,
-    m: undefined,
-    d: undefined,
-    a: undefined,
-    f: undefined,
-    b: undefined,
-  };
-}
-
-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 function serializeConstant(node: SerovalConstantNode): string {
-  switch (node.s) {
-    case SerovalConstant.True:
-      return '!0';
-    case SerovalConstant.False:
-      return '!1';
-    case SerovalConstant.Undefined:
-      return 'void 0';
-    case SerovalConstant.Null:
-      return 'null';
-    case SerovalConstant.NegativeZero:
-      return '-0';
-    case SerovalConstant.Infinity:
-      return '1/0';
-    case SerovalConstant.NegativeInfinity:
-      return '-1/0';
-    case SerovalConstant.NaN:
-      return 'NaN';
-    default:
-      throw new Error('invariant');
-  }
-}
-
-export function deserializeConstant(node: SerovalConstantNode): unknown {
-  switch (node.s) {
-    case SerovalConstant.True:
-      return true;
-    case SerovalConstant.False:
-      return false;
-    case SerovalConstant.Undefined:
-      return undefined;
-    case SerovalConstant.Null:
-      return null;
-    case SerovalConstant.NegativeZero:
-      return -0;
-    case SerovalConstant.Infinity:
-      return Infinity;
-    case SerovalConstant.NegativeInfinity:
-      return -Infinity;
-    case SerovalConstant.NaN:
-      return NaN;
-    default:
-      throw new Error('invariant');
-  }
-}

package/src/tree/iterator.ts

@@ -1,14 +0,0 @@
-export default function createIterator<T>(
-  values: Array<T>,
-): Iterator<T> {
-  let index = 0;
-  const len = values.length;
-  return {
-    next() {
-      return {
-        value: values[index++],
-        done: index >= len,
-      };
-    },
-  };
-}

package/src/tree/symbols.ts

@@ -1,65 +0,0 @@
-export const enum Symbols {
-  AsyncIterator = 0,
-  HasInstance = 1,
-  IsConcatSpreadable = 2,
-  Iterator = 3,
-  Match = 4,
-  MatchAll = 5,
-  Replace = 6,
-  Search = 7,
-  Species = 8,
-  Split = 9,
-  ToPrimitive = 10,
-  ToStringTag = 11,
-  Unscopables = 12,
-}
-
-export const SYMBOL_STRING: Record<Symbols, string> = {
-  [Symbols.AsyncIterator]: 'Symbol.asyncIterator',
-  [Symbols.HasInstance]: 'Symbol.hasInstance',
-  [Symbols.IsConcatSpreadable]: 'Symbol.isConcatSpreadable',
-  [Symbols.Iterator]: 'Symbol.iterator',
-  [Symbols.Match]: 'Symbol.match',
-  [Symbols.MatchAll]: 'Symbol.matchAll',
-  [Symbols.Replace]: 'Symbol.replace',
-  [Symbols.Search]: 'Symbol.search',
-  [Symbols.Species]: 'Symbol.species',
-  [Symbols.Split]: 'Symbol.split',
-  [Symbols.ToPrimitive]: 'Symbol.toPrimitive',
-  [Symbols.ToStringTag]: 'Symbol.toStringTag',
-  [Symbols.Unscopables]: 'Symbol.unscopables',
-};
-
-export const INV_SYMBOL_REF = {
-  [Symbol.asyncIterator]: Symbols.AsyncIterator,
-  [Symbol.hasInstance]: Symbols.HasInstance,
-  [Symbol.isConcatSpreadable]: Symbols.IsConcatSpreadable,
-  [Symbol.iterator]: Symbols.Iterator,
-  [Symbol.match]: Symbols.Match,
-  [Symbol.matchAll]: Symbols.MatchAll,
-  [Symbol.replace]: Symbols.Replace,
-  [Symbol.search]: Symbols.Search,
-  [Symbol.species]: Symbols.Species,
-  [Symbol.split]: Symbols.Split,
-  [Symbol.toPrimitive]: Symbols.ToPrimitive,
-  [Symbol.toStringTag]: Symbols.ToStringTag,
-  [Symbol.unscopables]: Symbols.Unscopables,
-};
-
-export type WellKnownSymbols = keyof typeof INV_SYMBOL_REF;
-
-export const SYMBOL_REF: Record<Symbols, WellKnownSymbols> = {
-  [Symbols.AsyncIterator]: Symbol.asyncIterator,
-  [Symbols.HasInstance]: Symbol.hasInstance,
-  [Symbols.IsConcatSpreadable]: Symbol.isConcatSpreadable,
-  [Symbols.Iterator]: Symbol.iterator,
-  [Symbols.Match]: Symbol.match,
-  [Symbols.MatchAll]: Symbol.matchAll,
-  [Symbols.Replace]: Symbol.replace,
-  [Symbols.Search]: Symbol.search,
-  [Symbols.Species]: Symbol.species,
-  [Symbols.Split]: Symbol.split,
-  [Symbols.ToPrimitive]: Symbol.toPrimitive,
-  [Symbols.ToStringTag]: Symbol.toStringTag,
-  [Symbols.Unscopables]: Symbol.unscopables,
-};