resurrect-esm 2.0.3 → 2.0.4

package/.github/workflows/publish.yml

@@ -8,14 +8,13 @@ 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
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          cache: pnpm
       - run: pnpm install
       - run: pnpm test
       - run: pnpm prepare

package/README.md

@@ -9,13 +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.
+> * 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
@@ -121,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
 
@@ -132,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) {
+
         }
     }
 };
@@ -149,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,6 +1,6 @@
 {
     "name": "resurrect-esm",
-    "version": "2.0.3",
+    "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": {

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) { }

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
@@ -141,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) {
@@ -153,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.
      */
@@ -181,12 +180,12 @@ export class Resurrect {
                     throw new ResurrectError("Constructor mismatch!");
                 } else {
                     object[this._protocode] = constructor;
-                    this._cleanups.push(() => { delete object[this._protocode as any]; })
+                    this._cleanups.push(() => delete object[this._protocode]);
                 }
             }
         }
         object[this._refcode] = this._table!.length;
-        this._cleanups.push(() => { delete object[this._refcode as any]; })
+        this._cleanups.push(() => delete object[this._refcode]);
         this._table!.push(object);
         return object[this._refcode];
     }
@@ -245,21 +244,21 @@ export class Resurrect {
      * @returns A fresh copy of root to be serialized.
      */
     private _visit(root: any, transform: (obj: any) => any, replacer?: (k: string, v: any) => any): any {
-        if (Resurrect.isAtom(root)) {
+        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]; })
+                this._cleanups.push(() => delete root[this._refcode as any]);
                 for (let i = 0; i < root.length; i++) {
                     copy.push(this._visit(root[i], transform, replacer));
                 }
             } else { /* Object */
                 copy = Object.create(Object.getPrototypeOf(root));
                 root[this._refcode as any] = this._tag(copy);
-                this._cleanups.push(() => { delete root[this._refcode as any]; })
+                this._cleanups.push(() => delete root[this._refcode]);
                 for (const key of Object.getOwnPropertyNames(root)) {
                     let value = root[key];
                     if (replacer && value !== undefined) {
@@ -288,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) {
@@ -317,14 +318,14 @@ 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 = (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._cleanups = [];
@@ -332,22 +333,24 @@ export class Resurrect {
             try {
                 this._visit(object, this._handleAtom.bind(this), replacer);
             } catch (e) {
-                this._cleanups.forEach(e => e());
+                this._cleanup();
                 throw e;
             } finally {
                 for (let i = 0; i < table.length; i++) {
                     if (this.cleanup) {
-                        delete table[i][this._origcode][this._refcode];
+                        delete table[i]?.[this._origcode]?.[this._refcode];
                     } else {
-                        const obj = table[i][this._origcode];
+                        const obj = table[i]?.[this._origcode];
                         if (obj) obj[this._refcode] = null;
                     }
-                    delete table[i][this._refcode];
-                    delete table[i][this._origcode];
+                    delete table[i]?.[this._refcode];
+                    delete table[i]?.[this._origcode];
                 }
                 this._table = null;
             }
-            return JSON.stringify(table, null, space);
+            const s = JSON.stringify(table, null, space);
+            if (this.cleanup) this._cleanup();
+            return s;
         }
     }
 
@@ -397,7 +400,7 @@ export class Resurrect {
                 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]))) {
+                        if (!(Resurrect._isAtom(object[key]))) {
                             object[key] = this._decode(object[key]);
                         }
                     }
@@ -424,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;
     /**
@@ -432,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;
     /**
@@ -439,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;
     /**
@@ -447,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;
 }