@wular/pnext 0.0.4 → 0.0.6

package/src/compat/cache/custom-handler.ts

@@ -14,17 +14,17 @@
 // single require covers every shape.
 // ---------------------------------------------------------------------------
 
-import { createRequire } from 'node:module';
-import { existsSync, readFileSync } from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-import { getNextConfig } from '../next/config-loader';
-import { setCacheHandler, type CacheHandler } from './handler';
+import { createRequire } from 'node:module'
+import { existsSync, readFileSync } from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+import { getNextConfig } from '../next/config-loader'
+import { setCacheHandler, type CacheHandler } from './handler'
 
-type CacheHandlerCtor = new (options: { maxMemoryCacheSize?: number }) => CacheHandler;
+type CacheHandlerCtor = new (options: { maxMemoryCacheSize?: number }) => CacheHandler
 
-let installedFor: string | undefined;
-let installedRoot: string | undefined;
+let installedFor: string | undefined
+let installedRoot: string | undefined
 
 /**
  * Load + instantiate the configured `cacheHandler` and install it into core.
@@ -32,16 +32,16 @@ let installedRoot: string | undefined;
  * ("initialized custom cache-handler") are what the suites assert.
  */
 export function installCustomCacheHandler(root: string): void {
-  const configured = getNextConfig().cacheHandler;
+  const configured = getNextConfig().cacheHandler
   if (typeof configured !== 'string' || configured.length === 0) {
     if (installedFor !== undefined) {
-      setCacheHandler(undefined);
-      installedFor = undefined;
-      installedRoot = undefined;
+      setCacheHandler(undefined)
+      installedFor = undefined
+      installedRoot = undefined
     }
-    return;
+    return
   }
-  const resolved = configured.startsWith('file:') ? fileURLToPath(configured) : configured;
+  const resolved = configured.startsWith('file:') ? fileURLToPath(configured) : configured
   // `import.meta.resolve('./x.js')` in next.config resolves against the bundled
   // config location (`.pnext/config/`), not the project — fall back to the same
   // basename at the project root so the handler still loads.
@@ -50,39 +50,39 @@ export function installCustomCacheHandler(root: string): void {
       ? resolved
       : existsSync(path.join(root, path.basename(resolved)))
         ? path.join(root, path.basename(resolved))
-        : resolved;
-  if (installedFor === filePath) return;
+        : resolved
+  if (installedFor === filePath) return
 
-  const Ctor = loadHandlerCtor(filePath, root);
-  if (!Ctor) return;
-  const instance = new Ctor({});
-  setCacheHandler(instance);
-  installedFor = filePath;
-  installedRoot = root;
+  const Ctor = loadHandlerCtor(filePath, root)
+  if (!Ctor) return
+  const instance = new Ctor({})
+  setCacheHandler(instance)
+  installedFor = filePath
+  installedRoot = root
 }
 
 export function reinstallCustomCacheHandlerForEdge(): void {
-  if (!installedRoot) return;
-  installedFor = undefined;
-  installCustomCacheHandler(installedRoot);
+  if (!installedRoot) return
+  installedFor = undefined
+  installCustomCacheHandler(installedRoot)
 }
 
 function loadHandlerCtor(filePath: string, root: string): CacheHandlerCtor | undefined {
   try {
-    const require = createRequire(pathToFileURL(`${root}/index.js`).href);
+    const require = createRequire(pathToFileURL(`${root}/index.js`).href)
     try {
-      return pickCtor(require(filePath));
+      return pickCtor(require(filePath))
     } catch (error) {
       // Handlers commonly extend Next internals (e.g. `require('next/dist/
       // server/lib/incremental-cache/file-system-cache')`) that don't exist
       // without a real `next` install. Re-evaluate the module with those
       // requires stubbed to an inert base class so the subclass (whose own
       // get/set overrides carry the observable behavior) still loads.
-      if (!isNextDistMissing(error)) return undefined;
-      return loadCommonJsCtorWithNextStubs(filePath, require);
+      if (!isNextDistMissing(error)) return undefined
+      return loadCommonJsCtorWithNextStubs(filePath, require)
     }
   } catch {
-    return undefined;
+    return undefined
   }
 }
 
@@ -91,33 +91,40 @@ function loadCommonJsCtorWithNextStubs(
   rootRequire: NodeRequire,
 ): CacheHandlerCtor | undefined {
   try {
-    const module = { exports: {} as unknown };
+    const module = { exports: {} as unknown }
     const localRequire = (specifier: string): unknown => {
-      if (specifier.startsWith('next/dist/')) return nextDistStubModule();
+      if (specifier.startsWith('next/dist/')) return nextDistStubModule()
       if (specifier.startsWith('./') || specifier.startsWith('../')) {
-        return rootRequire(path.resolve(path.dirname(filePath), specifier));
+        return rootRequire(path.resolve(path.dirname(filePath), specifier))
       }
-      return rootRequire(specifier);
-    };
-    const source = readFileSync(filePath, 'utf8');
+      return rootRequire(specifier)
+    }
+    const source = readFileSync(filePath, 'utf8')
     // eslint-disable-next-line @typescript-eslint/no-implied-eval
-    const evaluate = new Function('require', 'module', 'exports', '__filename', '__dirname', source) as (
+    const evaluate = new Function(
+      'require',
+      'module',
+      'exports',
+      '__filename',
+      '__dirname',
+      source,
+    ) as (
       require: (specifier: string) => unknown,
       module: { exports: unknown },
       exports: unknown,
       filename: string,
       dirname: string,
-    ) => void;
-    evaluate(localRequire, module, module.exports, filePath, path.dirname(filePath));
-    return pickCtor(module.exports);
+    ) => void
+    evaluate(localRequire, module, module.exports, filePath, path.dirname(filePath))
+    return pickCtor(module.exports)
   } catch {
-    return undefined;
+    return undefined
   }
 }
 
 function isNextDistMissing(error: unknown): boolean {
-  const message = (error as { message?: unknown }).message;
-  return typeof message === 'string' && message.includes('next/dist/');
+  const message = (error as { message?: unknown }).message
+  return typeof message === 'string' && message.includes('next/dist/')
 }
 
 /**
@@ -129,16 +136,16 @@ function isNextDistMissing(error: unknown): boolean {
 function nextDistStubModule(): unknown {
   class NextDistStub {
     get(): Promise<null> {
-      return Promise.resolve(null);
+      return Promise.resolve(null)
     }
     set(): Promise<void> {
-      return Promise.resolve();
+      return Promise.resolve()
     }
     revalidateTag(): Promise<void> {
-      return Promise.resolve();
+      return Promise.resolve()
     }
     resetRequestCache(): null {
-      return null;
+      return null
     }
   }
   return new Proxy(NextDistStub, {
@@ -146,14 +153,14 @@ function nextDistStubModule(): unknown {
       key === 'default'
         ? NextDistStub
         : ((target as unknown as Record<string | symbol, unknown>)[key] ?? NextDistStub),
-  });
+  })
 }
 
 function pickCtor(mod: unknown): CacheHandlerCtor | undefined {
-  if (typeof mod === 'function') return mod as CacheHandlerCtor;
+  if (typeof mod === 'function') return mod as CacheHandlerCtor
   if (mod && typeof mod === 'object') {
-    const record = mod as Record<string, unknown>;
-    if (typeof record.default === 'function') return record.default as CacheHandlerCtor;
+    const record = mod as Record<string, unknown>
+    if (typeof record.default === 'function') return record.default as CacheHandlerCtor
   }
-  return undefined;
+  return undefined
 }