seroval 0.11.5 → 0.12.0

package/src/core/tree/context.ts

@@ -1,125 +0,0 @@
-import { ALL_ENABLED } from '../compat';
-import type { BaseParserContext, BaseSerializerContext } from '../context';
-import getIdentifier from '../get-identifier';
-
-export interface ParserReference {
-  ids: Map<unknown, number>;
-  marked: Set<number>;
-}
-
-export interface ParserContext extends BaseParserContext {
-  reference: ParserReference;
-}
-
-export interface ParserOptions {
-  disabledFeatures: number;
-}
-
-export function createParserContext(options: Partial<ParserOptions> = {}): ParserContext {
-  return {
-    reference: {
-      ids: new Map(),
-      marked: new Set(),
-    },
-    features: ALL_ENABLED ^ (options.disabledFeatures || 0),
-  };
-}
-
-export interface SerializerReference {
-  size: number;
-  // Map tree refs to actual refs
-  valid: (number | undefined)[];
-  // Refs that are...referenced
-  marked: Set<number>;
-}
-
-export interface SerializerContext extends BaseSerializerContext {
-  reference: SerializerReference;
-  // Variables
-  vars: (string | undefined)[];
-}
-
-export interface SerializerOptions {
-  markedRefs: number[] | Set<number>;
-  features: number;
-}
-
-export function createSerializerContext(options: SerializerOptions): SerializerContext {
-  return {
-    stack: [],
-    vars: [],
-    assignments: [],
-    reference: {
-      valid: [],
-      size: 0,
-      marked: new Set(options.markedRefs),
-    },
-    features: options.features,
-    flags: [],
-  };
-}
-
-/**
- * Increments the number of references the referenced value has
- */
-export function markRef(
-  ctx: ParserContext | SerializerContext,
-  current: number,
-): void {
-  ctx.reference.marked.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: SerializerContext, 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.reference.valid[index];
-  if (actualIndex == null) {
-    actualIndex = ctx.reference.size++;
-    ctx.reference.valid[index] = actualIndex;
-  }
-  let identifier = ctx.vars[actualIndex];
-  if (identifier == null) {
-    identifier = getIdentifier(actualIndex);
-    ctx.vars[actualIndex] = identifier;
-  }
-  return identifier;
-}
-
-export function createIndexedValue<T>(
-  ctx: ParserContext,
-  current: T,
-): number {
-  const ref = ctx.reference.ids.get(current);
-  if (ref == null) {
-    const id = ctx.reference.ids.size;
-    ctx.reference.ids.set(current, id);
-    return id;
-  }
-  markRef(ctx, ref);
-  return ref;
-}
-
-export interface DeserializerContext {
-  values: Map<number, unknown>;
-  refs: Set<number>;
-}
-
-export interface DeserializerOptions {
-  markedRefs: number[] | Set<number>;
-}
-
-export function createDeserializerContext(
-  options: DeserializerOptions,
-): DeserializerContext {
-  return {
-    values: new Map(),
-    refs: new Set(options.markedRefs),
-  };
-}

package/src/core/tree/primitives.ts

@@ -1,123 +0,0 @@
-import assert from '../assert';
-import type { ParserContext } from './context';
-import { createIndexedValue } from './context';
-import type { BigIntTypedArrayValue, TypedArrayValue } from '../../types';
-import { hasReferenceID } from '../reference';
-import type {
-  SerovalBigIntTypedArrayNode,
-  SerovalTypedArrayNode,
-  SerovalWKSymbolNode,
-  SerovalReferenceNode,
-  SerovalDataViewNode,
-  SerovalNode,
-  SerovalIndexedValueNode,
-} from '../types';
-import type { WellKnownSymbols } from '../constants';
-import { SerovalNodeType } from '../constants';
-import {
-  createArrayBufferNode,
-  createIndexedValueNode,
-  createReferenceNode,
-  createWKSymbolNode,
-} from '../base-primitives';
-
-export function serializeArrayBuffer(
-  ctx: ParserContext,
-  current: ArrayBuffer,
-): SerovalNode {
-  const id = createIndexedValue(ctx, current);
-  if (ctx.reference.marked.has(id)) {
-    return createIndexedValueNode(id);
-  }
-  return createArrayBufferNode(id, current);
-}
-
-export function createTypedArrayNode(
-  ctx: ParserContext,
-  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: ParserContext,
-  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: ParserContext,
-  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: ParserContext,
-  current: symbol,
-): SerovalIndexedValueNode | SerovalReferenceNode | SerovalWKSymbolNode {
-  const id = createIndexedValue(ctx, current);
-  if (ctx.reference.marked.has(id)) {
-    return createIndexedValueNode(id);
-  }
-  if (hasReferenceID(current)) {
-    return createReferenceNode(id, current);
-  }
-  return createWKSymbolNode(id, current as WellKnownSymbols);
-}
-
-export function createFunctionNode(
-  ctx: ParserContext,
-  // 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 = createIndexedValue(ctx, current);
-  if (ctx.reference.marked.has(id)) {
-    return createIndexedValueNode(id);
-  }
-  return createReferenceNode(id, current);
-}

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

@@ -1,50 +0,0 @@
-import type { ParserContext } 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: ParserContext,
-  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: ParserContext,
-  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,
-  };
-}