seroval 0.2.0 → 0.3.0

package/src/types.ts

@@ -5,21 +5,58 @@ export type PrimitiveValue =
   | number
   | undefined
   | null
-  | bigint
+  | bigint;
+
+export type ErrorValue =
+  | Error
+  | AggregateError
+  | EvalError
+  | RangeError
+  | ReferenceError
+  | TypeError
+  | SyntaxError
+  | URIError;
+
+export type TypedArrayValue =
+  | Int8Array
+  | Int16Array
+  | Int32Array
+  | Uint8Array
+  | Uint16Array
+  | Uint32Array
+  | Uint8ClampedArray
+  | Float32Array
+  | Float64Array
+  | BigInt64Array
+  | BigUint64Array;
+
+export type SemiPrimitiveValue =
+  | RegExp
   | Date
-  | RegExp;
+  | TypedArrayValue;
 
-export type ServerValue =
+export type CommonServerValue =
   | PrimitiveValue
+  | SemiPrimitiveValue
+  | ErrorValue;
+
+export type ServerValue =
+  | CommonServerValue
   | Array<ServerValue>
+  | readonly ServerValue[]
+  | Iterable<ServerValue>
   | { [key: string | number]: ServerValue }
+  | { readonly [key: string | number]: ServerValue }
   | Set<ServerValue>
   | Map<ServerValue, ServerValue>;
 
 export type AsyncServerValue =
-  | PrimitiveValue
+  | CommonServerValue
   | Array<AsyncServerValue>
+  | readonly AsyncServerValue[]
+  | Iterable<AsyncServerValue>
   | { [key: string | number]: AsyncServerValue }
+  | { readonly [key: string | number]: AsyncServerValue }
   | Set<AsyncServerValue>
   | Map<AsyncServerValue, AsyncServerValue>
   | PromiseLike<AsyncServerValue>;

package/dist/types/array.d.ts

@@ -1,2 +0,0 @@
-export declare function forEach<T>(arr: T[], callback: (value: T, index: number) => (boolean | void)): void;
-export declare function join(arr: string[], joiner: string): string;

package/dist/types/async.d.ts

@@ -1,4 +0,0 @@
-import { SerializationContext } from './context';
-import { AsyncServerValue } from './types';
-export declare function lookupRefsAsync(ctx: SerializationContext, current: AsyncServerValue): Promise<void>;
-export declare function traverseAsync(ctx: SerializationContext, current: AsyncServerValue): Promise<string>;

package/dist/types/context.d.ts

@@ -1,33 +0,0 @@
-import { AsyncServerValue } from './types';
-export declare const EMPTY_SET = "new Set";
-export declare const EMPTY_MAP = "new Map";
-export declare const EMPTY_ARRAY = "[]";
-export type Assignment = [source: string, value: string];
-export type MapSet = [source: string, key: string, value: string];
-export type SetAdd = [source: string, value: string];
-export interface SerializationContext {
-    stack: Set<unknown>;
-    assignedRefs: Set<number>;
-    vars: string[];
-    assignments: Assignment[];
-    mapSets: MapSet[];
-    setAdds: SetAdd[];
-    refCount: Map<unknown, number>;
-    refs: Map<unknown, number>;
-}
-export declare function createSerializationContext(): SerializationContext;
-export declare function resolveAssignments(ctx: SerializationContext): string;
-export declare function resolveMapSets(ctx: SerializationContext): string;
-export declare function resolveSetAdds(ctx: SerializationContext): string;
-export declare function resolvePatches(ctx: SerializationContext): string;
-export declare function insertRef(ctx: SerializationContext, current: unknown): boolean;
-export declare function constructorCheck<T extends NonNullable<AsyncServerValue>>(value: NonNullable<AsyncServerValue>, constructor: unknown): value is T;
-export declare function createRef(ctx: SerializationContext, value: unknown): number;
-export declare function getRefParam(ctx: SerializationContext, index: number): string;
-export declare function assignRef(ctx: SerializationContext, index: number, value: string): string;
-export declare function createAssignment(ctx: SerializationContext, source: string, value: string): void;
-export declare function createSetAdd(ctx: SerializationContext, ref: number, value: string): void;
-export declare function createMapSet(ctx: SerializationContext, ref: number, key: string, value: string): void;
-export declare function createArrayAssign(ctx: SerializationContext, ref: number, index: number, value: string): void;
-export declare function createObjectIdentifierAssign(ctx: SerializationContext, ref: number, key: string, value: string): void;
-export declare function createObjectComputedAssign(ctx: SerializationContext, ref: number, key: string, value: string): void;

package/dist/types/is-primitive.d.ts

@@ -1,2 +0,0 @@
-import { PrimitiveValue } from './types';
-export default function isPrimitive(current: unknown): current is PrimitiveValue;

package/dist/types/is-promise.d.ts

@@ -1 +0,0 @@
-export default function isPromise<T>(obj: unknown): obj is PromiseLike<T>;

package/dist/types/sync.d.ts

@@ -1,4 +0,0 @@
-import { SerializationContext } from './context';
-import { ServerValue } from './types';
-export declare function lookupRefs(ctx: SerializationContext, current: ServerValue): void;
-export declare function traverseSync(ctx: SerializationContext, current: ServerValue): string;

package/src/array.ts

@@ -1,18 +0,0 @@
-export function forEach<T>(arr: T[], callback: (value: T, index: number) => (boolean | void)) {
-  for (let i = 0, len = arr.length; i < len; i++) {
-    if (callback(arr[i], i)) {
-      break;
-    }
-  }
-}
-
-export function join(arr: string[], joiner: string): string {
-  let result = '';
-  forEach(arr, (value, index) => {
-    result += value;
-    if (index < arr.length - 1) {
-      result += joiner;
-    }
-  });
-  return result;
-}

package/src/async.ts

@@ -1,229 +0,0 @@
-/* eslint-disable no-await-in-loop */
-import { join } from './array';
-import {
-  SerializationContext,
-  insertRef,
-  constructorCheck,
-  getRefParam,
-  createRef,
-  assignRef,
-  createSetAdd,
-  EMPTY_SET,
-  createMapSet,
-  EMPTY_MAP,
-  createArrayAssign,
-  EMPTY_ARRAY,
-  createObjectIdentifierAssign,
-  createObjectComputedAssign,
-} from './context';
-import isPrimitive from './is-primitive';
-import isPromise from './is-promise';
-import quote from './quote';
-import serializePrimitive from './serialize-primitive';
-import { ServerValue, AsyncServerValue } from './types';
-
-export async function lookupRefsAsync(
-  ctx: SerializationContext,
-  current: AsyncServerValue,
-) {
-  if (isPrimitive(current)) {
-    return;
-  }
-  if (isPromise(current)) {
-    if (insertRef(ctx, current)) {
-      await current.then((value) => lookupRefsAsync(ctx, value));
-    }
-  } else if (Array.isArray(current)) {
-    if (insertRef(ctx, current)) {
-      for (const value of current) {
-        await lookupRefsAsync(ctx, value);
-      }
-    }
-  } else if (constructorCheck<Set<AsyncServerValue>>(current, Set)) {
-    if (insertRef(ctx, current)) {
-      for (const item of current.keys()) {
-        await lookupRefsAsync(ctx, item);
-      }
-    }
-  } else if (constructorCheck<Map<AsyncServerValue, AsyncServerValue>>(current, Map)) {
-    if (insertRef(ctx, current)) {
-      for (const [key, value] of current.entries()) {
-        await lookupRefsAsync(ctx, key);
-        await lookupRefsAsync(ctx, value);
-      }
-    }
-  } else if (
-    (current.constructor === Object || current.constructor == null)
-    && insertRef(ctx, current)
-  ) {
-    for (const value of Object.values(current)) {
-      await lookupRefsAsync(ctx, value);
-    }
-  }
-}
-
-export async function traverseAsync(
-  ctx: SerializationContext,
-  current: AsyncServerValue,
-): Promise<string> {
-  // Skip primitives
-  if (isPrimitive(current)) {
-    return serializePrimitive(current);
-  }
-  // Get reference of the current object
-  let refResult = ctx.refs.get(current);
-  if (refResult != null) {
-    // Return the reference if already assigned a value
-    if (ctx.assignedRefs.has(refResult)) {
-      return getRefParam(ctx, refResult);
-    }
-    // Early sign (to prevent recursion)
-    ctx.assignedRefs.add(refResult);
-  }
-  function getCurrentRef() {
-    // This object received a ref, we must generate a setter ref
-    if (refResult == null) {
-      refResult = createRef(ctx, current);
-    }
-    return refResult;
-  }
-  function processRef(value: string) {
-    if (refResult != null) {
-      return assignRef(ctx, refResult, value);
-    }
-    return value;
-  }
-  if (isPromise(current)) {
-    return current.then(async (value) => {
-      ctx.stack.add(current);
-      let result: string;
-      if (ctx.stack.has(value)) {
-        const refParam = getRefParam(ctx, createRef(ctx, value));
-        result = `Promise.resolve().then(()=>${refParam})`;
-      } else {
-        result = `Promise.resolve(${await traverseAsync(ctx, value)})`;
-      }
-      ctx.stack.delete(current);
-      return processRef(result);
-    });
-  }
-  // Transform Set
-  if (constructorCheck<Set<AsyncServerValue>>(current, Set)) {
-    if (current.size) {
-      const values: string[] = [];
-
-      ctx.stack.add(current);
-      for (const value of current.keys()) {
-        if (ctx.stack.has(value)) {
-          // Received a ref, this might be a recursive ref, defer an assignment
-          createSetAdd(ctx, getCurrentRef(), getRefParam(ctx, createRef(ctx, value)));
-        } else {
-          values.push(await traverseAsync(ctx, value));
-        }
-      }
-      ctx.stack.delete(current);
-
-      return processRef(values.length ? `new Set([${join(values, ',')}])` : EMPTY_SET);
-    }
-    return EMPTY_SET;
-  }
-  if (constructorCheck<Map<ServerValue, ServerValue>>(current, Map)) {
-    if (current.size) {
-      const values: string[] = [];
-
-      ctx.stack.add(current);
-      for (const [key, value] of current.entries()) {
-        if (ctx.stack.has(key)) {
-          const ref = getCurrentRef();
-          const keyRef = getRefParam(ctx, createRef(ctx, key));
-          if (ctx.stack.has(value)) {
-            const valueRef = getRefParam(ctx, createRef(ctx, value));
-            createMapSet(ctx, ref, keyRef, valueRef);
-          } else {
-            const valueResult = await traverseAsync(ctx, value);
-            createMapSet(ctx, ref, keyRef, valueResult);
-          }
-        } else if (ctx.stack.has(value)) {
-          const valueRef = getRefParam(ctx, createRef(ctx, value));
-          const keyResult = await traverseAsync(ctx, key);
-          createMapSet(ctx, getCurrentRef(), keyResult, valueRef);
-        } else {
-          const keyResult = await traverseAsync(ctx, key);
-          const valueResult = await traverseAsync(ctx, value);
-          values.push(`[${keyResult},${valueResult}]`);
-        }
-      }
-      ctx.stack.delete(current);
-      return processRef(values.length ? `new Map([${join(values, ',')}])` : EMPTY_MAP);
-    }
-    return EMPTY_MAP;
-  }
-  if (Array.isArray(current)) {
-    if (current.length) {
-      let values = '';
-
-      ctx.stack.add(current);
-      for (let i = 0, len = current.length; i < len; i += 1) {
-        if (i in current) {
-          const item = current[i];
-          if (ctx.stack.has(item)) {
-            const refParam = getRefParam(ctx, createRef(ctx, item));
-            createArrayAssign(ctx, getCurrentRef(), i, refParam);
-            values += ',';
-          } else {
-            values += await traverseAsync(ctx, item);
-            if (i < current.length - 1) {
-              values += ',';
-            }
-          }
-        } else {
-          values += ',';
-        }
-      }
-      ctx.stack.delete(current);
-      return processRef(`[${values}]`);
-    }
-    return EMPTY_ARRAY;
-  }
-  const empty = current.constructor == null;
-  if (current.constructor === Object || empty) {
-    const values: string[] = [];
-
-    ctx.stack.add(current);
-    for (const [key, value] of Object.entries(current)) {
-      const check = Number(key);
-      // Test if key is a valid number or JS identifier
-      // so that we don't have to serialize the key and wrap with brackets
-      if (
-        check >= 0
-        || (Number.isNaN(check) && /^([$A-Z_][0-9A-Z_$]*)$/i.test(key))
-      ) {
-        if (ctx.stack.has(value)) {
-          const ref = getCurrentRef();
-          const refParam = getRefParam(ctx, createRef(ctx, value));
-          if (Number.isNaN(check)) {
-            createObjectIdentifierAssign(ctx, ref, key, refParam);
-          } else {
-            createObjectComputedAssign(ctx, ref, key, refParam);
-          }
-        } else {
-          const valueResult = await traverseAsync(ctx, value as AsyncServerValue);
-          values.push(`${key}:${valueResult}`);
-        }
-      } else if (ctx.stack.has(value)) {
-        const refParam = getRefParam(ctx, createRef(ctx, value));
-        createObjectComputedAssign(ctx, getCurrentRef(), quote(key), refParam);
-      } else {
-        const valueResult = await traverseAsync(ctx, value as AsyncServerValue);
-        values.push(`${quote(key)}:${valueResult}`);
-      }
-    }
-    ctx.stack.delete(current);
-    const value = `{${join(values, ',')}}`;
-    if (empty) {
-      return processRef(`Object.assign(Object.create(null),${value})`);
-    }
-    return processRef(value);
-  }
-  throw new Error('Unserializable value');
-}

package/src/context.ts

@@ -1,200 +0,0 @@
-import { forEach, join } from './array';
-import getIdentifier from './get-identifier';
-import { AsyncServerValue } from './types';
-
-export const EMPTY_SET = 'new Set';
-export const EMPTY_MAP = 'new Map';
-export const EMPTY_ARRAY = '[]';
-
-// Array of assignments to be done (used for recursion)
-export type Assignment = [source: string, value: string];
-
-// Array of Map.prototype.set calls
-export type MapSet = [source: string, key: string, value: string];
-
-// Array of Set.prototype.add calls
-export type SetAdd = [source: string, value: string];
-
-export interface SerializationContext {
-  stack: Set<unknown>;
-  // Set to check if ref id already has an assigned value
-  assignedRefs: Set<number>;
-  // Variables
-  vars: string[];
-  // Array of assignments to be done (used for recursion)
-  assignments: Assignment[];
-  // Array of Map.prototype.set calls
-  mapSets: MapSet[];
-  // Array of Set.prototype.add calls
-  setAdds: SetAdd[];
-  // Reference counter
-  refCount: Map<unknown, number>;
-  // Value-to-ref map
-  refs: Map<unknown, number>;
-}
-
-export function createSerializationContext(): SerializationContext {
-  return {
-    refCount: new Map(),
-    stack: new Set(),
-    refs: new Map(),
-    assignedRefs: new Set(),
-    vars: [],
-    assignments: [],
-    mapSets: [],
-    setAdds: [],
-  };
-}
-
-export function resolveAssignments(ctx: SerializationContext) {
-  if (ctx.assignments.length) {
-    const result: Record<string, string> = {};
-
-    // Merge all assignments with similar source
-    forEach(ctx.assignments, ([source, value]) => {
-      if (value in result) {
-        result[value] = `${source}=${result[value]}`;
-      } else {
-        result[value] = `${source}=${value}`;
-      }
-    });
-
-    return `${join(Object.values(result), ',')},`;
-  }
-  return '';
-}
-
-export function resolveMapSets(ctx: SerializationContext) {
-  if (ctx.mapSets.length) {
-    const result: Record<string, string> = {};
-
-    // Merge all assignments with similar source
-    forEach(ctx.mapSets, ([source, key, value]) => {
-      if (source in result) {
-        result[source] = `${result[source]}.set(${key},${value})`;
-      } else {
-        result[source] = `${source}.set(${key},${value})`;
-      }
-    });
-
-    return `${join(Object.values(result), ',')},`;
-  }
-  return '';
-}
-
-export function resolveSetAdds(ctx: SerializationContext) {
-  if (ctx.setAdds.length) {
-    const result: Record<string, string> = {};
-
-    // Merge all assignments with similar source
-    forEach(ctx.setAdds, ([source, value]) => {
-      if (source in result) {
-        result[source] = `${result[source]}.add(${value})`;
-      } else {
-        result[source] = `${source}.add(${value})`;
-      }
-    });
-
-    return `${join(Object.values(result), ',')},`;
-  }
-  return '';
-}
-
-export function resolvePatches(ctx: SerializationContext) {
-  return `${resolveAssignments(ctx)}${resolveMapSets(ctx)}${resolveSetAdds(ctx)}`;
-}
-
-export function insertRef(ctx: SerializationContext, current: unknown) {
-  const count = ctx.refCount.get(current) || 0;
-  ctx.refCount.set(current, count + 1);
-  return count === 0;
-}
-
-export function constructorCheck<T extends NonNullable<AsyncServerValue>>(
-  value: NonNullable<AsyncServerValue>,
-  constructor: unknown,
-): value is T {
-  return value.constructor === constructor;
-}
-
-export function createRef(
-  ctx: SerializationContext,
-  value: unknown,
-) {
-  const current = ctx.refs.get(value);
-  if (current != null) {
-    return current;
-  }
-  const id = ctx.refs.size;
-  ctx.refs.set(value, id);
-  return id;
-}
-
-export function getRefParam(ctx: SerializationContext, index: number) {
-  if (ctx.vars[index]) {
-    return ctx.vars[index];
-  }
-  const result = getIdentifier(index);
-  ctx.vars[index] = result;
-  return result;
-}
-
-export function assignRef(
-  ctx: SerializationContext,
-  index: number,
-  value: string,
-) {
-  return `${getRefParam(ctx, index)}=${value}`;
-}
-
-export function createAssignment(
-  ctx: SerializationContext,
-  source: string,
-  value: string,
-) {
-  ctx.assignments.push([source, value]);
-}
-
-export function createSetAdd(
-  ctx: SerializationContext,
-  ref: number,
-  value: string,
-) {
-  ctx.setAdds.push([getRefParam(ctx, ref), value]);
-}
-
-export function createMapSet(
-  ctx: SerializationContext,
-  ref: number,
-  key: string,
-  value: string,
-) {
-  ctx.mapSets.push([getRefParam(ctx, ref), key, value]);
-}
-
-export function createArrayAssign(
-  ctx: SerializationContext,
-  ref: number,
-  index: number,
-  value: string,
-) {
-  createAssignment(ctx, `${getRefParam(ctx, ref)}[${index}]`, value);
-}
-
-export function createObjectIdentifierAssign(
-  ctx: SerializationContext,
-  ref: number,
-  key: string,
-  value: string,
-) {
-  createAssignment(ctx, `${getRefParam(ctx, ref)}.${key}`, value);
-}
-
-export function createObjectComputedAssign(
-  ctx: SerializationContext,
-  ref: number,
-  key: string,
-  value: string,
-) {
-  createAssignment(ctx, `${getRefParam(ctx, ref)}[${key}]`, value);
-}

package/src/is-primitive.ts

@@ -1,14 +0,0 @@
-import { PrimitiveValue } from './types';
-
-export default function isPrimitive(current: unknown): current is PrimitiveValue {
-  if (!current || current === true) {
-    return true;
-  }
-  const type = typeof current;
-  const classConst = current.constructor;
-  return type === 'number'
-    || type === 'string'
-    || type === 'bigint'
-    || classConst === Date
-    || classConst === RegExp;
-}

package/src/is-promise.ts

@@ -1,6 +0,0 @@
-export default function isPromise<T>(obj: unknown): obj is PromiseLike<T> {
-  return !!obj
-    && (typeof obj === 'object' || typeof obj === 'function')
-    && 'then' in obj
-    && typeof obj.then === 'function';
-}