resurrect-esm 2.0.2 → 2.0.3

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
@@ -19,7 +16,7 @@ jobs:
         with:
           version: 10
           cache: on
-          install: yes
+      - 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,6 +9,7 @@ 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

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.3",
+    "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

@@ -107,3 +107,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

@@ -83,6 +83,7 @@
 
 export class Resurrect {
     private _table: any[] | null;
+    private _cleanups: (() => void)[] = [];
     prefix: string;
     cleanup: boolean;
     revive: boolean;
@@ -180,10 +181,12 @@ export class Resurrect {
                     throw new ResurrectError("Constructor mismatch!");
                 } else {
                     object[this._protocode] = constructor;
+                    this._cleanups.push(() => { delete object[this._protocode as any]; })
                 }
             }
         }
         object[this._refcode] = this._table!.length;
+        this._cleanups.push(() => { delete object[this._refcode as any]; })
         this._table!.push(object);
         return object[this._refcode];
     }
@@ -241,32 +244,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 {
+    private _visit(root: any, transform: (obj: any) => any, replacer?: (k: string, v: any) => any): any {
         if (Resurrect.isAtom(root)) {
-            return f(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 as any]; })
+                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;
@@ -321,26 +322,31 @@ export class Resurrect {
             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)) {
             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._cleanups.forEach(e => e());
+                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);
         }
     }
@@ -359,18 +365,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 +384,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)) {
+                /* 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;
     }
 }