@esmx/router-vue 3.0.0-rc.29 → 3.0.0-rc.31

package/dist/util.test.mjs

@@ -1,9 +1,11 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { beforeEach, describe, expect, it } from "vitest";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { computed, nextTick, ref } from "vue";
 import { version } from "vue";
 import {
+  createDependentProxy,
   createSymbolProperty,
   isESModule,
   isVue3,
@@ -194,131 +196,155 @@ describe("util.ts - Utility Functions", () => {
         });
       });
       it("should return false for primitive values", () => {
-        const primitives = ["string", 42, true, false, Symbol("test")];
+        const primitives = [42, "string", true, false, Symbol("test")];
         primitives.forEach((primitive) => {
           expect(isESModule(primitive)).toBe(false);
         });
       });
-    });
-  });
-  describe("resolveComponent", () => {
-    describe("should return null for falsy inputs", () => {
-      const falsyValues = [null, void 0, false, 0, "", Number.NaN];
-      falsyValues.forEach((value) => {
-        it("should return null for ".concat(value), () => {
-          expect(resolveComponent(value)).toBeNull();
+      it("should return false for functions and arrays", () => {
+        const nonObjects = [
+          () => {
+          },
+          () => {
+          },
+          [],
+          [1, 2, 3],
+          /* @__PURE__ */ new Date()
+        ];
+        nonObjects.forEach((nonObj) => {
+          expect(isESModule(nonObj)).toBe(false);
         });
       });
     });
-    describe("should handle ES modules", () => {
-      it("should return default export when available", () => {
-        const defaultComponent = { name: "DefaultComponent" };
-        const esModule = {
-          __esModule: true,
-          default: defaultComponent,
-          namedExport: { name: "NamedComponent" }
-        };
-        const result = resolveComponent(esModule);
-        expect(result).toBe(defaultComponent);
+  });
+  describe("resolveComponent", () => {
+    describe("should return default export or module itself", () => {
+      it("should return null for falsy values", () => {
+        expect(resolveComponent(null)).toBeNull();
+        expect(resolveComponent(void 0)).toBeNull();
+        expect(resolveComponent(false)).toBeNull();
+        expect(resolveComponent(0)).toBeNull();
+        expect(resolveComponent("")).toBeNull();
       });
-      it("should return the module itself when no default export", () => {
-        const esModule = {
+      it("should return default export if available", () => {
+        const defaultExport = { name: "DefaultComponent" };
+        const module = {
           __esModule: true,
-          namedExport: { name: "NamedComponent" }
+          default: defaultExport,
+          other: "value"
         };
-        const result = resolveComponent(esModule);
-        expect(result).toBe(esModule);
+        expect(resolveComponent(module)).toBe(defaultExport);
       });
-      it("should prefer default export over module when both exist", () => {
-        const defaultComponent = { name: "DefaultComponent" };
-        const esModule = {
+      it("should return the module itself if no default export", () => {
+        const module = {
           __esModule: true,
-          default: defaultComponent,
-          name: "ModuleComponent"
+          someExport: "value",
+          otherExport: 42
         };
-        const result = resolveComponent(esModule);
-        expect(result).toBe(defaultComponent);
-        expect(result).not.toBe(esModule);
+        expect(resolveComponent(module)).toBe(module);
       });
       it("should handle modules with Symbol.toStringTag", () => {
-        const defaultComponent = { name: "SymbolTagComponent" };
-        const esModule = {
+        const defaultExport = { name: "SymbolDefaultComponent" };
+        const module = {
           [Symbol.toStringTag]: "Module",
-          default: defaultComponent
+          default: defaultExport
         };
-        const result = resolveComponent(esModule);
-        expect(result).toBe(defaultComponent);
+        expect(resolveComponent(module)).toBe(defaultExport);
       });
-      it("should handle falsy default export", () => {
-        const falsyDefaults = [null, void 0, false, 0, ""];
-        falsyDefaults.forEach((falsyDefault) => {
-          const esModule = {
-            __esModule: true,
-            default: falsyDefault,
-            fallback: { name: "FallbackComponent" }
-          };
-          const result = resolveComponent(esModule);
-          expect(result).toBe(esModule);
-        });
-      });
-    });
-    describe("should handle non-ES modules", () => {
-      it("should return component directly for non-ES modules", () => {
-        const component = { name: "RegularComponent" };
-        const result = resolveComponent(component);
-        expect(result).toBe(component);
+      it("should return non-module objects as is", () => {
+        const nonModule = { prop: "value" };
+        expect(resolveComponent(nonModule)).toBe(nonModule);
       });
-      it("should return function components directly", () => {
+      it("should handle various component types", () => {
         const functionComponent = () => ({ name: "FunctionComponent" });
-        const result = resolveComponent(functionComponent);
-        expect(result).toBe(functionComponent);
-      });
-      it("should return class components directly", () => {
+        expect(resolveComponent(functionComponent)).toBe(
+          functionComponent
+        );
         class ClassComponent {
           constructor() {
             __publicField(this, "name", "ClassComponent");
           }
         }
-        const result = resolveComponent(ClassComponent);
-        expect(result).toBe(ClassComponent);
+        const classInstance = new ClassComponent();
+        expect(resolveComponent(classInstance)).toBe(classInstance);
       });
     });
-    describe("edge cases", () => {
-      it("should handle circular references in modules", () => {
-        const esModule = {
-          __esModule: true
-        };
-        esModule.default = esModule;
-        const result = resolveComponent(esModule);
-        expect(result).toBe(esModule);
-      });
-      it("should handle deeply nested default exports", () => {
-        const actualComponent = { name: "DeepComponent" };
-        const esModule = {
-          __esModule: true,
-          default: {
-            default: {
-              default: actualComponent
-            }
-          }
-        };
-        const result = resolveComponent(esModule);
-        expect(result).toEqual({
-          default: {
-            default: actualComponent
-          }
-        });
+  });
+  describe("createDependentProxy", () => {
+    it("should return original property values", () => {
+      const original = { foo: "bar", count: 42 };
+      const dep = ref(false);
+      const proxy = createDependentProxy(original, dep);
+      expect(proxy.foo).toBe("bar");
+      expect(proxy.count).toBe(42);
+    });
+    it("should handle method calls correctly", () => {
+      const original = {
+        items: [1, 2, 3],
+        getItems() {
+          return this.items;
+        }
+      };
+      const dep = ref(false);
+      const proxy = createDependentProxy(original, dep);
+      expect(proxy.getItems()).toEqual([1, 2, 3]);
+      expect(proxy.getItems()).toBe(original.items);
+    });
+    it("should handle nested property access", () => {
+      const original = {
+        nested: {
+          value: "nested-value"
+        }
+      };
+      const dep = ref(false);
+      const proxy = createDependentProxy(original, dep);
+      expect(proxy.nested.value).toBe("nested-value");
+    });
+    it("should allow property modification", () => {
+      const original = { value: "original" };
+      const dep = ref(false);
+      const proxy = createDependentProxy(original, dep);
+      proxy.value = "modified";
+      expect(proxy.value).toBe("modified");
+      expect(original.value).toBe("modified");
+    });
+    it("should trigger computed updates when dependency changes", async () => {
+      const original = { value: "test" };
+      const dep = ref(false);
+      const proxy = createDependentProxy(original, dep);
+      const computedValue = computed(() => {
+        return proxy.value + "-" + String(dep.value);
       });
-      it("should handle modules with both __esModule and Symbol.toStringTag", () => {
-        const defaultComponent = { name: "BothPropertiesComponent" };
-        const esModule = {
-          __esModule: true,
-          [Symbol.toStringTag]: "Module",
-          default: defaultComponent
-        };
-        const result = resolveComponent(esModule);
-        expect(result).toBe(defaultComponent);
+      expect(computedValue.value).toBe("test-false");
+      dep.value = true;
+      await nextTick();
+      expect(computedValue.value).toBe("test-true");
+      proxy.value = "updated";
+      dep.value = false;
+      await nextTick();
+      expect(computedValue.value).toBe("updated-false");
+    });
+    it("should handle special properties", () => {
+      const symbol = Symbol("test");
+      const original = {
+        [symbol]: "symbol-value"
+      };
+      const dep = ref(false);
+      const proxy = createDependentProxy(original, dep);
+      expect(proxy[symbol]).toBe("symbol-value");
+    });
+    it("should read the dependency on property access", () => {
+      const original = { value: "test" };
+      const dep = ref(false);
+      const spy = vi.fn();
+      const depValue = dep.value;
+      vi.spyOn(dep, "value", "get").mockImplementation(() => {
+        spy();
+        return depValue;
       });
+      const proxy = createDependentProxy(original, dep);
+      proxy.value;
+      expect(spy).toHaveBeenCalled();
     });
   });
 });

package/package.json

@@ -50,11 +50,11 @@
         "vue": "^3.5.0 || ^2.7.0"
     },
     "dependencies": {
-        "@esmx/router": "3.0.0-rc.29"
+        "@esmx/router": "3.0.0-rc.31"
     },
     "devDependencies": {
         "@biomejs/biome": "1.9.4",
-        "@esmx/lint": "3.0.0-rc.29",
+        "@esmx/lint": "3.0.0-rc.31",
         "@types/node": "^24.0.0",
         "@vitest/coverage-v8": "3.2.4",
         "stylelint": "16.21.0",
@@ -64,7 +64,7 @@
         "vue": "3.5.13",
         "vue2": "npm:vue@2.7.16"
     },
-    "version": "3.0.0-rc.29",
+    "version": "3.0.0-rc.31",
     "type": "module",
     "private": false,
     "exports": {
@@ -83,5 +83,5 @@
         "template",
         "public"
     ],
-    "gitHead": "98aba9be77d48240c61d3bc7a507970533faa7da"
+    "gitHead": "d472904500f5d697cd61b99b012570f6b063c580"
 }

package/src/plugin.test.ts

@@ -223,7 +223,7 @@ describe('plugin.ts - RouterPlugin', () => {
             await nextTick();
 
             // Verify the getter was called and returned correct value
-            expect(routerResult).toBe(router);
+            expect(routerResult).toEqual(router);
             expect(routerResult).toBeInstanceOf(Router);
         });