seroval 0.8.0 → 0.10.1

package/src/core/literals.ts

@@ -0,0 +1,28 @@
+import { SerovalConstant, SerovalNodeType } from './constants';
+import type { SerovalConstantNode } from './types';
+
+function createConstantNode(value: SerovalConstant): SerovalConstantNode {
+  return {
+    t: SerovalNodeType.Constant,
+    i: undefined,
+    s: value,
+    l: undefined,
+    c: undefined,
+    m: undefined,
+    p: undefined,
+    e: undefined,
+    a: undefined,
+    f: undefined,
+    b: undefined,
+    o: undefined,
+  };
+}
+
+export const TRUE_NODE = createConstantNode(SerovalConstant.True);
+export const FALSE_NODE = createConstantNode(SerovalConstant.False);
+export const UNDEFINED_NODE = createConstantNode(SerovalConstant.Undefined);
+export const NULL_NODE = createConstantNode(SerovalConstant.Null);
+export const NEG_ZERO_NODE = createConstantNode(SerovalConstant.NegativeZero);
+export const INFINITY_NODE = createConstantNode(SerovalConstant.Infinity);
+export const NEG_INFINITY_NODE = createConstantNode(SerovalConstant.NegativeInfinity);
+export const NAN_NODE = createConstantNode(SerovalConstant.NaN);

package/src/core/promise-to-result.ts

@@ -0,0 +1,9 @@
+export default async function promiseToResult(
+  current: Promise<unknown>,
+): Promise<[0 | 1, unknown]> {
+  try {
+    return [1, await current];
+  } catch (e) {
+    return [0, e];
+  }
+}

package/src/{tree → core}/reference.ts

@@ -1,6 +1,6 @@
-/* eslint-disable @typescript-eslint/no-unnecessary-condition */
 /* eslint-disable no-restricted-globals */
-import assert from '../assert';
+import assert from './assert';
+import { REFERENCES_KEY } from './keys';
 
 const REFERENCE = new Map<unknown, string>();
 const INV_REFERENCE = new Map<string, unknown>();
@@ -29,31 +29,29 @@ export function getReference<T>(id: string): T {
   return INV_REFERENCE.get(id) as T;
 }
 
-export const GLOBAL_KEY = '__SEROVAL__';
-
 if (typeof globalThis !== undefined) {
-  Object.defineProperty(globalThis, GLOBAL_KEY, {
+  Object.defineProperty(globalThis, REFERENCES_KEY, {
     value: INV_REFERENCE,
     configurable: true,
     writable: false,
     enumerable: false,
   });
 } else if (typeof window !== undefined) {
-  Object.defineProperty(window, GLOBAL_KEY, {
+  Object.defineProperty(window, REFERENCES_KEY, {
     value: INV_REFERENCE,
     configurable: true,
     writable: false,
     enumerable: false,
   });
 } else if (typeof self !== undefined) {
-  Object.defineProperty(self, GLOBAL_KEY, {
+  Object.defineProperty(self, REFERENCES_KEY, {
     value: INV_REFERENCE,
     configurable: true,
     writable: false,
     enumerable: false,
   });
 } else if (typeof global !== undefined) {
-  Object.defineProperty(global, GLOBAL_KEY, {
+  Object.defineProperty(global, REFERENCES_KEY, {
     value: INV_REFERENCE,
     configurable: true,
     writable: false,

package/src/{tree → core}/shared.ts

@@ -1,8 +1,9 @@
-import { Feature } from '../compat';
-import type { ParserContext } from '../context';
+import { Feature } from './compat';
 import type {
   ErrorValue,
 } from '../types';
+import { SerovalObjectFlags } from './constants';
+import type { BaseParserContext } from './context';
 
 export function getErrorConstructorName(error: ErrorValue): string {
   if (error instanceof EvalError) {
@@ -50,7 +51,7 @@ export function getErrorConstructor(errorName: string): ErrorConstructors {
 }
 
 export function getErrorOptions(
-  ctx: ParserContext,
+  ctx: BaseParserContext,
   error: Error,
 ): Record<string, unknown> | undefined {
   let options: Record<string, unknown> | undefined;
@@ -152,3 +153,16 @@ export function isValidIdentifier(name: string): boolean {
     || (char >= 'a' && char <= 'z')
   ) && IDENTIFIER_CHECK.test(name);
 }
+
+export function getObjectFlag(obj: unknown): SerovalObjectFlags {
+  if (Object.isFrozen(obj)) {
+    return SerovalObjectFlags.Frozen;
+  }
+  if (Object.isSealed(obj)) {
+    return SerovalObjectFlags.Sealed;
+  }
+  if (Object.isExtensible(obj)) {
+    return SerovalObjectFlags.None;
+  }
+  return SerovalObjectFlags.NonExtensible;
+}

package/src/{tree → core/tree}/async.ts

@@ -2,43 +2,36 @@
 /* eslint-disable @typescript-eslint/no-use-before-define */
 import assert from '../assert';
 import { Feature } from '../compat';
-import type { ParserContext } from '../context';
+import type { ParserContext } from './context';
 import {
   createIndexedValue,
-} from '../context';
+} from './context';
 import { serializeString } from '../string';
 import type {
   BigIntTypedArrayValue,
   TypedArrayValue,
-} from '../types';
-import UnsupportedTypeError from './UnsupportedTypeError';
+} from '../../types';
+import UnsupportedTypeError from '../UnsupportedTypeError';
 import {
   TRUE_NODE,
   FALSE_NODE,
   UNDEFINED_NODE,
   NULL_NODE,
-} from './constants';
+} from '../literals';
 import {
-  createBigIntNode,
   createBigIntTypedArrayNode,
-  createDateNode,
-  createNumberNode,
-  createIndexedValueNode,
-  createRegExpNode,
-  createStringNode,
   createTypedArrayNode,
-  createReferenceNode,
-  createArrayBufferNode,
   createDataViewNode,
   createSymbolNode,
   createFunctionNode,
 } from './primitives';
-import { hasReferenceID } from './reference';
+import { hasReferenceID } from '../reference';
 import {
   getErrorConstructorName,
   getErrorOptions,
+  getObjectFlag,
   isIterable,
-} from './shared';
+} from '../shared';
 import type {
   SerovalAggregateErrorNode,
   SerovalArrayNode,
@@ -55,17 +48,27 @@ import type {
   SerovalPlainRecordNode,
   SerovalPromiseNode,
   SerovalSetNode,
-} from './types';
+} from '../types';
 import {
-  SerovalNodeType,
   SerovalObjectRecordSpecialKey,
-} from './types';
+} from '../types';
 import {
   createBlobNode,
   createFileNode,
-  createURLNode,
-  createURLSearchParamsNode,
 } from './web-api';
+import { SerovalNodeType } from '../constants';
+import {
+  createArrayBufferNode,
+  createBigIntNode,
+  createDateNode,
+  createIndexedValueNode,
+  createNumberNode,
+  createReferenceNode,
+  createRegExpNode,
+  createStringNode,
+} from '../base-primitives';
+import { createURLNode, createURLSearchParamsNode } from '../web-api';
+import promiseToResult from '../promise-to-result';
 
 type ObjectLikeNode =
   | SerovalObjectNode
@@ -110,10 +113,12 @@ async function generateArrayNode(
     l: current.length,
     c: undefined,
     m: undefined,
-    d: undefined,
+    p: undefined,
+    e: undefined,
     a: await generateNodeList(ctx, current),
     f: undefined,
     b: undefined,
+    o: getObjectFlag(current),
   };
 }
 
@@ -153,10 +158,12 @@ async function generateMapNode(
     l: undefined,
     c: undefined,
     m: undefined,
-    d: { k: keyNodes, v: valueNodes, s: len },
+    p: undefined,
+    e: { k: keyNodes, v: valueNodes, s: len },
     a: undefined,
     f: undefined,
     b: undefined,
+    o: undefined,
   };
 }
 
@@ -190,10 +197,12 @@ async function generateSetNode(
     l: len,
     c: undefined,
     m: undefined,
-    d: undefined,
+    p: undefined,
+    e: undefined,
     a: nodes,
     f: undefined,
     b: undefined,
+    o: undefined,
   };
 }
 
@@ -291,18 +300,20 @@ async function generatePromiseNode(
   current: Promise<unknown>,
 ): Promise<SerovalPromiseNode> {
   assert(ctx.features & Feature.Promise, new UnsupportedTypeError(current));
+  const [status, result] = await promiseToResult(current);
   return {
     t: SerovalNodeType.Promise,
     i: id,
-    s: undefined,
+    s: status,
     l: undefined,
     c: undefined,
     m: undefined,
-    // Parse options first before the items
-    d: undefined,
+    p: undefined,
+    e: undefined,
     a: undefined,
-    f: await parseAsync(ctx, await current),
+    f: await parseAsync(ctx, result),
     b: undefined,
+    o: undefined,
   };
 }
 
@@ -319,10 +330,12 @@ async function generateObjectNode(
     l: undefined,
     c: undefined,
     m: undefined,
-    d: await generateProperties(ctx, current),
+    p: await generateProperties(ctx, current),
+    e: undefined,
     a: undefined,
     f: undefined,
     b: undefined,
+    o: getObjectFlag(current),
   };
 }
 
@@ -342,10 +355,12 @@ async function generateAggregateErrorNode(
     l: undefined,
     c: undefined,
     m: serializeString(current.message),
-    d: optionsNode,
+    p: optionsNode,
+    e: undefined,
     a: undefined,
     f: undefined,
     b: undefined,
+    o: undefined,
   };
 }
 
@@ -365,10 +380,12 @@ async function generateErrorNode(
     l: undefined,
     c: getErrorConstructorName(current),
     m: serializeString(current.message),
-    d: optionsNode,
+    p: optionsNode,
+    e: undefined,
     a: undefined,
     f: undefined,
     b: undefined,
+    o: undefined,
   };
 }
 
@@ -389,10 +406,12 @@ async function generateHeadersNode(
     l: undefined,
     c: undefined,
     m: undefined,
-    d: await generatePlainProperties(ctx, items),
+    p: undefined,
+    e: await generatePlainProperties(ctx, items),
     a: undefined,
     f: undefined,
     b: undefined,
+    o: undefined,
   };
 }
 
@@ -413,10 +432,12 @@ async function generateFormDataNode(
     l: undefined,
     c: undefined,
     m: undefined,
-    d: await generatePlainProperties(ctx, items),
+    p: undefined,
+    e: await generatePlainProperties(ctx, items),
     a: undefined,
     f: undefined,
     b: undefined,
+    o: undefined,
   };
 }
 
@@ -432,10 +453,12 @@ async function generateBoxedNode(
     l: undefined,
     c: undefined,
     m: undefined,
-    d: undefined,
+    p: undefined,
+    e: undefined,
     a: undefined,
     f: await parseAsync(ctx, current.valueOf()),
     b: undefined,
+    o: undefined,
   };
 }
 
@@ -449,7 +472,7 @@ async function parseObject(
   // Non-primitive values needs a reference ID
   // mostly because the values themselves are stateful
   const id = createIndexedValue(ctx, current);
-  if (ctx.markedRefs.has(id)) {
+  if (ctx.reference.marked.has(id)) {
     return createIndexedValueNode(id);
   }
   if (hasReferenceID(current)) {

package/src/core/tree/context.ts

@@ -0,0 +1,136 @@
+import { ALL_ENABLED } from '../compat';
+import type { BaseParserContext, BaseSerializerContext } from '../context';
+import getIdentifier from '../get-identifier';
+
+export interface ParserReference {
+  ids: Map<unknown, number>;
+  marked: Set<number>;
+}
+
+export interface ParserContext extends BaseParserContext {
+  reference: ParserReference;
+}
+
+export interface ParserOptions {
+  disabledFeatures: number;
+}
+
+export function createParserContext(options: Partial<ParserOptions> = {}): ParserContext {
+  return {
+    reference: {
+      ids: new Map(),
+      marked: new Set(),
+    },
+    features: ALL_ENABLED ^ (options.disabledFeatures || 0),
+  };
+}
+
+export interface SerializerReference {
+  size: number;
+  // Map tree refs to actual refs
+  valid: (number | undefined)[];
+  // Refs that are...referenced
+  marked: Set<number>;
+}
+
+export interface SerializerContext extends BaseSerializerContext {
+  reference: SerializerReference;
+  // Variables
+  vars: (string | undefined)[];
+}
+
+export interface SerializerOptions {
+  markedRefs: number[] | Set<number>;
+  features: number;
+}
+
+export function createSerializerContext(options: SerializerOptions): SerializerContext {
+  return {
+    stack: [],
+    vars: [],
+    assignments: [],
+    reference: {
+      valid: [],
+      size: 0,
+      marked: new Set(options.markedRefs),
+    },
+    features: options.features,
+    flags: [],
+  };
+}
+
+/**
+ * Increments the number of references the referenced value has
+ */
+export function markRef(
+  ctx: ParserContext | SerializerContext,
+  current: number,
+): void {
+  ctx.reference.marked.add(current);
+}
+/**
+ * Creates the reference param (identifier) from the given reference ID
+ * Calling this function means the value has been referenced somewhere
+ */
+export function getRefParam(ctx: SerializerContext, index: number): string {
+  /**
+   * Creates a new reference ID from a given reference ID
+   * This new reference ID means that the reference itself
+   * has been referenced at least once, and is used to generate
+   * the variables
+   */
+  let actualIndex = ctx.reference.valid[index];
+  if (actualIndex == null) {
+    actualIndex = ctx.reference.size++;
+    ctx.reference.valid[index] = actualIndex;
+  }
+  let identifier = ctx.vars[actualIndex];
+  if (identifier == null) {
+    identifier = getIdentifier(actualIndex);
+    ctx.vars[actualIndex] = identifier;
+  }
+  return identifier;
+}
+
+export function getRootID<T>(
+  ctx: ParserContext,
+  current: T,
+): number {
+  const ref = ctx.reference.ids.get(current);
+  if (ref == null) {
+    return ctx.reference.ids.size;
+  }
+  return ref;
+}
+
+export function createIndexedValue<T>(
+  ctx: ParserContext,
+  current: T,
+): number {
+  const ref = ctx.reference.ids.get(current);
+  if (ref == null) {
+    const id = ctx.reference.ids.size;
+    ctx.reference.ids.set(current, id);
+    return id;
+  }
+  markRef(ctx, ref);
+  return ref;
+}
+
+export interface DeserializerContext {
+  values: Map<number, unknown>;
+  refs: Set<number>;
+}
+
+export interface DeserializerOptions {
+  markedRefs: number[] | Set<number>;
+}
+
+export function createDeserializerContext(
+  options: DeserializerOptions,
+): DeserializerContext {
+  return {
+    values: new Map(),
+    refs: new Set(options.markedRefs),
+  };
+}