resurrect-esm 2.0.2 → 2.0.4

package/.github/workflows/publish.yml

@@ -1,8 +1,5 @@
 name: Publish Package
-on:
-  push:
-    tags:
-      - 'v*'
+on: workflow_dispatch
 permissions:
   id-token: write  # Required for OIDC
   contents: read
@@ -11,15 +8,14 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: "24"
-          registry-url: https://registry.npmjs.org
       - uses: pnpm/action-setup@v4
         with:
           version: 10
-          cache: on
-          install: yes
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          cache: pnpm
+      - run: pnpm install
       - run: pnpm test
       - run: pnpm prepare
       - run: npm publish

package/.vscode/settings.json

@@ -1,6 +1,7 @@
 {
     "cSpell.words": [
         "kybernetikos",
-        "registrator"
+        "registrator",
+        "skeeto"
     ]
 }

package/README.md

@@ -9,12 +9,14 @@ An ES6 module port of ResurrectTS.
 > * ResurrectError is now a top-level export, instead of living inside a Resurrect object.
 > * NamespaceResolver is now a top-level export, instead of living inside the Resurrect static constructor namespace.
 > * NamespaceResolver now has a new method, `getConstructor(name: string)`, which should return the constructor function to generate the object (it will not be called directly, so the parameters are irrelevant).
+> * The bug found in skeeto/resurrect-js#11 has been fixed.
 
 ResurrectJS preserves object behavior (prototypes) and reference
 circularity with a special JSON encoding. Unlike flat JSON, it can
 also properly resurrect these types of values:
 
  * Date
+ * URL
  * RegExp
  * `undefined`
  * NaN, Infinity, -Infinity
@@ -120,7 +122,7 @@ unwrapped. This means extra properties added to these objects will not
 be preserved.
 
 Functions cannot ever be serialized. Resurrect will throw an error if
-a function is found when traversing a data structure.
+a function is found when traversing a data structure, rather than just silently dropping the property or replacing it with `null` like JSON.stringify does.
 
 ### Custom Resolvers
 
@@ -131,9 +133,13 @@ the Foo constructor in this example,
 ```ts
 import { Resurrect, NamespaceResolver } from "resurrect-esm";
 const namespace = {
-    Foo: class {
+    Foo: class Foo {
         constructor() {
             this.bar = true;
+            Foo.bax(this);
+        }
+        static bax(obj) {
+
         }
     }
 };
@@ -148,6 +154,9 @@ find the name of the constructor in the namespace when given the
 constructor. Keep in mind that using this form will bind the variable
 Foo to the surrounding function within the body of Foo.
 
+If you're using a bundler, you **must** enable the "keep names" option
+for at least the classes that will be stringified, so that Resurrect.js can get the correct `.name` from the constructor functions. (For esbuild, the option is `--keep-names`.)
+
 ## See Also
 
 * [HydrateJS](https://github.com/nanodeath/HydrateJS)

package/package.json

@@ -1,42 +1,42 @@
 {
-  "name": "resurrect-esm",
-  "version": "2.0.2",
-  "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": {
-    "type": "git",
-    "url": "git+https://github.com/dragoncoder047/resurrect-esm.git"
-  },
-  "keywords": [],
-  "author": "skeeto",
-  "contributors": [
-    {
-      "name": "Andrew Bradley",
-      "email": "cspotcode@gmail.com",
-      "url": "https://github.com/cspotcode"
+    "name": "resurrect-esm",
+    "version": "2.0.4",
+    "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": {
+        "type": "git",
+        "url": "git+https://github.com/dragoncoder047/resurrect-esm.git"
     },
-    {
-      "name": "dragoncoder047",
-      "url": "https://github.com/dragoncoder047"
+    "keywords": [],
+    "author": "skeeto",
+    "contributors": [
+        {
+            "name": "Andrew Bradley",
+            "email": "cspotcode@gmail.com",
+            "url": "https://github.com/cspotcode"
+        },
+        {
+            "name": "dragoncoder047",
+            "url": "https://github.com/dragoncoder047"
+        }
+    ],
+    "license": "UNLICENSE",
+    "bugs": {
+        "url": "https://github.com/dragoncoder047/resurrect-esm/issues"
+    },
+    "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"
+    },
+    "main": "resurrect.ts",
+    "scripts": {
+        "build": "pnpm esbuild --sourcemap --platform=browser --target=esnext --format=esm resurrect.ts --outfile=resurrect.js",
+        "test": "pnpm bun test",
+        "test:watch": "pnpm test --watch",
+        "prepare": "pnpm build --minify --mangle-props=^_"
     }
-  ],
-  "license": "UNLICENSE",
-  "bugs": {
-    "url": "https://github.com/dragoncoder047/resurrect-esm/issues"
-  },
-  "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"
-  },
-  "main": "resurrect.ts",
-  "scripts": {
-    "build": "pnpm esbuild --sourcemap --platform=browser --target=esnext --format=esm resurrect.ts --outfile=resurrect.js",
-    "test": "pnpm bun test",
-    "test:watch": "pnpm test --watch",
-    "prepare": "pnpm build --minify --mangle-props=^_"
-  }
 }

package/resurrect.test.ts

@@ -66,7 +66,26 @@ function suite(opt?: ResurrectOptions) {
         expect(() => roundtrip(obj)).toThrow(new ResurrectError("Can't serialize functions."));
     });
 
+    test("can serialize URL objects ok", () => {
+        const obj = { a_url_object: new URL("about:test") };
+        expect(roundtrip(obj).a_url_object).toBeInstanceOf(URL);
+    });
+
     if (defOpts.revive) {
+        test("can revive classes with cleanup true and false", () => {
+            const ns = {
+                Foo: class Foo {
+                    bar: number;
+                    constructor() {
+                        this.bar = 1;
+                        Foo.bax();
+                    }
+                    static bax() { }
+                }
+            };
+            expect(roundtrip(new ns.Foo(), { cleanup: false, resolver: new NamespaceResolver(ns) })).toBeInstanceOf(ns.Foo);
+            expect(roundtrip(new ns.Foo(), { cleanup: true, resolver: new NamespaceResolver(ns) })).toBeInstanceOf(ns.Foo);
+        });
         test("revive and custom resolver", () => {
             class Dog {
                 constructor(public loudness: number, public sound: string) { }
@@ -107,3 +126,11 @@ function suite(opt?: ResurrectOptions) {
 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
+    const r = new Resurrect();
+    const O = { test() { } };
+    expect(() => r.stringify(O)).toThrow(new ResurrectError("Can't serialize functions."));
+    expect(() => r.stringify(O)).toThrow(new ResurrectError("Can't serialize functions."));
+});

package/resurrect.ts

@@ -5,7 +5,7 @@
  *
  * ResurrectJS preserves object behavior (prototypes) and reference
  * circularity with a special JSON encoding. Unlike regular JSON,
- * Date, RegExp, DOM objects, and `undefined` are also properly
+ * Date, URL, RegExp, DOM objects, and `undefined` are also properly
  * preserved.
  *
  * ## Examples
@@ -41,16 +41,10 @@
  *     string. This option must be consistent between both
  *     serialization and deserialization.
  *
- *   cleanup (false): Perform full property cleanup after both
- *     serialization and deserialization using the `delete`
- *     operator. This may cause performance penalties (breaking hidden
- *     classes in V8) on objects that ResurrectJS touches, so enable
- *     with care.
- *
  *   revive (true): Restore behavior (__proto__) to objects that have
  *     been resurrected. If this is set to false during serialization,
  *     resurrection information will not be encoded. You still get
- *     circularity and Date support.
+ *     circularity and Date/URL support.
  *
  *   resolver (Resurrect.NamespaceResolver(window)): Converts between
  *     a name and a prototype. Create a custom resolver if your
@@ -60,8 +54,7 @@
  * For example,
  *
  * const necromancer = new Resurrect({
- *     prefix: '__#',
- *     cleanup: true
+ *     prefix: "__#",
  * });
  *
  * ## Caveats
@@ -83,6 +76,7 @@
 
 export class Resurrect {
     private _table: any[] | null;
+    private _cleanups: (() => void)[] = [];
     prefix: string;
     cleanup: boolean;
     revive: boolean;
@@ -140,9 +134,10 @@ export class Resurrect {
     private static _isNumber = Resurrect._is("Number") as (obj: any) => obj is number;
     private static _isFunction = Resurrect._is("Function") as (obj: any) => obj is Function;
     private static _isDate = Resurrect._is("Date") as (obj: any) => obj is Date;
+    private static _isURL = Resurrect._is("URL") as (obj: any) => obj is URL;
     private static _isRegExp = Resurrect._is("RegExp") as (obj: any) => obj is RegExp;
     private static _isObject = Resurrect._is("Object") as (obj: any) => obj is object;
-    private static isAtom(object: any) {
+    private static _isAtom(object: any) {
         return !Resurrect._isObject(object) && !Resurrect._isArray(object);
     }
     private static _isPrimitive(object: any) {
@@ -152,6 +147,11 @@ export class Resurrect {
             Resurrect._isBoolean(object);
     }
 
+    private _cleanup() {
+        this._cleanups.forEach(e => e());
+        this._cleanups = [];
+    }
+
     /**
      * Create a reference (encoding) to an object.
      */
@@ -180,10 +180,12 @@ export class Resurrect {
                     throw new ResurrectError("Constructor mismatch!");
                 } else {
                     object[this._protocode] = constructor;
+                    this._cleanups.push(() => delete object[this._protocode]);
                 }
             }
         }
         object[this._refcode] = this._table!.length;
+        this._cleanups.push(() => delete object[this._refcode]);
         this._table!.push(object);
         return object[this._refcode];
     }
@@ -241,32 +243,30 @@ export class Resurrect {
      * Visit root and all its ancestors, visiting atoms with f.
      * @returns A fresh copy of root to be serialized.
      */
-    private _visit(root: any, f: (obj: any) => any, replacer?: (k: string, v: any) => any): any {
-        if (Resurrect.isAtom(root)) {
-            return f(root);
+    private _visit(root: any, transform: (obj: any) => any, replacer?: (k: string, v: any) => any): any {
+        if (Resurrect._isAtom(root)) {
+            return transform(root);
         } else if (!this._isTagged(root)) {
             let copy: any = null;
             if (Resurrect._isArray(root)) {
                 copy = [];
                 root[this._refcode as any] = this._tag(copy);
+                this._cleanups.push(() => delete root[this._refcode as any]);
                 for (let i = 0; i < root.length; i++) {
-                    copy.push(this._visit(root[i], f, replacer));
+                    copy.push(this._visit(root[i], transform, replacer));
                 }
             } else { /* Object */
                 copy = Object.create(Object.getPrototypeOf(root));
                 root[this._refcode as any] = this._tag(copy);
-                for (const key in root) {
+                this._cleanups.push(() => delete root[this._refcode]);
+                for (const key of Object.getOwnPropertyNames(root)) {
                     let value = root[key];
-                    if (root.hasOwnProperty(key)) {
-                        if (replacer && value !== undefined) {
-                            // Call replacer like JSON.stringify's replacer
-                            value = replacer.call(root, key, root[key]);
-                            if (value === undefined) {
-                                continue; // Omit from result
-                            }
-                        }
-                        copy[key] = this._visit(value, f, replacer);
+                    if (replacer && value !== undefined) {
+                        // Call replacer like JSON.stringify's replacer
+                        value = replacer.call(root, key, root[key]);
+                        if (value === undefined) continue; // Omit from result
                     }
+                    copy[key] = this._visit(value, transform, replacer);
                 }
             }
             copy[this._origcode] = root;
@@ -287,6 +287,8 @@ export class Resurrect {
             return this._builder("Resurrect.Node", [new XMLSerializer().serializeToString(atom)]);
         } else if (Resurrect._isDate(atom)) {
             return this._builder("Date", [atom.toISOString()]);
+        } else if (Resurrect._isURL(atom)) {
+            return this._builder("URL", [atom.href]);
         } else if (Resurrect._isRegExp(atom)) {
             return this._builder("RegExp", ("" + atom).match(/\/(.+)\/([a-z]*)/)!.slice(1));
         } else if (atom === undefined) {
@@ -316,32 +318,39 @@ export class Resurrect {
     /**
      * Serialize an arbitrary JavaScript object, carefully preserving it.
      */
-    stringify(object: any, replacer?: any[] | ((k: string, v: any) => any), space?: string) {
+    stringify(object: any, replacer?: any[] | ((k: string, v: any) => any), space?: string | number) {
         if (Resurrect._isFunction(replacer)) {
             replacer = this._replacerWrapper(replacer);
         } else if (Resurrect._isArray(replacer)) {
             const acceptKeys = replacer;
-            replacer = function (k, v) {
-                return acceptKeys.indexOf(k) >= 0 ? v : undefined;
-            };
+            replacer = (k, v) => acceptKeys.includes(k) ? v : undefined;
         }
-        if (Resurrect.isAtom(object)) {
+        if (Resurrect._isAtom(object)) {
             return JSON.stringify(this._handleAtom(object), replacer, space);
         } else {
-            this._table = [];
-            this._visit(object, this._handleAtom.bind(this), replacer);
-            for (let i = 0; i < this._table.length; i++) {
-                if (this.cleanup) {
-                    delete this._table[i][this._origcode][this._refcode];
-                } else {
-                    this._table[i][this._origcode][this._refcode] = null;
+            this._cleanups = [];
+            const table = this._table = [] as any[];
+            try {
+                this._visit(object, this._handleAtom.bind(this), replacer);
+            } catch (e) {
+                this._cleanup();
+                throw e;
+            } finally {
+                for (let i = 0; i < table.length; i++) {
+                    if (this.cleanup) {
+                        delete table[i]?.[this._origcode]?.[this._refcode];
+                    } else {
+                        const obj = table[i]?.[this._origcode];
+                        if (obj) obj[this._refcode] = null;
+                    }
+                    delete table[i]?.[this._refcode];
+                    delete table[i]?.[this._origcode];
                 }
-                delete this._table[i][this._refcode];
-                delete this._table[i][this._origcode];
+                this._table = null;
             }
-            const table = this._table;
-            this._table = null;
-            return JSON.stringify(table, null, space);
+            const s = JSON.stringify(table, null, space);
+            if (this.cleanup) this._cleanup();
+            return s;
         }
     }
 
@@ -359,18 +368,17 @@ export class Resurrect {
                     delete (object as any)[this._protocode];
                 }
                 return object;
-            } else { // IE
-                const copy = Object.create(prototype);
-                for (const key in object) {
-                    if (object.hasOwnProperty(key) && key !== this.prefix) {
-                        copy[key] = object[key];
-                    }
+            }
+            // IE
+            const copy = Object.create(prototype);
+            for (const key of Object.getOwnPropertyNames(object)) {
+                if (key !== this._protocode) {
+                    copy[key] = (object as any)[key];
                 }
-                return copy;
             }
-        } else {
-            return object;
+            return copy;
         }
+        return object;
     }
 
     /**
@@ -379,33 +387,34 @@ export class Resurrect {
     resurrect(string: string): any {
         let result = null;
         const data = JSON.parse(string);
-        if (Resurrect._isArray(data)) {
-            this._table = data;
-            /* Restore __proto__. */
-            if (this.revive) {
-                for (let i = 0; i < this._table.length; i++) {
-                    this._table[i] = this._fixPrototype(this._table[i]);
+        try {
+            if (Resurrect._isArray(data)) {
+                this._table = data;
+                /* Restore __proto__. */
+                if (this.revive) {
+                    for (let i = 0; i < this._table.length; i++) {
+                        this._table[i] = this._fixPrototype(this._table[i]);
+                    }
                 }
-            }
-            /* Re-establish object references and construct atoms. */
-            for (let i = 0; i < this._table.length; i++) {
-                const object = this._table[i];
-                for (const key in object) {
-                    if (object.hasOwnProperty(key)) {
-                        if (!(Resurrect.isAtom(object[key]))) {
+                /* Re-establish object references and construct atoms. */
+                for (let i = 0; i < this._table.length; i++) {
+                    const object = this._table[i];
+                    for (const key of Object.getOwnPropertyNames(object)) {
+                        if (!(Resurrect._isAtom(object[key]))) {
                             object[key] = this._decode(object[key]);
                         }
                     }
                 }
+                result = this._table[0];
+            } else if (Resurrect._isObject(data)) {
+                this._table = [];
+                result = this._decode(data);
+            } else {
+                result = data;
             }
-            result = this._table[0];
-        } else if (Resurrect._isObject(data)) {
-            this._table = [];
-            result = this._decode(data);
-        } else {
-            result = data;
+        } finally {
+            this._table = null;
         }
-        this._table = null;
         return result;
     }
 }
@@ -418,6 +427,7 @@ export interface ResurrectOptions {
      * important that you don't use any properties beginning with this
      * string. This option must be consistent between both
      * serialization and deserialization.
+     * @default "#"
      */
     prefix?: string;
     /**
@@ -426,6 +436,7 @@ export interface ResurrectOptions {
      * operator. This may cause performance penalties (breaking hidden
      * classes in V8) on objects that ResurrectJS touches, so enable
      * with care.
+     * @default false
      */
     cleanup?: boolean;
     /**
@@ -433,6 +444,7 @@ export interface ResurrectOptions {
      * been resurrected. If this is set to false during serialization,
      * resurrection information will not be encoded. You still get
      * circularity and Date support.
+     * @default true
      */
     revive?: boolean;
     /**
@@ -441,6 +453,7 @@ export interface ResurrectOptions {
      *
      * If you're using ES6 modules for your custom classes, you WILL need
      * to use this!
+     * @default undefined
      */
     resolver?: NamespaceResolver;
 }