jg-sw 0.0.0-stage → 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,36 @@
+# Changelog
+
+## 1.0.0
+
+The first release of `jg-sw`, which replaces `sw-service` 1.2.0 and `sw-builder` 1.2.1.
+
+### Added
+
+- `registerServiceWorker`, `getServiceWorkerSnapshot`, `subscribeToServiceWorker`, `updateApp`, `canInstallApp`, and `installApp`, which replace the `SWService` object, with `ERRORS` and the `REGISTRATION_DURATION_SECONDS`, `UPDATE_INSTALL_TIMEOUT_SECONDS`, `DEFAULT_SERVICE_WORKER_PATH`, `DEFAULT_SERVICE_WORKER_SCOPE`, and `SKIP_WAITING_MESSAGE_TYPE` constants.
+- A snapshot whose identity changes only with the state, for `useSyncExternalStore`, with `hasWaitingWorker` and the installation state.
+- `jg-sw/build`, with `buildServiceWorker`, `writeServiceWorker`, `readServiceWorkerConfig`, `ServiceWorkerConfigSchema`, and `ERRORS`, the codes of every error it throws.
+- `serviceWorkerPlugin`, a Vite plugin that writes the worker after a build and serves it without caching in development.
+- The `jg-sw` CLI, with `--config`, `--environment`, `--no-caching`, and `--help`.
+- The worker activates when the page posts the skip-waiting message.
+- `caching: false` and `--no-caching`, which generate a worker without precaching, cache cleanup, or a fetch handler.
+- The `INVALID_FIREBASE_SDK_VERSION` code.
+
+### Changed
+
+- `updateApp()` activates the waiting worker and reloads once it controls the page. Without one, it waits up to 30 seconds for a new worker to install, and reloads as it is when none installs.
+- `registerServiceWorker()` resolves once the registration settles, never rejects, and returns the first call's promise on later calls.
+- `installApp()` resolves to the prompt's outcome.
+- The install prompt is tracked from the first `registerServiceWorker()` call, before the registration settles.
+- Logs appear only with `debugMode`, and nothing touches `window` or `navigator` when the module loads.
+- The worker never caches responses marked `Cache-Control: no-store` or `private`.
+- The config file is named `jg-sw.config.json`, and the Firebase background hook `self.jgSwFcmBackgroundMessageHandler`.
+- `firebaseSdkVersion` must be a version such as `12.4.0`. An invalid template fails with `INVALID_TEMPLATE_NAME`, and an unsupported environment with `INVALID_ENVIRONMENT`, whatever the template.
+- Environment files load with Node.js's `process.loadEnvFile`.
+- Precached paths are URL paths from `outDir`, with `#`, `?`, and `%` percent-encoded and each directory's files sorted. A path outside `outDir` fails with `NOT_A_PATH_ELEMENT`.
+- Values written into the worker are serialized as JSON.
+- Errors are `Exception`s from `jg-exception`.
+
+### Removed
+
+- The `SWService` object and its `ISWService`, `IAppInstallerService`, and `ISWRegistrationOptions` types.
+- Running the CLI on import, and the `dotenv` and `argv-utils` dependencies.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jesus Graterol
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,198 @@
-# Temporary Holding Version
+# jg-sw
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Service workers for web apps: a generated caching worker with a Vite plugin and CLI, plus registration, updates, and installation.
+
+## Install
+
+```bash
+npm install jg-sw
+```
+
+## Usage
+
+### Register the worker
+
+```ts
+import { registerServiceWorker } from 'jg-sw';
+
+const { registration, registrationError } = await registerServiceWorker(); // registers /sw.js
+```
+
+It never rejects: a failure lands in `registrationError`. Later calls return the first call's promise, and nothing runs until the first call, so it's safe to import during server-side rendering.
+
+### Offer updates and installation
+
+The snapshot tells you when a new version waits and whether the app can be installed. It keeps its identity until something changes, so React can read it directly:
+
+```tsx
+import { useSyncExternalStore } from 'react';
+import { getServiceWorkerSnapshot, installApp, subscribeToServiceWorker, updateApp } from 'jg-sw';
+
+export const AppBanner = () => {
+  const { hasWaitingWorker, installation } = useSyncExternalStore(
+    subscribeToServiceWorker,
+    getServiceWorkerSnapshot,
+    getServiceWorkerSnapshot,
+  );
+  return (
+    <>
+      {hasWaitingWorker && <button onClick={() => void updateApp()}>Update</button>}
+      {installation.canInstall && <button onClick={() => void installApp()}>Install</button>}
+    </>
+  );
+};
+```
+
+Without React, `subscribeToServiceWorker(listener)` calls the listener on every change and returns a function that stops it.
+
+`updateApp()` reloads the page once, never in a loop:
+
+- When a new version waits, it asks it to activate and reloads once it controls the page.
+- Otherwise it checks for one, waits up to `UPDATE_INSTALL_TIMEOUT_SECONDS` (30) for it to install, then activates it the same way.
+- When nothing new is found, the installation fails, or the time runs out, it reloads the page as it is.
+
+`installApp()` shows the browser's install prompt and resolves to `'accepted'` or `'dismissed'`. Only Chromium-based browsers offer it, so check `canInstallApp()` or `installation.canInstall` first.
+
+### Describe the worker
+
+Create `jg-sw.config.json` next to your app's `package.json`:
+
+```json
+{
+  "outDir": "dist",
+  "template": "base",
+  "cacheNamePrefix": "my-app",
+  "includeToPrecache": ["/assets"],
+  "excludeFilesFromPrecache": ["some-ignorable-file.woff2"],
+  "excludeMIMETypesFromCache": ["application/json", "text/plain", "text/html"]
+}
+```
+
+| Field                       | What it does                                                                                                                                                   |
+| --------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `outDir`                    | The directory the app's build is written to. The worker is written there as `sw.js`.                                                                           |
+| `template`                  | `base` caches the app. `firebase-fcm` also shows Firebase Cloud Messaging notifications.                                                                       |
+| `cacheNamePrefix`           | The namespace of the worker's caches, in lowercase words separated by hyphens, such as `my-app`. Each build caches under `<cacheNamePrefix>--<10 characters>`. |
+| `includeToPrecache`         | The files and directories, relative to `outDir`, cached when the worker installs. Directories are read recursively, and `/` stands for the app's root page.    |
+| `excludeFilesFromPrecache`  | File names left out of precaching, wherever they are.                                                                                                          |
+| `excludeMIMETypesFromCache` | MIME types whose responses are never cached.                                                                                                                   |
+
+This config precaches the hashed files under `dist/assets`, but not `/` or `index.html`. Nothing is precached unless it's listed: add `/` and `/index.html` to precache the app's shell.
+
+### Generate it with Vite
+
+```ts
+// vite.config.ts
+import { defineConfig } from 'vite';
+import { serviceWorkerPlugin } from 'jg-sw/build';
+
+export default defineConfig({
+  plugins: [serviceWorkerPlugin({ config: 'jg-sw.config.json' })],
+});
+```
+
+`vite build` writes `dist/sw.js` after the app's files. `vite` serves a worker without caching at `/sw.js`, so you can test registration and updates while every request still reaches the dev server.
+
+### Generate it with the CLI
+
+Run `jg-sw` after your build:
+
+```json
+{
+  "scripts": {
+    "build": "vite build && jg-sw"
+  }
+}
+```
+
+```text
+Usage: jg-sw [options]
+
+Options:
+  --config <path>        The config file. Defaults to jg-sw.config.json.
+  --environment <name>   development, staging, or production.
+  --no-caching           Generates a worker without precaching, cache cleanup, or a fetch handler.
+  --help                 Prints this message.
+```
+
+It prints the path it wrote and exits 0, or prints the error and exits 1.
+
+### Generate it from code
+
+```ts
+import { readServiceWorkerConfig, writeServiceWorker } from 'jg-sw/build';
+
+const config = await readServiceWorkerConfig('jg-sw.config.json');
+await writeServiceWorker(config, { environment: 'production' }); // '/app/dist/sw.js'
+```
+
+`buildServiceWorker` returns the worker's source without writing it.
+
+### What the worker does
+
+- `install` fills only the new version's cache, and doesn't skip waiting, so the previous worker keeps serving its clients.
+- The page activates a waiting worker by posting `{ type: 'JG_SW_SKIP_WAITING' }` to it.
+- `activate` deletes the older caches in its own namespace, keeps every other cache, then claims its clients.
+- It answers same-origin `GET` requests from the current version's cache, then from the network, and caches successful responses unless they're opaque, partial, marked `Vary: *`, marked `Cache-Control: no-store` or `private`, or of an excluded MIME type. A failed cache write never replaces a valid response.
+
+### Firebase Cloud Messaging
+
+The `firebase-fcm` template adds two fields:
+
+```json
+{
+  "template": "firebase-fcm",
+  "firebaseConfigProcessEnvKey": "VITE_FIREBASE_CONFIG",
+  "firebaseSdkVersion": "12.4.0"
+}
+```
+
+The environment variable holds the Firebase web app's options as JSON:
+
+```bash
+VITE_FIREBASE_CONFIG='{"options":{"apiKey":"example-api-key","authDomain":"example.firebaseapp.com","projectId":"example-project","storageBucket":"example.firebasestorage.app","messagingSenderId":"123456789012","appId":"1:123456789012:web:example"}}'
+```
+
+Generate the worker with an environment, such as `jg-sw --environment production`. It loads `.env`, `.env.staging`, or `.env.production` when the file exists, and variables already set keep their values.
+
+The worker loads Firebase's compat SDK from `gstatic`. When no app window is visible, it shows a notification for each data-only message, using its `title`, `body`, `icon`, `badge`, and `url` fields, and Firebase shows the messages that carry a notification. Clicking a notification focuses or opens its URL, limited to the app's origin. To decide yourself, append code to the generated worker that assigns `self.jgSwFcmBackgroundMessageHandler = async (payload) => { … }`. The worker waits for it, and shows nothing else.
+
+## Coming from `sw-service` and `sw-builder`
+
+| `sw-service` and `sw-builder`                                                  | `jg-sw`                                                                                              |
+| ------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------- |
+| `SWService.register(options)`                                                  | `registerServiceWorker(options)`, now awaitable                                                      |
+| `SWService.updateApp()`                                                        | `updateApp()`, which now activates the waiting worker                                                |
+| `SWService.registration`, `.worker`, `.registrationError`                      | `getServiceWorkerSnapshot().registration`, `.worker`, `.registrationError`                           |
+| polling `SWService` for changes                                                | `subscribeToServiceWorker(listener)`                                                                 |
+| `SWService.registrationDurationSeconds`                                        | `REGISTRATION_DURATION_SECONDS`                                                                      |
+| `SWService.installer.canAppBeInstalled()`                                      | `canInstallApp()`                                                                                    |
+| `SWService.installer.installApp()`                                             | `installApp()`, which now resolves to the outcome                                                    |
+| `installer.installationPromptOutcome`, `.appInstalled`, `.runningInstalledApp` | `getServiceWorkerSnapshot().installation.promptOutcome`, `.isAppInstalled`, `.isRunningInstalledApp` |
+| `ISWService`, `IAppInstallerService`                                           | `IServiceWorkerSnapshot`, `IAppInstallationState`                                                    |
+| `ISWRegistrationOptions`                                                       | `IRegisterServiceWorkerOptions`                                                                      |
+| the codes, not exported                                                        | `ERRORS` from `jg-sw`, and from `jg-sw/build`                                                        |
+| the `sw-builder` CLI and `sw-builder.config.json`                              | the `jg-sw` CLI and `jg-sw.config.json`, or `writeServiceWorker()` and `serviceWorkerPlugin()`       |
+| `self.swBuilderFcmBackgroundMessageHandler`                                    | `self.jgSwFcmBackgroundMessageHandler`                                                               |
+
+`IInstallationPromptOutcome`, `IUserChoice`, `IBeforeInstallPromptEvent`, the config fields, and the error codes keep their names.
+
+- `updateApp()` used to reload without activating the waiting worker, which then kept waiting. It now activates it and reloads once the new worker controls the page, waiting for a worker that's still installing.
+- The install prompt is tracked from the first `registerServiceWorker()` call, before the registration settles and even when it fails.
+- Nothing logs unless `debugMode` is set, and nothing touches `window` or `navigator` when the module loads.
+- The worker activates when the page posts the skip-waiting message, never caches `Cache-Control: no-store` or `private` responses, and can be generated without caching for development.
+- The Vite plugin serves the worker in development, so you no longer need an empty `public/sw.js`.
+- `firebaseSdkVersion` must be a version such as `12.4.0`, or generation fails with `INVALID_FIREBASE_SDK_VERSION`. A template other than `base` or `firebase-fcm` fails with `INVALID_TEMPLATE_NAME`, and an unsupported `--environment` with `INVALID_ENVIRONMENT`, whatever the template.
+- Environment files load with Node.js's `process.loadEnvFile`, without `dotenv`.
+- Precached paths are URL paths from `outDir`: `app.js` becomes `/app.js`, `#`, `?`, and `%` are percent-encoded, each directory's files are sorted, and a path outside `outDir` fails with `NOT_A_PATH_ELEMENT`.
+- Values written into the worker are serialized as JSON, so paths with quotes stay intact.
+- Importing the package no longer runs the CLI.
+- Errors are `Exception`s from `jg-exception`.
+
+## Documentation
+
+The full API reference is at https://jg-packages.jesusgraterol.dev/packages/jg-sw/.
+
+## License
+
+[MIT](https://github.com/jesusgraterol/jg-packages/blob/main/packages/jg-sw/LICENSE)

package/dist/build/config/config.d.ts

@@ -0,0 +1,34 @@
+import { type IServiceWorkerEnvironment } from '../shared/index.js';
+import { type IServiceWorkerConfig } from './schema.js';
+/**
+ * Validates a service worker config.
+ * @param value The config to validate.
+ * @param source Where the config came from, such as its file path, for the error message.
+ * @returns The config.
+ * @throws
+ * - INVALID_TEMPLATE_NAME: The template must be 'base' or 'firebase-fcm'.
+ * - INVALID_FIREBASE_SDK_VERSION: The Firebase SDK version must be a version such as 12.4.0.
+ * - FAILED_TO_READ_BASE_CONFIG: The service worker config is invalid.
+ */
+export declare const parseServiceWorkerConfig: (value: unknown, source?: string) => IServiceWorkerConfig;
+/**
+ * Checks the environment option, which JavaScript callers and the CLI pass unchecked.
+ * @param environment The environment, or undefined when none was given.
+ * @returns The environment.
+ * @throws
+ * - INVALID_ENVIRONMENT: The environment must be development, staging, or production.
+ */
+export declare const parseEnvironment: (environment: string | undefined) => IServiceWorkerEnvironment | undefined;
+/**
+ * Reads and validates a service worker config file, such as `jg-sw.config.json`.
+ * @param path The config file's path.
+ * @returns A promise that resolves to the config.
+ * @example
+ * const config = await readServiceWorkerConfig('jg-sw.config.json');
+ * config.template; // 'base'
+ * @throws
+ * - FAILED_TO_READ_BASE_CONFIG: Unable to read the service worker config, or it is invalid.
+ * - INVALID_TEMPLATE_NAME: The template must be 'base' or 'firebase-fcm'.
+ * - INVALID_FIREBASE_SDK_VERSION: The Firebase SDK version must be a version such as 12.4.0.
+ */
+export declare const readServiceWorkerConfig: (path: string) => Promise<IServiceWorkerConfig>;

package/dist/build/config/config.js

@@ -0,0 +1,75 @@
+import { Exception, extractMessage } from 'jg-exception';
+import { readJSONFile } from 'jg-fs';
+import { ENV_FILE_NAME_BY_ENVIRONMENT, ERRORS, } from '../shared/index.js';
+import { ServiceWorkerConfigSchema } from './schema.js';
+/**
+ * Picks the code for a config that failed validation: a bad template or Firebase SDK version
+ * alone gets its own code, and anything else is a bad config.
+ * @param issues The validation issues.
+ * @returns The error code.
+ */
+const getConfigErrorCode = (issues) => {
+    if (issues.every(({ code, path }) => code === 'invalid_union' && path[0] === 'template')) {
+        return ERRORS.INVALID_TEMPLATE_NAME;
+    }
+    if (issues.every(({ code, path }) => code === 'invalid_format' && path[0] === 'firebaseSdkVersion')) {
+        return ERRORS.INVALID_FIREBASE_SDK_VERSION;
+    }
+    return ERRORS.FAILED_TO_READ_BASE_CONFIG;
+};
+/**
+ * Validates a service worker config.
+ * @param value The config to validate.
+ * @param source Where the config came from, such as its file path, for the error message.
+ * @returns The config.
+ * @throws
+ * - INVALID_TEMPLATE_NAME: The template must be 'base' or 'firebase-fcm'.
+ * - INVALID_FIREBASE_SDK_VERSION: The Firebase SDK version must be a version such as 12.4.0.
+ * - FAILED_TO_READ_BASE_CONFIG: The service worker config is invalid.
+ */
+export const parseServiceWorkerConfig = (value, source) => {
+    const result = ServiceWorkerConfigSchema.safeParse(value);
+    if (result.success) {
+        return result.data;
+    }
+    const issues = result.error.issues
+        .map(({ path, message }) => `${path.length === 0 ? 'config' : path.join('.')}: ${message}`)
+        .join('; ');
+    throw new Exception(`The service worker config${source === undefined ? '' : ` '${source}'`} is invalid: ${issues}`, getConfigErrorCode(result.error.issues));
+};
+/**
+ * Checks the environment option, which JavaScript callers and the CLI pass unchecked.
+ * @param environment The environment, or undefined when none was given.
+ * @returns The environment.
+ * @throws
+ * - INVALID_ENVIRONMENT: The environment must be development, staging, or production.
+ */
+export const parseEnvironment = (environment) => {
+    if (environment === undefined || Object.hasOwn(ENV_FILE_NAME_BY_ENVIRONMENT, environment)) {
+        return environment;
+    }
+    throw new Exception(`The environment '${environment}' isn't supported. Use development, staging, or production.`, ERRORS.INVALID_ENVIRONMENT);
+};
+/**
+ * Reads and validates a service worker config file, such as `jg-sw.config.json`.
+ * @param path The config file's path.
+ * @returns A promise that resolves to the config.
+ * @example
+ * const config = await readServiceWorkerConfig('jg-sw.config.json');
+ * config.template; // 'base'
+ * @throws
+ * - FAILED_TO_READ_BASE_CONFIG: Unable to read the service worker config, or it is invalid.
+ * - INVALID_TEMPLATE_NAME: The template must be 'base' or 'firebase-fcm'.
+ * - INVALID_FIREBASE_SDK_VERSION: The Firebase SDK version must be a version such as 12.4.0.
+ */
+export const readServiceWorkerConfig = async (path) => {
+    let value;
+    try {
+        value = await readJSONFile(path);
+    }
+    catch (error) {
+        throw new Exception(`Unable to read the service worker config '${path}': ${extractMessage(error)}`, ERRORS.FAILED_TO_READ_BASE_CONFIG);
+    }
+    return parseServiceWorkerConfig(value, path);
+};
+//# sourceMappingURL=config.js.map

package/dist/build/config/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../../../src/build/config/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,OAAO,CAAC;AAGrC,OAAO,EACL,4BAA4B,EAC5B,MAAM,GAEP,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,yBAAyB,EAA6B,MAAM,aAAa,CAAC;AAEnF;;;;;GAKG;AACH,MAAM,kBAAkB,GAAG,CAAC,MAA0B,EAAU,EAAE;IAChE,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,KAAK,eAAe,IAAI,IAAI,CAAC,CAAC,CAAC,KAAK,UAAU,CAAC,EAAE,CAAC;QACzF,OAAO,MAAM,CAAC,qBAAqB,CAAC;IACtC,CAAC;IACD,IACE,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,KAAK,gBAAgB,IAAI,IAAI,CAAC,CAAC,CAAC,KAAK,oBAAoB,CAAC,EAC/F,CAAC;QACD,OAAO,MAAM,CAAC,4BAA4B,CAAC;IAC7C,CAAC;IACD,OAAO,MAAM,CAAC,0BAA0B,CAAC;AAC3C,CAAC,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,KAAc,EAAE,MAAe,EAAwB,EAAE;IAChG,MAAM,MAAM,GAAG,yBAAyB,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IAC1D,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;QACnB,OAAO,MAAM,CAAC,IAAI,CAAC;IACrB,CAAC;IACD,MAAM,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,MAAM;SAC/B,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,OAAO,EAAE,CAAC;SAC1F,IAAI,CAAC,IAAI,CAAC,CAAC;IACd,MAAM,IAAI,SAAS,CACjB,4BAA4B,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,MAAM,GAAG,gBAAgB,MAAM,EAAE,EAC9F,kBAAkB,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CACxC,CAAC;AACJ,CAAC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAC9B,WAA+B,EACQ,EAAE;IACzC,IAAI,WAAW,KAAK,SAAS,IAAI,MAAM,CAAC,MAAM,CAAC,4BAA4B,EAAE,WAAW,CAAC,EAAE,CAAC;QAC1F,OAAO,WAAoD,CAAC;IAC9D,CAAC;IACD,MAAM,IAAI,SAAS,CACjB,oBAAoB,WAAW,6DAA6D,EAC5F,MAAM,CAAC,mBAAmB,CAC3B,CAAC;AACJ,CAAC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,KAAK,EAAE,IAAY,EAAiC,EAAE;IAC3F,IAAI,KAAc,CAAC;IACnB,IAAI,CAAC;QACH,KAAK,GAAG,MAAM,YAAY,CAAU,IAAI,CAAC,CAAC;IAC5C,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,IAAI,SAAS,CACjB,6CAA6C,IAAI,MAAM,cAAc,CAAC,KAAK,CAAC,EAAE,EAC9E,MAAM,CAAC,0BAA0B,CAClC,CAAC;IACJ,CAAC;IACD,OAAO,wBAAwB,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;AAC/C,CAAC,CAAC","sourcesContent":["import { Exception, extractMessage } from 'jg-exception';\nimport { readJSONFile } from 'jg-fs';\nimport type { z } from 'zod';\n\nimport {\n  ENV_FILE_NAME_BY_ENVIRONMENT,\n  ERRORS,\n  type IServiceWorkerEnvironment,\n} from '../shared/index.js';\nimport { ServiceWorkerConfigSchema, type IServiceWorkerConfig } from './schema.js';\n\n/**\n * Picks the code for a config that failed validation: a bad template or Firebase SDK version\n * alone gets its own code, and anything else is a bad config.\n * @param issues The validation issues.\n * @returns The error code.\n */\nconst getConfigErrorCode = (issues: z.core.$ZodIssue[]): string => {\n  if (issues.every(({ code, path }) => code === 'invalid_union' && path[0] === 'template')) {\n    return ERRORS.INVALID_TEMPLATE_NAME;\n  }\n  if (\n    issues.every(({ code, path }) => code === 'invalid_format' && path[0] === 'firebaseSdkVersion')\n  ) {\n    return ERRORS.INVALID_FIREBASE_SDK_VERSION;\n  }\n  return ERRORS.FAILED_TO_READ_BASE_CONFIG;\n};\n\n/**\n * Validates a service worker config.\n * @param value The config to validate.\n * @param source Where the config came from, such as its file path, for the error message.\n * @returns The config.\n * @throws\n * - INVALID_TEMPLATE_NAME: The template must be 'base' or 'firebase-fcm'.\n * - INVALID_FIREBASE_SDK_VERSION: The Firebase SDK version must be a version such as 12.4.0.\n * - FAILED_TO_READ_BASE_CONFIG: The service worker config is invalid.\n */\nexport const parseServiceWorkerConfig = (value: unknown, source?: string): IServiceWorkerConfig => {\n  const result = ServiceWorkerConfigSchema.safeParse(value);\n  if (result.success) {\n    return result.data;\n  }\n  const issues = result.error.issues\n    .map(({ path, message }) => `${path.length === 0 ? 'config' : path.join('.')}: ${message}`)\n    .join('; ');\n  throw new Exception(\n    `The service worker config${source === undefined ? '' : ` '${source}'`} is invalid: ${issues}`,\n    getConfigErrorCode(result.error.issues),\n  );\n};\n\n/**\n * Checks the environment option, which JavaScript callers and the CLI pass unchecked.\n * @param environment The environment, or undefined when none was given.\n * @returns The environment.\n * @throws\n * - INVALID_ENVIRONMENT: The environment must be development, staging, or production.\n */\nexport const parseEnvironment = (\n  environment: string | undefined,\n): IServiceWorkerEnvironment | undefined => {\n  if (environment === undefined || Object.hasOwn(ENV_FILE_NAME_BY_ENVIRONMENT, environment)) {\n    return environment as IServiceWorkerEnvironment | undefined;\n  }\n  throw new Exception(\n    `The environment '${environment}' isn't supported. Use development, staging, or production.`,\n    ERRORS.INVALID_ENVIRONMENT,\n  );\n};\n\n/**\n * Reads and validates a service worker config file, such as `jg-sw.config.json`.\n * @param path The config file's path.\n * @returns A promise that resolves to the config.\n * @example\n * const config = await readServiceWorkerConfig('jg-sw.config.json');\n * config.template; // 'base'\n * @throws\n * - FAILED_TO_READ_BASE_CONFIG: Unable to read the service worker config, or it is invalid.\n * - INVALID_TEMPLATE_NAME: The template must be 'base' or 'firebase-fcm'.\n * - INVALID_FIREBASE_SDK_VERSION: The Firebase SDK version must be a version such as 12.4.0.\n */\nexport const readServiceWorkerConfig = async (path: string): Promise<IServiceWorkerConfig> => {\n  let value: unknown;\n  try {\n    value = await readJSONFile<unknown>(path);\n  } catch (error) {\n    throw new Exception(\n      `Unable to read the service worker config '${path}': ${extractMessage(error)}`,\n      ERRORS.FAILED_TO_READ_BASE_CONFIG,\n    );\n  }\n  return parseServiceWorkerConfig(value, path);\n};\n"]}

package/dist/build/config/firebase.d.ts

@@ -0,0 +1,18 @@
+import { type IServiceWorkerEnvironment } from '../shared/index.js';
+import { type IFirebaseOptions } from './schema.js';
+/**
+ * Reads the Firebase options the firebase-fcm worker is initialized with, from the environment
+ * variable the config names, after loading the environment's file.
+ * @param envKey The environment variable that holds the Firebase config.
+ * @param environment The environment, which selects the environment file.
+ * @param cwd The directory the environment file is resolved from.
+ * @returns A promise that resolves to the Firebase options.
+ * @throws
+ * - INVALID_ENVIRONMENT: The firebase-fcm template needs an environment.
+ * - FAILED_TO_BUILD_CONFIG: Unable to load the environment file.
+ * - INVALID_FIREBASE_CONFIG: The environment variable that holds the Firebase config is missing or
+ *   empty.
+ * - FAILED_TO_READ_FIREBASE_CONFIG: Unable to read the Firebase config from the environment
+ *   variable.
+ */
+export declare const readFirebaseOptions: (envKey: string, environment: IServiceWorkerEnvironment | undefined, cwd: string) => Promise<IFirebaseOptions>;

package/dist/build/config/firebase.js

@@ -0,0 +1,58 @@
+import { resolve } from 'node:path';
+import { Exception, extractMessage } from 'jg-exception';
+import { pathExists } from 'jg-fs';
+import { ENV_FILE_NAME_BY_ENVIRONMENT, ERRORS, } from '../shared/index.js';
+import { FirebaseConfigSchema } from './schema.js';
+/**
+ * Loads the environment's file into process.env when it exists. Variables already set keep their
+ * values.
+ * @param cwd The directory the file is resolved from.
+ * @param environment The environment.
+ * @returns A promise that resolves once the file is loaded, or found missing.
+ * @throws
+ * - FAILED_TO_BUILD_CONFIG: Unable to load the environment file.
+ */
+const loadEnvironmentFile = async (cwd, environment) => {
+    const path = resolve(cwd, ENV_FILE_NAME_BY_ENVIRONMENT[environment]);
+    if (!(await pathExists(path))) {
+        return;
+    }
+    try {
+        process.loadEnvFile(path);
+    }
+    catch (error) {
+        throw new Exception(`Unable to load the environment file '${path}': ${extractMessage(error)}`, ERRORS.FAILED_TO_BUILD_CONFIG);
+    }
+};
+/**
+ * Reads the Firebase options the firebase-fcm worker is initialized with, from the environment
+ * variable the config names, after loading the environment's file.
+ * @param envKey The environment variable that holds the Firebase config.
+ * @param environment The environment, which selects the environment file.
+ * @param cwd The directory the environment file is resolved from.
+ * @returns A promise that resolves to the Firebase options.
+ * @throws
+ * - INVALID_ENVIRONMENT: The firebase-fcm template needs an environment.
+ * - FAILED_TO_BUILD_CONFIG: Unable to load the environment file.
+ * - INVALID_FIREBASE_CONFIG: The environment variable that holds the Firebase config is missing or
+ *   empty.
+ * - FAILED_TO_READ_FIREBASE_CONFIG: Unable to read the Firebase config from the environment
+ *   variable.
+ */
+export const readFirebaseOptions = async (envKey, environment, cwd) => {
+    if (environment === undefined) {
+        throw new Exception('The firebase-fcm template needs an environment, which selects the environment file that holds its Firebase config. Pass --environment, or the environment option.', ERRORS.INVALID_ENVIRONMENT);
+    }
+    await loadEnvironmentFile(cwd, environment);
+    const value = process.env[envKey];
+    if (value === undefined || value.trim() === '') {
+        throw new Exception(`The environment variable '${envKey}' that holds the Firebase config is missing or empty.`, ERRORS.INVALID_FIREBASE_CONFIG);
+    }
+    try {
+        return FirebaseConfigSchema.parse(JSON.parse(value)).options;
+    }
+    catch (error) {
+        throw new Exception(`Unable to read the Firebase config from the environment variable '${envKey}': ${extractMessage(error)}`, ERRORS.FAILED_TO_READ_FIREBASE_CONFIG);
+    }
+};
+//# sourceMappingURL=firebase.js.map

package/dist/build/config/firebase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"firebase.js","sourceRoot":"","sources":["../../../src/build/config/firebase.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACzD,OAAO,EAAE,UAAU,EAAE,MAAM,OAAO,CAAC;AAEnC,OAAO,EACL,4BAA4B,EAC5B,MAAM,GAEP,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,oBAAoB,EAAyB,MAAM,aAAa,CAAC;AAE1E;;;;;;;;GAQG;AACH,MAAM,mBAAmB,GAAG,KAAK,EAC/B,GAAW,EACX,WAAsC,EACvB,EAAE;IACjB,MAAM,IAAI,GAAG,OAAO,CAAC,GAAG,EAAE,4BAA4B,CAAC,WAAW,CAAC,CAAC,CAAC;IACrE,IAAI,CAAC,CAAC,MAAM,UAAU,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC;QAC9B,OAAO;IACT,CAAC;IACD,IAAI,CAAC;QACH,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IAC5B,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,IAAI,SAAS,CACjB,wCAAwC,IAAI,MAAM,cAAc,CAAC,KAAK,CAAC,EAAE,EACzE,MAAM,CAAC,sBAAsB,CAC9B,CAAC;IACJ,CAAC;AACH,CAAC,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,KAAK,EACtC,MAAc,EACd,WAAkD,EAClD,GAAW,EACgB,EAAE;IAC7B,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;QAC9B,MAAM,IAAI,SAAS,CACjB,mKAAmK,EACnK,MAAM,CAAC,mBAAmB,CAC3B,CAAC;IACJ,CAAC;IACD,MAAM,mBAAmB,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC;IAE5C,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IAClC,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;QAC/C,MAAM,IAAI,SAAS,CACjB,6BAA6B,MAAM,uDAAuD,EAC1F,MAAM,CAAC,uBAAuB,CAC/B,CAAC;IACJ,CAAC;IACD,IAAI,CAAC;QACH,OAAO,oBAAoB,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC;IAC/D,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,IAAI,SAAS,CACjB,qEAAqE,MAAM,MAAM,cAAc,CAAC,KAAK,CAAC,EAAE,EACxG,MAAM,CAAC,8BAA8B,CACtC,CAAC;IACJ,CAAC;AACH,CAAC,CAAC","sourcesContent":["import { resolve } from 'node:path';\nimport { Exception, extractMessage } from 'jg-exception';\nimport { pathExists } from 'jg-fs';\n\nimport {\n  ENV_FILE_NAME_BY_ENVIRONMENT,\n  ERRORS,\n  type IServiceWorkerEnvironment,\n} from '../shared/index.js';\nimport { FirebaseConfigSchema, type IFirebaseOptions } from './schema.js';\n\n/**\n * Loads the environment's file into process.env when it exists. Variables already set keep their\n * values.\n * @param cwd The directory the file is resolved from.\n * @param environment The environment.\n * @returns A promise that resolves once the file is loaded, or found missing.\n * @throws\n * - FAILED_TO_BUILD_CONFIG: Unable to load the environment file.\n */\nconst loadEnvironmentFile = async (\n  cwd: string,\n  environment: IServiceWorkerEnvironment,\n): Promise<void> => {\n  const path = resolve(cwd, ENV_FILE_NAME_BY_ENVIRONMENT[environment]);\n  if (!(await pathExists(path))) {\n    return;\n  }\n  try {\n    process.loadEnvFile(path);\n  } catch (error) {\n    throw new Exception(\n      `Unable to load the environment file '${path}': ${extractMessage(error)}`,\n      ERRORS.FAILED_TO_BUILD_CONFIG,\n    );\n  }\n};\n\n/**\n * Reads the Firebase options the firebase-fcm worker is initialized with, from the environment\n * variable the config names, after loading the environment's file.\n * @param envKey The environment variable that holds the Firebase config.\n * @param environment The environment, which selects the environment file.\n * @param cwd The directory the environment file is resolved from.\n * @returns A promise that resolves to the Firebase options.\n * @throws\n * - INVALID_ENVIRONMENT: The firebase-fcm template needs an environment.\n * - FAILED_TO_BUILD_CONFIG: Unable to load the environment file.\n * - INVALID_FIREBASE_CONFIG: The environment variable that holds the Firebase config is missing or\n *   empty.\n * - FAILED_TO_READ_FIREBASE_CONFIG: Unable to read the Firebase config from the environment\n *   variable.\n */\nexport const readFirebaseOptions = async (\n  envKey: string,\n  environment: IServiceWorkerEnvironment | undefined,\n  cwd: string,\n): Promise<IFirebaseOptions> => {\n  if (environment === undefined) {\n    throw new Exception(\n      'The firebase-fcm template needs an environment, which selects the environment file that holds its Firebase config. Pass --environment, or the environment option.',\n      ERRORS.INVALID_ENVIRONMENT,\n    );\n  }\n  await loadEnvironmentFile(cwd, environment);\n\n  const value = process.env[envKey];\n  if (value === undefined || value.trim() === '') {\n    throw new Exception(\n      `The environment variable '${envKey}' that holds the Firebase config is missing or empty.`,\n      ERRORS.INVALID_FIREBASE_CONFIG,\n    );\n  }\n  try {\n    return FirebaseConfigSchema.parse(JSON.parse(value)).options;\n  } catch (error) {\n    throw new Exception(\n      `Unable to read the Firebase config from the environment variable '${envKey}': ${extractMessage(error)}`,\n      ERRORS.FAILED_TO_READ_FIREBASE_CONFIG,\n    );\n  }\n};\n"]}

package/dist/build/config/index.d.ts

@@ -0,0 +1,3 @@
+export { parseEnvironment, parseServiceWorkerConfig, readServiceWorkerConfig } from './config.js';
+export { readFirebaseOptions } from './firebase.js';
+export { FirebaseConfigSchema, FirebaseOptionsSchema, ServiceWorkerConfigSchema, type IFirebaseOptions, type IServiceWorkerConfig, } from './schema.js';

package/dist/build/config/index.js

@@ -0,0 +1,7 @@
+// config files
+export { parseEnvironment, parseServiceWorkerConfig, readServiceWorkerConfig } from './config.js';
+// Firebase
+export { readFirebaseOptions } from './firebase.js';
+// schemas and types
+export { FirebaseConfigSchema, FirebaseOptionsSchema, ServiceWorkerConfigSchema, } from './schema.js';
+//# sourceMappingURL=index.js.map

package/dist/build/config/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/build/config/index.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,gBAAgB,EAAE,wBAAwB,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAElG,WAAW;AACX,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAEpD,oBAAoB;AACpB,OAAO,EACL,oBAAoB,EACpB,qBAAqB,EACrB,yBAAyB,GAG1B,MAAM,aAAa,CAAC","sourcesContent":["// config files\nexport { parseEnvironment, parseServiceWorkerConfig, readServiceWorkerConfig } from './config.js';\n\n// Firebase\nexport { readFirebaseOptions } from './firebase.js';\n\n// schemas and types\nexport {\n  FirebaseConfigSchema,\n  FirebaseOptionsSchema,\n  ServiceWorkerConfigSchema,\n  type IFirebaseOptions,\n  type IServiceWorkerConfig,\n} from './schema.js';\n"]}

package/dist/build/config/schema.d.ts

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+/**
+ * The schema of a service worker config: the `jg-sw.config.json` file the CLI reads, or the
+ * object passed to `buildServiceWorker`. `template` selects the worker: `base` caches the app,
+ * and `firebase-fcm` also shows Firebase Cloud Messaging notifications.
+ * @example
+ * const config = ServiceWorkerConfigSchema.parse({
+ *   outDir: 'dist',
+ *   cacheNamePrefix: 'my-app',
+ *   template: 'base',
+ *   includeToPrecache: ['/', '/index.html', '/assets'],
+ *   excludeFilesFromPrecache: [],
+ *   excludeMIMETypesFromCache: ['application/json'],
+ * });
+ */
+export declare const ServiceWorkerConfigSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    template: z.ZodLiteral<"base">;
+    outDir: z.ZodString;
+    cacheNamePrefix: z.ZodString;
+    includeToPrecache: z.ZodArray<z.ZodString>;
+    excludeFilesFromPrecache: z.ZodArray<z.ZodString>;
+    excludeMIMETypesFromCache: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    template: z.ZodLiteral<"firebase-fcm">;
+    firebaseConfigProcessEnvKey: z.ZodString;
+    firebaseSdkVersion: z.ZodString;
+    outDir: z.ZodString;
+    cacheNamePrefix: z.ZodString;
+    includeToPrecache: z.ZodArray<z.ZodString>;
+    excludeFilesFromPrecache: z.ZodArray<z.ZodString>;
+    excludeMIMETypesFromCache: z.ZodArray<z.ZodString>;
+}, z.core.$strict>], "template">;
+export type IServiceWorkerConfig = z.infer<typeof ServiceWorkerConfigSchema>;
+export declare const FirebaseOptionsSchema: z.ZodObject<{
+    apiKey: z.ZodString;
+    authDomain: z.ZodString;
+    projectId: z.ZodString;
+    storageBucket: z.ZodString;
+    messagingSenderId: z.ZodString;
+    appId: z.ZodString;
+}, z.core.$strict>;
+export type IFirebaseOptions = z.infer<typeof FirebaseOptionsSchema>;
+export declare const FirebaseConfigSchema: z.ZodObject<{
+    options: z.ZodObject<{
+        apiKey: z.ZodString;
+        authDomain: z.ZodString;
+        projectId: z.ZodString;
+        storageBucket: z.ZodString;
+        messagingSenderId: z.ZodString;
+        appId: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strip>;

package/dist/build/config/schema.js

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+import { CACHE_NAME_PREFIX_PATTERN, FIREBASE_SDK_VERSION_PATTERN } from '../shared/index.js';
+// the fields every template shares
+const BaseConfigShape = {
+    // the directory the app's build is written to, where the worker is written too
+    outDir: z.string().min(1),
+    // the application-owned namespace the worker's caches are named in, such as 'my-app'
+    cacheNamePrefix: z
+        .string()
+        .regex(CACHE_NAME_PREFIX_PATTERN, 'The cache name prefix must contain lowercase alphanumeric tokens separated by hyphens.'),
+    // the files and directories, relative to outDir, the worker caches when it installs
+    includeToPrecache: z.array(z.string()),
+    // the file names left out of precaching, wherever they are
+    excludeFilesFromPrecache: z.array(z.string()),
+    // the MIME types whose responses the worker never caches, such as 'application/json'
+    excludeMIMETypesFromCache: z.array(z.string()),
+};
+// the config of a worker that caches the app
+const BaseConfigSchema = z.strictObject({
+    ...BaseConfigShape,
+    template: z.literal('base'),
+});
+// the config of a worker that caches the app and shows Firebase Cloud Messaging notifications
+const FirebaseFcmConfigSchema = z.strictObject({
+    ...BaseConfigShape,
+    template: z.literal('firebase-fcm'),
+    // the environment variable holding the Firebase config, as JSON: { "options": { … } }
+    firebaseConfigProcessEnvKey: z.string().min(1),
+    // the Firebase JavaScript SDK version the worker loads, such as '12.4.0'
+    firebaseSdkVersion: z
+        .string()
+        .regex(FIREBASE_SDK_VERSION_PATTERN, 'The Firebase SDK version must be a version such as 12.4.0.'),
+});
+/**
+ * The schema of a service worker config: the `jg-sw.config.json` file the CLI reads, or the
+ * object passed to `buildServiceWorker`. `template` selects the worker: `base` caches the app,
+ * and `firebase-fcm` also shows Firebase Cloud Messaging notifications.
+ * @example
+ * const config = ServiceWorkerConfigSchema.parse({
+ *   outDir: 'dist',
+ *   cacheNamePrefix: 'my-app',
+ *   template: 'base',
+ *   includeToPrecache: ['/', '/index.html', '/assets'],
+ *   excludeFilesFromPrecache: [],
+ *   excludeMIMETypesFromCache: ['application/json'],
+ * });
+ */
+export const ServiceWorkerConfigSchema = z.discriminatedUnion('template', [
+    BaseConfigSchema,
+    FirebaseFcmConfigSchema,
+]);
+// the options Firebase's initializeApp receives in the worker
+export const FirebaseOptionsSchema = z.strictObject({
+    apiKey: z.string().min(1),
+    authDomain: z.string().min(1),
+    projectId: z.string().min(1),
+    storageBucket: z.string().min(1),
+    messagingSenderId: z.string().min(1),
+    appId: z.string().min(1),
+});
+// the JSON value the environment variable named by firebaseConfigProcessEnvKey holds
+export const FirebaseConfigSchema = z.object({
+    options: FirebaseOptionsSchema,
+});
+//# sourceMappingURL=schema.js.map

package/dist/build/config/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../../src/build/config/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,yBAAyB,EAAE,4BAA4B,EAAE,MAAM,oBAAoB,CAAC;AAE7F,mCAAmC;AACnC,MAAM,eAAe,GAAG;IACtB,+EAA+E;IAC/E,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAEzB,qFAAqF;IACrF,eAAe,EAAE,CAAC;SACf,MAAM,EAAE;SACR,KAAK,CACJ,yBAAyB,EACzB,wFAAwF,CACzF;IAEH,oFAAoF;IACpF,iBAAiB,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IAEtC,2DAA2D;IAC3D,wBAAwB,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IAE7C,qFAAqF;IACrF,yBAAyB,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;CAC/C,CAAC;AAEF,6CAA6C;AAC7C,MAAM,gBAAgB,GAAG,CAAC,CAAC,YAAY,CAAC;IACtC,GAAG,eAAe;IAClB,QAAQ,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC;CAC5B,CAAC,CAAC;AAEH,8FAA8F;AAC9F,MAAM,uBAAuB,GAAG,CAAC,CAAC,YAAY,CAAC;IAC7C,GAAG,eAAe;IAClB,QAAQ,EAAE,CAAC,CAAC,OAAO,CAAC,cAAc,CAAC;IAEnC,sFAAsF;IACtF,2BAA2B,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAE9C,yEAAyE;IACzE,kBAAkB,EAAE,CAAC;SAClB,MAAM,EAAE;SACR,KAAK,CACJ,4BAA4B,EAC5B,4DAA4D,CAC7D;CACJ,CAAC,CAAC;AAEH;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,CAAC,kBAAkB,CAAC,UAAU,EAAE;IACxE,gBAAgB;IAChB,uBAAuB;CACxB,CAAC,CAAC;AAKH,8DAA8D;AAC9D,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,CAAC,YAAY,CAAC;IAClD,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACzB,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC7B,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC5B,aAAa,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAChC,iBAAiB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACpC,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;CACzB,CAAC,CAAC;AAIH,qFAAqF;AACrF,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC3C,OAAO,EAAE,qBAAqB;CAC/B,CAAC,CAAC","sourcesContent":["import { z } from 'zod';\n\nimport { CACHE_NAME_PREFIX_PATTERN, FIREBASE_SDK_VERSION_PATTERN } from '../shared/index.js';\n\n// the fields every template shares\nconst BaseConfigShape = {\n  // the directory the app's build is written to, where the worker is written too\n  outDir: z.string().min(1),\n\n  // the application-owned namespace the worker's caches are named in, such as 'my-app'\n  cacheNamePrefix: z\n    .string()\n    .regex(\n      CACHE_NAME_PREFIX_PATTERN,\n      'The cache name prefix must contain lowercase alphanumeric tokens separated by hyphens.',\n    ),\n\n  // the files and directories, relative to outDir, the worker caches when it installs\n  includeToPrecache: z.array(z.string()),\n\n  // the file names left out of precaching, wherever they are\n  excludeFilesFromPrecache: z.array(z.string()),\n\n  // the MIME types whose responses the worker never caches, such as 'application/json'\n  excludeMIMETypesFromCache: z.array(z.string()),\n};\n\n// the config of a worker that caches the app\nconst BaseConfigSchema = z.strictObject({\n  ...BaseConfigShape,\n  template: z.literal('base'),\n});\n\n// the config of a worker that caches the app and shows Firebase Cloud Messaging notifications\nconst FirebaseFcmConfigSchema = z.strictObject({\n  ...BaseConfigShape,\n  template: z.literal('firebase-fcm'),\n\n  // the environment variable holding the Firebase config, as JSON: { \"options\": { … } }\n  firebaseConfigProcessEnvKey: z.string().min(1),\n\n  // the Firebase JavaScript SDK version the worker loads, such as '12.4.0'\n  firebaseSdkVersion: z\n    .string()\n    .regex(\n      FIREBASE_SDK_VERSION_PATTERN,\n      'The Firebase SDK version must be a version such as 12.4.0.',\n    ),\n});\n\n/**\n * The schema of a service worker config: the `jg-sw.config.json` file the CLI reads, or the\n * object passed to `buildServiceWorker`. `template` selects the worker: `base` caches the app,\n * and `firebase-fcm` also shows Firebase Cloud Messaging notifications.\n * @example\n * const config = ServiceWorkerConfigSchema.parse({\n *   outDir: 'dist',\n *   cacheNamePrefix: 'my-app',\n *   template: 'base',\n *   includeToPrecache: ['/', '/index.html', '/assets'],\n *   excludeFilesFromPrecache: [],\n *   excludeMIMETypesFromCache: ['application/json'],\n * });\n */\nexport const ServiceWorkerConfigSchema = z.discriminatedUnion('template', [\n  BaseConfigSchema,\n  FirebaseFcmConfigSchema,\n]);\n\n// a service worker config, validated by ServiceWorkerConfigSchema\nexport type IServiceWorkerConfig = z.infer<typeof ServiceWorkerConfigSchema>;\n\n// the options Firebase's initializeApp receives in the worker\nexport const FirebaseOptionsSchema = z.strictObject({\n  apiKey: z.string().min(1),\n  authDomain: z.string().min(1),\n  projectId: z.string().min(1),\n  storageBucket: z.string().min(1),\n  messagingSenderId: z.string().min(1),\n  appId: z.string().min(1),\n});\n\nexport type IFirebaseOptions = z.infer<typeof FirebaseOptionsSchema>;\n\n// the JSON value the environment variable named by firebaseConfigProcessEnvKey holds\nexport const FirebaseConfigSchema = z.object({\n  options: FirebaseOptionsSchema,\n});\n"]}

package/dist/build/index.d.ts

@@ -0,0 +1,5 @@
+export { ERRORS } from './shared/index.js';
+export type { IBuildServiceWorkerOptions } from './shared/index.js';
+export { ServiceWorkerConfigSchema, readServiceWorkerConfig, type IServiceWorkerConfig, } from './config/index.js';
+export { buildServiceWorker, writeServiceWorker } from './service-worker/index.js';
+export { serviceWorkerPlugin } from './plugin/index.js';