seroval 0.4.0-alpha.8 → 0.4.0

package/src/tree/shared.ts

@@ -1,10 +1,9 @@
-import assert from '../assert';
-import { constructorCheck } from '../checks';
 import { Feature } from '../compat';
-import { SerializationContext, ParserContext, markRef } from '../context';
-import quote from '../quote';
-import { ErrorValue, PrimitiveValue } from '../types';
-import { SerovalNode, SerovalReferenceNode, SerovalNodeType } from './types';
+import { ParserContext } from '../context';
+import {
+  AsyncServerValue,
+  ErrorValue,
+} from '../types';
 
 export function getErrorConstructor(error: ErrorValue) {
   if (error instanceof EvalError) {
@@ -29,6 +28,7 @@ export function getErrorConstructor(error: ErrorValue) {
 }
 
 export function getErrorOptions(
+  ctx: ParserContext,
   error: Error,
 ) {
   let options: Record<string, any> | undefined;
@@ -44,8 +44,15 @@ export function getErrorOptions(
   const names = Object.getOwnPropertyNames(error);
   for (const name of names) {
     if (name !== 'name' && name !== 'message') {
-      options = options || {};
-      options[name] = error[name as keyof Error];
+      if (name === 'stack') {
+        if (ctx.features & Feature.ErrorPrototypeStack) {
+          options = options || {};
+          options[name] = error[name as keyof Error];
+        }
+      } else {
+        options = options || {};
+        options[name] = error[name as keyof Error];
+      }
     }
   }
   return options;
@@ -63,115 +70,32 @@ export function getIterableOptions(obj: Iterable<any>) {
   return undefined;
 }
 
-export function isReferenceInStack(
-  ctx: SerializationContext,
-  node: SerovalNode,
-): node is SerovalReferenceNode {
-  return node[0] === SerovalNodeType.Reference && ctx.stack.includes(node[1]);
-}
-
-export function generateRef(
-  ctx: ParserContext,
-  current: unknown,
-): number | SerovalReferenceNode {
-  // Check if reference number already exists
-  const ref = ctx.refs.has(current);
-  if (ref) {
-    // Exists, means this value is currently
-    // being referenced
-    const refID = ctx.refs.get(current) || 0;
-    // Mark reference
-    markRef(ctx, refID);
-    return [SerovalNodeType.Reference, refID];
-  }
-  // Create a new reference ID
-  const id = ctx.refs.size;
-  ctx.refs.set(current, id);
-  return id;
-}
-
-export function generateSemiPrimitiveValue(
-  ctx: ParserContext,
-  current: unknown,
-  id: number,
-): SerovalNode | undefined {
-  if (typeof current === 'bigint') {
-    assert(ctx.features & Feature.BigInt, 'Unsupported type "BigInt"');
-    return [SerovalNodeType.BigInt, `${current}n`];
-  }
-  if (constructorCheck<Date>(current, Date)) {
-    return [SerovalNodeType.Date, current.toISOString(), id];
-  }
-  if (constructorCheck<RegExp>(current, RegExp)) {
-    return [SerovalNodeType.RegExp, String(current), id];
-  }
-  if (
-    constructorCheck<Int8Array>(current, Int8Array)
-    || constructorCheck<Int16Array>(current, Int16Array)
-    || constructorCheck<Int32Array>(current, Int32Array)
-    || constructorCheck<Uint8Array>(current, Uint8Array)
-    || constructorCheck<Uint16Array>(current, Uint16Array)
-    || constructorCheck<Uint32Array>(current, Uint32Array)
-    || constructorCheck<Uint8ClampedArray>(current, Uint8ClampedArray)
-    || constructorCheck<Float32Array>(current, Float32Array)
-    || constructorCheck<Float64Array>(current, Float64Array)
-  ) {
-    const constructor = current.constructor.name;
-    assert(ctx.features & Feature.TypedArray, `Unsupported value type "${constructor}"`);
-    return [SerovalNodeType.TypedArray, [constructor, current.toString(), current.byteOffset], id];
-  }
-  if (
-    constructorCheck<BigInt64Array>(current, BigInt64Array)
-    || constructorCheck<BigUint64Array>(current, BigUint64Array)
-  ) {
-    const constructor = current.constructor.name;
-    assert(
-      ctx.features & (Feature.BigIntTypedArray),
-      `Unsupported value type "${constructor}"`,
-    );
-    let result = '';
-    const cap = current.length - 1;
-    for (let i = 0; i < cap; i++) {
-      result += `${current[i]}n,`;
-    }
-    result += `"${current[cap]}"`;
-    return [
-      SerovalNodeType.BigIntTypedArray,
-      [constructor, result, current.byteOffset],
-      id,
-    ];
-  }
-  return undefined;
-}
-
-export function serializePrimitive(
-  value: PrimitiveValue,
-): string | number | null {
-  // Shortened forms
-  if (value === true) {
-    return '!0';
-  }
-  if (value === false) {
-    return '!1';
-  }
-  if (value === undefined) {
-    return 'void 0';
-  }
-  if (value === null) {
-    return null;
-  }
-  if (typeof value === 'string') {
-    return quote(value);
-  }
-  // negative 0 isn't the same as 0
-  if (Object.is(value, -0)) {
-    return '-0';
-  }
-  if (Object.is(value, Infinity)) {
-    return '1/0';
-  }
-  if (Object.is(value, -Infinity)) {
-    return '-1/0';
-  }
-  return value;
+export function isIterable(
+  value: unknown,
+): value is Iterable<AsyncServerValue> {
+  if (!value || typeof value !== 'object') {
+    return false;
+  }
+  if (Array.isArray(value)) {
+    return false;
+  }
+  switch (value.constructor) {
+    case Map:
+    case Set:
+    case Int8Array:
+    case Int16Array:
+    case Int32Array:
+    case Uint8Array:
+    case Uint16Array:
+    case Uint32Array:
+    case Uint8ClampedArray:
+    case Float32Array:
+    case Float64Array:
+    case BigInt64Array:
+    case BigUint64Array:
+      return false;
+    default:
+      break;
+  }
+  return Symbol.iterator in value;
 }