@wells-nelson/build-tools 1.0.0 → 1.0.2

package/README.md

@@ -40,14 +40,19 @@ export default defineConfig(({ mode, command }) => ({
 
 ```ts
 /// <reference types="@sveltejs/kit" />
-import { version } from '$app/env';
+import { dev, version } from '$app/env';
 import { assets, immutable } from '$app/manifest';
 import { self } from '$app/service-worker';
 import { registerAppShellCache } from '@wells-nelson/build-tools/service-worker';
 
-registerAppShellCache({ sw: self, version, files: [...immutable, ...assets], cachePrefix: 'my-app' });
+registerAppShellCache({ sw: self, version, dev, files: [...immutable, ...assets], cachePrefix: 'my-app' });
 ```
 
+Navigations go to the network first, so starting the app online always loads the latest deploy;
+offline they fall back to the cached shell. A new worker skips waiting and takes over open
+pages. `networkOnly` paths are never cached (default: SvelteKit's `_app/version.json`, so
+`updated` from `$app/state` notices new deploys). `dev` caches nothing.
+
 ## Templates
 
 `templates/deploy-pages.yml` (replace `__REPO__`) and `templates/manifest.webmanifest`.

package/dist/service-worker.d.ts

@@ -1,17 +1,19 @@
 /**
  * Offline-first app shell for a SvelteKit service worker. Everything the app needs is precached
- * on install; navigations fall back to the cached shell (the app root) when the network is
- * unavailable; cross-origin requests (Supabase, Google avatars) are left to the network.
+ * on install; navigations go to the network first (so starting the app online always
+ * loads the latest deploy) and fall back to the cached shell (the app root) offline. A new
+ * deploy's worker installs, skips waiting and takes over open pages straight away. Cross-origin
+ * requests (Supabase, Google avatars) are left to the network.
  *
  * ```ts
  * // src/service-worker/index.ts
  * /// <reference types="@sveltejs/kit" />
- * import { version } from '$app/env';
+ * import { dev, version } from '$app/env';
  * import { assets, immutable } from '$app/manifest';
  * import { self } from '$app/service-worker';
  * import { registerAppShellCache } from '@wells-nelson/build-tools/service-worker';
  *
- * registerAppShellCache({ sw: self, version, files: [...immutable, ...assets], cachePrefix: 'my-app' });
+ * registerAppShellCache({ sw: self, version, dev, files: [...immutable, ...assets], cachePrefix: 'my-app' });
  * ```
  */
 /** The parts of ServiceWorkerGlobalScope this uses (so it type-checks without the WebWorker lib). */
@@ -35,8 +37,22 @@ export interface AppShellCacheOptions {
     }>;
     /** Cache name prefix (default 'app'). */
     cachePrefix?: string;
+    /**
+     * Development: cache nothing and delete what an earlier worker cached, so every code change
+     * loads (a cache-first worker would otherwise keep serving stale dev modules).
+     */
+    dev?: boolean;
+    /**
+     * Paths (relative to the scope) that always go to the network and are never cached. Defaults
+     * to SvelteKit's `_app/version.json`, so its update check (`updated` in `$app/state`) sees
+     * new deploys instead of the first answer it ever cached.
+     */
+    networkOnly?: string[];
 }
-export declare function registerAppShellCache({ sw, version, files, cachePrefix }: AppShellCacheOptions): {
+export declare function registerAppShellCache({ sw, version, files, cachePrefix, dev, networkOnly }: AppShellCacheOptions): {
+    cacheName: null;
+    precache: never[];
+} | {
     cacheName: string;
     precache: string[];
 };

package/dist/service-worker.js

@@ -1,24 +1,39 @@
 /**
  * Offline-first app shell for a SvelteKit service worker. Everything the app needs is precached
- * on install; navigations fall back to the cached shell (the app root) when the network is
- * unavailable; cross-origin requests (Supabase, Google avatars) are left to the network.
+ * on install; navigations go to the network first (so starting the app online always
+ * loads the latest deploy) and fall back to the cached shell (the app root) offline. A new
+ * deploy's worker installs, skips waiting and takes over open pages straight away. Cross-origin
+ * requests (Supabase, Google avatars) are left to the network.
  *
  * ```ts
  * // src/service-worker/index.ts
  * /// <reference types="@sveltejs/kit" />
- * import { version } from '$app/env';
+ * import { dev, version } from '$app/env';
  * import { assets, immutable } from '$app/manifest';
  * import { self } from '$app/service-worker';
  * import { registerAppShellCache } from '@wells-nelson/build-tools/service-worker';
  *
- * registerAppShellCache({ sw: self, version, files: [...immutable, ...assets], cachePrefix: 'my-app' });
+ * registerAppShellCache({ sw: self, version, dev, files: [...immutable, ...assets], cachePrefix: 'my-app' });
  * ```
  */
-export function registerAppShellCache({ sw, version, files, cachePrefix = 'app' }) {
+export function registerAppShellCache({ sw, version, files, cachePrefix = 'app', dev = false, networkOnly = ['_app/version.json'] }) {
     const CACHE = `${cachePrefix}-cache-${version}`;
+    if (dev) {
+        sw.addEventListener('install', (event) => event.waitUntil(sw.skipWaiting()));
+        sw.addEventListener('activate', (event) => {
+            event.waitUntil((async () => {
+                for (const key of await caches.keys())
+                    if (key.startsWith(`${cachePrefix}-cache-`))
+                        await caches.delete(key);
+                await sw.clients.claim();
+            })());
+        });
+        return { cacheName: null, precache: [] };
+    }
     const scope = new URL(sw.registration.scope);
     // The app root serves the SPA shell (index.html on GitHub Pages, the fallback page elsewhere).
     const SHELL = scope.href;
+    const NETWORK_ONLY = new Set(networkOnly.map((p) => new URL(p, scope).pathname));
     const PRECACHE = files.map((f) => new URL(typeof f === 'string' ? f : f.path, scope).href).concat(SHELL);
     sw.addEventListener('install', (event) => {
         event.waitUntil((async () => {
@@ -40,7 +55,7 @@ export function registerAppShellCache({ sw, version, files, cachePrefix = 'app'
         if (request.method !== 'GET')
             return;
         const url = new URL(request.url);
-        if (url.origin !== scope.origin)
+        if (url.origin !== scope.origin || NETWORK_ONLY.has(url.pathname))
             return;
         if (request.mode === 'navigate') {
             event.respondWith((async () => {

package/dist/vite.d.ts

@@ -16,8 +16,19 @@ export declare function basePath({ mode, env, fallback }: {
  * break ("Cannot read properties of undefined (reading 'call')" / a 500 page) until a full reload.
  */
 export declare const SHARED_OPTIMIZE_DEPS: string[];
-/** `optimizeDeps` with the shared list plus the app's own lazily loaded deps (e.g. a search library). */
-export declare function optimizeDeps(extra?: string[]): {
+/**
+ * Entry points of the Wells Nelson packages. They must be pre-bundled at startup too: one
+ * imported only by a lazily loaded page (e.g. `interactions/account`) or by the service worker
+ * otherwise triggers the same mid-session re-bundle.
+ */
+export declare const WELLS_NELSON_ENTRIES: string[];
+/** The entries that resolve from `root` (an app installs only the packages it uses). */
+export declare function installedEntries(entries: string[], root?: string): string[];
+/**
+ * `optimizeDeps` with the shared runtime dependencies, every installed Wells Nelson entry point,
+ * and the app's own lazily loaded deps (e.g. a search library).
+ */
+export declare function optimizeDeps(extra?: string[], root?: string): {
     include: string[];
 };
 /**

package/dist/vite.js

@@ -1,5 +1,6 @@
 import { existsSync, readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
+import { createRequire } from 'node:module';
+import { join, resolve } from 'node:path';
 /**
  * SvelteKit `paths.base` from the BASE_PATH env var: the one place the deploy path is configured.
  * GitHub project pages are served from /<repo-name> (the `fallback`); set BASE_PATH to "/" for
@@ -23,9 +24,37 @@ export const SHARED_OPTIMIZE_DEPS = [
     'rxdb/plugins/replication-supabase',
     'rxdb/plugins/storage-dexie'
 ];
-/** `optimizeDeps` with the shared list plus the app's own lazily loaded deps (e.g. a search library). */
-export function optimizeDeps(extra = []) {
-    return { include: [...extra, ...SHARED_OPTIMIZE_DEPS] };
+/**
+ * Entry points of the Wells Nelson packages. They must be pre-bundled at startup too: one
+ * imported only by a lazily loaded page (e.g. `interactions/account`) or by the service worker
+ * otherwise triggers the same mid-session re-bundle.
+ */
+export const WELLS_NELSON_ENTRIES = [
+    '@wells-nelson/displays',
+    '@wells-nelson/interactions',
+    '@wells-nelson/interactions/account',
+    '@wells-nelson/data-storage',
+    '@wells-nelson/build-tools/service-worker'
+];
+/** The entries that resolve from `root` (an app installs only the packages it uses). */
+export function installedEntries(entries, root = process.cwd()) {
+    const require = createRequire(join(root, 'package.json'));
+    return entries.filter((id) => {
+        try {
+            require.resolve(id);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    });
+}
+/**
+ * `optimizeDeps` with the shared runtime dependencies, every installed Wells Nelson entry point,
+ * and the app's own lazily loaded deps (e.g. a search library).
+ */
+export function optimizeDeps(extra = [], root = process.cwd()) {
+    return { include: [...extra, ...installedEntries(WELLS_NELSON_ENTRIES, root), ...SHARED_OPTIMIZE_DEPS] };
 }
 /**
  * Serve a git-ignored JSON file (e.g. seed data with real names) as a virtual module to the dev

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wells-nelson/build-tools",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Build and deployment tooling for Wells Nelson SvelteKit PWAs: postbuild, PWA icon generator, Vite config pieces, service worker, and templates.",
   "license": "MIT",
   "repository": {