seroval 1.4.0 → 1.4.1

package/src/core/cross/index.ts

@@ -1,186 +0,0 @@
-import type { AsyncParserContextOptions } from '../context/async-parser';
-import {
-  createAsyncParserContext,
-  parseTopAsync,
-} from '../context/async-parser';
-import type { CrossDeserializerContextOptions } from '../context/deserializer';
-import {
-  createCrossDeserializerContext,
-  deserializeTop,
-} from '../context/deserializer';
-import type { CrossContextOptions } from '../context/serializer';
-import {
-  createCrossSerializerContext,
-  serializeTopCross,
-} from '../context/serializer';
-import type {
-  StreamParserContextOptions,
-  SyncParserContextOptions,
-} from '../context/sync-parser';
-import {
-  createStreamParserContext,
-  createSyncParserContext,
-  destroyStreamParse,
-  parseTop,
-  startStreamParse,
-} from '../context/sync-parser';
-import { resolvePlugins, SerovalMode } from '../plugin';
-import type { SerovalNode } from '../types';
-
-export interface CrossSerializeOptions
-  extends SyncParserContextOptions,
-    CrossContextOptions {}
-
-export function crossSerialize<T>(
-  source: T,
-  options: CrossSerializeOptions = {},
-): string {
-  const plugins = resolvePlugins(options.plugins);
-  const ctx = createSyncParserContext(SerovalMode.Cross, {
-    plugins,
-    disabledFeatures: options.disabledFeatures,
-    refs: options.refs,
-  });
-  const tree = parseTop(ctx, source);
-  const serial = createCrossSerializerContext({
-    plugins,
-    features: ctx.base.features,
-    scopeId: options.scopeId,
-    markedRefs: ctx.base.marked,
-  });
-  return serializeTopCross(serial, tree);
-}
-
-export interface CrossSerializeAsyncOptions
-  extends AsyncParserContextOptions,
-    CrossContextOptions {}
-
-export async function crossSerializeAsync<T>(
-  source: T,
-  options: CrossSerializeAsyncOptions = {},
-): Promise<string> {
-  const plugins = resolvePlugins(options.plugins);
-  const ctx = createAsyncParserContext(SerovalMode.Cross, {
-    plugins,
-    disabledFeatures: options.disabledFeatures,
-    refs: options.refs,
-  });
-  const tree = await parseTopAsync(ctx, source);
-  const serial = createCrossSerializerContext({
-    plugins,
-    features: ctx.base.features,
-    scopeId: options.scopeId,
-    markedRefs: ctx.base.marked,
-  });
-  return serializeTopCross(serial, tree);
-}
-
-export type ToCrossJSONOptions = SyncParserContextOptions;
-
-export function toCrossJSON<T>(
-  source: T,
-  options: ToCrossJSONOptions = {},
-): SerovalNode {
-  const plugins = resolvePlugins(options.plugins);
-  const ctx = createSyncParserContext(SerovalMode.Cross, {
-    plugins,
-    disabledFeatures: options.disabledFeatures,
-    refs: options.refs,
-  });
-  return parseTop(ctx, source);
-}
-
-export type ToCrossJSONAsyncOptions = AsyncParserContextOptions;
-
-export async function toCrossJSONAsync<T>(
-  source: T,
-  options: ToCrossJSONAsyncOptions = {},
-): Promise<SerovalNode> {
-  const plugins = resolvePlugins(options.plugins);
-  const ctx = createAsyncParserContext(SerovalMode.Cross, {
-    plugins,
-    disabledFeatures: options.disabledFeatures,
-    refs: options.refs,
-  });
-  return await parseTopAsync(ctx, source);
-}
-
-export interface CrossSerializeStreamOptions
-  extends Omit<StreamParserContextOptions, 'onParse'>,
-    CrossContextOptions {
-  onSerialize: (data: string, initial: boolean) => void;
-}
-
-export function crossSerializeStream<T>(
-  source: T,
-  options: CrossSerializeStreamOptions,
-): () => void {
-  const plugins = resolvePlugins(options.plugins);
-  const ctx = createStreamParserContext({
-    plugins,
-    refs: options.refs,
-    disabledFeatures: options.disabledFeatures,
-    onParse(node, initial): void {
-      const serial = createCrossSerializerContext({
-        plugins,
-        features: ctx.base.features,
-        scopeId: options.scopeId,
-        markedRefs: ctx.base.marked,
-      });
-
-      let serialized: string;
-
-      try {
-        serialized = serializeTopCross(serial, node);
-      } catch (err) {
-        if (options.onError) {
-          options.onError(err);
-        }
-        return;
-      }
-
-      options.onSerialize(serialized, initial);
-    },
-    onError: options.onError,
-    onDone: options.onDone,
-  });
-
-  startStreamParse(ctx, source);
-
-  return destroyStreamParse.bind(null, ctx);
-}
-
-export type ToCrossJSONStreamOptions = StreamParserContextOptions;
-
-export function toCrossJSONStream<T>(
-  source: T,
-  options: ToCrossJSONStreamOptions,
-): () => void {
-  const plugins = resolvePlugins(options.plugins);
-  const ctx = createStreamParserContext({
-    plugins,
-    refs: options.refs,
-    disabledFeatures: options.disabledFeatures,
-    onParse: options.onParse,
-    onError: options.onError,
-    onDone: options.onDone,
-  });
-
-  startStreamParse(ctx, source);
-
-  return destroyStreamParse.bind(null, ctx);
-}
-
-export type FromCrossJSONOptions = CrossDeserializerContextOptions;
-
-export function fromCrossJSON<T>(
-  source: SerovalNode,
-  options: FromCrossJSONOptions,
-): T {
-  const plugins = resolvePlugins(options.plugins);
-  const ctx = createCrossDeserializerContext({
-    plugins,
-    refs: options.refs,
-  });
-  return deserializeTop(ctx, source) as T;
-}

package/src/core/errors.ts

@@ -1,163 +0,0 @@
-/// <reference types="pridepack/env" />
-
-import { serializeString } from './string';
-import type { SerovalNode } from './types';
-
-const { toString: objectToString } = /* @__PURE__ */ Object.prototype;
-
-const enum StepErrorCodes {
-  Parse = 1,
-  Serialize = 2,
-  Deserialize = 3,
-}
-
-function getErrorMessageDev(type: string, cause: any): string {
-  if (cause instanceof Error) {
-    return `Seroval caught an error during the ${type} process.
-  
-${cause.name}
-${cause.message}
-
-- For more information, please check the "cause" property of this error.
-- If you believe this is an error in Seroval, please submit an issue at https://github.com/lxsmnsyc/seroval/issues/new`;
-  }
-  return `Seroval caught an error during the ${type} process.
-
-"${objectToString.call(cause)}"
-
-For more information, please check the "cause" property of this error.`;
-}
-
-const STEP_ERROR_CODES: Record<string, StepErrorCodes> = {
-  parsing: StepErrorCodes.Parse,
-  serialization: StepErrorCodes.Serialize,
-  deserialization: StepErrorCodes.Deserialize,
-};
-
-function getErrorMessageProd(type: string): string {
-  return `Seroval Error (step: ${STEP_ERROR_CODES[type]})`;
-}
-
-const getErrorMessage = (type: string, cause: any) =>
-  import.meta.env.PROD
-    ? getErrorMessageProd(type)
-    : getErrorMessageDev(type, cause);
-
-export class SerovalError extends Error {
-  constructor(
-    type: string,
-    public cause: any,
-  ) {
-    super(getErrorMessage(type, cause));
-  }
-}
-
-export class SerovalParserError extends SerovalError {
-  constructor(cause: any) {
-    super('parsing', cause);
-  }
-}
-
-export class SerovalSerializationError extends SerovalError {
-  constructor(cause: any) {
-    super('serialization', cause);
-  }
-}
-
-export class SerovalDeserializationError extends SerovalError {
-  constructor(cause: any) {
-    super('deserialization', cause);
-  }
-}
-
-const enum SpecificErrorCodes {
-  UnsupportedType = 1,
-  UnsupportedNode = 2,
-  MissingPlugin = 3,
-  MissingInstance = 4,
-  MissingReference = 5,
-  MissingReferenceForId = 6,
-  UnknownTypedArray = 7,
-}
-
-function getSpecificErrorMessage(code: SpecificErrorCodes): string {
-  return `Seroval Error (specific: ${code})`;
-}
-
-export class SerovalUnsupportedTypeError extends Error {
-  constructor(public value: unknown) {
-    super(
-      import.meta.env.PROD
-        ? getSpecificErrorMessage(SpecificErrorCodes.UnsupportedType)
-        : `The value ${objectToString.call(value)} of type "${typeof value}" cannot be parsed/serialized.
-      
-There are few workarounds for this problem:
-- Transform the value in a way that it can be serialized.
-- If the reference is present on multiple runtimes (isomorphic), you can use the Reference API to map the references.`,
-    );
-  }
-}
-
-export class SerovalUnsupportedNodeError extends Error {
-  constructor(node: SerovalNode) {
-    super(
-      import.meta.env.PROD
-        ? getSpecificErrorMessage(SpecificErrorCodes.UnsupportedNode)
-        : 'Unsupported node type "' + node.t + '".',
-    );
-  }
-}
-
-export class SerovalMissingPluginError extends Error {
-  constructor(tag: string) {
-    super(
-      import.meta.env.PROD
-        ? getSpecificErrorMessage(SpecificErrorCodes.MissingPlugin)
-        : 'Missing plugin for tag "' + tag + '".',
-    );
-  }
-}
-
-export class SerovalMissingInstanceError extends Error {
-  constructor(tag: string) {
-    super(
-      import.meta.env.PROD
-        ? getSpecificErrorMessage(SpecificErrorCodes.MissingInstance)
-        : 'Missing "' + tag + '" instance.',
-    );
-  }
-}
-
-export class SerovalMissingReferenceError extends Error {
-  constructor(public value: unknown) {
-    super(
-      import.meta.env.PROD
-        ? getSpecificErrorMessage(SpecificErrorCodes.MissingReference)
-        : 'Missing reference for the value "' +
-            objectToString.call(value) +
-            '" of type "' +
-            typeof value +
-            '"',
-    );
-  }
-}
-
-export class SerovalMissingReferenceForIdError extends Error {
-  constructor(id: string) {
-    super(
-      import.meta.env.PROD
-        ? getSpecificErrorMessage(SpecificErrorCodes.MissingReferenceForId)
-        : 'Missing reference for id "' + serializeString(id) + '"',
-    );
-  }
-}
-
-export class SerovalUnknownTypedArrayError extends Error {
-  constructor(name: string) {
-    super(
-      import.meta.env.PROD
-        ? getSpecificErrorMessage(SpecificErrorCodes.UnknownTypedArray)
-        : 'Unknown TypedArray "' + name + '"',
-    );
-  }
-}

package/src/core/function-string.ts

@@ -1,32 +0,0 @@
-
-declare const T: unknown;
-
-const RETURN = () => T;
-const SERIALIZED_RETURN = /* @__PURE__ */ RETURN.toString();
-
-const IS_MODERN = /* @__PURE__ */ /=>/.test(SERIALIZED_RETURN);
-
-export function createFunction(parameters: string[], body: string): string {
-  if (IS_MODERN) {
-    const joined =
-      parameters.length === 1
-        ? parameters[0]
-        : '(' + parameters.join(',') + ')';
-    return joined + '=>' + (body.startsWith('{') ? '(' + body + ')' : body);
-  }
-  return 'function(' + parameters.join(',') + '){return ' + body + '}';
-}
-
-export function createEffectfulFunction(
-  parameters: string[],
-  body: string,
-): string {
-  if (IS_MODERN) {
-    const joined =
-      parameters.length === 1
-        ? parameters[0]
-        : '(' + parameters.join(',') + ')';
-    return joined + '=>{' + body + '}';
-  }
-  return 'function(' + parameters.join(',') + '){' + body + '}';
-}

package/src/core/keys.ts

@@ -1,17 +0,0 @@
-import { serializeString } from './string';
-
-// Used for mapping isomorphic references
-export const REFERENCES_KEY = '__SEROVAL_REFS__';
-
-export const GLOBAL_CONTEXT_REFERENCES = '$R';
-
-const GLOBAL_CONTEXT_R = `self.${GLOBAL_CONTEXT_REFERENCES}`;
-
-export function getCrossReferenceHeader(id?: string): string {
-  if (id == null) {
-    return `${GLOBAL_CONTEXT_R}=${GLOBAL_CONTEXT_R}||[]`;
-  }
-  return `(${GLOBAL_CONTEXT_R}=${GLOBAL_CONTEXT_R}||{})["${serializeString(
-    id,
-  )}"]=[]`;
-}

package/src/core/literals.ts

@@ -1,43 +0,0 @@
-import { NIL, SerovalConstant, SerovalNodeType } from './constants';
-import { createSerovalNode } from './node';
-import type { SerovalConstantNode } from './types';
-
-function createConstantNode(value: SerovalConstant): SerovalConstantNode {
-  return createSerovalNode(
-    SerovalNodeType.Constant,
-    NIL,
-    value,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-    NIL,
-  );
-}
-
-export const TRUE_NODE = /* @__PURE__ */ createConstantNode(
-  SerovalConstant.True,
-);
-export const FALSE_NODE = /* @__PURE__ */ createConstantNode(
-  SerovalConstant.False,
-);
-export const UNDEFINED_NODE = /* @__PURE__ */ createConstantNode(
-  SerovalConstant.Undefined,
-);
-export const NULL_NODE = /* @__PURE__ */ createConstantNode(
-  SerovalConstant.Null,
-);
-export const NEG_ZERO_NODE = /* @__PURE__ */ createConstantNode(
-  SerovalConstant.NegZero,
-);
-export const INFINITY_NODE = /* @__PURE__ */ createConstantNode(
-  SerovalConstant.Inf,
-);
-export const NEG_INFINITY_NODE = /* @__PURE__ */ createConstantNode(
-  SerovalConstant.NegInf,
-);
-export const NAN_NODE = /* @__PURE__ */ createConstantNode(SerovalConstant.Nan);

package/src/core/node.ts

@@ -1,40 +0,0 @@
-import type { SerovalNodeType } from './constants';
-import type { SerovalNode } from './types';
-
-type ExtractedNodeType<T extends SerovalNodeType> = Extract<
-  SerovalNode,
-  { t: T }
->;
-
-export function createSerovalNode<
-  T extends SerovalNodeType,
-  N extends ExtractedNodeType<T>,
->(
-  t: T,
-  i: N['i'],
-  s: N['s'],
-  l: N['l'],
-  c: N['c'],
-  m: N['m'],
-  p: N['p'],
-  e: N['e'],
-  a: N['a'],
-  f: N['f'],
-  b: N['b'],
-  o: N['o'],
-): N {
-  return {
-    t,
-    i,
-    s,
-    l,
-    c,
-    m,
-    p,
-    e,
-    a,
-    f,
-    b,
-    o,
-  } as N;
-}

package/src/core/opaque-reference.ts

@@ -1,9 +0,0 @@
-/**
- * An opaque reference allows hiding values from the serializer.
- */
-export class OpaqueReference<V, R = undefined> {
-  constructor(
-    public readonly value: V,
-    public readonly replacement?: R,
-  ) {}
-}

package/src/core/plugin.ts

@@ -1,100 +0,0 @@
-import type { AsyncParsePluginContext } from './context/async-parser';
-import type { DeserializePluginContext } from './context/deserializer';
-import type { SerializePluginContext } from './context/serializer';
-import type {
-  StreamParsePluginContext,
-  SyncParsePluginContext,
-} from './context/sync-parser';
-
-export const enum SerovalMode {
-  Vanilla = 1,
-  Cross = 2,
-}
-
-export interface PluginData {
-  id: number;
-}
-
-export interface Plugin<Value, Node> {
-  /**
-   * A unique string that helps idenfity the plugin
-   */
-  tag: string;
-  /**
-   * List of dependency plugins
-   */
-  extends?: Plugin<any, any>[];
-  /**
-   * Method to test if a value is an expected value of the plugin
-   * @param value
-   */
-  test(value: unknown): boolean;
-  /**
-   * Parsing modes
-   */
-  parse: {
-    sync?: (
-      value: Value,
-      ctx: SyncParsePluginContext,
-      data: PluginData,
-    ) => Node;
-    async?: (
-      value: Value,
-      ctx: AsyncParsePluginContext,
-      data: PluginData,
-    ) => Promise<Node>;
-    stream?: (
-      value: Value,
-      ctx: StreamParsePluginContext,
-      data: PluginData,
-    ) => Node;
-  };
-  /**
-   * Convert the parsed node into a JS string
-   */
-  serialize(node: Node, ctx: SerializePluginContext, data: PluginData): string;
-  /**
-   * Convert the parsed node into its runtime equivalent.
-   */
-  deserialize(
-    node: Node,
-    ctx: DeserializePluginContext,
-    data: PluginData,
-  ): Value;
-}
-
-export function createPlugin<Value, Node>(
-  plugin: Plugin<Value, Node>,
-): Plugin<Value, Node> {
-  return plugin;
-}
-
-export interface PluginAccessOptions {
-  plugins?: Plugin<any, any>[];
-}
-
-function dedupePlugins(
-  deduped: Set<Plugin<any, any>>,
-  plugins: Plugin<any, any>[],
-): void {
-  for (let i = 0, len = plugins.length; i < len; i++) {
-    const current = plugins[i];
-    if (!deduped.has(current)) {
-      deduped.add(current);
-      if (current.extends) {
-        dedupePlugins(deduped, current.extends);
-      }
-    }
-  }
-}
-
-export function resolvePlugins(
-  plugins?: Plugin<any, any>[],
-): Plugin<any, any>[] | undefined {
-  if (plugins) {
-    const deduped = new Set<Plugin<any, any>>();
-    dedupePlugins(deduped, plugins);
-    return [...deduped];
-  }
-  return undefined;
-}

package/src/core/reference.ts

@@ -1,66 +0,0 @@
-import {
-  SerovalMissingReferenceError,
-  SerovalMissingReferenceForIdError,
-} from '..';
-import { REFERENCES_KEY } from './keys';
-
-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 {
-  if (hasReferenceID(value)) {
-    return REFERENCE.get(value)!;
-  }
-  throw new SerovalMissingReferenceError(value);
-}
-
-export function getReference<T>(id: string): T {
-  if (hasReference(id)) {
-    return INV_REFERENCE.get(id) as T;
-  }
-  throw new SerovalMissingReferenceForIdError(id);
-}
-
-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,42 +0,0 @@
-import {
-  SERIALIZED_ARRAY_BUFFER_CONSTRUCTOR,
-  SERIALIZED_PROMISE_CONSTRUCTOR,
-  SERIALIZED_PROMISE_FAILURE,
-  SERIALIZED_PROMISE_SUCCESS,
-  SERIALIZED_STREAM_CONSTRUCTOR,
-} from './constructors';
-
-export const ITERATOR = {};
-
-export const ASYNC_ITERATOR = {};
-
-export const enum SpecialReference {
-  MapSentinel = 0,
-  PromiseConstructor = 1,
-  PromiseSuccess = 2,
-  PromiseFailure = 3,
-  StreamConstructor = 4,
-  ArrayBufferConstructor = 5,
-}
-
-/**
- * Placeholder references
- */
-export const SPECIAL_REFS: Record<SpecialReference, unknown> = {
-  [SpecialReference.MapSentinel]: {},
-  [SpecialReference.PromiseConstructor]: {},
-  [SpecialReference.PromiseSuccess]: {},
-  [SpecialReference.PromiseFailure]: {},
-  [SpecialReference.StreamConstructor]: {},
-  [SpecialReference.ArrayBufferConstructor]: {},
-};
-
-export const SPECIAL_REF_STRING: Record<SpecialReference, string> = {
-  [SpecialReference.MapSentinel]: '[]',
-  [SpecialReference.PromiseConstructor]: SERIALIZED_PROMISE_CONSTRUCTOR,
-  [SpecialReference.PromiseSuccess]: SERIALIZED_PROMISE_SUCCESS,
-  [SpecialReference.PromiseFailure]: SERIALIZED_PROMISE_FAILURE,
-  [SpecialReference.StreamConstructor]: SERIALIZED_STREAM_CONSTRUCTOR,
-  [SpecialReference.ArrayBufferConstructor]:
-    SERIALIZED_ARRAY_BUFFER_CONSTRUCTOR,
-};