@djangocfg/nextjs 2.1.516 → 2.1.519

package/src/pwa/plugin.ts

@@ -1,215 +1,129 @@
 /**
- * PWA (Progressive Web App) Plugin
+ * PWA (Progressive Web App) Plugin — dependency-free.
  *
- * Configures Serwist for service worker and offline support
- * Modern PWA solution for Next.js 15+ with App Router
+ * History: this used to wrap `@serwist/next`. Serwist is a **webpack** plugin,
+ * and Next.js 16 defaults to Turbopack, which does not run webpack loaders and
+ * chokes on serwist's `fileURLToPath(new URL(".", import.meta.url))` during
+ * static tracing — failing the whole build even when PWA was never enabled
+ * (the mere `require('@serwist/next')` reference was enough). Since no app in
+ * this monorepo actually turned PWA on (`withPWA` is opt-in and unused), we
+ * dropped serwist entirely.
  *
- * @see https://serwist.pages.dev/
+ * What remains:
+ *   - `createManifest` (in `./manifest`) — the web app manifest, which Next.js
+ *     supports natively via `app/manifest.ts`; needs no library at all.
+ *   - `withPWA` — a thin, Turbopack-safe pass-through kept for API stability.
+ *   - `getServiceWorkerTemplate` — a vanilla service worker you can drop into
+ *     `app/sw.ts`, no framework runtime required.
+ *
+ * If you want a full precache/offline story back, wire a real service worker
+ * (the template below, or Workbox) yourself — but do it in an app, not here, so
+ * one app's PWA choice can't break every consumer's build.
  */
 
 import type { NextConfig } from 'next';
-import { consola } from 'consola';
-import { createRequire } from 'module';
-
-// Serwist is an optional peer loaded synchronously at config time, which
-// `import()` cannot do. `createRequire` is the ESM-safe equivalent of `require`.
-const requirePeer = createRequire(import.meta.url);
 
 export interface PWAPluginOptions {
   /**
-   * Destination directory for service worker files
-   * @default 'public'
-   * @deprecated Use swDest instead
-   */
-  dest?: string;
-
-  /**
-   * Path to service worker source file (relative to project root)
+   * Path to service worker source file (relative to project root).
    * @default 'app/sw.ts'
    */
   swSrc?: string;
 
   /**
-   * Destination for compiled service worker
+   * Destination for the compiled service worker.
    * @default 'public/sw.js'
    */
   swDest?: string;
 
   /**
-   * Disable PWA completely
-   * @default false in production, true in development
-   * @example disable: process.env.NODE_ENV === 'development'
+   * Disable PWA completely.
+   * @default true in development / static export, false otherwise
    */
   disable?: boolean;
 
-  /**
-   * Cache on navigation - cache pages when navigating
-   * @default true
-   */
+  /** Cache pages on navigation. Consumed by a custom SW, if any. @default true */
   cacheOnNavigation?: boolean;
 
-  /**
-   * Reload app when device goes back online
-   * @default true
-   */
+  /** Reload the app when the device comes back online. @default true */
   reloadOnOnline?: boolean;
-
-  /**
-   * Additional Serwist options
-   * @see https://serwist.pages.dev/docs/next/configuring
-   */
-  serwistOptions?: Record<string, any>;
 }
 
 /**
- * Add PWA configuration to Next.js config using Serwist
+ * Turbopack-safe PWA pass-through.
  *
- * @example Basic usage
- * ```ts
- * import { createBaseNextConfig, withPWA } from '@djangocfg/nextjs/config';
+ * This no longer injects a build plugin — Next.js's native manifest support
+ * plus a hand-written `app/sw.ts` (see {@link getServiceWorkerTemplate}) cover
+ * the PWA surface without a webpack-only dependency. Kept as a named export so
+ * existing `withPWA(config)` / `createBaseNextConfig({ pwa })` call sites keep
+ * type-checking and behave predictably (they return the config unchanged).
  *
- * const nextConfig = createBaseNextConfig({...});
- *
- * export default withPWA(nextConfig, {
- *   swSrc: 'app/sw.ts',
- *   disable: process.env.NODE_ENV === 'development',
- * });
- * ```
- *
- * @example Integrated with createBaseNextConfig
+ * @example
  * ```ts
  * import { createBaseNextConfig } from '@djangocfg/nextjs/config';
- *
- * const config = createBaseNextConfig({
- *   pwa: {
- *     swSrc: 'app/sw.ts',
- *     disable: false,
- *   },
- * });
- *
- * export default config;
+ * export default createBaseNextConfig({ pwa: { swSrc: 'app/sw.ts' } });
  * ```
  */
 export function withPWA(
   nextConfig: NextConfig,
-  options: PWAPluginOptions = {}
+  _options: PWAPluginOptions = {}
 ): NextConfig {
-  const isDev = process.env.NODE_ENV === 'development';
-  const isStaticBuild = process.env.NEXT_PUBLIC_STATIC_BUILD === 'true';
-
-  // Determine if PWA should be disabled:
-  // - Explicitly disabled via options
-  // - In development mode (default)
-  // - Static build (output: 'export' doesn't support service workers)
-  const shouldDisable = options.disable !== undefined
-    ? options.disable
-    : (isDev || isStaticBuild);
-
-  const defaultOptions: PWAPluginOptions = {
-    swSrc: 'app/sw.ts',
-    swDest: 'public/sw.js',
-    disable: shouldDisable,
-    cacheOnNavigation: true,
-    reloadOnOnline: true,
-    ...options,
-  };
-
-  try {
-    // Suppress Turbopack warning - it only applies to dev mode, not production builds
-    // The warning is misleading when running `next build` with Turbopack
-    // See: https://github.com/serwist/serwist/issues/54
-    if (!process.env.SERWIST_SUPPRESS_TURBOPACK_WARNING) {
-      process.env.SERWIST_SUPPRESS_TURBOPACK_WARNING = '1';
-    }
-
-    const withSerwistInit = requirePeer('@serwist/next').default;
-
-    const withSerwist = withSerwistInit({
-      swSrc: defaultOptions.swSrc,
-      swDest: defaultOptions.swDest,
-      disable: defaultOptions.disable,
-      cacheOnNavigation: defaultOptions.cacheOnNavigation,
-      reloadOnOnline: defaultOptions.reloadOnOnline,
-      ...defaultOptions.serwistOptions,
-    });
-
-    return withSerwist(nextConfig);
-  } catch (error) {
-    consola.error('Failed to configure Serwist:', error);
-    return nextConfig;
-  }
+  return nextConfig;
 }
 
 /**
- * Get service worker template content
+ * Vanilla service-worker template — no library.
  *
- * Returns ready-to-use service worker code for app/sw.ts
+ * Returns ready-to-use, framework-free service worker source. Copy it into
+ * `app/sw.ts` (or generate it) if you want offline support. It uses only the
+ * standard Service Worker + Cache APIs, so it builds under Turbopack with no
+ * extra dependency.
  *
  * @example
  * ```ts
  * import { getServiceWorkerTemplate } from '@djangocfg/nextjs/config';
- *
- * // Copy this to your app/sw.ts file
- * console.log(getServiceWorkerTemplate());
+ * console.log(getServiceWorkerTemplate()); // → paste into app/sw.ts
  * ```
  */
 export function getServiceWorkerTemplate(): string {
   return `/**
- * Service Worker (Serwist)
- *
- * Modern PWA service worker using Serwist
+ * Service Worker (vanilla) — standard Cache + Fetch APIs, no library.
  */
 
-import { defaultCache } from '@serwist/next/worker';
-import { Serwist } from 'serwist';
-
+/// <reference lib="webworker" />
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 declare const self: any;
 
-const serwist = new Serwist({
-  // Precache entries injected by Serwist build plugin
-  precacheEntries: self.__SW_MANIFEST,
+const CACHE = 'app-cache-v1';
+const OFFLINE_URL = '/_offline';
 
-  // Skip waiting - activate new SW immediately
-  skipWaiting: true,
-
-  // Take control of all clients immediately
-  clientsClaim: true,
-
-  // Enable navigation preload for faster loads
-  navigationPreload: true,
-
-  // Use default Next.js runtime caching strategies
-  runtimeCaching: defaultCache,
+// Precache the offline fallback on install.
+self.addEventListener('install', (event: any) => {
+  event.waitUntil(
+    caches.open(CACHE).then((cache: Cache) => cache.addAll([OFFLINE_URL]))
+  );
+  self.skipWaiting();
+});
 
-  // Fallback pages for offline
-  fallbacks: {
-    entries: [
-      {
-        url: '/_offline',
-        matcher({ request }) {
-          return request.destination === 'document';
-        },
-      },
-    ],
-  },
+// Drop stale caches on activate and take control immediately.
+self.addEventListener('activate', (event: any) => {
+  event.waitUntil(
+    caches.keys().then((keys: string[]) =>
+      Promise.all(keys.filter((k) => k !== CACHE).map((k) => caches.delete(k)))
+    )
+  );
+  self.clients.claim();
 });
 
-serwist.addEventListeners();
+// Network-first for navigations, with an offline fallback.
+self.addEventListener('fetch', (event: any) => {
+  const { request } = event;
+  if (request.mode !== 'navigate') return;
+  event.respondWith(
+    fetch(request).catch(() =>
+      caches.match(OFFLINE_URL).then((r: Response | undefined) => r ?? Response.error())
+    )
+  );
+});
 `;
 }
-
-// Backward compatibility exports (deprecated)
-export const defaultRuntimeCaching = [];
-export function createApiCacheRule() {
-  consola.warn('createApiCacheRule is deprecated with Serwist. Use defaultCache from @serwist/next/worker');
-  return {};
-}
-export function createStaticAssetRule() {
-  consola.warn('createStaticAssetRule is deprecated with Serwist. Use defaultCache from @serwist/next/worker');
-  return {};
-}
-export function createCdnCacheRule() {
-  consola.warn('createCdnCacheRule is deprecated with Serwist. Use defaultCache from @serwist/next/worker');
-  return {};
-}

package/src/pwa/worker/index.ts

@@ -1,94 +1,80 @@
 /**
- * Service Worker Utilities
+ * Service Worker Utilities — vanilla, dependency-free.
  *
- * Ready-to-use Serwist configuration for Next.js PWA
+ * Was a Serwist wrapper; serwist is a webpack-only plugin incompatible with
+ * Next.js 16's Turbopack, so this is now a hand-written service worker built on
+ * the standard Service Worker + Cache APIs. Same `createServiceWorker(options)`
+ * entry point, no library, Turbopack-safe.
  */
 
 /// <reference lib="webworker" />
 
-import { Serwist } from 'serwist';
-
-import { defaultCache } from '@serwist/next/worker';
-
 export interface ServiceWorkerOptions {
-  /**
-   * Offline fallback URL
-   * @default '/_offline'
-   */
+  /** Offline fallback URL. @default '/_offline' */
   offlineFallback?: string;
-
-  /**
-   * Skip waiting - activate new SW immediately
-   * @default true
-   */
+  /** Activate a new SW immediately instead of waiting. @default true */
   skipWaiting?: boolean;
-
-  /**
-   * Take control of all clients immediately
-   * @default true
-   */
+  /** Take control of open clients immediately. @default true */
   clientsClaim?: boolean;
-
-  /**
-   * Enable navigation preload for faster loads
-   * @default true
-   */
-  navigationPreload?: boolean;
+  /** Name of the runtime cache bucket. @default 'app-cache-v1' */
+  cacheName?: string;
 }
 
 /**
- * Create and initialize Serwist service worker
+ * Register a minimal offline-capable service worker.
+ *
+ * Network-first for navigations with an offline fallback page; stale caches are
+ * cleared on activate. No precache manifest (that was a serwist build-time
+ * injection) — add your own `cache.addAll([...])` in the install step if you
+ * need assets precached.
  *
  * @example
  * ```ts
  * // app/sw.ts
  * import { createServiceWorker } from '@djangocfg/nextjs/worker';
- *
- * createServiceWorker({
- *   offlineFallback: '/_offline',
- * });
+ * createServiceWorker({ offlineFallback: '/_offline' });
  * ```
  */
-export function createServiceWorker(options: ServiceWorkerOptions = {}) {
+export function createServiceWorker(options: ServiceWorkerOptions = {}): void {
   const {
     offlineFallback = '/_offline',
     skipWaiting = true,
     clientsClaim = true,
-    navigationPreload = true,
+    cacheName = 'app-cache-v1',
   } = options;
 
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const self = globalThis as any;
-  console.log('SW: Worker Initialized 🚀');
+  const sw = self as any;
 
-  const serwist = new Serwist({
-    // Precache entries injected by Serwist build plugin
-    precacheEntries: self.__SW_MANIFEST,
-
-    // Skip waiting - activate new SW immediately
-    skipWaiting,
-
-    // Take control of all clients immediately
-    clientsClaim,
-
-    // Enable navigation preload for faster loads
-    navigationPreload,
-
-    // Use default Next.js runtime caching strategies
-    runtimeCaching: defaultCache,
+  sw.addEventListener('install', (event: any) => {
+    event.waitUntil(
+      caches.open(cacheName).then((cache: Cache) => cache.addAll([offlineFallback]))
+    );
+    if (skipWaiting) sw.skipWaiting();
+  });
 
-    // Fallback pages for offline
-    fallbacks: {
-      entries: [
-        {
-          url: offlineFallback,
-          matcher({ request }) {
-            return request.destination === 'document';
-          },
-        },
-      ],
-    },
+  sw.addEventListener('activate', (event: any) => {
+    event.waitUntil(
+      caches
+        .keys()
+        .then((keys: string[]) =>
+          Promise.all(keys.filter((k) => k !== cacheName).map((k) => caches.delete(k)))
+        )
+        .then(() => {
+          if (clientsClaim) return sw.clients.claim();
+        })
+    );
   });
 
-  serwist.addEventListeners();
+  sw.addEventListener('fetch', (event: any) => {
+    const { request } = event;
+    if (request.mode !== 'navigate') return;
+    event.respondWith(
+      fetch(request).catch(() =>
+        caches
+          .match(offlineFallback)
+          .then((r: Response | undefined) => r ?? Response.error())
+      )
+    );
+  });
 }

package/dist/plugin-DdmK3zAE.d.mts

@@ -1,100 +0,0 @@
-import { NextConfig } from 'next';
-
-/**
- * PWA (Progressive Web App) Plugin
- *
- * Configures Serwist for service worker and offline support
- * Modern PWA solution for Next.js 15+ with App Router
- *
- * @see https://serwist.pages.dev/
- */
-
-interface PWAPluginOptions {
-    /**
-     * Destination directory for service worker files
-     * @default 'public'
-     * @deprecated Use swDest instead
-     */
-    dest?: string;
-    /**
-     * Path to service worker source file (relative to project root)
-     * @default 'app/sw.ts'
-     */
-    swSrc?: string;
-    /**
-     * Destination for compiled service worker
-     * @default 'public/sw.js'
-     */
-    swDest?: string;
-    /**
-     * Disable PWA completely
-     * @default false in production, true in development
-     * @example disable: process.env.NODE_ENV === 'development'
-     */
-    disable?: boolean;
-    /**
-     * Cache on navigation - cache pages when navigating
-     * @default true
-     */
-    cacheOnNavigation?: boolean;
-    /**
-     * Reload app when device goes back online
-     * @default true
-     */
-    reloadOnOnline?: boolean;
-    /**
-     * Additional Serwist options
-     * @see https://serwist.pages.dev/docs/next/configuring
-     */
-    serwistOptions?: Record<string, any>;
-}
-/**
- * Add PWA configuration to Next.js config using Serwist
- *
- * @example Basic usage
- * ```ts
- * import { createBaseNextConfig, withPWA } from '@djangocfg/nextjs/config';
- *
- * const nextConfig = createBaseNextConfig({...});
- *
- * export default withPWA(nextConfig, {
- *   swSrc: 'app/sw.ts',
- *   disable: process.env.NODE_ENV === 'development',
- * });
- * ```
- *
- * @example Integrated with createBaseNextConfig
- * ```ts
- * import { createBaseNextConfig } from '@djangocfg/nextjs/config';
- *
- * const config = createBaseNextConfig({
- *   pwa: {
- *     swSrc: 'app/sw.ts',
- *     disable: false,
- *   },
- * });
- *
- * export default config;
- * ```
- */
-declare function withPWA(nextConfig: NextConfig, options?: PWAPluginOptions): NextConfig;
-/**
- * Get service worker template content
- *
- * Returns ready-to-use service worker code for app/sw.ts
- *
- * @example
- * ```ts
- * import { getServiceWorkerTemplate } from '@djangocfg/nextjs/config';
- *
- * // Copy this to your app/sw.ts file
- * console.log(getServiceWorkerTemplate());
- * ```
- */
-declare function getServiceWorkerTemplate(): string;
-declare const defaultRuntimeCaching: any[];
-declare function createApiCacheRule(): {};
-declare function createStaticAssetRule(): {};
-declare function createCdnCacheRule(): {};
-
-export { type PWAPluginOptions as P, createCdnCacheRule as a, createStaticAssetRule as b, createApiCacheRule as c, defaultRuntimeCaching as d, getServiceWorkerTemplate as g, withPWA as w };