@immense/vue-pom-generator 1.0.56 → 1.0.57

package/RELEASE_NOTES.md

@@ -1,27 +1,30 @@
 ● ## Highlights
 
-  - Added support for awaited handler wrappers in POM generation
-  - Enhanced async/await pattern detection in Vue event handlers
-  - Improved test coverage with 39 new test lines across transform and utils
+  - Fixed router introspection cleanup to properly restore DOM globals after execution
+  - Improved test coverage for router introspection with 83 new test lines
+  - Refactored router-introspection implementation for better DOM shim management
 
   ## Changes
 
-  - **Handler Detection:** `utils.ts` now correctly identifies and processes event handlers
-  wrapped in `await` expressions
-  - **Test Coverage:** Added comprehensive tests for awaited handler scenarios in
-  `transform.test.ts` and `utils-coverage.test.ts`
+  ### Bug Fixes
+  - **Router introspection**: Restored router DOM globals after introspection to prevent state
+  pollution between test runs and avoid interfering with downstream code that depends on these
+  globals
+
+  ### Testing
+  - Added comprehensive test coverage for router DOM global restoration behavior
 
   ## Breaking Changes
 
-  None.
+  None
 
   ## Pull Requests Included
 
-  - #17 fix: support awaited handler wrappers
-  (https://github.com/immense/vue-pom-generator/pull/17) by @dkattan
+  - #18 fix: restore router DOM globals after introspection
+  (https://github.com/immense/vue-pom-generator/pull/18)
 
   ## Testing
 
-  Added 39 lines of new tests covering awaited handler wrapper scenarios and edge cases. All tests
-   passing.
+  Added 83 lines of test coverage for router introspection DOM global handling. All existing tests
+   continue to pass.
 

package/dist/index.cjs

@@ -3157,6 +3157,56 @@ function createRouterIntrospectionVueStubPlugin(options) {
     }
   };
 }
+function snapshotGlobalValue(name) {
+  const g = globalThis;
+  return {
+    descriptor: Object.getOwnPropertyDescriptor(globalThis, name),
+    value: g[name]
+  };
+}
+function setTemporaryGlobal(name, value, snapshots) {
+  if (!snapshots.has(name))
+    snapshots.set(name, snapshotGlobalValue(name));
+  const snapshot = snapshots.get(name);
+  if (!snapshot)
+    return false;
+  if (!snapshot.descriptor || snapshot.descriptor.configurable) {
+    Object.defineProperty(globalThis, name, {
+      configurable: true,
+      enumerable: snapshot.descriptor?.enumerable ?? true,
+      writable: true,
+      value
+    });
+    return true;
+  }
+  if ("writable" in snapshot.descriptor && snapshot.descriptor.writable) {
+    Reflect.set(globalThis, name, value);
+    return true;
+  }
+  if (snapshot.descriptor.set) {
+    snapshot.descriptor.set.call(globalThis, value);
+    return true;
+  }
+  return false;
+}
+function restoreTemporaryGlobals(snapshots) {
+  for (const [name, snapshot] of Array.from(snapshots.entries()).reverse()) {
+    const { descriptor, value } = snapshot;
+    if (!descriptor) {
+      Reflect.deleteProperty(globalThis, name);
+      continue;
+    }
+    if (descriptor.configurable) {
+      Object.defineProperty(globalThis, name, descriptor);
+      continue;
+    }
+    if ("writable" in descriptor && descriptor.writable) {
+      Reflect.set(globalThis, name, value);
+      continue;
+    }
+    descriptor.set?.call(globalThis, value);
+  }
+}
 const PARAM_TOKEN_PREFIX = "__VUE_TESTID_PARAM__";
 function getParamToken(name) {
   return `${PARAM_TOKEN_PREFIX}${name}__`;
@@ -3505,12 +3555,18 @@ function createMinimalLocation() {
     ancestorOrigins: { length: 0, contains: () => false, item: () => null, [Symbol.iterator]: [][Symbol.iterator] }
   };
 }
-async function ensureDomShim() {
+function ensureDomShim() {
   const g = globalThis;
   if (typeof document !== "undefined" && typeof window !== "undefined")
-    return;
+    return () => {
+    };
   const minimalDoc = createMinimalDocument();
   const minimalLocation = createMinimalLocation();
+  const snapshots = /* @__PURE__ */ new Map();
+  const setGlobal = (name, value) => {
+    if (!setTemporaryGlobal(name, value, snapshots))
+      debugLog(`could not temporarily install global ${name}`);
+  };
   const win = {
     document: minimalDoc,
     location: minimalLocation,
@@ -3555,17 +3611,17 @@ async function ensureDomShim() {
     queueMicrotask,
     performance: globalThis.performance
   };
-  g.window = win;
-  g.document = minimalDoc;
-  g.location = minimalLocation;
+  setGlobal("window", win);
+  setGlobal("document", minimalDoc);
+  setGlobal("location", minimalLocation);
   if (!g.self)
-    g.self = win;
+    setGlobal("self", win);
   if (!g.navigator)
-    g.navigator = win.navigator;
+    setGlobal("navigator", win.navigator);
   if (!g.history)
-    g.history = win.history;
+    setGlobal("history", win.history);
   if (!g.MutationObserver) {
-    g.MutationObserver = class {
+    setGlobal("MutationObserver", class {
       disconnect() {
       }
       observe() {
@@ -3573,20 +3629,20 @@ async function ensureDomShim() {
       takeRecords() {
         return [];
       }
-    };
+    });
   }
   if (!g.ResizeObserver) {
-    g.ResizeObserver = class {
+    setGlobal("ResizeObserver", class {
       disconnect() {
       }
       observe() {
       }
       unobserve() {
       }
-    };
+    });
   }
   if (!g.IntersectionObserver) {
-    g.IntersectionObserver = class {
+    setGlobal("IntersectionObserver", class {
       disconnect() {
       }
       observe() {
@@ -3596,10 +3652,10 @@ async function ensureDomShim() {
       takeRecords() {
         return [];
       }
-    };
+    });
   }
   if (!g.requestIdleCallback) {
-    g.requestIdleCallback = (cb) => setTimeout(() => cb({ didTimeout: false, timeRemaining: () => 0 }), 1);
+    setGlobal("requestIdleCallback", (cb) => setTimeout(() => cb({ didTimeout: false, timeRemaining: () => 0 }), 1));
   }
   if (!g.localStorage || !g.sessionStorage) {
     const storageFactory = () => {
@@ -3622,12 +3678,15 @@ async function ensureDomShim() {
       };
     };
     if (!g.localStorage)
-      g.localStorage = storageFactory();
+      setGlobal("localStorage", storageFactory());
     if (!g.sessionStorage)
-      g.sessionStorage = storageFactory();
+      setGlobal("sessionStorage", storageFactory());
   }
   if (!g.requestAnimationFrame)
-    g.requestAnimationFrame = (cb) => setTimeout(() => cb(Date.now()), 16);
+    setGlobal("requestAnimationFrame", (cb) => setTimeout(() => cb(Date.now()), 16));
+  return () => {
+    restoreTemporaryGlobals(snapshots);
+  };
 }
 function unwrapNuxtPageSegment(segment, prefix, suffix) {
   if (!segment.startsWith(prefix) || !segment.endsWith(suffix))
@@ -3745,85 +3804,89 @@ async function parseRouterFileFromCwd(routerEntryPath, options = {}) {
     }
     const cwd = path.dirname(routerEntry);
     const moduleShims = normalizeRouterIntrospectionModuleShims(options.moduleShims);
-    await ensureDomShim();
-    debugLog(`parseRouterFileFromCwd cwd=${cwd}`);
-    const vite = await import("vite");
-    const server = await vite.createServer({
-      root: cwd,
-      configFile: false,
-      logLevel: "error",
-      // This server is created only to SSR-load the router module. Disable HMR/WebSocket
-      // to avoid port conflicts in dev/test environments.
-      server: { middlewareMode: true, hmr: false, ws: false },
-      appType: "custom",
-      // IMPORTANT:
-      // This internal, short-lived Vite server exists only to `ssrLoadModule()` the router entry.
-      // We close it immediately after reading routes.
-      //
-      // Vite's dependency optimizer (vite:dep-scan / optimizeDeps) runs asynchronously and can
-      // still have pending resolve requests when we call `server.close()`, which surfaces as:
-      //   "The server is being restarted or closed. Request is outdated [plugin vite:dep-scan]"
-      //
-      // Disable optimizeDeps entirely for this internal server to avoid that race.
-      optimizeDeps: {
-        disabled: true
-      },
-      resolve: {
-        alias: {
-          "@": cwd
-        }
-      },
-      // Important: Do NOT include @vitejs/plugin-vue here.
-      // We stub all `.vue` imports ourselves, and including the Vue plugin would attempt to parse
-      // those stubbed modules as real SFCs (and fail).
-      plugins: [createRouterIntrospectionVueStubPlugin({ routerEntryAbs: routerEntry, moduleShims })]
-    });
+    const restoreDomShim = ensureDomShim();
     try {
-      const moduleId = node_url.pathToFileURL(routerEntry).href;
-      debugLog(`ssrLoadModule(${moduleId}) start`);
-      const mod = await server.ssrLoadModule(moduleId);
-      debugLog(`ssrLoadModule(${moduleId}) done; hasDefault=${typeof mod?.default === "function"}`);
-      const makeRouter = mod?.default;
-      if (typeof makeRouter !== "function") {
-        throw new TypeError(`[vue-pom-generator] ${routerEntry} must export a default router factory function (export default makeRouter).`);
-      }
-      let router;
+      debugLog(`parseRouterFileFromCwd cwd=${cwd}`);
+      const vite = await import("vite");
+      const server = await vite.createServer({
+        root: cwd,
+        configFile: false,
+        logLevel: "error",
+        // This server is created only to SSR-load the router module. Disable HMR/WebSocket
+        // to avoid port conflicts in dev/test environments.
+        server: { middlewareMode: true, hmr: false, ws: false },
+        appType: "custom",
+        // IMPORTANT:
+        // This internal, short-lived Vite server exists only to `ssrLoadModule()` the router entry.
+        // We close it immediately after reading routes.
+        //
+        // Vite's dependency optimizer (vite:dep-scan / optimizeDeps) runs asynchronously and can
+        // still have pending resolve requests when we call `server.close()`, which surfaces as:
+        //   "The server is being restarted or closed. Request is outdated [plugin vite:dep-scan]"
+        //
+        // Disable optimizeDeps entirely for this internal server to avoid that race.
+        optimizeDeps: {
+          disabled: true
+        },
+        resolve: {
+          alias: {
+            "@": cwd
+          }
+        },
+        // Important: Do NOT include @vitejs/plugin-vue here.
+        // We stub all `.vue` imports ourselves, and including the Vue plugin would attempt to parse
+        // those stubbed modules as real SFCs (and fail).
+        plugins: [createRouterIntrospectionVueStubPlugin({ routerEntryAbs: routerEntry, moduleShims })]
+      });
       try {
-        router = makeRouter();
-      } catch (err) {
-        throw new Error(`[vue-pom-generator] makeRouter() invocation failed: ${String(err)}`);
-      }
-      const routeNameMap = /* @__PURE__ */ new Map();
-      const routePathMap = /* @__PURE__ */ new Map();
-      const routeMetaEntries = [];
-      for (const r of router.getRoutes()) {
-        const componentInfo = await getComponentInfoFromRouteRecord(r, { rootDir: cwd });
-        const componentName = resolveIntrospectedComponentName(componentInfo, options.componentNaming);
-        if (!componentName)
-          continue;
-        if (typeof r.path === "string" && r.path.length) {
-          routePathMap.set(r.path, componentName);
+        const moduleId = node_url.pathToFileURL(routerEntry).href;
+        debugLog(`ssrLoadModule(${moduleId}) start`);
+        const mod = await server.ssrLoadModule(moduleId);
+        debugLog(`ssrLoadModule(${moduleId}) done; hasDefault=${typeof mod?.default === "function"}`);
+        const makeRouter = mod?.default;
+        if (typeof makeRouter !== "function") {
+          throw new TypeError(`[vue-pom-generator] ${routerEntry} must export a default router factory function (export default makeRouter).`);
         }
-        if (typeof r.name === "string" && r.name.length) {
-          const key = toPascalCase(r.name);
-          routeNameMap.set(key, componentName);
+        let router;
+        try {
+          router = makeRouter();
+        } catch (err) {
+          throw new Error(`[vue-pom-generator] makeRouter() invocation failed: ${String(err)}`);
         }
-        const { paramKeys, queryKeys } = getRoutePropsKeys(r);
-        const paramsMeta = getRouteParamMeta(router, r, paramKeys);
-        const pathTemplate = buildRouteTemplate(router, r, paramsMeta.map((p) => p.name));
-        if (typeof pathTemplate === "string" && pathTemplate.length) {
-          routeMetaEntries.push({
-            componentName,
-            pathTemplate,
-            params: paramsMeta,
-            query: queryKeys
-          });
+        const routeNameMap = /* @__PURE__ */ new Map();
+        const routePathMap = /* @__PURE__ */ new Map();
+        const routeMetaEntries = [];
+        for (const r of router.getRoutes()) {
+          const componentInfo = await getComponentInfoFromRouteRecord(r, { rootDir: cwd });
+          const componentName = resolveIntrospectedComponentName(componentInfo, options.componentNaming);
+          if (!componentName)
+            continue;
+          if (typeof r.path === "string" && r.path.length) {
+            routePathMap.set(r.path, componentName);
+          }
+          if (typeof r.name === "string" && r.name.length) {
+            const key = toPascalCase(r.name);
+            routeNameMap.set(key, componentName);
+          }
+          const { paramKeys, queryKeys } = getRoutePropsKeys(r);
+          const paramsMeta = getRouteParamMeta(router, r, paramKeys);
+          const pathTemplate = buildRouteTemplate(router, r, paramsMeta.map((p) => p.name));
+          if (typeof pathTemplate === "string" && pathTemplate.length) {
+            routeMetaEntries.push({
+              componentName,
+              pathTemplate,
+              params: paramsMeta,
+              query: queryKeys
+            });
+          }
         }
+        return { routeNameMap, routePathMap, routeMetaEntries };
+      } finally {
+        debugLog("closing internal vite server");
+        await server.close();
       }
-      return { routeNameMap, routePathMap, routeMetaEntries };
     } finally {
-      debugLog("closing internal vite server");
-      await server.close();
+      restoreDomShim();
     }
   });
 }