seroval 1.3.2 → 1.4.0

package/src/core/cross/index.ts

@@ -1,18 +1,34 @@
-import { resolvePlugins } from '../plugin';
+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';
-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,
+  extends SyncParserContextOptions,
     CrossContextOptions {}
 
 export function crossSerialize<T>(
@@ -20,23 +36,23 @@ export function crossSerialize<T>(
   options: CrossSerializeOptions = {},
 ): string {
   const plugins = resolvePlugins(options.plugins);
-  const ctx = new SyncCrossParserContext({
+  const ctx = createSyncParserContext(SerovalMode.Cross, {
     plugins,
     disabledFeatures: options.disabledFeatures,
     refs: options.refs,
   });
-  const tree = ctx.parseTop(source);
-  const serial = new CrossSerializerContext({
+  const tree = parseTop(ctx, source);
+  const serial = createCrossSerializerContext({
     plugins,
-    features: ctx.features,
+    features: ctx.base.features,
     scopeId: options.scopeId,
-    markedRefs: ctx.marked,
+    markedRefs: ctx.base.marked,
   });
-  return serial.serializeTop(tree);
+  return serializeTopCross(serial, tree);
 }
 
 export interface CrossSerializeAsyncOptions
-  extends CrossAsyncParserContextOptions,
+  extends AsyncParserContextOptions,
     CrossContextOptions {}
 
 export async function crossSerializeAsync<T>(
@@ -44,53 +60,53 @@ export async function crossSerializeAsync<T>(
   options: CrossSerializeAsyncOptions = {},
 ): Promise<string> {
   const plugins = resolvePlugins(options.plugins);
-  const ctx = new AsyncCrossParserContext({
+  const ctx = createAsyncParserContext(SerovalMode.Cross, {
     plugins,
     disabledFeatures: options.disabledFeatures,
     refs: options.refs,
   });
-  const tree = await ctx.parseTop(source);
-  const serial = new CrossSerializerContext({
+  const tree = await parseTopAsync(ctx, source);
+  const serial = createCrossSerializerContext({
     plugins,
-    features: ctx.features,
+    features: ctx.base.features,
     scopeId: options.scopeId,
-    markedRefs: ctx.marked,
+    markedRefs: ctx.base.marked,
   });
-  return serial.serializeTop(tree);
+  return serializeTopCross(serial, tree);
 }
 
-export type ToCrossJSONOptions = CrossParserContextOptions;
+export type ToCrossJSONOptions = SyncParserContextOptions;
 
 export function toCrossJSON<T>(
   source: T,
-  options: CrossParserContextOptions = {},
+  options: ToCrossJSONOptions = {},
 ): SerovalNode {
   const plugins = resolvePlugins(options.plugins);
-  const ctx = new SyncCrossParserContext({
+  const ctx = createSyncParserContext(SerovalMode.Cross, {
     plugins,
     disabledFeatures: options.disabledFeatures,
     refs: options.refs,
   });
-  return ctx.parseTop(source);
+  return parseTop(ctx, source);
 }
 
-export type ToCrossJSONAsyncOptions = CrossParserContextOptions;
+export type ToCrossJSONAsyncOptions = AsyncParserContextOptions;
 
 export async function toCrossJSONAsync<T>(
   source: T,
-  options: CrossParserContextOptions = {},
+  options: ToCrossJSONAsyncOptions = {},
 ): Promise<SerovalNode> {
   const plugins = resolvePlugins(options.plugins);
-  const ctx = new AsyncCrossParserContext({
+  const ctx = createAsyncParserContext(SerovalMode.Cross, {
     plugins,
     disabledFeatures: options.disabledFeatures,
     refs: options.refs,
   });
-  return await ctx.parseTop(source);
+  return await parseTopAsync(ctx, source);
 }
 
 export interface CrossSerializeStreamOptions
-  extends Omit<CrossStreamParserContextOptions, 'onParse'>,
+  extends Omit<StreamParserContextOptions, 'onParse'>,
     CrossContextOptions {
   onSerialize: (data: string, initial: boolean) => void;
 }
@@ -100,22 +116,22 @@ export function crossSerializeStream<T>(
   options: CrossSerializeStreamOptions,
 ): () => void {
   const plugins = resolvePlugins(options.plugins);
-  const ctx = new StreamCrossParserContext({
+  const ctx = createStreamParserContext({
     plugins,
     refs: options.refs,
     disabledFeatures: options.disabledFeatures,
     onParse(node, initial): void {
-      const serial = new CrossSerializerContext({
+      const serial = createCrossSerializerContext({
         plugins,
-        features: ctx.features,
+        features: ctx.base.features,
         scopeId: options.scopeId,
-        markedRefs: ctx.marked,
+        markedRefs: ctx.base.marked,
       });
 
       let serialized: string;
 
       try {
-        serialized = serial.serializeTop(node);
+        serialized = serializeTopCross(serial, node);
       } catch (err) {
         if (options.onError) {
           options.onError(err);
@@ -129,19 +145,19 @@ export function crossSerializeStream<T>(
     onDone: options.onDone,
   });
 
-  ctx.start(source);
+  startStreamParse(ctx, source);
 
-  return ctx.destroy.bind(ctx);
+  return destroyStreamParse.bind(null, ctx);
 }
 
-export type ToCrossJSONStreamOptions = CrossStreamParserContextOptions;
+export type ToCrossJSONStreamOptions = StreamParserContextOptions;
 
 export function toCrossJSONStream<T>(
   source: T,
   options: ToCrossJSONStreamOptions,
 ): () => void {
   const plugins = resolvePlugins(options.plugins);
-  const ctx = new StreamCrossParserContext({
+  const ctx = createStreamParserContext({
     plugins,
     refs: options.refs,
     disabledFeatures: options.disabledFeatures,
@@ -150,9 +166,9 @@ export function toCrossJSONStream<T>(
     onDone: options.onDone,
   });
 
-  ctx.start(source);
+  startStreamParse(ctx, source);
 
-  return ctx.destroy.bind(ctx);
+  return destroyStreamParse.bind(null, ctx);
 }
 
 export type FromCrossJSONOptions = CrossDeserializerContextOptions;
@@ -162,9 +178,9 @@ export function fromCrossJSON<T>(
   options: FromCrossJSONOptions,
 ): T {
   const plugins = resolvePlugins(options.plugins);
-  const ctx = new CrossDeserializerContext({
+  const ctx = createCrossDeserializerContext({
     plugins,
     refs: options.refs,
   });
-  return ctx.deserializeTop(source) as T;
+  return deserializeTop(ctx, source) as T;
 }

package/src/core/errors.ts

@@ -1,9 +1,17 @@
+/// <reference types="pridepack/env" />
+
 import { serializeString } from './string';
 import type { SerovalNode } from './types';
 
 const { toString: objectToString } = /* @__PURE__ */ Object.prototype;
 
-function getErrorMessage(type: string, cause: any): string {
+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.
   
@@ -20,6 +28,21 @@ ${cause.message}
 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,
@@ -47,10 +70,26 @@ export class SerovalDeserializationError extends SerovalError {
   }
 }
 
+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(
-      `The value ${objectToString.call(value)} of type "${typeof value}" cannot be parsed/serialized.
+      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.
@@ -61,42 +100,64 @@ There are few workarounds for this problem:
 
 export class SerovalUnsupportedNodeError extends Error {
   constructor(node: SerovalNode) {
-    super('Unsupported node type "' + node.t + '".');
+    super(
+      import.meta.env.PROD
+        ? getSpecificErrorMessage(SpecificErrorCodes.UnsupportedNode)
+        : 'Unsupported node type "' + node.t + '".',
+    );
   }
 }
 
 export class SerovalMissingPluginError extends Error {
   constructor(tag: string) {
-    super('Missing plugin for tag "' + tag + '".');
+    super(
+      import.meta.env.PROD
+        ? getSpecificErrorMessage(SpecificErrorCodes.MissingPlugin)
+        : 'Missing plugin for tag "' + tag + '".',
+    );
   }
 }
 
 export class SerovalMissingInstanceError extends Error {
   constructor(tag: string) {
-    super('Missing "' + tag + '" instance.');
+    super(
+      import.meta.env.PROD
+        ? getSpecificErrorMessage(SpecificErrorCodes.MissingInstance)
+        : '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 +
-        '"',
+      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('Missing reference for id "' + serializeString(id) + '"');
+    super(
+      import.meta.env.PROD
+        ? getSpecificErrorMessage(SpecificErrorCodes.MissingReferenceForId)
+        : 'Missing reference for id "' + serializeString(id) + '"',
+    );
   }
 }
 
 export class SerovalUnknownTypedArrayError extends Error {
   constructor(name: string) {
-    super('Unknown TypedArray "' + name + '"');
+    super(
+      import.meta.env.PROD
+        ? getSpecificErrorMessage(SpecificErrorCodes.UnknownTypedArray)
+        : 'Unknown TypedArray "' + name + '"',
+    );
   }
 }

package/src/core/function-string.ts

@@ -1,11 +1,13 @@
-import { Feature } from './compat';
 
-export function createFunction(
-  features: number,
-  parameters: string[],
-  body: string,
-): string {
-  if (features & Feature.ArrowFunction) {
+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]
@@ -16,11 +18,10 @@ export function createFunction(
 }
 
 export function createEffectfulFunction(
-  features: number,
   parameters: string[],
   body: string,
 ): string {
-  if (features & Feature.ArrowFunction) {
+  if (IS_MODERN) {
     const joined =
       parameters.length === 1
         ? parameters[0]
@@ -28,4 +29,4 @@ export function createEffectfulFunction(
     return joined + '=>{' + body + '}';
   }
   return 'function(' + parameters.join(',') + '){' + body + '}';
-}
+}

package/src/core/plugin.ts

@@ -1,10 +1,15 @@
-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';
+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 type SerovalMode = 'vanilla' | 'cross';
+export const enum SerovalMode {
+  Vanilla = 1,
+  Cross = 2,
+}
 
 export interface PluginData {
   id: number;
@@ -28,28 +33,32 @@ export interface Plugin<Value, Node> {
    * Parsing modes
    */
   parse: {
-    sync?: (value: Value, ctx: BaseSyncParserContext, data: PluginData) => Node;
+    sync?: (
+      value: Value,
+      ctx: SyncParsePluginContext,
+      data: PluginData,
+    ) => Node;
     async?: (
       value: Value,
-      ctx: BaseAsyncParserContext,
+      ctx: AsyncParsePluginContext,
       data: PluginData,
     ) => Promise<Node>;
     stream?: (
       value: Value,
-      ctx: BaseStreamParserContext,
+      ctx: StreamParsePluginContext,
       data: PluginData,
     ) => Node;
   };
   /**
    * Convert the parsed node into a JS string
    */
-  serialize(node: Node, ctx: BaseSerializerContext, data: PluginData): string;
+  serialize(node: Node, ctx: SerializePluginContext, data: PluginData): string;
   /**
    * Convert the parsed node into its runtime equivalent.
    */
   deserialize(
     node: Node,
-    ctx: BaseDeserializerContext,
+    ctx: DeserializePluginContext,
     data: PluginData,
   ): Value;
 }

package/src/core/reference.ts

@@ -3,7 +3,6 @@ import {
   SerovalMissingReferenceForIdError,
 } from '..';
 import { REFERENCES_KEY } from './keys';
-import assert from './utils/assert';
 
 const REFERENCE = new Map<unknown, string>();
 const INV_REFERENCE = new Map<string, unknown>();
@@ -23,13 +22,17 @@ export function hasReference(id: string): boolean {
 }
 
 export function getReferenceID<T>(value: T): string {
-  assert(hasReferenceID(value), new SerovalMissingReferenceError(value));
-  return REFERENCE.get(value)!;
+  if (hasReferenceID(value)) {
+    return REFERENCE.get(value)!;
+  }
+  throw new SerovalMissingReferenceError(value);
 }
 
 export function getReference<T>(id: string): T {
-  assert(hasReference(id), new SerovalMissingReferenceForIdError(id));
-  return INV_REFERENCE.get(id) as T;
+  if (hasReference(id)) {
+    return INV_REFERENCE.get(id) as T;
+  }
+  throw new SerovalMissingReferenceForIdError(id);
 }
 
 if (typeof globalThis !== 'undefined') {

package/src/core/special-reference.ts

@@ -1,4 +1,10 @@
-import { createEffectfulFunction, createFunction } from './function-string';
+import {
+  SERIALIZED_ARRAY_BUFFER_CONSTRUCTOR,
+  SERIALIZED_PROMISE_CONSTRUCTOR,
+  SERIALIZED_PROMISE_FAILURE,
+  SERIALIZED_PROMISE_SUCCESS,
+  SERIALIZED_STREAM_CONSTRUCTOR,
+} from './constructors';
 
 export const ITERATOR = {};
 
@@ -10,6 +16,7 @@ export const enum SpecialReference {
   PromiseSuccess = 2,
   PromiseFailure = 3,
   StreamConstructor = 4,
+  ArrayBufferConstructor = 5,
 }
 
 /**
@@ -21,94 +28,15 @@ export const SPECIAL_REFS: Record<SpecialReference, unknown> = {
   [SpecialReference.PromiseSuccess]: {},
   [SpecialReference.PromiseFailure]: {},
   [SpecialReference.StreamConstructor]: {},
+  [SpecialReference.ArrayBufferConstructor]: {},
 };
 
-function serializePromiseConstructor(features: number): string {
-  return createFunction(
-    features,
-    ['r'],
-    '(r.p=new Promise(' +
-      createEffectfulFunction(features, ['s', 'f'], 'r.s=s,r.f=f') +
-      '))',
-  );
-}
-
-function serializePromiseSuccess(features: number): string {
-  return createEffectfulFunction(
-    features,
-    ['r', 'd'],
-    'r.s(d),r.p.s=1,r.p.v=d',
-  );
-}
-
-function serializePromiseFailure(features: number): string {
-  return createEffectfulFunction(
-    features,
-    ['r', 'd'],
-    'r.f(d),r.p.s=2,r.p.v=d',
-  );
-}
-
-function serializeStreamConstructor(features: number): string {
-  return createFunction(
-    features,
-    ['b', 'a', 's', 'l', 'p', 'f', 'e', 'n'],
-    '(b=[],a=!0,s=!1,l=[],p=0,f=' +
-      createEffectfulFunction(
-        features,
-        ['v', 'm', 'x'],
-        'for(x=0;x<p;x++)l[x]&&l[x][m](v)',
-      ) +
-      ',n=' +
-      createEffectfulFunction(
-        features,
-        ['o', 'x', 'z', 'c'],
-        'for(x=0,z=b.length;x<z;x++)(c=b[x],(!a&&x===z-1)?o[s?"return":"throw"](c):o.next(c))',
-      ) +
-      ',e=' +
-      createFunction(
-        features,
-        ['o', 't'],
-        '(a&&(l[t=p++]=o),n(o),' +
-          createEffectfulFunction(features, [], 'a&&(l[t]=void 0)') +
-          ')',
-      ) +
-      ',{__SEROVAL_STREAM__:!0,on:' +
-      createFunction(features, ['o'], 'e(o)') +
-      ',next:' +
-      createEffectfulFunction(features, ['v'], 'a&&(b.push(v),f(v,"next"))') +
-      ',throw:' +
-      createEffectfulFunction(
-        features,
-        ['v'],
-        'a&&(b.push(v),f(v,"throw"),a=s=!1,l.length=0)',
-      ) +
-      ',return:' +
-      createEffectfulFunction(
-        features,
-        ['v'],
-        'a&&(b.push(v),f(v,"return"),a=!1,s=!0,l.length=0)',
-      ) +
-      '})',
-  );
-}
-
-export function serializeSpecialReferenceValue(
-  features: number,
-  ref: SpecialReference,
-): string {
-  switch (ref) {
-    case SpecialReference.MapSentinel:
-      return '[]';
-    case SpecialReference.PromiseConstructor:
-      return serializePromiseConstructor(features);
-    case SpecialReference.PromiseSuccess:
-      return serializePromiseSuccess(features);
-    case SpecialReference.PromiseFailure:
-      return serializePromiseFailure(features);
-    case SpecialReference.StreamConstructor:
-      return serializeStreamConstructor(features);
-    default:
-      return '';
-  }
-}
+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,
+};