sec update json5

configs/common-tsupconfig.js

@@ -10,18 +10,6 @@ OF ANY KIND, either express or implied. See the License for the specific languag
 governing permissions and limitations under the License.
 */
 
-/** @type {import("tsup").Options} */
-const base = {
-  entry: ["src/index.ts"], // will be relative to the directory that uses it
-  tsconfig: "./tsconfig.json", // see above
-  format: ["cjs"],
-  platform: "browser",
-  target: "ES2020", // TODO: this is cool, right?
-  replaceNodeEnv: true,
-  legacyOutput: true,
-  treeshake: "recommended"
-};
-
 const allowedModes = ["development", "production", "report"];
 
 let mode = process.env.UIX_SDK_BUILDMODE;
@@ -39,6 +27,23 @@ if (!mode) {
   process.exit(1);
 }
 
+/** @type {import("tsup").Options} */
+const base = {
+  entry: ["src/index.ts"], // will be relative to the directory that uses it
+  define: {
+    UIX_SDK_BUILDMODE: mode,
+    UIX_SDK_VERSION: `"${require("../package.json").version}"`,
+  },
+  tsconfig: "./tsconfig.json", // see above
+  format: ["cjs"],
+  platform: "browser",
+  target: "ES2020", // TODO: this is cool, right?
+  replaceNodeEnv: true,
+  legacyOutput: true,
+  treeshake: "recommended",
+};
+
+
 const configs = {
   development: {
     ...base,

jest.config.ts

@@ -22,6 +22,10 @@ const jestConfig: JestConfigWithTsJest = {
           },
         ],
       },
+      globals: {
+        UIX_SDK_VERSION: "0.0.1-test",
+        UIX_SDK_BUILDMODE: "test",
+      },
     },
   ],
 };

package.json

@@ -12,7 +12,7 @@
     "clean": "del {dist,*.tsbuildinfo,docs/temp,.parcel-cache,node_modules/.cache} {packages,examples}/*/{dist,*.tsbuildinfo,node_modules/.cache,.parcel-cache,node_modules/.vite} packages/*/src/**/*.{d.ts,d.ts.map,js,js.map} && npm run -s any -- -s clean",
     "declarations:build": "tsc --build",
     "declarations:watch": "tsc --build tsconfig.json --watch",
-    "demo": "npm run build:production -- --silent --esm && npm run any example:build && node scripts/multi-server.mjs production",
+    "demo": "npm run build:production -- --esm && npm run any example:build && node scripts/multi-server.mjs production",
     "dev": "node scripts/multi-server.mjs development",
     "docs": "node scripts/generate-docs.mjs",
     "docs:watch": "node scripts/generate-docs.mjs --watch",
@@ -28,7 +28,8 @@
     "report:size": "node scripts/bundler.mjs report",
     "test": "run-s lint test:unit test:subtests",
     "test:subtests": "npm run any test",
-    "test:unit": "jest"
+    "test:unit": "jest",
+    "test:unit:watch": "jest --watch"
   },
   "devDependencies": {
     "@adobe/react-spectrum": "^3.20.0",

packages/uix-core/src/constants.ts

@@ -1,6 +1,10 @@
+declare const UIX_SDK_VERSION: string;
+declare const UIX_SDK_BUILDMODE: string;
+
 /** @internal */
 export const NS_ROOT = "_$pg";
-export const VERSION = "0.0.1";
+export const VERSION = UIX_SDK_VERSION;
+export const BUILDMODE = UIX_SDK_BUILDMODE;
 export const SYM_CLEANUP = Symbol(`${NS_ROOT}_cleanup`);
 export const SYM_INTERNAL = Symbol(`${NS_ROOT}_internal`);
 export const INIT_CALLBACK = `${NS_ROOT}_init_cb`;

packages/uix-core/src/object-simulator.test.ts

@@ -120,6 +120,199 @@ describe("function simulator exchanges functions and tickets", () => {
     await expect(loneFn()).resolves.not.toThrowError();
     expect(called).toBe(true);
   });
+  it("Unwraps prototypes and exchange all functions to tickets", async () => {
+    class ca {
+      pa: number;
+      constructor() {
+        this.pa = 4;
+      }
+      getPa() {
+        return this.pa;
+      }
+    }
+    class cb {
+      pb: number;
+      ca: ca;
+      constructor(aa: number) {
+        this.pb = aa;
+        this.ca = new ca();
+      }
+      getNumber() {
+        return this.pb;
+      }
+      giftOne() {
+        this.pb--;
+      }
+    }
+    class cd extends cb {
+      giftOne() {
+        this.pb++;
+      }
+      robOne() {
+        this.pb--;
+      }
+    }
+
+    const toBeTicketed = new cd(5);
+    const ticketed = objectSimulator.simulate(toBeTicketed);
+    expect(ticketed).toMatchInlineSnapshot(`
+      {
+        "ca": {
+          "getPa": {
+            "_\$pg": {
+              "fnId": "getPa_1",
+            },
+          },
+          "pa": 4,
+        },
+        "getNumber": {
+          "_\$pg": {
+            "fnId": "getNumber_4",
+          },
+        },
+        "giftOne": {
+          "_\$pg": {
+            "fnId": "giftOne_2",
+          },
+        },
+        "pb": 5,
+        "robOne": {
+          "_\$pg": {
+            "fnId": "robOne_3",
+          },
+        },
+      }
+    `);
+    const unticketed = objectSimulator.materialize(ticketed);
+    expect(unticketed).toMatchInlineSnapshot(`
+      {
+        "ca": {
+          "getPa": [Function],
+          "pa": 4,
+        },
+        "getNumber": [Function],
+        "giftOne": [Function],
+        "pb": 5,
+        "robOne": [Function],
+      }
+    `);
+
+    await expect(unticketed.getNumber()).resolves.toBe(5);
+    await unticketed.giftOne();
+    await expect(unticketed.getNumber()).resolves.toBe(6);
+    await unticketed.robOne();
+    await expect(unticketed.getNumber()).resolves.toBe(5);
+    await expect(unticketed.ca.getPa()).resolves.toBe(4);
+  });
+
+  it("Ignores circular dependencies in properties, but relove them through the methods", async () => {
+    class ca {
+      pa: ca;
+      constructor() {
+        this.pa = this;
+      }
+      getPa() {
+        return this.pa;
+      }
+    }
+
+    const toBeTicketed = new ca();
+    const ticketed = objectSimulator.simulate(toBeTicketed);
+    expect(ticketed).toMatchInlineSnapshot(`
+      {
+        "getPa": {
+          "_$pg": {
+            "fnId": "getPa_1",
+          },
+        },
+        "pa": "[[Circular]]",
+      }
+    `);
+    const unticketed = objectSimulator.materialize(ticketed);
+    expect(unticketed).toMatchInlineSnapshot(`
+      {
+        "getPa": [Function],
+        "pa": "[[Circular]]",
+      }
+    `);
+    expect(
+      Reflect.has(
+        await (await (await unticketed.getPa()).getPa()).getPa(),
+        "getPa"
+      )
+    ).toBeTruthy();
+  });
+  it("Supports classes wrapped in other classes", async () => {
+    class ca {
+      pa: number;
+      constructor() {
+        this.pa = 5;
+      }
+      getPa() {
+        return this.pa;
+      }
+    }
+    class cb {
+      pb: ca;
+      constructor() {
+        this.pb = new ca();
+      }
+      getCaValue() {
+        return this.pb.getPa();
+      }
+    }
+    const toBeTicketed = new cb();
+    const ticketed = objectSimulator.simulate(toBeTicketed);
+    expect(ticketed).toMatchInlineSnapshot(`
+      {
+        "getCaValue": {
+          "_$pg": {
+            "fnId": "getCaValue_2",
+          },
+        },
+        "pb": {
+          "getPa": {
+            "_$pg": {
+              "fnId": "getPa_1",
+            },
+          },
+          "pa": 5,
+        },
+      }
+    `);
+    const unticketed = objectSimulator.materialize(ticketed);
+    expect(unticketed).toMatchInlineSnapshot(`
+      {
+        "getCaValue": [Function],
+        "pb": {
+          "getPa": [Function],
+          "pa": 5,
+        },
+      }
+    `);
+    await expect(unticketed.pb.getPa()).resolves.toBe(5);
+  });
+
+  it("Supports objects with null prototypes", async () => {
+    const toBeTicketed = Object.create(null);
+    toBeTicketed["key1"] = "val1";
+    toBeTicketed["key2"] = "val2";
+    const ticketed = objectSimulator.simulate(toBeTicketed);
+    expect(ticketed).toMatchInlineSnapshot(`
+      {
+        "key1": "val1",
+        "key2": "val2",
+      }
+    `);
+    const unticketed = objectSimulator.materialize(ticketed);
+    expect(unticketed).toMatchInlineSnapshot(`
+      {
+        "key1": "val1",
+        "key2": "val2",
+      }
+    `);
+  });
+
   it("notifies remote when FinalizationRegistry calls cleanup handler", async () => {
     const willBeGCed = objectSimulator.simulate(() => {}) as DefMessage;
     objectSimulator.materialize(willBeGCed);

packages/uix-core/src/object-simulator.ts

@@ -86,7 +86,7 @@ export class ObjectSimulator implements Simulator {
 
   // #region Public Methods
 
-  makeReceiver(fn: CallableFunction) {
+  makeReceiver(fn: CallableFunction, parent?: Object) {
     if (typeof fn !== "function") {
       return NOT_TRANSFORMED;
     }
@@ -95,9 +95,18 @@ export class ObjectSimulator implements Simulator {
       fnTicket = {
         fnId: `${fn.name || "<anonymous>"}_${++this.fnCounter}`,
       };
-      const cleanup = receiveCalls(fn, fnTicket, new WeakRef(this.subject));
+      // Bind function to parent object if it exists
+      let boundFunction = fn;
+      if (parent) {
+        boundFunction = fn.bind(parent);
+      }
+      const cleanup = receiveCalls(
+        boundFunction,
+        fnTicket,
+        new WeakRef(this.subject)
+      );
       this.subject.onOutOfScope(fnTicket, cleanup);
-      this.receiverTicketCache.set(fn, fnTicket);
+      this.receiverTicketCache.set(boundFunction, fnTicket);
     }
     return wrap(fnTicket);
   }