resurrect-esm 2.0.6 → 2.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "resurrect-esm",
-    "version": "2.0.6",
+    "version": "2.0.7",
     "type": "module",
     "description": "ResurrectJS preserves object behavior (prototypes) and reference circularity with a special JSON encoding. Unlike flat JSON, it can also properly resurrect self-referential objects, objects with shared structure, Dates, RegExps, HTMLElements, NaN, Infinity, undefined (which won't get turned into null), and any other custom object type given the proper resolver.",
     "repository": {
@@ -26,15 +26,14 @@
     },
     "homepage": "https://github.com/dragoncoder047/resurrect-esm#readme",
     "devDependencies": {
-        "@happy-dom/global-registrator": "^20.6.1",
-        "@types/bun": "^1.3.9",
-        "bun": "^1.3.9",
-        "esbuild": "^0.25.0",
-        "typescript": "^5.6.2"
+        "@happy-dom/global-registrator": "^20.10.5",
+        "@types/bun": "^1.3.14",
+        "bun": "^1.3.14",
+        "typescript": "^5.9.3"
     },
     "main": "resurrect.ts",
     "scripts": {
-        "build": "pnpm esbuild --sourcemap --platform=browser --target=esnext --format=esm resurrect.ts --outfile=resurrect.js",
+        "build": "pnpm bun build --sourcemap --target=browser --format=esm resurrect.ts --outfile=resurrect.js",
         "test": "pnpm bun test",
         "test:watch": "pnpm test --watch",
         "prepare": "pnpm build --minify"

package/resurrect.test.ts

@@ -4,7 +4,11 @@ import { FakeNode, NamespaceResolver, Resurrect, ResurrectError, ResurrectOption
 
 GlobalRegistrator.register();
 
-function suite(opt?: ResurrectOptions) {
+describe.each([
+    ["default options", {}],
+    ["custom prefix", { prefix: "qwerty" }],
+    ["no revive", { revive: false }]
+])("%s", (_, opt: ResurrectOptions) => {
 
     const defOpts = new Resurrect(opt);
 
@@ -20,8 +24,8 @@ function suite(opt?: ResurrectOptions) {
         expect(roundtrip(undefined)).toBeUndefined();
         expect(roundtrip("foo")).toBe("foo");
         expect(roundtrip(NaN)).toBeNaN();
-        expect(roundtrip(Infinity)).toBeGreaterThan(Number.MAX_VALUE);
-        expect(roundtrip(-Infinity)).toBeLessThan(Number.MIN_VALUE);
+        expect(roundtrip(Infinity)).toEqual(Infinity);
+        expect(roundtrip(-Infinity)).toEqual(-Infinity);
     });
 
     test("basic JSON serialization", () => {
@@ -121,21 +125,18 @@ function suite(opt?: ResurrectOptions) {
         test("no revive preserves own properties but not functionality", () => {
             class Dog {
                 constructor(public loudness: number, public sound: string) { }
-                woof() { return this.sound.repeat(this.loudness) + "!"; }
+                woof() { }
             }
             const obj = new Dog(3, "wow");
             const roundtripped = roundtrip(obj, {
                 resolver: new NamespaceResolver({ Dog }),
             });
             expect(roundtripped).not.toBeInstanceOf(Dog);
+            expect(roundtripped).toEqual({ loudness: 3, sound: "wow" } as Dog);
             expect(roundtripped.woof).toBeUndefined();
         });
     }
-}
-
-describe("default options", () => suite());
-describe("custom prefix", () => suite({ prefix: "qwerty" }));
-describe("no revive", () => suite({ revive: false }));
+});
 
 test("malformed state bug", () => {
     // Test for the bug found in skeeto/resurrect-js#11

package/resurrect.ts

@@ -1,10 +1,12 @@
 /**
  * resurrect-esm, a fork of resurrect-ts, which is in turn a fork of resurrect.js
- * @version 2.0.6
+ * @version 2.0.7
  * @license CC0
  * @see http://nullprogram.com/blog/2013/03/28/
  */
 
+import { isArray } from "lib0/array";
+import { isNumber, isString } from "lib0/function";
 import { parse, stringify } from "lib0/json";
 import { keys } from "lib0/object";
 
@@ -26,26 +28,23 @@ const GLOBAL: typeof globalThis = globalThis ?? (0, eval)("this");
  */
 const escapeRegExp = RegExp.escape ?? ((string: string) => string.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"));
 
-function is(type: string) {
+const is = (type: string) => {
     const string = `[object ${type}]`;
     return (obj: any) => {
         return {}.toString.call(obj) === string;
     };
 }
 
-const isArray = is("Array") as (obj: any) => obj is any[];
-const isString = is("String") as (obj: any) => obj is string;
 const isBoolean = is("Boolean") as (obj: any) => obj is boolean;
-const isNumber = is("Number") as (obj: any) => obj is number;
 const isFunction = is("Function") as (obj: any) => obj is Function;
 const isDate = is("Date") as (obj: any) => obj is Date;
 const isURL = is("URL") as (obj: any) => obj is URL;
 const isRegExp = is("RegExp") as (obj: any) => obj is RegExp;
 const isObject = is("Object") as (obj: any) => obj is object;
-function isAtom(object: any) {
+const isAtom = (object: any) => {
     return !isObject(object) && !isArray(object);
 }
-function isPrimitive(object: any) {
+const isPrimitive = (object: any) => {
     return object == null ||
         isNumber(object) ||
         isString(object) ||
@@ -109,7 +108,7 @@ export class Resurrect {
     /**
      * Put a temporary identifier on an object and store it in the table.
      */
-    #tagObject(object: any): number {
+    #tagObject(object: any) {
         if (this.revive) {
             const constructor = this.resolver.getName(object);
             if (constructor) {
@@ -132,7 +131,7 @@ export class Resurrect {
      * Create a builder object (encoding) for serialization.
      * @param value The value to pass to the constructor.
      */
-    #createBuilderObject(name: string, value: any): object {
+    #createBuilderObject(name: string, value: any) {
         return {
             [this.#buildcode]: name,
             [this.#valuecode]: value
@@ -144,7 +143,7 @@ export class Resurrect {
      * @see http://stackoverflow.com/a/14378462
      * @see http://nullprogram.com/blog/2013/03/24/
      */
-    #buildFromEncoding(ref: any): any {
+    #buildFromEncoding(ref: any) {
         const type = this.resolver.getConstructor(ref[this.#buildcode]);
         /* Brilliant hack by kybernetikos: */
         const result: any = new (type.bind.apply(type, [null].concat(ref[this.#valuecode]) as [any, any[]]))();
@@ -159,7 +158,7 @@ export class Resurrect {
      * Dereference or build an object or value from an encoding.
      * @method
      */
-    #decodeReference(ref: object): object | undefined {
+    #decodeReference(ref: object) {
         if (this.#backrefcode in ref) {
             return this.#dereference(ref);
         } else if (this.#buildcode in ref) {
@@ -181,7 +180,7 @@ export class Resurrect {
      * Visit root and all its ancestors, visiting atoms with f.
      * @returns A fresh copy of root to be serialized.
      */
-    #visit(root: any, transform: (obj: any) => any, replacer?: (k: string, v: any) => any): any {
+    #visit(root: any, transform: (obj: any) => any, replacer?: (k: string, v: any) => any) {
         if (isAtom(root)) {
             return transform(root);
         } else if (!this.#isTagged(root)) {
@@ -218,7 +217,7 @@ export class Resurrect {
      * Manage special atom values, possibly returning an encoding.
      */
     #encodeAtom(atom: any): any {
-        const Node = GLOBAL.Node || function () { };
+        const Node = GLOBAL.Node || class { };
         if (isFunction(atom)) {
             throw new ResurrectError("Can't serialize functions.");
         } else if (atom instanceof Node) {