seroval 1.4.2 → 1.5.0

package/src/core/base-primitives.ts

@@ -29,6 +29,7 @@ import type {
   SerovalPluginNode,
   SerovalReferenceNode,
   SerovalRegExpNode,
+  SerovalSequenceNode,
   SerovalSetNode,
   SerovalStreamConstructorNode,
   SerovalStreamNextNode,
@@ -208,7 +209,7 @@ export function createReferenceNode<T>(
 export function createPluginNode(
   id: number,
   tag: string,
-  value: unknown,
+  value: Record<string, SerovalNode>,
 ): SerovalPluginNode {
   return createSerovalNode(
     SerovalNodeType.Plugin,
@@ -394,7 +395,7 @@ export function createSetNode(
 
 export function createIteratorFactoryInstanceNode(
   factory: SerovalNodeWithID,
-  items: SerovalNode,
+  items: SerovalNodeWithID,
 ): SerovalIteratorFactoryInstanceNode {
   return createSerovalNode(
     SerovalNodeType.IteratorFactoryInstance,
@@ -414,7 +415,7 @@ export function createIteratorFactoryInstanceNode(
 
 export function createAsyncIteratorFactoryInstanceNode(
   factory: SerovalNodeWithID,
-  items: SerovalNode,
+  items: SerovalNodeWithID,
 ): SerovalAsyncIteratorFactoryInstanceNode {
   return createSerovalNode(
     SerovalNodeType.AsyncIteratorFactoryInstance,
@@ -512,3 +513,25 @@ export function createStreamReturnNode(
     NIL,
   );
 }
+
+export function createSequenceNode(
+  id: number,
+  sequence: SerovalNode[],
+  throwAt: number,
+  doneAt: number,
+): SerovalSequenceNode {
+  return createSerovalNode(
+    SerovalNodeType.Sequence,
+    id,
+    throwAt,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    sequence,
+    NIL,
+    NIL,
+    NIL,
+    doneAt,
+  );
+}

package/src/core/constants.ts

@@ -61,6 +61,7 @@ export const enum SerovalNodeType {
   StreamNext = 32,
   StreamThrow = 33,
   StreamReturn = 34,
+  Sequence = 35,
 }
 
 export const enum SerovalObjectFlags {

package/src/core/constructors.ts

@@ -1,3 +1,4 @@
+import { Sequence } from './sequence';
 import type { Stream } from './stream';
 
 type SpecialPromise = Promise<unknown> & { s?: 1 | 2; v?: unknown };
@@ -130,12 +131,6 @@ export const STREAM_CONSTRUCTOR = () => {
 export const SERIALIZED_STREAM_CONSTRUCTOR =
   /* @__PURE__ */ STREAM_CONSTRUCTOR.toString();
 
-export interface Sequence {
-  v: unknown[];
-  t: number;
-  d: number;
-}
-
 export const ITERATOR_CONSTRUCTOR =
   (symbol: symbol) => (sequence: Sequence) => () => {
     let index = 0;

package/src/core/context/async-parser.ts

@@ -12,6 +12,7 @@ import {
   createNumberNode,
   createPluginNode,
   createRegExpNode,
+  createSequenceNode,
   createSetNode,
   createStreamConstructorNode,
   createStreamNextNode,
@@ -27,6 +28,11 @@ import { FALSE_NODE, NULL_NODE, TRUE_NODE, UNDEFINED_NODE } from '../literals';
 import { createSerovalNode } from '../node';
 import { OpaqueReference } from '../opaque-reference';
 import type { SerovalMode } from '../plugin';
+import {
+  createSequenceFromIterable,
+  isSequence,
+  type Sequence,
+} from '../sequence';
 import { SpecialReference } from '../special-reference';
 import type { Stream } from '../stream';
 import { createStreamFromAsyncIterable, isStream } from '../stream';
@@ -46,18 +52,19 @@ import type {
   SerovalErrorNode,
   SerovalMapNode,
   SerovalNode,
+  SerovalNodeWithID,
   SerovalNullConstructorNode,
   SerovalObjectNode,
   SerovalObjectRecordKey,
   SerovalObjectRecordNode,
   SerovalPluginNode,
   SerovalPromiseNode,
+  SerovalSequenceNode,
   SerovalSetNode,
   SerovalStreamConstructorNode,
   SerovalTypedArrayNode,
 } from '../types';
 import { getErrorOptions } from '../utils/error';
-import { iteratorToSequence } from '../utils/iterator-to-sequence';
 import promiseToResult from '../utils/promise-to-result';
 import type {
   BigIntTypedArrayValue,
@@ -155,11 +162,13 @@ async function parseProperties(
     valueNodes.push(
       createIteratorFactoryInstanceNode(
         parseIteratorFactory(ctx.base),
-        await parseAsync(
+        (await parseAsync(
           ctx,
           depth,
-          iteratorToSequence(properties as unknown as Iterable<unknown>),
-        ),
+          createSequenceFromIterable(
+            properties as unknown as Iterable<unknown>,
+          ),
+        )) as SerovalNodeWithID,
       ),
     );
   }
@@ -168,13 +177,13 @@ async function parseProperties(
     valueNodes.push(
       createAsyncIteratorFactoryInstanceNode(
         parseAsyncIteratorFactory(ctx.base),
-        await parseAsync(
+        (await parseAsync(
           ctx,
           depth,
           createStreamFromAsyncIterable(
             properties as unknown as AsyncIterable<unknown>,
           ),
-        ),
+        )) as SerovalNodeWithID,
       ),
     );
   }
@@ -435,6 +444,19 @@ async function parseStream(
   );
 }
 
+async function parseSequence(
+  ctx: AsyncParserContext,
+  depth: number,
+  id: number,
+  current: Sequence,
+): Promise<SerovalSequenceNode> {
+  const nodes: SerovalNode[] = [];
+  for (let i = 0, len = current.v.length; i < len; i++) {
+    nodes[i] = await parseAsync(ctx, depth, current.v[i]);
+  }
+  return createSequenceNode(id, nodes, current.t, current.d);
+}
+
 export async function parseObjectAsync(
   ctx: AsyncParserContext,
   depth: number,
@@ -447,6 +469,9 @@ export async function parseObjectAsync(
   if (isStream(current)) {
     return parseStream(ctx, depth, id, current);
   }
+  if (isSequence(current)) {
+    return parseSequence(ctx, depth, id, current);
+  }
   const currentClass = current.constructor;
   if (currentClass === OpaqueReference) {
     return parseAsync(

package/src/core/context/deserializer.ts

@@ -23,6 +23,7 @@ import {
 import type { PluginAccessOptions } from '../plugin';
 import { SerovalMode } from '../plugin';
 import { getReference } from '../reference';
+import { createSequence, type Sequence, sequenceToIterator } from '../sequence';
 import type { Stream } from '../stream';
 import { createStream, isStream, streamToAsyncIterable } from '../stream';
 import { deserializeString } from '../string';
@@ -57,6 +58,7 @@ import type {
   SerovalPromiseResolveNode,
   SerovalReferenceNode,
   SerovalRegExpNode,
+  SerovalSequenceNode,
   SerovalSetNode,
   SerovalStreamConstructorNode,
   SerovalStreamNextNode,
@@ -64,8 +66,6 @@ import type {
   SerovalStreamThrowNode,
   SerovalTypedArrayNode,
 } from '../types';
-import type { Sequence } from '../utils/iterator-to-sequence';
-import { sequenceToIterator } from '../utils/iterator-to-sequence';
 import type {
   BigIntTypedArrayValue,
   TypedArrayValue,
@@ -713,6 +713,22 @@ function deserializeAsyncIteratorFactory(
   return NIL;
 }
 
+function deserializeSequence(
+  ctx: DeserializerContext,
+  depth: number,
+  node: SerovalSequenceNode,
+): Sequence {
+  const result = assignIndexedValue(
+    ctx,
+    node.i,
+    createSequence([], node.s, node.l),
+  );
+  for (let i = 0, len = node.a.length; i < len; i++) {
+    result.v[i] = deserialize(ctx, depth, node.a[i]);
+  }
+  return result;
+}
+
 function deserialize(
   ctx: DeserializerContext,
   depth: number,
@@ -793,6 +809,8 @@ function deserialize(
     case SerovalNodeType.AsyncIteratorFactory:
       return deserializeAsyncIteratorFactory(ctx, depth, node);
     // case SerovalNodeType.SpecialReference:
+    case SerovalNodeType.Sequence:
+      return deserializeSequence(ctx, depth, node);
     default:
       throw new SerovalUnsupportedNodeError(node);
   }

package/src/core/context/serializer.ts

@@ -50,6 +50,7 @@ import type {
   SerovalPromiseResolveNode,
   SerovalReferenceNode,
   SerovalRegExpNode,
+  SerovalSequenceNode,
   SerovalSetNode,
   SerovalStreamConstructorNode,
   SerovalStreamNextNode,
@@ -484,6 +485,15 @@ function createObjectAssign(
   createAssignment(ctx.base, getRefParam(ctx, ref) + '.' + key, value);
 }
 
+function createSequenceAssign(
+  ctx: SerializerContext,
+  ref: number,
+  index: number | string,
+  value: string,
+): void {
+  createAssignment(ctx.base, getRefParam(ctx, ref) + '.v[' + index + ']', value);
+}
+
 /**
  * Checks if the value is in the stack. Stack here is a reference
  * structure to know if a object is to be accessed in a TDZ.
@@ -1239,6 +1249,48 @@ function serializeStreamReturn(
   return getRefParam(ctx, node.i) + '.return(' + serialize(ctx, node.f) + ')';
 }
 
+function serializeSequenceItem(
+  ctx: SerializerContext,
+  id: number,
+  index: number,
+  item: SerovalNode,
+): string {
+  const base = ctx.base;
+  if (isIndexedValueInStack(base, item)) {
+    markSerializerRef(base, id);
+    createSequenceAssign(
+      ctx,
+      id,
+      index,
+      getRefParam(ctx, (item as SerovalIndexedValueNode).i),
+    );
+    return '';
+  }
+  return serialize(ctx, item);
+}
+
+function serializeSequence(
+  ctx: SerializerContext,
+  node: SerovalSequenceNode,
+): string {
+  const items = node.a;
+  const size = items.length;
+  const id = node.i;
+  if (size > 0) {
+    ctx.base.stack.push(id);
+    let result = serializeSequenceItem(ctx, id, 0, items[0]);
+    for (let i = 1, item = result; i < size; i++) {
+      item = serializeSequenceItem(ctx, id, i, items[i]);
+      result += (item && result && ',') + item;
+    }
+    ctx.base.stack.pop();
+    if (result) {
+      return '{__SEROVAL_SEQUENCE__:!0,v:[' + result + '],t:' + node.s + ',d:' + node.l + '}';
+    }
+  }
+  return '{__SEROVAL_SEQUENCE__:!0,v:[],t:-1,d:0}';
+}
+
 function serializeAssignable(
   ctx: SerializerContext,
   node: SerovalNode,
@@ -1283,6 +1335,8 @@ function serializeAssignable(
       return serializePlugin(ctx, node);
     case SerovalNodeType.SpecialReference:
       return SPECIAL_REF_STRING[node.s];
+    case SerovalNodeType.Sequence:
+      return serializeSequence(ctx, node);
     default:
       throw new SerovalUnsupportedNodeError(node);
   }

package/src/core/context/sync-parser.ts

@@ -12,6 +12,7 @@ import {
   createNumberNode,
   createPluginNode,
   createRegExpNode,
+  createSequenceNode,
   createSetNode,
   createStreamConstructorNode,
   createStreamNextNode,
@@ -31,6 +32,11 @@ import { FALSE_NODE, NULL_NODE, TRUE_NODE, UNDEFINED_NODE } from '../literals';
 import { createSerovalNode } from '../node';
 import { OpaqueReference } from '../opaque-reference';
 import { type Plugin, SerovalMode } from '../plugin';
+import {
+  createSequenceFromIterable,
+  isSequence,
+  type Sequence,
+} from '../sequence';
 import { SpecialReference } from '../special-reference';
 import type { Stream } from '../stream';
 import {
@@ -54,17 +60,18 @@ import type {
   SerovalErrorNode,
   SerovalMapNode,
   SerovalNode,
+  SerovalNodeWithID,
   SerovalNullConstructorNode,
   SerovalObjectNode,
   SerovalObjectRecordKey,
   SerovalObjectRecordNode,
   SerovalPluginNode,
   SerovalPromiseConstructorNode,
+  SerovalSequenceNode,
   SerovalSetNode,
   SerovalTypedArrayNode,
 } from '../types';
 import { getErrorOptions } from '../utils/error';
-import { iteratorToSequence } from '../utils/iterator-to-sequence';
 import type {
   BigIntTypedArrayValue,
   TypedArrayValue,
@@ -255,8 +262,10 @@ function parseProperties(
         parseSOS(
           ctx,
           depth,
-          iteratorToSequence(properties as unknown as Iterable<unknown>),
-        ),
+          createSequenceFromIterable(
+            properties as unknown as Iterable<unknown>,
+          ),
+        ) as SerovalNodeWithID,
       ),
     );
   }
@@ -273,7 +282,7 @@ function parseProperties(
             : createStreamFromAsyncIterable(
                 properties as unknown as AsyncIterable<unknown>,
               ),
-        ),
+        ) as SerovalNodeWithID,
       ),
     );
   }
@@ -599,6 +608,19 @@ function parsePlugin(
   return NIL;
 }
 
+function parseSequence(
+  ctx: SOSParserContext,
+  depth: number,
+  id: number,
+  current: Sequence,
+): SerovalSequenceNode {
+  const nodes: SerovalNode[] = [];
+  for (let i = 0, len = current.v.length; i < len; i++) {
+    nodes[i] = parseSOS(ctx, depth, current.v[i]);
+  }
+  return createSequenceNode(id, nodes, current.t, current.d);
+}
+
 function parseObjectPhase2(
   ctx: SOSParserContext,
   depth: number,
@@ -733,6 +755,9 @@ function parseObject(
   if (isStream(current)) {
     return parseStream(ctx, depth, id, current);
   }
+  if (isSequence(current)) {
+    return parseSequence(ctx, depth, id, current);
+  }
   const currentClass = current.constructor;
   if (currentClass === OpaqueReference) {
     return parseSOS(

package/src/core/errors.ts

@@ -11,10 +11,10 @@ const enum StepErrorCodes {
   Deserialize = 3,
 }
 
-function getErrorMessageDev(type: string, cause: any): string {
+function getErrorMessageDev(type: string, cause: unknown): string {
   if (cause instanceof Error) {
     return `Seroval caught an error during the ${type} process.
-  
+
 ${cause.name}
 ${cause.message}
 
@@ -46,26 +46,26 @@ const getErrorMessage = (type: string, cause: any) =>
 export class SerovalError extends Error {
   constructor(
     type: string,
-    public cause: any,
+    public cause: unknown,
   ) {
     super(getErrorMessage(type, cause));
   }
 }
 
 export class SerovalParserError extends SerovalError {
-  constructor(cause: any) {
+  constructor(cause: unknown) {
     super('parsing', cause);
   }
 }
 
 export class SerovalSerializationError extends SerovalError {
-  constructor(cause: any) {
+  constructor(cause: unknown) {
     super('serialization', cause);
   }
 }
 
 export class SerovalDeserializationError extends SerovalError {
-  constructor(cause: any) {
+  constructor(cause: unknown) {
     super('deserialization', cause);
   }
 }

package/src/core/plugin.ts

@@ -5,6 +5,7 @@ import type {
   StreamParsePluginContext,
   SyncParsePluginContext,
 } from './context/sync-parser';
+import type { SerovalNode } from './types';
 
 export const enum SerovalMode {
   Vanilla = 1,
@@ -15,7 +16,11 @@ export interface PluginData {
   id: number;
 }
 
-export interface Plugin<Value, Node> {
+export type PluginInfo = {
+  [key: string]: SerovalNode;
+};
+
+export interface Plugin<Value, Info extends PluginInfo> {
   /**
    * A unique string that helps idenfity the plugin
    */
@@ -37,35 +42,35 @@ export interface Plugin<Value, Node> {
       value: Value,
       ctx: SyncParsePluginContext,
       data: PluginData,
-    ) => Node;
+    ) => Info;
     async?: (
       value: Value,
       ctx: AsyncParsePluginContext,
       data: PluginData,
-    ) => Promise<Node>;
+    ) => Promise<Info>;
     stream?: (
       value: Value,
       ctx: StreamParsePluginContext,
       data: PluginData,
-    ) => Node;
+    ) => Info;
   };
   /**
    * Convert the parsed node into a JS string
    */
-  serialize(node: Node, ctx: SerializePluginContext, data: PluginData): string;
+  serialize(node: Info, ctx: SerializePluginContext, data: PluginData): string;
   /**
    * Convert the parsed node into its runtime equivalent.
    */
   deserialize(
-    node: Node,
+    node: Info,
     ctx: DeserializePluginContext,
     data: PluginData,
   ): Value;
 }
 
-export function createPlugin<Value, Node>(
-  plugin: Plugin<Value, Node>,
-): Plugin<Value, Node> {
+export function createPlugin<Value, Info extends PluginInfo>(
+  plugin: Plugin<Value, Info>,
+): Plugin<Value, Info> {
   return plugin;
 }
 

package/src/core/{utils/iterator-to-sequence.ts → sequence.ts}

@@ -1,17 +1,32 @@
-import { ITERATOR_CONSTRUCTOR } from '../constructors';
-import { SYM_ITERATOR } from '../symbols';
+import { ITERATOR_CONSTRUCTOR } from "./constructors";
+import { SYM_ITERATOR } from "./symbols";
 
 export interface Sequence {
+  __SEROVAL_SEQUENCE__: true;
+
   v: unknown[];
   t: number;
   d: number;
 }
 
-export function iteratorToSequence<T>(source: Iterable<T>): Sequence {
+export function isSequence(value: object): value is Sequence {
+  return '__SEROVAL_SEQUENCE__' in value;
+}
+
+export function createSequence(values: unknown[], throwAt: number, doneAt: number): Sequence {
+  return {
+    __SEROVAL_SEQUENCE__: true,
+
+    v: values,
+    t: throwAt,
+    d: doneAt,
+  };
+}
+
+export function createSequenceFromIterable<T>(source: Iterable<T>): Sequence {
   const values: unknown[] = [];
   let throwsAt = -1;
   let doneAt = -1;
-
   const iterator = source[SYM_ITERATOR]();
 
   while (true) {
@@ -28,11 +43,7 @@ export function iteratorToSequence<T>(source: Iterable<T>): Sequence {
     }
   }
 
-  return {
-    v: values,
-    t: throwsAt,
-    d: doneAt,
-  };
+  return createSequence(values, throwsAt, doneAt);
 }
 
 const createIterator = ITERATOR_CONSTRUCTOR(SYM_ITERATOR);

package/src/core/types.ts

@@ -261,7 +261,7 @@ export interface SerovalPluginNode extends SerovalBaseNode {
   t: SerovalNodeType.Plugin;
   i: number;
   // value
-  s: unknown;
+  s: Record<string, SerovalNode>;
   // tag name
   c: string;
 }
@@ -283,7 +283,7 @@ export interface SerovalIteratorFactoryNode extends SerovalBaseNode {
 
 export interface SerovalIteratorFactoryInstanceNode extends SerovalBaseNode {
   t: SerovalNodeType.IteratorFactoryInstance;
-  a: [instance: SerovalNodeWithID, sequence: SerovalNode];
+  a: [instance: SerovalNodeWithID, sequence: SerovalNodeWithID];
 }
 
 export interface SerovalAsyncIteratorFactoryNode extends SerovalBaseNode {
@@ -295,7 +295,7 @@ export interface SerovalAsyncIteratorFactoryNode extends SerovalBaseNode {
 export interface SerovalAsyncIteratorFactoryInstanceNode
   extends SerovalBaseNode {
   t: SerovalNodeType.AsyncIteratorFactoryInstance;
-  a: [instance: SerovalNodeWithID, sequence: SerovalNode];
+  a: [instance: SerovalNodeWithID, sequence: SerovalNodeWithID];
 }
 
 export interface SerovalStreamConstructorNode extends SerovalBaseNode {
@@ -327,6 +327,16 @@ export interface SerovalStreamReturnNode extends SerovalBaseNode {
   f: SerovalNode;
 }
 
+export interface SerovalSequenceNode extends SerovalBaseNode {
+  t: SerovalNodeType.Sequence;
+  i: number;
+  // Throw at
+  s: number;
+  a: SerovalNode[];
+  // Done at
+  l: number;
+}
+
 export type SerovalSyncNode =
   | SerovalPrimitiveNode
   | SerovalIndexedValueNode
@@ -349,7 +359,8 @@ export type SerovalSyncNode =
   | SerovalIteratorFactoryNode
   | SerovalIteratorFactoryInstanceNode
   | SerovalAsyncIteratorFactoryNode
-  | SerovalAsyncIteratorFactoryInstanceNode;
+  | SerovalAsyncIteratorFactoryInstanceNode
+  | SerovalSequenceNode;
 
 export type SerovalAsyncNode =
   | SerovalPromiseNode

package/dist/types/core/utils/iterator-to-sequence.d.ts

@@ -1,8 +0,0 @@
-export interface Sequence {
-    v: unknown[];
-    t: number;
-    d: number;
-}
-export declare function iteratorToSequence<T>(source: Iterable<T>): Sequence;
-export declare function sequenceToIterator<T>(sequence: Sequence): () => IterableIterator<T>;
-//# sourceMappingURL=iterator-to-sequence.d.ts.map

package/dist/types/core/utils/iterator-to-sequence.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"iterator-to-sequence.d.ts","sourceRoot":"","sources":["../../../../src/core/utils/iterator-to-sequence.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,QAAQ;IACvB,CAAC,EAAE,OAAO,EAAE,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,QAAQ,CA0BnE;AAID,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,QAAQ,EAAE,QAAQ,GACjB,MAAM,gBAAgB,CAAC,CAAC,CAAC,CAE3B"}