Merge pull request #69 from lxsmnsyc/feat-sequence

feat: `Sequence`

Author: lxsmnsyc

.changeset/sour-frogs-rush.md

@@ -0,0 +1,5 @@
+---
+"seroval": minor
+---
+
+feat: sequence node

packages/seroval/src/core/base-primitives.ts

@@ -29,6 +29,7 @@ import type {
   SerovalPluginNode,
   SerovalReferenceNode,
   SerovalRegExpNode,
+  SerovalSequenceNode,
   SerovalSetNode,
   SerovalStreamConstructorNode,
   SerovalStreamNextNode,
@@ -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,
+  );
+}

packages/seroval/src/core/constants.ts

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

packages/seroval/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;

packages/seroval/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(

packages/seroval/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,15 +58,14 @@ import type {
   SerovalPromiseResolveNode,
   SerovalReferenceNode,
   SerovalRegExpNode,
+  SerovalSequenceNode,
   SerovalSetNode,
   SerovalStreamConstructorNode,
   SerovalStreamNextNode,
   SerovalStreamReturnNode,
   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);
   }

packages/seroval/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);
   }