seroval 0.11.6 → 0.12.1

package/dist/types/core/assignments.d.ts

@@ -1,33 +0,0 @@
-import { SerovalObjectFlags } from './constants';
-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 FlaggedObject {
-    type: SerovalObjectFlags;
-    value: string;
-}
-export declare function resolveAssignments(assignments: Assignment[]): string | undefined;
-export declare function resolveFlags(flags: FlaggedObject[]): string | undefined;
-export {};

package/dist/types/core/context.d.ts

@@ -1,9 +0,0 @@
-import type { Assignment, FlaggedObject } from './assignments';
-export interface BaseParserContext {
-    features: number;
-}
-export interface BaseSerializerContext extends BaseParserContext {
-    stack: number[];
-    flags: FlaggedObject[];
-    assignments: Assignment[];
-}

package/dist/types/core/cross/context.d.ts

@@ -1,37 +0,0 @@
-import type { Assignment, FlaggedObject } from '../assignments';
-import type { BaseParserContext } from '../context';
-import type { SerovalNode } from '../types';
-export interface CrossParserContextOptions {
-    scopeId?: string;
-    refs?: Map<unknown, number>;
-    disabledFeatures?: number;
-}
-export interface CrossParserContext {
-    scopeId?: string;
-    refs: Map<unknown, number>;
-    features: number;
-}
-export declare function createCrossParserContext(options?: CrossParserContextOptions): CrossParserContext;
-export declare function createCrossIndexedValue<T>(ctx: CrossParserContext, current: T): number;
-export interface StreamingCrossParserContextOptions extends CrossParserContextOptions {
-    onParse: (node: SerovalNode, initial: boolean) => void;
-    onDone?: () => void;
-}
-export interface StreamingCrossParserContext extends CrossParserContext {
-    alive: boolean;
-    pending: number;
-    onParse(node: SerovalNode, initial: boolean): void;
-    onDone(): void;
-}
-export declare function createStreamingCrossParserContext(options: StreamingCrossParserContextOptions): StreamingCrossParserContext;
-export declare function pushPendingState(ctx: StreamingCrossParserContext): void;
-export declare function popPendingState(ctx: StreamingCrossParserContext): void;
-export interface CrossSerializerContext extends BaseParserContext {
-    stack: number[];
-    assignments: Assignment[];
-    flags: FlaggedObject[];
-}
-export interface CrossSerializerOptions {
-    features: number;
-}
-export declare function createCrossSerializerContext(options: CrossSerializerOptions): CrossSerializerContext;

package/dist/types/core/cross/primitives.d.ts

@@ -1,9 +0,0 @@
-import type { CrossParserContext } from './context';
-import type { BigIntTypedArrayValue, TypedArrayValue } from '../../types';
-import type { SerovalBigIntTypedArrayNode, SerovalTypedArrayNode, SerovalDataViewNode, SerovalNode, SerovalIndexedValueNode, SerovalReferenceNode, SerovalWKSymbolNode } from '../types';
-export declare function serializeArrayBuffer(ctx: CrossParserContext, current: ArrayBuffer): SerovalNode;
-export declare function createTypedArrayNode(ctx: CrossParserContext, id: number, current: TypedArrayValue): SerovalTypedArrayNode;
-export declare function createBigIntTypedArrayNode(ctx: CrossParserContext, id: number, current: BigIntTypedArrayValue): SerovalBigIntTypedArrayNode;
-export declare function createDataViewNode(ctx: CrossParserContext, id: number, current: DataView): SerovalDataViewNode;
-export declare function createSymbolNode(ctx: CrossParserContext, current: symbol): SerovalIndexedValueNode | SerovalReferenceNode | SerovalWKSymbolNode;
-export declare function createFunctionNode(ctx: CrossParserContext, current: Function): SerovalIndexedValueNode | SerovalReferenceNode;

package/dist/types/core/cross/web-api.d.ts

@@ -1,4 +0,0 @@
-import type { CrossParserContext } from './context';
-import type { SerovalBlobNode, SerovalFileNode } from '../types';
-export declare function createBlobNode(ctx: CrossParserContext, id: number, current: Blob): Promise<SerovalBlobNode>;
-export declare function createFileNode(ctx: CrossParserContext, id: number, current: File): Promise<SerovalFileNode>;

package/dist/types/core/tree/context.d.ts

@@ -1,44 +0,0 @@
-import type { BaseParserContext, BaseSerializerContext } from '../context';
-export interface ParserReference {
-    ids: Map<unknown, number>;
-    marked: Set<number>;
-}
-export interface ParserContext extends BaseParserContext {
-    reference: ParserReference;
-}
-export interface ParserOptions {
-    disabledFeatures: number;
-}
-export declare function createParserContext(options?: Partial<ParserOptions>): ParserContext;
-export interface SerializerReference {
-    size: number;
-    valid: (number | undefined)[];
-    marked: Set<number>;
-}
-export interface SerializerContext extends BaseSerializerContext {
-    reference: SerializerReference;
-    vars: (string | undefined)[];
-}
-export interface SerializerOptions {
-    markedRefs: number[] | Set<number>;
-    features: number;
-}
-export declare function createSerializerContext(options: SerializerOptions): SerializerContext;
-/**
- * Increments the number of references the referenced value has
- */
-export declare function markRef(ctx: ParserContext | SerializerContext, 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: SerializerContext, index: number): string;
-export declare function createIndexedValue<T>(ctx: ParserContext, current: T): number;
-export interface DeserializerContext {
-    values: Map<number, unknown>;
-    refs: Set<number>;
-}
-export interface DeserializerOptions {
-    markedRefs: number[] | Set<number>;
-}
-export declare function createDeserializerContext(options: DeserializerOptions): DeserializerContext;

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

@@ -1,9 +0,0 @@
-import type { ParserContext } from './context';
-import type { BigIntTypedArrayValue, TypedArrayValue } from '../../types';
-import type { SerovalBigIntTypedArrayNode, SerovalTypedArrayNode, SerovalWKSymbolNode, SerovalReferenceNode, SerovalDataViewNode, SerovalNode, SerovalIndexedValueNode } from '../types';
-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 createDataViewNode(ctx: ParserContext, id: number, current: DataView): SerovalDataViewNode;
-export declare function createSymbolNode(ctx: ParserContext, current: symbol): SerovalIndexedValueNode | SerovalReferenceNode | SerovalWKSymbolNode;
-export declare function createFunctionNode(ctx: ParserContext, current: Function): SerovalIndexedValueNode | SerovalReferenceNode;

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

@@ -1,4 +0,0 @@
-import type { ParserContext } from './context';
-import type { SerovalBlobNode, SerovalFileNode } from '../types';
-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/core/assignments.ts

@@ -1,159 +0,0 @@
-import { SerovalObjectFlags } from './constants';
-
-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 FlaggedObject {
-  type: SerovalObjectFlags;
-  value: string;
-}
-
-function getAssignmentExpression(assignment: Assignment): string {
-  switch (assignment.t) {
-    case 'index':
-      return assignment.s + '=' + assignment.v;
-    case 'set':
-      return assignment.s + '.set(' + assignment.k + ',' + assignment.v + ')';
-    case 'add':
-      return assignment.s + '.add(' + assignment.v + ')';
-    case 'append':
-      return assignment.s + '.append(' + assignment.k + ',' + assignment.v + ')';
-    default:
-      return '';
-  }
-}
-
-const OBJECT_FLAG_CONSTRUCTOR: Record<SerovalObjectFlags, string | undefined> = {
-  [SerovalObjectFlags.Frozen]: 'Object.freeze',
-  [SerovalObjectFlags.Sealed]: 'Object.seal',
-  [SerovalObjectFlags.NonExtensible]: 'Object.preventExtensions',
-  [SerovalObjectFlags.None]: undefined,
-};
-
-function mergeAssignments(assignments: Assignment[]): Assignment[] {
-  const newAssignments: Assignment[] = [];
-  let current = assignments[0];
-  let prev = current;
-  let item: Assignment;
-  for (let i = 1, len = assignments.length; i < len; i++) {
-    item = assignments[i];
-    if (item.t === prev.t) {
-      switch (item.t) {
-        case 'index':
-          if (item.v === prev.v) {
-            // Merge if the right-hand value is the same
-            // saves at least 2 chars
-            current = {
-              t: 'index',
-              s: item.s,
-              k: undefined,
-              v: getAssignmentExpression(current),
-            };
-          } else {
-            // Different assignment, push current
-            newAssignments.push(current);
-            current = item;
-          }
-          break;
-        case 'set':
-          if (item.s === prev.s) {
-            // Maps has chaining methods, merge if source is the same
-            current = {
-              t: 'set',
-              s: getAssignmentExpression(current),
-              k: item.k,
-              v: item.v,
-            };
-          } else {
-            // Different assignment, push current
-            newAssignments.push(current);
-            current = item;
-          }
-          break;
-        case 'add':
-          if (item.s === prev.s) {
-            // Sets has chaining methods too
-            current = {
-              t: 'add',
-              s: getAssignmentExpression(current),
-              k: undefined,
-              v: item.v,
-            };
-          } else {
-            // Different assignment, push current
-            newAssignments.push(current);
-            current = item;
-          }
-          break;
-        case 'append':
-          // Different assignment, push current
-          newAssignments.push(current);
-          current = item;
-          break;
-        default:
-          break;
-      }
-    } else {
-      newAssignments.push(current);
-      current = item;
-    }
-    prev = item;
-  }
-
-  newAssignments.push(current);
-
-  return newAssignments;
-}
-
-export function resolveAssignments(assignments: Assignment[]): string | undefined {
-  if (assignments.length) {
-    let result = '';
-    const merged = mergeAssignments(assignments);
-    for (let i = 0, len = merged.length; i < len; i++) {
-      result += getAssignmentExpression(merged[i]) + ',';
-    }
-    return result;
-  }
-  return undefined;
-}
-
-export function resolveFlags(flags: FlaggedObject[]): string | undefined {
-  let result = '';
-  for (let i = 0, len = flags.length; i < len; i++) {
-    const flag = flags[i];
-    result += OBJECT_FLAG_CONSTRUCTOR[flag.type] + '(' + flag.value + '),';
-  }
-  return result;
-}

package/src/core/context.ts

@@ -1,15 +0,0 @@
-import type { Assignment, FlaggedObject } from './assignments';
-
-export interface BaseParserContext {
-  // Supported features
-  features: number;
-}
-
-export interface BaseSerializerContext extends BaseParserContext {
-  // To check if an object is synchronously referencing itself
-  stack: number[];
-  // Array of object mutations
-  flags: FlaggedObject[];
-  // Array of assignments to be done (used for recursion)
-  assignments: Assignment[];
-}

package/src/core/cross/context.ts

@@ -1,102 +0,0 @@
-import type { Assignment, FlaggedObject } from '../assignments';
-import { ALL_ENABLED } from '../compat';
-import type { BaseParserContext } from '../context';
-import type { SerovalNode } from '../types';
-
-export interface CrossParserContextOptions {
-  scopeId?: string;
-  refs?: Map<unknown, number>;
-  disabledFeatures?: number;
-}
-
-export interface CrossParserContext {
-  scopeId?: string;
-  refs: Map<unknown, number>;
-  features: number;
-}
-
-export function createCrossParserContext(
-  options: CrossParserContextOptions = {},
-): CrossParserContext {
-  return {
-    scopeId: options.scopeId,
-    refs: options.refs || new Map<unknown, number>(),
-    features: ALL_ENABLED ^ (options.disabledFeatures || 0),
-  };
-}
-
-export function createCrossIndexedValue<T>(
-  ctx: CrossParserContext,
-  current: T,
-): number {
-  const ref = ctx.refs.get(current);
-  if (ref == null) {
-    const id = ctx.refs.size;
-    ctx.refs.set(current, id);
-    return id;
-  }
-  return ref;
-}
-
-export interface StreamingCrossParserContextOptions extends CrossParserContextOptions {
-  onParse: (node: SerovalNode, initial: boolean) => void;
-  onDone?: () => void;
-}
-
-export interface StreamingCrossParserContext extends CrossParserContext {
-  alive: boolean;
-  pending: number;
-  onParse(node: SerovalNode, initial: boolean): void;
-  onDone(): void;
-}
-
-export function createStreamingCrossParserContext(
-  options: StreamingCrossParserContextOptions,
-): StreamingCrossParserContext {
-  return {
-    alive: true,
-    pending: 0,
-    refs: options.refs || new Map<unknown, number>(),
-    features: ALL_ENABLED ^ (options.disabledFeatures || 0),
-    onParse: options.onParse,
-    onDone(): void {
-      if (options.onDone) {
-        options.onDone();
-      }
-    },
-    scopeId: options.scopeId,
-  };
-}
-
-export function pushPendingState(ctx: StreamingCrossParserContext): void {
-  ctx.pending++;
-}
-
-export function popPendingState(ctx: StreamingCrossParserContext): void {
-  if (--ctx.pending <= 0) {
-    ctx.onDone();
-  }
-}
-
-export interface CrossSerializerContext extends BaseParserContext {
-  stack: number[];
-  // Array of assignments to be done (used for recursion)
-  assignments: Assignment[];
-  // Object flags
-  flags: FlaggedObject[];
-}
-
-export interface CrossSerializerOptions {
-  features: number;
-}
-
-export function createCrossSerializerContext(
-  options: CrossSerializerOptions,
-): CrossSerializerContext {
-  return {
-    stack: [],
-    assignments: [],
-    features: options.features,
-    flags: [],
-  };
-}

package/src/core/cross/primitives.ts

@@ -1,128 +0,0 @@
-import assert from '../assert';
-import type { CrossParserContext } from './context';
-import type { BigIntTypedArrayValue, TypedArrayValue } from '../../types';
-import { hasReferenceID } from '../reference';
-import type {
-  SerovalBigIntTypedArrayNode,
-  SerovalTypedArrayNode,
-  SerovalDataViewNode,
-  SerovalNode,
-  SerovalIndexedValueNode,
-  SerovalReferenceNode,
-  SerovalWKSymbolNode,
-} from '../types';
-import type { WellKnownSymbols } from '../constants';
-import { SerovalNodeType } from '../constants';
-import {
-  createIndexedValueNode,
-  createArrayBufferNode,
-  createWKSymbolNode,
-  createReferenceNode,
-} from '../base-primitives';
-
-export function serializeArrayBuffer(
-  ctx: CrossParserContext,
-  current: ArrayBuffer,
-): SerovalNode {
-  const id = ctx.refs.get(current);
-  if (id != null) {
-    return createIndexedValueNode(id);
-  }
-  const newID = ctx.refs.size;
-  ctx.refs.set(current, newID);
-  return createArrayBufferNode(newID, current);
-}
-
-export function createTypedArrayNode(
-  ctx: CrossParserContext,
-  id: number,
-  current: TypedArrayValue,
-): SerovalTypedArrayNode {
-  return {
-    t: SerovalNodeType.TypedArray,
-    i: id,
-    s: undefined,
-    l: current.length,
-    c: current.constructor.name,
-    m: undefined,
-    p: undefined,
-    e: undefined,
-    a: undefined,
-    f: serializeArrayBuffer(ctx, current.buffer),
-    b: current.byteOffset,
-    o: undefined,
-  };
-}
-
-export function createBigIntTypedArrayNode(
-  ctx: CrossParserContext,
-  id: number,
-  current: BigIntTypedArrayValue,
-): SerovalBigIntTypedArrayNode {
-  return {
-    t: SerovalNodeType.BigIntTypedArray,
-    i: id,
-    s: undefined,
-    l: current.length,
-    c: current.constructor.name,
-    m: undefined,
-    p: undefined,
-    e: undefined,
-    a: undefined,
-    f: serializeArrayBuffer(ctx, current.buffer),
-    b: current.byteOffset,
-    o: undefined,
-  };
-}
-
-export function createDataViewNode(
-  ctx: CrossParserContext,
-  id: number,
-  current: DataView,
-): SerovalDataViewNode {
-  return {
-    t: SerovalNodeType.DataView,
-    i: id,
-    s: undefined,
-    l: current.byteLength,
-    c: undefined,
-    m: undefined,
-    p: undefined,
-    e: undefined,
-    a: undefined,
-    f: serializeArrayBuffer(ctx, current.buffer),
-    b: current.byteOffset,
-    o: undefined,
-  };
-}
-
-export function createSymbolNode(
-  ctx: CrossParserContext,
-  current: symbol,
-): SerovalIndexedValueNode | SerovalReferenceNode | SerovalWKSymbolNode {
-  const id = ctx.refs.get(current);
-  if (id != null) {
-    return createIndexedValueNode(id);
-  }
-  const newID = ctx.refs.size;
-  ctx.refs.set(current, newID);
-  if (hasReferenceID(current)) {
-    return createReferenceNode(newID, current);
-  }
-  return createWKSymbolNode(newID, current as WellKnownSymbols);
-}
-
-export function createFunctionNode(
-  ctx: CrossParserContext,
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  current: Function,
-): SerovalIndexedValueNode | SerovalReferenceNode {
-  assert(hasReferenceID(current), new Error('Cannot serialize function without reference ID.'));
-  const id = ctx.refs.get(current);
-  if (id != null) {
-    return createIndexedValueNode(id);
-  }
-  const newID = ctx.refs.size;
-  ctx.refs.set(current, newID);
-  return createReferenceNode(newID, current);
-}

package/src/core/cross/web-api.ts

@@ -1,50 +0,0 @@
-import type { CrossParserContext } from './context';
-import { serializeString } from '../string';
-import { serializeArrayBuffer } from './primitives';
-import type {
-  SerovalBlobNode,
-  SerovalFileNode,
-} from '../types';
-import { SerovalNodeType } from '../constants';
-
-export async function createBlobNode(
-  ctx: CrossParserContext,
-  id: number,
-  current: Blob,
-): Promise<SerovalBlobNode> {
-  return {
-    t: SerovalNodeType.Blob,
-    i: id,
-    s: undefined,
-    l: undefined,
-    c: serializeString(current.type),
-    m: undefined,
-    p: undefined,
-    e: undefined,
-    f: serializeArrayBuffer(ctx, await current.arrayBuffer()),
-    a: undefined,
-    b: undefined,
-    o: undefined,
-  };
-}
-
-export async function createFileNode(
-  ctx: CrossParserContext,
-  id: number,
-  current: File,
-): Promise<SerovalFileNode> {
-  return {
-    t: SerovalNodeType.File,
-    i: id,
-    s: undefined,
-    l: undefined,
-    c: serializeString(current.type),
-    m: serializeString(current.name),
-    p: undefined,
-    e: undefined,
-    f: serializeArrayBuffer(ctx, await current.arrayBuffer()),
-    a: undefined,
-    b: current.lastModified,
-    o: undefined,
-  };
-}