@vite-pwa/nuxt 1.1.0 → 2.0.1

package/dist/chunks/prepare-module.mjs

@@ -0,0 +1,871 @@
+import fs, { promises, existsSync } from 'node:fs';
+import { addTemplate, addPluginTemplate, useLogger, addPlugin, addComponent, addImports } from '@nuxt/kit';
+import { resolveDefaultConfig } from '@unplugin-pwa/core/config';
+import { preparePWAAssetsGenerator, normalizeManifest, normalizePath as normalizePath$1, preparePWAStrategy } from '@unplugin-pwa/core/helpers';
+import { loadPwaConfiguration } from '@vite-pwa/nuxt-core';
+import path from 'node:path';
+import { generateWebManifest } from '@unplugin-pwa/core/generate-web-manifest';
+import { INSPECTOR_BASE_PATH_URL, INSPECTOR_BASE_PATH } from '@unplugin-pwa/core/constants';
+import { defu } from 'defu';
+import { access, lstat } from 'node:fs/promises';
+import { prepareSwNamesAndGlobDirectory } from '@unplugin-pwa/core/dev/prepare-sw-names-and-glob-directory';
+import process from 'node:process';
+import { resolveSWNames, normalizePath, extractSwDestNameFromSource } from '@vite-pwa/workbox-build/utils/resolve-sw-names';
+import { hash } from 'node:crypto';
+import { getMajor } from 'verkit';
+import { createRequire } from 'node:module';
+
+async function buildPwaAssets(ctx, nuxt) {
+  const pwaAssetsGenerator = await ctx.pwaAssetsGenerator;
+  if (pwaAssetsGenerator) {
+    await pwaAssetsGenerator.generate();
+    pwaAssetsGenerator.injectManifestIcons();
+  }
+  if (ctx.resolvedOptions.manifest) {
+    const webManifest = generateWebManifest(ctx);
+    await promises.writeFile(
+      path.resolve(ctx.outDir, ctx.resolvedOptions.manifestFilename || "manifest.webmanifest"),
+      webManifest,
+      "utf-8"
+    );
+  }
+  if (!ctx.resolvedOptions.disable) {
+    await nuxt.callHook("pwa:beforeBuildServiceWorker", ctx.resolvedOptions);
+    await ctx.runBuild();
+  }
+}
+
+function buildBeforeHook(ctx) {
+  return async () => {
+    await ctx.nuxt.prepareNuxtOptions();
+  };
+}
+
+function devtoolsCustomTabsHook(ctx) {
+  return (tabs) => {
+    if (ctx.resolvedOptions.devOptions?.inspector) {
+      tabs.push({
+        title: "Unplugin PWA Inspector",
+        name: "vite-pwa:nuxt:inspector",
+        icon: `${INSPECTOR_BASE_PATH}/icon_gray.svg`,
+        view: {
+          type: "iframe",
+          src: INSPECTOR_BASE_PATH_URL
+        }
+      });
+    }
+  };
+}
+
+function nitroConfigHook(ctx, nuxt) {
+  return (nitroConfig) => {
+    if (nuxt.options.experimental.payloadExtraction) {
+      ctx.nuxt.enableGlobPatterns = !!nuxt.options.nitro.static || !!nitroConfig.prerender?.routes?.length || Object.values(nitroConfig.routeRules ?? {}).some((r) => r.prerender);
+    }
+  };
+}
+
+async function initPwaAssetsGenerator(ctx, nuxt) {
+  if (ctx.resolvedOptions.pwaAssets) {
+    const config = ctx.resolvedOptions.pwaAssets.config;
+    if (typeof config === "string") {
+      ctx.resolvedOptions.pwaAssets.config = await ctx.nuxt.moduleResolver.resolvePath(
+        config,
+        {
+          cwd: nuxt.options.rootDir,
+          alias: nuxt.options.alias
+        }
+      );
+    }
+    ctx.resolvedOptions.pwaAssets.integration = {
+      baseUrl: ctx.base,
+      publicDir: ctx.publicDir,
+      outDir: ctx.outDir,
+      resolveImage: resolveImageFactory(ctx, nuxt)
+    };
+    preparePWAAssetsGenerator(ctx);
+  }
+}
+async function checkFileExists(pathname) {
+  try {
+    await access(pathname, fs.constants.R_OK);
+  } catch {
+    return false;
+  }
+  return true;
+}
+function* preparePaths(nuxt, imageName, layers = false) {
+  if (layers) {
+    for (const [idx, layer] of nuxt.options._layers.entries()) {
+      if (idx === 0) {
+        continue;
+      }
+      yield path.resolve(layer.config.rootDir, imageName);
+      yield path.resolve(layer.config.srcDir, imageName);
+    }
+    return;
+  }
+  if (nuxt.options.nitro.publicAssets) {
+    for (const publicAsset of nuxt.options.nitro.publicAssets) {
+      if (publicAsset?.dir) {
+        yield path.resolve(publicAsset.dir, imageName);
+      }
+    }
+  }
+  yield path.resolve(nuxt.options.rootDir, imageName);
+  yield path.resolve(nuxt.options.srcDir, imageName);
+}
+async function* tryToResolveImage(ctx, nuxt, imageName) {
+  for (const imagePath of preparePaths(nuxt, imageName)) {
+    if (await checkFileExists(imagePath)) {
+      yield imagePath;
+    }
+  }
+  try {
+    const imagePath = await ctx.nuxt.moduleResolver.resolvePath(imageName, {
+      cwd: nuxt.options.rootDir,
+      alias: nuxt.options.alias
+    });
+    if (await checkFileExists(imagePath)) {
+      yield imagePath;
+    }
+  } catch {
+  }
+  for (const imagePath of preparePaths(nuxt, imageName, true)) {
+    if (await checkFileExists(imagePath)) {
+      yield imagePath;
+    }
+  }
+}
+function resolveImageFactory(ctx, nuxt) {
+  return async (image) => {
+    for await (const imagePath of tryToResolveImage(ctx, nuxt, image)) {
+      if (imagePath) {
+        return imagePath;
+      }
+    }
+    throw new Error(`PWA Assets image '${image}' cannot be resolved!`);
+  };
+}
+
+function prepareBuildSwNames(ctx, nitroPublicDir) {
+  let swSrc;
+  let options;
+  switch (ctx.strategy) {
+    case "generate-sw":
+      swSrc = "x";
+      options = ctx.resolvedOptions.generateSW;
+      break;
+    case "inject-manifest":
+      swSrc = ctx.resolvedOptions.injectManifest.swSrc;
+      options = ctx.resolvedOptions.injectManifest;
+      break;
+    case "build-sw":
+      swSrc = ctx.resolvedOptions.buildSW.swSrc;
+      options = ctx.resolvedOptions.buildSW;
+      break;
+  }
+  if (options) {
+    const {
+      swDest,
+      classicSWDest,
+      moduleSWDest
+    } = resolveSWNames(
+      normalizePath(path.relative(process.cwd(), path.resolve(nitroPublicDir, options.swDest))),
+      swSrc,
+      ctx.strategy === "generate-sw"
+    );
+    ctx.swNames = {
+      hasNames: true,
+      name: swDest,
+      classic: classicSWDest,
+      module: moduleSWDest
+    };
+  }
+}
+
+async function prepareNitroRoutes(ctx, nuxt) {
+  const isDev = nuxt.options.dev;
+  let swDisabled = false;
+  if (isDev) {
+    ctx.devEnvironment = true;
+    if (ctx.resolvedOptions.disable) {
+      swDisabled = true;
+    } else {
+      const devOptions = ctx.resolvedOptions.devOptions;
+      if (devOptions) {
+        swDisabled = !(devOptions.enabled === true);
+      } else {
+        swDisabled = true;
+      }
+    }
+  } else {
+    if (ctx.resolvedOptions.disable) {
+      swDisabled = true;
+    }
+    if (!swDisabled) {
+      prepareBuildSwNames(
+        ctx,
+        ctx.outDir
+      );
+    }
+  }
+  const webManifest = ctx.resolvedOptions.manifest;
+  let swNames;
+  if (isDev) {
+    if (!swDisabled) {
+      await prepareSwNamesAndGlobDirectory(ctx);
+      swNames = ctx.dev.options.swNames;
+      await promises.mkdir(ctx.outDir, { recursive: true });
+    }
+  } else {
+    swNames = ctx.swNames;
+  }
+  const routeRules = ctx.nuxt.nitroPWAOptions.routeRules;
+  if (swNames?.hasNames) {
+    if (ctx.resolvedOptions.swType === "classic-and-module") {
+      routeRules[`${ctx.base}${path.basename(swNames.classic)}`] = {
+        headers: {
+          "Cache-Control": "public, max-age=0, must-revalidate"
+        }
+      };
+      routeRules[`${ctx.base}${path.basename(swNames.module)}`] = {
+        headers: {
+          "Cache-Control": "public, max-age=0, must-revalidate"
+        }
+      };
+    } else {
+      routeRules[`${ctx.base}${path.basename(swNames.name)}`] = {
+        headers: {
+          "Cache-Control": "public, max-age=0, must-revalidate"
+        }
+      };
+    }
+  }
+  if ((nuxt.options.dev || ctx.nuxt.registerWebManifestInRouteRules) && webManifest) {
+    routeRules[`${ctx.base}${ctx.resolvedOptions.manifestFilename ?? "manifest.webmanifest"}`] = {
+      headers: {
+        "Content-Type": "application/manifest+json",
+        "Cache-Control": "public, max-age=0, must-revalidate"
+      }
+    };
+  }
+}
+
+async function prepareResolvedPwaOptions(ctx, nuxt, outDir) {
+  normalizeManifest(ctx);
+  let config;
+  if (ctx.strategy === "build-sw") {
+    ctx.resolvedOptions.buildSW.swSrc = await ctx.nuxt.moduleResolver.resolvePath(
+      ctx.resolvedOptions.buildSW.swSrc,
+      {
+        cwd: nuxt.options.rootDir,
+        alias: nuxt.options.alias
+      }
+    );
+    ctx.consumerOptions.filename = ctx.consumerOptions.filename ?? normalizePath$1(
+      path.resolve(ctx.outDir, extractSwDestNameFromSource(ctx.resolvedOptions.buildSW.swSrc))
+    );
+    ctx.resolvedOptions.buildSW.swDest = ctx.consumerOptions.filename;
+    ctx.resolvedOptions.buildSW.alias = nuxt.options.alias;
+    config = ctx.resolvedOptions.buildSW;
+  } else if (ctx.strategy === "generate-sw") {
+    ctx.resolvedOptions.generateSW ??= {};
+    const generateSW = ctx.resolvedOptions.generateSW;
+    if (ctx.resolvedOptions.registerType === "autoUpdate" && (ctx.nuxt.client.registerPlugin || ctx.resolvedOptions.injectRegister === "script" || ctx.resolvedOptions.injectRegister === "inline")) {
+      generateSW.clientsClaim = true;
+      generateSW.skipWaiting = true;
+    }
+    if (nuxt.options.dev) {
+      generateSW.navigateFallback = generateSW.navigateFallback ?? nuxt.options.app.baseURL ?? "/";
+      const devOptions = ctx.resolvedOptions.devOptions;
+      if (devOptions?.enabled && !devOptions.navigateFallbackAllowlist) {
+        const baseURL = nuxt.options.app.baseURL;
+        devOptions.navigateFallbackAllowlist = [
+          baseURL ? new RegExp(`^${baseURL.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&")}$`) : /^\/$/
+        ];
+      }
+    }
+    if (!("navigateFallback" in generateSW)) {
+      generateSW.navigateFallback = ctx.base;
+    }
+    config = generateSW;
+  } else if (ctx.strategy === "inject-manifest") {
+    ctx.resolvedOptions.injectManifest ??= {};
+    ctx.resolvedOptions.injectManifest.swSrc = await ctx.nuxt.moduleResolver.resolvePath(
+      ctx.resolvedOptions.injectManifest.swSrc,
+      {
+        cwd: nuxt.options.rootDir,
+        alias: nuxt.options.alias
+      }
+    );
+    ctx.consumerOptions.filename = ctx.consumerOptions.filename ?? normalizePath$1(
+      path.resolve(ctx.outDir, extractSwDestNameFromSource(ctx.resolvedOptions.injectManifest.swSrc))
+    );
+    ctx.resolvedOptions.injectManifest.swDest = ctx.consumerOptions.filename;
+    config = ctx.resolvedOptions.injectManifest;
+  }
+  if (!config) {
+    return;
+  }
+  if (!nuxt.options.dev) {
+    config.globDirectory = outDir;
+  }
+  if (!("globPatterns" in config)) {
+    config.globPatterns = ["**/*.{js,css,html}"];
+  }
+  const buildAssetsDir = ctx.nuxt.buildAssetsDir;
+  if (!("dontCacheBustURLsMatching" in config)) {
+    config.dontCacheBustURLsMatching = new RegExp(`^${buildAssetsDir.replace(/^\.*\//, "")}`);
+  }
+  if (ctx.nuxt.enableGlobPatterns) {
+    config.globPatterns = config.globPatterns ?? [];
+    config.globPatterns.push("**/_payload.json");
+    if (ctx.resolvedOptions.strategy === "generate-sw" && (ctx.nuxt.experimental?.enableWorkboxPayloadQueryParams === true || ctx.nuxt.experimental?.enableGenerateSWPayloadQueryParams === true)) {
+      const generateSW = ctx.resolvedOptions.generateSW;
+      generateSW.runtimeCaching = generateSW.runtimeCaching ?? [];
+      generateSW.runtimeCaching.push({
+        urlPattern: /\/_payload\.json\?/,
+        handler: "NetworkOnly",
+        options: {
+          plugins: [
+            {
+              /* this callback will be called when the fetch call fails */
+              handlerDidError: async ({ request }) => {
+                const url = new URL(request.url);
+                url.search = "";
+                return Response.redirect(url.href, 302);
+              },
+              /* this callback will prevent caching the response */
+              cacheWillUpdate: async () => null
+            }
+          ]
+        }
+      });
+    }
+  }
+  let appManifestFolder;
+  if (nuxt.options.experimental.appManifest) {
+    config.globPatterns = config.globPatterns ?? [];
+    appManifestFolder = `${buildAssetsDir}builds/`;
+    config.globPatterns.push(`${appManifestFolder}**/*.json`);
+  }
+  if (!nuxt.options.dev && !config.manifestTransforms) {
+    config.manifestTransforms = [
+      createManifestTransform(ctx.base ?? "/", outDir, appManifestFolder)
+    ];
+  }
+  await preparePWAStrategy(
+    ctx,
+    nuxt.options.rootDir,
+    ctx.outDir,
+    buildAssetsDir
+  );
+}
+function createManifestTransform(base, publicFolder, appManifestFolder) {
+  return async (entries) => {
+    const regexp = /\.html$/;
+    for (const e of entries) {
+      if (!e.url.endsWith(".html")) {
+        continue;
+      }
+      const url = e.url.startsWith("/") ? e.url.slice(1) : e.url;
+      if (url === "index.html") {
+        e.url = base;
+      } else {
+        const parts = url.split("/");
+        parts[parts.length - 1] = parts[parts.length - 1].replace(regexp, "");
+        e.url = parts.length > 1 ? parts.slice(0, parts.length - 1).join("/") : parts[0];
+      }
+    }
+    if (appManifestFolder) {
+      const regExp = /(\/)?[0-9a-f]{8}\b-[0-9a-f]{4}\b-[0-9a-f]{4}\b-[0-9a-f]{4}\b-[0-9a-f]{12}\.json$/i;
+      entries.filter((e) => e.url.startsWith(appManifestFolder) && regExp.test(e.url)).forEach((e) => {
+        e.revision = null;
+      });
+      const latest = `${appManifestFolder}latest.json`;
+      const latestJson = path.resolve(publicFolder, latest);
+      const data = await lstat(latestJson).catch(() => void 0);
+      if (data?.isFile()) {
+        const revision = hash("md5", await promises.readFile(latestJson, "utf-8"), "hex");
+        const latestEntry = entries.find((e) => e.url === latest);
+        if (latestEntry)
+          latestEntry.revision = revision;
+        else
+          entries.push({ url: latest, revision, size: data.size });
+      } else {
+        entries = entries.filter((e) => e.url !== latest);
+      }
+    }
+    return { manifest: entries, warnings: [] };
+  };
+}
+
+function addPwaTemplate(filename, content) {
+  if (content?.length) {
+    return addTemplate({
+      write: true,
+      filename: `pwa-icons/${filename}.d.ts`,
+      getContents: () => content
+    }).filename;
+  } else {
+    return addTemplate({
+      write: true,
+      filename: `pwa-icons/${filename}.d.ts`,
+      getContents: () => generatePwaImageType(filename)
+    }).filename;
+  }
+}
+function pwaIcons(types) {
+  return `// Generated by @vite-pwa/nuxt
+import type { AppleSplashScreenLink, FaviconLink, HtmlLink, IconAsset } from '@vite-pwa/assets-generator/api'
+
+export interface PWAAssetIconImage {
+  width?: number | string
+  height?: number | string
+  key: string
+  src: string
+}
+export type PWAAssetIcon<T extends HtmlLink> = Omit<IconAsset<T>, 'buffer'> & {
+  asImage: PWAAssetIconImage
+}
+export interface PWAIcons {
+  transparent: Record<${generateTypes(types?.transparent)}, PWAAssetIcon<HtmlLink>>
+  maskable: Record<${generateTypes(types?.maskable)}, PWAAssetIcon<HtmlLink>>
+  favicon: Record<${generateTypes(types?.favicon)}, PWAAssetIcon<FaviconLink>>
+  apple: Record<${generateTypes(types?.apple)}, PWAAssetIcon<HtmlLink>>
+  appleSplashScreen: Record<${generateTypes(types?.appleSplashScreen)}, PWAAssetIcon<AppleSplashScreenLink>>
+}
+`;
+}
+function generatePwaImageType(propsName, names) {
+  return `// Generated by @vite-pwa/nuxt
+import type { ImgHTMLAttributes } from 'vue'
+
+export type PWAVueImageType = Omit<ImgHTMLAttributes, 'src'>
+
+export type ${propsName} = PWAVueImageType & {
+  /**
+   * Name of the PWA icon to render.
+   * @type {${generateTypes(names)}}
+   */
+  image: ${generateTypes(names)}
+}
+`;
+}
+function generateTypes(types) {
+  return types?.length ? types.map((name) => `'${name}'`).join(" | ") : "string";
+}
+function addPWAIconsPluginTemplate(ctx, nuxt, nuxt4, pwaAssetsEnabled) {
+  const buildDir = ctx.nuxt.moduleResolver.resolve(nuxt.options.buildDir, "pwa-icons");
+  const resolvePluginJsPath = (name) => ctx.nuxt.moduleResolver.resolve(
+    buildDir,
+    name
+  );
+  if (nuxt4) {
+    addTemplate({
+      filename: resolvePluginJsPath("plugin.d.ts"),
+      write: true,
+      getContents: () => `// Generated by @vite-pwa/nuxt
+import type { Plugin } from '#app';
+import type { PWAIcons } from '#build/pwa-icons';
+declare const plugin: Plugin<{
+    pwaIcons?: PWAIcons;
+}>;
+export default plugin;
+`
+    });
+    addPWAIconPluginTemplate(
+      resolvePluginJsPath,
+      pwaAssetsEnabled,
+      "all"
+    );
+  } else {
+    addPWAIconPluginTemplate(
+      resolvePluginJsPath,
+      pwaAssetsEnabled,
+      "client"
+    );
+    addPWAIconPluginTemplate(
+      resolvePluginJsPath,
+      pwaAssetsEnabled,
+      "server"
+    );
+  }
+}
+function addPWAIconPluginTemplate(resolvePluginJsPath, pwaAssetsEnabled, mode) {
+  const suffix = mode === "all" ? "" : `:${mode}`;
+  const filename = mode === "all" ? "plugin" : `plugin.${mode}`;
+  if (mode !== "all") {
+    addTemplate({
+      filename: resolvePluginJsPath(`plugin.${mode}.d.ts`),
+      write: true,
+      getContents: () => `// Generated by @vite-pwa/nuxt
+import type { Plugin } from '#app';
+import type { PWAIcons } from '#build/pwa-icons';
+
+declare const plugin: Plugin<{
+    pwaIcons?: PWAIcons;
+}>;
+export default plugin;
+`
+    });
+  }
+  if (pwaAssetsEnabled) {
+    addPluginTemplate({
+      filename: resolvePluginJsPath(`${filename}.js`),
+      name: `vite-pwa:nuxt:pwa-icons${suffix}:plugin`,
+      write: true,
+      mode,
+      getContents: () => `// Generated by @vite-pwa/nuxt
+import { pwaAssetsIcons } from 'virtual:pwa-assets/icons';
+import { defineNuxtPlugin } from '#imports';
+
+export default defineNuxtPlugin(() => ({
+  provide: {
+    pwaIcons: {
+      transparent: configureEntry("transparent"),
+      maskable: configureEntry("maskable"),
+      favicon: configureEntry("favicon"),
+      apple: configureEntry("apple"),
+      appleSplashScreen: configureEntry("appleSplashScreen")
+    }
+  }
+}))
+
+function configureEntry(key) {
+  return Object.values(pwaAssetsIcons[key] ?? {}).reduce((acc, icon) => {
+    const entry = Object.assign({}, icon, {
+      asImage: {
+        src: icon.url,
+        key: \`\${key}-\${icon.name}\`
+      }
+    });
+    if (icon.width && icon.height) {
+      entry.asImage.width = icon.width;
+      entry.asImage.height = icon.height;
+    }
+    acc[icon.name] = entry;
+    return acc;
+  }, {});
+}
+`
+    });
+  } else {
+    addPluginTemplate({
+      filename: resolvePluginJsPath(`${filename}.js`),
+      name: `vite-pwa:nuxt:pwa-icons${suffix}:plugin`,
+      write: true,
+      mode,
+      getContents: () => `// Generated by @vite-pwa/nuxt
+import { defineNuxtPlugin } from '#imports'
+
+export default defineNuxtPlugin(() => ({
+  provide: {
+    pwaIcons: {
+      transparent: {},
+      maskable: {},
+      favicon: {},
+      apple: {},
+      appleSplashScreen: {}
+    }
+  }
+}))
+`
+    });
+  }
+}
+
+async function registerPwaIconsTypes(ctx, nuxt) {
+  const options = ctx.resolvedOptions;
+  const pwaAssets = options.pwaAssets && !options.pwaAssets.disabled;
+  let dts;
+  if (pwaAssets) {
+    try {
+      const { preparePWAIcons } = await import('./prepare-pwa-icons.mjs');
+      dts = await preparePWAIcons(nuxt, ctx);
+    } catch (error) {
+      useLogger("@vite-pwa/nuxt").warn("Unable to generate PWA icons types.", error);
+      dts = void 0;
+    }
+  }
+  const templates = [];
+  const dtsContent = dts?.dts;
+  if (dtsContent) {
+    templates.push(addTemplate({
+      write: true,
+      filename: "pwa-icons/index.d.ts",
+      getContents: () => dtsContent
+    }).filename);
+  } else {
+    templates.push(addTemplate({
+      write: true,
+      filename: "pwa-icons/index.d.ts",
+      getContents: () => pwaIcons()
+    }).filename);
+  }
+  templates.push(addPwaTemplate("PwaTransparentImageProps", dts?.transparent));
+  templates.push(addPwaTemplate("PwaMaskableImageProps", dts?.maskable));
+  templates.push(addPwaTemplate("PwaFaviconImageProps", dts?.favicon));
+  templates.push(addPwaTemplate("PwaAppleImageProps", dts?.apple));
+  templates.push(addPwaTemplate("PwaAppleSplashScreenImageProps", dts?.appleSplashScreen));
+  addPWAIconsPluginTemplate(
+    ctx,
+    nuxt,
+    getMajor(ctx.nuxt.nuxtVersion) >= 4,
+    pwaAssets === true
+  );
+  const pwaInjectionPath = normalizePath$1(path.relative(
+    ctx.nuxt.moduleResolver.resolve(nuxt.options.buildDir, "types"),
+    ctx.nuxt.moduleResolver.resolve("runtime/plugins/types")
+  ));
+  const nuxt5 = getMajor(ctx.nuxt.nuxtVersion) > 4;
+  addTemplate({
+    write: true,
+    filename: "types/pwa-augments.d.ts",
+    getContents: () => prepareVueModuleAugmentation(
+      pwaInjectionPath,
+      nuxt5
+    )
+  });
+  const pwaPath = addTemplate({
+    filename: "types/pwa.d.ts",
+    write: true,
+    getContents: () => templates.map(
+      (t) => `/// <reference path="../${t}" />`
+    ).join("\n")
+  }).dst;
+  nuxt.hook("prepare:types", (context) => {
+    context.references.push({ path: pwaPath });
+    if (getMajor(ctx.nuxt.nuxtVersion) >= 4) {
+      context.nodeReferences.push({ path: pwaPath });
+    }
+  });
+}
+function prepareVueModuleAugmentation(pwaInjectionPath, nuxt5) {
+  const footer = nuxt5 ? "" : `
+export {}
+`;
+  return `// Generated by @vite-pwa/nuxt
+import { UnwrapNestedRefs } from 'vue'
+import { PWAIcons } from '#build/pwa-icons'
+import { PwaInjection, PwaInstallPromptInjection } from '${pwaInjectionPath}'
+
+declare module '#app' {
+  interface NuxtApp {
+    /**
+     * Reactive PWA state and controls provided by \`@vite-pwa/nuxt\`.
+     *
+     * @example
+     * \`\`\`ts
+     * const { $pwa } = useNuxtApp()
+     * if ($pwa?.needRefresh) await $pwa.updateServiceWorker()
+     * \`\`\`
+     */
+    $pwa?: UnwrapNestedRefs<PwaInjection>
+    /**
+     * Internal usage, use \`$pwa\` instead.
+     */
+    $pwaInstallPrompt: PwaInstallPromptInjection
+    /**
+     * Available PWA icons.
+     */
+    $pwaIcons?: PWAIcons
+  }
+}
+
+declare module 'vue' {
+  interface ComponentCustomProperties {
+    /**
+     * Reactive PWA state and controls provided by \`@vite-pwa/nuxt\`.
+     *
+     * @example
+     * \`\`\`ts
+     * const { $pwa } = useNuxtApp()
+     * if ($pwa?.needRefresh) await $pwa.updateServiceWorker()
+     * \`\`\`
+     */
+    $pwa?: UnwrapNestedRefs<PwaInjection>
+    /**
+     * Internal usage, use \`$pwa\` instead.
+     */
+    $pwaInstallPrompt: PwaInstallPromptInjection
+    /**
+     * Available PWA icons.
+     */
+    $pwaIcons?: PWAIcons
+  }
+}
+${footer}
+`;
+}
+
+function nitroInitHook(ctx, nuxt) {
+  return async (nitro) => {
+    ctx.resolvedOptions.includeManifestIcons = false;
+    ctx.resolvedOptions.includeManifestScreenshots = false;
+    ctx.resolvedOptions.includeManifestShortcutIcons = false;
+    ctx.publicDir = nuxt.options.dir.public;
+    ctx.rootDir = nuxt.options.rootDir;
+    if (nuxt.options.dev) {
+      ctx.devEnvironment = true;
+      const internalDevOptions = ctx.dev.options;
+      internalDevOptions.tempFolder = path.resolve(nuxt.options.buildDir, "pwa-dev/.dev-dist");
+      ctx.outDir = internalDevOptions.tempFolder;
+    } else {
+      ctx.outDir = normalizePath$1(nitro.options.output.publicDir);
+    }
+    ctx.resolvedOptions.outDir = ctx.outDir;
+    ctx.strategy = ctx.resolvedOptions.strategy;
+    ctx.resolvedOptions.base ??= ctx.base;
+    ctx.resolvedOptions.buildBase ??= ctx.base;
+    ctx.resolvedOptions.scope ??= ctx.base;
+    await prepareResolvedPwaOptions(ctx, nuxt, ctx.outDir);
+    await ctx.nuxt.preparePwaConfiguration?.();
+    await initPwaAssetsGenerator(ctx, nuxt);
+    await registerPwaIconsTypes(ctx, nuxt);
+    await prepareNitroRoutes(ctx, nuxt);
+    const routeRules = ctx.nuxt.nitroPWAOptions.routeRules;
+    if (Object.keys(routeRules).length > 0) {
+      for (const [route, rules] of Object.entries(routeRules)) {
+        nitro.options.routeRules[route] = defu(nitro.options.routeRules[route], rules);
+      }
+      nitro.routing?.sync();
+    }
+  };
+}
+
+function prepareTypesHook(ctx) {
+  return (context) => {
+    const unpluginPwaCoreDir = path.dirname(
+      createRequire(import.meta.url).resolve("@unplugin-pwa/core/package.json")
+    );
+    const references = [
+      {
+        path: ctx.nuxt.moduleResolver.resolve("../configuration.d.ts")
+      },
+      ...["vue.d.ts", "info.d.ts", "pwa-assets.d.ts"].map((file) => ({
+        path: path.join(unpluginPwaCoreDir, file)
+      })),
+      { path: "types/pwa-augments.d.ts" }
+    ];
+    context.references.push(...references);
+    if (getMajor(ctx.nuxt.nuxtVersion) >= 4) {
+      context.nodeReferences.push(...references);
+    }
+  };
+}
+
+function serverDevHandlerHook(ctx, nuxt) {
+  return async () => {
+    const devOptions = ctx.resolvedOptions.devOptions;
+    if (nuxt.options.dev && devOptions && devOptions.inspector) {
+      await ctx.hooks.callHook("context:ready");
+    }
+  };
+}
+
+async function prepareModule(ctx, nuxt) {
+  const resolver = ctx.nuxt.moduleResolver;
+  const consumerOptions = ctx.consumerOptions;
+  if (consumerOptions.path) {
+    consumerOptions.path = await resolver.resolvePath(
+      consumerOptions.path,
+      {
+        cwd: nuxt.options.rootDir,
+        alias: nuxt.options.alias
+      }
+    );
+  } else {
+    for (const dir of [nuxt.options.srcDir, nuxt.options.rootDir]) {
+      const resolvedPath = resolveDefaultConfig(dir);
+      if (resolvedPath) {
+        consumerOptions.path = normalizePath$1(resolvedPath);
+        break;
+      }
+    }
+  }
+  ctx.externalConfigurationLoader = true;
+  ctx.base ??= consumerOptions.base || "/";
+  consumerOptions.base ??= ctx.base;
+  consumerOptions.scope ??= ctx.base;
+  const publicDirs = /* @__PURE__ */ new Set();
+  for (const layer of nuxt.options._layers) {
+    publicDirs.add(normalizePath$1(resolver.resolve(layer.config.rootDir, layer.config.dir?.public || "public")));
+  }
+  ctx.nuxt.publicDirs = [...publicDirs].filter((dir) => existsSync(dir));
+  await loadPwaConfiguration(ctx, nuxt);
+  if (ctx.resolvedOptions.path) {
+    nuxt.options.watch.push(ctx.resolvedOptions.path);
+    applyExternalNuxtOptions(ctx);
+  }
+  const runtimeDir = resolver.resolve("./runtime");
+  nuxt.options.build.transpile.push(runtimeDir);
+  nuxt.options.alias["#pwa"] = resolver.resolve(runtimeDir, "composables");
+  if (ctx.nuxt.client.registerPlugin) {
+    addPlugin({
+      src: resolver.resolve(runtimeDir, "plugins/pwa.client"),
+      mode: "client"
+    });
+    addPlugin({
+      src: resolver.resolve(runtimeDir, "plugins/pwa-install.client"),
+      mode: "client"
+    });
+  }
+  nuxt.hook("nitro:config", nitroConfigHook(ctx, nuxt));
+  nuxt.hook("nitro:init", nitroInitHook(ctx, nuxt));
+  nuxt.hook("prepare:types", prepareTypesHook(ctx));
+  nuxt.hook("devtools:customTabs", devtoolsCustomTabsHook(ctx));
+  for (const name of ["NuxtPwaAssets", "NuxtPwaManifest"]) {
+    addComponent({
+      name,
+      global: !nuxt.options.imports.autoImport,
+      filePath: resolver.resolve(runtimeDir, `components/${name}`)
+    });
+  }
+  addImports([
+    "usePWA",
+    "useTransparentPwaIcon",
+    "useMaskablePwaIcon",
+    "useFaviconPwaIcon",
+    "useApplePwaIcon",
+    "useAppleSplashScreenPwaIcon"
+  ].map((name) => ({
+    name,
+    from: resolver.resolve(runtimeDir, "composables")
+  })));
+  nuxt.hook("server:devHandler", serverDevHandlerHook(ctx, nuxt));
+  nuxt.hook("build:before", buildBeforeHook(ctx));
+  if (!nuxt.options.dev) {
+    nuxt.hook("nitro:build:public-assets", async () => {
+      await buildPwaAssets(ctx, nuxt);
+    });
+  }
+}
+function applyExternalNuxtOptions(ctx) {
+  const {
+    client,
+    experimental,
+    registerWebManifestInRouteRules,
+    writePlugin
+  } = ctx.resolvedOptions;
+  if (client) {
+    Object.assign(ctx.nuxt.client, client);
+  }
+  if (experimental) {
+    ctx.nuxt.experimental = experimental;
+  }
+  if (registerWebManifestInRouteRules !== void 0) {
+    ctx.nuxt.registerWebManifestInRouteRules = registerWebManifestInRouteRules;
+  }
+  if (writePlugin !== void 0) {
+    ctx.nuxt.writePlugin = writePlugin;
+  }
+}
+
+const prepareModule$1 = {
+  __proto__: null,
+  prepareModule: prepareModule
+};
+
+export { prepareModule$1 as a, generatePwaImageType as g, pwaIcons as p };