seroval 1.3.2 → 1.4.1

package/src/core/cross/async.ts

@@ -1,9 +0,0 @@
-import BaseAsyncParserContext from '../context/parser/async';
-import type { SerovalMode } from '../plugin';
-import type { CrossParserContextOptions } from './parser';
-
-export type CrossAsyncParserContextOptions = CrossParserContextOptions;
-
-export default class CrossAsyncParserContext extends BaseAsyncParserContext {
-  readonly mode: SerovalMode = 'cross';
-}

package/src/core/cross/deserializer.ts

@@ -1,16 +0,0 @@
-import type { BaseDeserializerOptions } from '../context/deserializer';
-import BaseDeserializerContext from '../context/deserializer';
-import type { SerovalMode } from '../plugin';
-
-export type CrossDeserializerContextOptions = BaseDeserializerOptions;
-
-export default class CrossDeserializerContext extends BaseDeserializerContext {
-  readonly mode: SerovalMode = 'cross';
-
-  assignIndexedValue<T>(index: number, value: T): T {
-    if (!this.refs.has(index)) {
-      this.refs.set(index, value);
-    }
-    return value;
-  }
-}

package/src/core/cross/index.ts

@@ -1,170 +0,0 @@
-import { resolvePlugins } from '../plugin';
-import type { SerovalNode } from '../types';
-import type { CrossAsyncParserContextOptions } from './async';
-import AsyncCrossParserContext from './async';
-import type { CrossDeserializerContextOptions } from './deserializer';
-import CrossDeserializerContext from './deserializer';
-import type { CrossContextOptions, CrossParserContextOptions } from './parser';
-import CrossSerializerContext from './serializer';
-import type { CrossStreamParserContextOptions } from './stream';
-import StreamCrossParserContext from './stream';
-import type { CrossSyncParserContextOptions } from './sync';
-import SyncCrossParserContext from './sync';
-
-export interface CrossSerializeOptions
-  extends CrossSyncParserContextOptions,
-    CrossContextOptions {}
-
-export function crossSerialize<T>(
-  source: T,
-  options: CrossSerializeOptions = {},
-): string {
-  const plugins = resolvePlugins(options.plugins);
-  const ctx = new SyncCrossParserContext({
-    plugins,
-    disabledFeatures: options.disabledFeatures,
-    refs: options.refs,
-  });
-  const tree = ctx.parseTop(source);
-  const serial = new CrossSerializerContext({
-    plugins,
-    features: ctx.features,
-    scopeId: options.scopeId,
-    markedRefs: ctx.marked,
-  });
-  return serial.serializeTop(tree);
-}
-
-export interface CrossSerializeAsyncOptions
-  extends CrossAsyncParserContextOptions,
-    CrossContextOptions {}
-
-export async function crossSerializeAsync<T>(
-  source: T,
-  options: CrossSerializeAsyncOptions = {},
-): Promise<string> {
-  const plugins = resolvePlugins(options.plugins);
-  const ctx = new AsyncCrossParserContext({
-    plugins,
-    disabledFeatures: options.disabledFeatures,
-    refs: options.refs,
-  });
-  const tree = await ctx.parseTop(source);
-  const serial = new CrossSerializerContext({
-    plugins,
-    features: ctx.features,
-    scopeId: options.scopeId,
-    markedRefs: ctx.marked,
-  });
-  return serial.serializeTop(tree);
-}
-
-export type ToCrossJSONOptions = CrossParserContextOptions;
-
-export function toCrossJSON<T>(
-  source: T,
-  options: CrossParserContextOptions = {},
-): SerovalNode {
-  const plugins = resolvePlugins(options.plugins);
-  const ctx = new SyncCrossParserContext({
-    plugins,
-    disabledFeatures: options.disabledFeatures,
-    refs: options.refs,
-  });
-  return ctx.parseTop(source);
-}
-
-export type ToCrossJSONAsyncOptions = CrossParserContextOptions;
-
-export async function toCrossJSONAsync<T>(
-  source: T,
-  options: CrossParserContextOptions = {},
-): Promise<SerovalNode> {
-  const plugins = resolvePlugins(options.plugins);
-  const ctx = new AsyncCrossParserContext({
-    plugins,
-    disabledFeatures: options.disabledFeatures,
-    refs: options.refs,
-  });
-  return await ctx.parseTop(source);
-}
-
-export interface CrossSerializeStreamOptions
-  extends Omit<CrossStreamParserContextOptions, 'onParse'>,
-    CrossContextOptions {
-  onSerialize: (data: string, initial: boolean) => void;
-}
-
-export function crossSerializeStream<T>(
-  source: T,
-  options: CrossSerializeStreamOptions,
-): () => void {
-  const plugins = resolvePlugins(options.plugins);
-  const ctx = new StreamCrossParserContext({
-    plugins,
-    refs: options.refs,
-    disabledFeatures: options.disabledFeatures,
-    onParse(node, initial): void {
-      const serial = new CrossSerializerContext({
-        plugins,
-        features: ctx.features,
-        scopeId: options.scopeId,
-        markedRefs: ctx.marked,
-      });
-
-      let serialized: string;
-
-      try {
-        serialized = serial.serializeTop(node);
-      } catch (err) {
-        if (options.onError) {
-          options.onError(err);
-        }
-        return;
-      }
-
-      options.onSerialize(serialized, initial);
-    },
-    onError: options.onError,
-    onDone: options.onDone,
-  });
-
-  ctx.start(source);
-
-  return ctx.destroy.bind(ctx);
-}
-
-export type ToCrossJSONStreamOptions = CrossStreamParserContextOptions;
-
-export function toCrossJSONStream<T>(
-  source: T,
-  options: ToCrossJSONStreamOptions,
-): () => void {
-  const plugins = resolvePlugins(options.plugins);
-  const ctx = new StreamCrossParserContext({
-    plugins,
-    refs: options.refs,
-    disabledFeatures: options.disabledFeatures,
-    onParse: options.onParse,
-    onError: options.onError,
-    onDone: options.onDone,
-  });
-
-  ctx.start(source);
-
-  return ctx.destroy.bind(ctx);
-}
-
-export type FromCrossJSONOptions = CrossDeserializerContextOptions;
-
-export function fromCrossJSON<T>(
-  source: SerovalNode,
-  options: FromCrossJSONOptions,
-): T {
-  const plugins = resolvePlugins(options.plugins);
-  const ctx = new CrossDeserializerContext({
-    plugins,
-    refs: options.refs,
-  });
-  return ctx.deserializeTop(source) as T;
-}

package/src/core/cross/parser.ts

@@ -1,7 +0,0 @@
-import type { BaseParserContextOptions } from '../context/parser';
-
-export type CrossParserContextOptions = BaseParserContextOptions;
-
-export interface CrossContextOptions {
-  scopeId?: string;
-}

package/src/core/cross/serializer.ts

@@ -1,72 +0,0 @@
-import { SerovalNodeType } from '../constants';
-import type { BaseSerializerContextOptions } from '../context/serializer';
-import BaseSerializerContext from '../context/serializer';
-import { GLOBAL_CONTEXT_REFERENCES } from '../keys';
-import type { SerovalMode } from '../plugin';
-import { serializeString } from '../string';
-import type { SerovalNode } from '../types';
-import type { CrossContextOptions } from './parser';
-
-export interface CrossSerializerContextOptions
-  extends BaseSerializerContextOptions,
-    CrossContextOptions {}
-
-export default class CrossSerializerContext extends BaseSerializerContext {
-  readonly mode: SerovalMode = 'cross';
-
-  scopeId?: string;
-
-  constructor(options: CrossSerializerContextOptions) {
-    super(options);
-    this.scopeId = options.scopeId;
-  }
-
-  getRefParam(id: number): string {
-    return GLOBAL_CONTEXT_REFERENCES + '[' + id + ']';
-  }
-
-  protected assignIndexedValue(index: number, value: string): string {
-    // In cross-reference, we have to assume that
-    // every reference are going to be referenced
-    // in the future, and so we need to store
-    // all of it into the reference array.
-    return this.getRefParam(index) + '=' + value;
-  }
-
-  serializeTop(tree: SerovalNode): string {
-    // Get the serialized result
-    const result = this.serialize(tree);
-    // If the node is a non-reference, return
-    // the result immediately
-    const id = tree.i;
-    if (id == null) {
-      return result;
-    }
-    // Get the patches
-    const patches = this.resolvePatches();
-    // Get the variable that represents the root
-    const ref = this.getRefParam(id);
-    // Parameters needed for scoping
-    const params = this.scopeId == null ? '' : GLOBAL_CONTEXT_REFERENCES;
-    // If there are patches, append it after the result
-    const body = patches ? '(' + result + ',' + patches + ref + ')' : result;
-    // If there are no params, there's no need to generate a function
-    if (params === '') {
-      if (tree.t === SerovalNodeType.Object && !patches) {
-        return '(' + body + ')';
-      }
-      return body;
-    }
-    // Get the arguments for the IIFE
-    const args =
-      this.scopeId == null
-        ? '()'
-        : '(' +
-          GLOBAL_CONTEXT_REFERENCES +
-          '["' +
-          serializeString(this.scopeId) +
-          '"])';
-    // Create the IIFE
-    return '(' + this.createFunction([params], body) + ')' + args;
-  }
-}

package/src/core/cross/stream.ts

@@ -1,9 +0,0 @@
-import type { BaseStreamParserContextOptions } from '../context/parser/stream';
-import BaseStreamParserContext from '../context/parser/stream';
-import type { SerovalMode } from '../plugin';
-
-export type CrossStreamParserContextOptions = BaseStreamParserContextOptions;
-
-export default class CrossStreamParserContext extends BaseStreamParserContext {
-  readonly mode: SerovalMode = 'cross';
-}

package/src/core/cross/sync.ts

@@ -1,9 +0,0 @@
-import BaseSyncParserContext from '../context/parser/sync';
-import type { SerovalMode } from '../plugin';
-import type { CrossParserContextOptions } from './parser';
-
-export type CrossSyncParserContextOptions = CrossParserContextOptions;
-
-export default class CrossSyncParserContext extends BaseSyncParserContext {
-  readonly mode: SerovalMode = 'cross';
-}

package/src/core/errors.ts

@@ -1,102 +0,0 @@
-import { serializeString } from './string';
-import type { SerovalNode } from './types';
-
-const { toString: objectToString } = /* @__PURE__ */ Object.prototype;
-
-function getErrorMessage(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.`;
-}
-
-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);
-  }
-}
-
-export class SerovalUnsupportedTypeError extends Error {
-  constructor(public value: unknown) {
-    super(
-      `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('Unsupported node type "' + node.t + '".');
-  }
-}
-
-export class SerovalMissingPluginError extends Error {
-  constructor(tag: string) {
-    super('Missing plugin for tag "' + tag + '".');
-  }
-}
-
-export class SerovalMissingInstanceError extends Error {
-  constructor(tag: string) {
-    super('Missing "' + tag + '" instance.');
-  }
-}
-
-export class SerovalMissingReferenceError extends Error {
-  constructor(public value: unknown) {
-    super(
-      'Missing reference for the value "' +
-        objectToString.call(value) +
-        '" of type "' +
-        typeof value +
-        '"',
-    );
-  }
-}
-
-export class SerovalMissingReferenceForIdError extends Error {
-  constructor(id: string) {
-    super('Missing reference for id "' + serializeString(id) + '"');
-  }
-}
-
-export class SerovalUnknownTypedArrayError extends Error {
-  constructor(name: string) {
-    super('Unknown TypedArray "' + name + '"');
-  }
-}

package/src/core/function-string.ts

@@ -1,31 +0,0 @@
-import { Feature } from './compat';
-
-export function createFunction(
-  features: number,
-  parameters: string[],
-  body: string,
-): string {
-  if (features & Feature.ArrowFunction) {
-    const joined =
-      parameters.length === 1
-        ? parameters[0]
-        : '(' + parameters.join(',') + ')';
-    return joined + '=>' + (body.startsWith('{') ? '(' + body + ')' : body);
-  }
-  return 'function(' + parameters.join(',') + '){return ' + body + '}';
-}
-
-export function createEffectfulFunction(
-  features: number,
-  parameters: string[],
-  body: string,
-): string {
-  if (features & Feature.ArrowFunction) {
-    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,91 +0,0 @@
-import type BaseDeserializerContext from './context/deserializer';
-import type BaseAsyncParserContext from './context/parser/async';
-import type BaseStreamParserContext from './context/parser/stream';
-import type BaseSyncParserContext from './context/parser/sync';
-import type BaseSerializerContext from './context/serializer';
-
-export type SerovalMode = 'vanilla' | 'cross';
-
-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: BaseSyncParserContext, data: PluginData) => Node;
-    async?: (
-      value: Value,
-      ctx: BaseAsyncParserContext,
-      data: PluginData,
-    ) => Promise<Node>;
-    stream?: (
-      value: Value,
-      ctx: BaseStreamParserContext,
-      data: PluginData,
-    ) => Node;
-  };
-  /**
-   * Convert the parsed node into a JS string
-   */
-  serialize(node: Node, ctx: BaseSerializerContext, data: PluginData): string;
-  /**
-   * Convert the parsed node into its runtime equivalent.
-   */
-  deserialize(
-    node: Node,
-    ctx: BaseDeserializerContext,
-    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;
-}