seroval 0.6.0 → 0.8.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "seroval",
   "type": "module",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "files": [
     "dist",
     "src"
@@ -15,12 +15,14 @@
   ],
   "devDependencies": {
     "@types/node": "^18.15.3",
-    "eslint": "^8.32.0",
-    "eslint-config-lxsmnsyc": "^0.5.1",
-    "pridepack": "2.4.1",
-    "tslib": "^2.4.1",
+    "@vitest/ui": "^0.30.1",
+    "eslint": "^8.39.0",
+    "eslint-config-lxsmnsyc": "^0.6.4",
+    "node-fetch-native": "^1.1.0",
+    "pridepack": "2.4.4",
+    "tslib": "^2.5.0",
     "typescript": "^4.9.4",
-    "vitest": "^0.28.1"
+    "vitest": "^0.30.1"
   },
   "scripts": {
     "prepublishOnly": "pridepack clean && pridepack build",
@@ -31,7 +33,8 @@
     "watch": "pridepack watch",
     "start": "pridepack start",
     "dev": "pridepack dev",
-    "test": "vitest"
+    "test": "vitest",
+    "test:ui": "vitest --ui"
   },
   "private": false,
   "description": "Stringify JS values",
@@ -64,5 +67,5 @@
   "typesVersions": {
     "*": {}
   },
-  "gitHead": "1d6e69079251612c6fc486e8517e225690363442"
+  "gitHead": "f7fe3305e0295499989d9f675ff54f9305db23b0"
 }

package/src/assert.ts

@@ -1,5 +1,5 @@
-export default function assert(cond: unknown, error: string): asserts cond {
+export default function assert(cond: unknown, error: Error): asserts cond {
   if (!cond) {
-    throw new Error(error);
+    throw error;
   }
 }

package/src/compat.ts

@@ -1,4 +1,3 @@
-/* eslint-disable guard-for-in */
 /**
  * References
  * - https://kangax.github.io/compat-table/es6/
@@ -22,4 +21,4 @@ export const enum Feature {
   WebAPI = 0x2000,
 }
 
-export const ALL_ENABLED = 0x2FFF;
+export const ALL_ENABLED = 0x3FFF;

package/src/context.ts

@@ -8,25 +8,33 @@ interface IndexAssignment {
   v: string;
 }
 
-interface MapAssignment {
-  t: 'map';
+interface SetAssignment {
+  t: 'set';
   s: string;
   k: string;
   v: string;
 }
 
-interface SetAssignment {
-  t: 'set';
+interface AddAssignment {
+  t: 'add';
   s: string;
   k: undefined;
   v: string;
 }
 
+interface AppendAssignment {
+  t: 'append';
+  s: string;
+  k: string;
+  v: string;
+}
+
 // Array of assignments to be done (used for recursion)
 export type Assignment =
   | IndexAssignment
-  | MapAssignment
-  | SetAssignment;
+  | AddAssignment
+  | SetAssignment
+  | AppendAssignment;
 
 export interface ParserContext {
   refs: Map<unknown, number>;
@@ -37,12 +45,12 @@ export interface ParserContext {
 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
@@ -61,7 +69,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(),
@@ -90,14 +98,17 @@ export function createSerializationContext(options: SerializationOptions): Seria
 /**
  * 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
@@ -120,7 +131,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;
@@ -131,7 +142,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

@@ -0,0 +1,53 @@
+export function serializeChar(str: string): string | undefined {
+  switch (str) {
+    case '"': return '\\"';
+    case '\\': return '\\\\';
+    case '\n': return '\\n';
+    case '\r': return '\\r';
+    case '\b': return '\\b';
+    case '\t': return '\\t';
+    case '\f': return '\\f';
+    case '<': return '\\x3C';
+    case '\u2028': return '\\u2028';
+    case '\u2029': return '\\u2029';
+    default: return undefined;
+  }
+}
+
+// Written by https://github.com/DylanPiercey and is distributed under the MIT license.
+// Creates a JavaScript double quoted string and escapes all characters
+// 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): string {
+  let result = '';
+  let lastPos = 0;
+  let replacement: string | undefined;
+  for (let i = 0, len = str.length; i < len; i++) {
+    replacement = serializeChar(str[i]);
+    if (replacement) {
+      result += str.slice(lastPos, i) + replacement;
+      lastPos = i + 1;
+    }
+  }
+  if (lastPos === 0) {
+    result = str;
+  } else {
+    result += str.slice(lastPos);
+  }
+  return result;
+}
+
+export function deserializeString(str: string): string {
+  return str
+    .replace(/\\"/g, '"')
+    .replace(/\\\\/g, '\\')
+    .replace(/\\n/g, '\n')
+    .replace(/\\r/g, '\r')
+    .replace(/\\b/g, '\b')
+    .replace(/\\t/g, '\t')
+    .replace(/\\f/g, '\f')
+    .replace(/\\x3C/g, '<')
+    .replace(/\\u2028/g, '\u2028')
+    .replace(/\\u2029/g, '\u2029');
+}

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) + '"');
+  }
+}