seroval 0.7.0 → 0.9.0

package/src/context.ts

@@ -1,5 +1,6 @@
 import { ALL_ENABLED } from './compat';
 import getIdentifier from './get-identifier';
+import type { SerovalObjectFlags } from './tree/types';
 
 interface IndexAssignment {
   t: 'index';
@@ -42,21 +43,29 @@ export interface ParserContext {
   features: number;
 }
 
+export interface FlaggedObject {
+  type: SerovalObjectFlags;
+  value: string;
+}
+
 export interface SerializationContext {
   stack: number[];
   // Map tree refs to actual refs
-  validRefs: number[];
+  validRefs: (number | undefined)[];
   refSize: number;
   // Refs that are...referenced
   markedRefs: Set<number>;
   // Variables
-  vars: string[];
+  vars: (string | undefined)[];
   // Array of assignments to be done (used for recursion)
   assignments: Assignment[];
   // Supported features
   features: number;
 
   valueMap: Map<number, unknown>;
+
+  // Object flags
+  flags: FlaggedObject[];
 }
 
 export interface Options {
@@ -69,7 +78,7 @@ const DEFAULT_OPTIONS: Options = {
 
 export function createParserContext(options: Partial<Options> = {}): ParserContext {
   // eslint-disable-next-line prefer-object-spread
-  const result = Object.assign({}, DEFAULT_OPTIONS, options || {});
+  const result = Object.assign({}, DEFAULT_OPTIONS, options);
   return {
     markedRefs: new Set(),
     refs: new Map(),
@@ -92,20 +101,24 @@ export function createSerializationContext(options: SerializationOptions): Seria
     features: options.features,
     markedRefs: new Set(options.markedRefs),
     valueMap: new Map(),
+    flags: [],
   };
 }
 
 /**
  * Increments the number of references the referenced value has
  */
-export function markRef(ctx: ParserContext | SerializationContext, current: number) {
+export function markRef(
+  ctx: ParserContext | SerializationContext,
+  current: number,
+): void {
   ctx.markedRefs.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: SerializationContext, index: number) {
+export function getRefParam(ctx: SerializationContext, index: number): string {
   /**
    * Creates a new reference ID from a given reference ID
    * This new reference ID means that the reference itself
@@ -128,7 +141,7 @@ export function getRefParam(ctx: SerializationContext, index: number) {
 export function getRootID<T>(
   ctx: ParserContext,
   current: T,
-) {
+): number {
   const ref = ctx.refs.get(current);
   if (ref == null) {
     return ctx.refs.size;
@@ -139,7 +152,7 @@ export function getRootID<T>(
 export function createIndexedValue<T>(
   ctx: ParserContext,
   current: T,
-) {
+): number {
   const ref = ctx.refs.get(current);
   if (ref == null) {
     const id = ctx.refs.size;

package/src/get-identifier.ts

@@ -4,7 +4,7 @@ const REF_START_CHARS_LEN = REF_START_CHARS.length;
 const REF_CHARS = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789$_';
 const REF_CHARS_LEN = REF_CHARS.length;
 
-export default function getIdentifier(index: number) {
+export default function getIdentifier(index: number): string {
   let mod = index % REF_START_CHARS_LEN;
   let ref = REF_START_CHARS[mod];
   index = (index - mod) / REF_START_CHARS_LEN;

package/src/index.ts

@@ -1,19 +1,23 @@
 /* eslint-disable no-await-in-loop */
 import { Feature } from './compat';
-import {
+import type {
   SerializationContext,
-  getRefParam,
   Options,
+} from './context';
+import {
+  getRefParam,
   createParserContext,
   createSerializationContext,
+  getRootID,
 } from './context';
+import parseSync from './tree/sync';
 import parseAsync from './tree/async';
 import deserializeTree from './tree/deserialize';
 import serializeTree, { resolvePatches } from './tree/serialize';
-import parseSync from './tree/sync';
-import { SerovalNode } from './tree/types';
+import type { SerovalNode } from './tree/types';
+import { SerovalNodeType } from './tree/types';
 
-export {
+export type {
   AsyncServerValue,
   ServerValue,
   PrimitiveValue,
@@ -28,7 +32,7 @@ function finalize(
   rootID: number,
   isObject: boolean,
   result: string,
-) {
+): string {
   // Shared references detected
   if (ctx.vars.length) {
     const patches = resolvePatches(ctx);
@@ -62,23 +66,33 @@ function finalize(
 export function serialize<T>(
   source: T,
   options?: Partial<Options>,
-) {
+): string {
   const ctx = createParserContext(options);
-  const [tree, rootID, isObject] = parseSync(ctx, source);
+  const tree = parseSync(ctx, source);
   const serial = createSerializationContext(ctx);
   const result = serializeTree(serial, tree);
-  return finalize(serial, rootID, isObject, result);
+  return finalize(
+    serial,
+    getRootID(ctx, source),
+    tree.t === SerovalNodeType.Object,
+    result,
+  );
 }
 
 export async function serializeAsync<T>(
   source: T,
   options?: Partial<Options>,
-) {
+): Promise<string> {
   const ctx = createParserContext(options);
-  const [tree, rootID, isObject] = await parseAsync(ctx, source);
+  const tree = await parseAsync(ctx, source);
   const serial = createSerializationContext(ctx);
   const result = serializeTree(serial, tree);
-  return finalize(serial, rootID, isObject, result);
+  return finalize(
+    serial,
+    getRootID(ctx, source),
+    tree.t === SerovalNodeType.Object,
+    result,
+  );
 }
 
 export function deserialize<T>(source: string): T {
@@ -87,11 +101,10 @@ export function deserialize<T>(source: string): T {
 }
 
 export interface SerovalJSON {
-  t: SerovalNode,
-  r: number,
-  i: boolean,
-  f: number,
-  m: number[],
+  t: SerovalNode;
+  r: number;
+  f: number;
+  m: number[];
 }
 
 export function toJSON<T>(
@@ -99,11 +112,9 @@ export function toJSON<T>(
   options?: Partial<Options>,
 ): SerovalJSON {
   const ctx = createParserContext(options);
-  const [tree, root, isObject] = parseSync(ctx, source);
   return {
-    t: tree,
-    r: root,
-    i: isObject,
+    t: parseSync(ctx, source),
+    r: getRootID(ctx, source),
     f: ctx.features,
     m: Array.from(ctx.markedRefs),
   };
@@ -114,11 +125,9 @@ export async function toJSONAsync<T>(
   options?: Partial<Options>,
 ): Promise<SerovalJSON> {
   const ctx = createParserContext(options);
-  const [tree, root, isObject] = await parseAsync(ctx, source);
   return {
-    t: tree,
-    r: root,
-    i: isObject,
+    t: await parseAsync(ctx, source),
+    r: getRootID(ctx, source),
     f: ctx.features,
     m: Array.from(ctx.markedRefs),
   };
@@ -130,7 +139,7 @@ export function compileJSON(source: SerovalJSON): string {
     markedRefs: source.m,
   });
   const result = serializeTree(serial, source.t);
-  return finalize(serial, source.r, source.i, result);
+  return finalize(serial, source.r, source.t.i === SerovalNodeType.Object, result);
 }
 
 export function fromJSON<T>(source: SerovalJSON): T {

package/src/string.ts

@@ -1,4 +1,4 @@
-export function serializeChar(str: string) {
+export function serializeChar(str: string): string | undefined {
   switch (str) {
     case '"': return '\\"';
     case '\\': return '\\\\';
@@ -19,7 +19,7 @@ export function serializeChar(str: string) {
 // not listed as DoubleStringCharacters on
 // Also includes "<" to escape "</script>" and "\" to avoid invalid escapes in the output.
 // http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.4
-export function serializeString(str: string) {
+export function serializeString(str: string): string {
   let result = '';
   let lastPos = 0;
   let replacement: string | undefined;

package/src/tree/UnsupportedTypeError.ts

@@ -0,0 +1,8 @@
+// eslint-disable-next-line @typescript-eslint/unbound-method
+const { toString } = Object.prototype;
+
+export default class UnsupportedTypeError extends Error {
+  constructor(value: unknown) {
+    super('Unsupported type "' + toString.call(value) + '"');
+  }
+}