mirror of
https://github.com/Sevichecc/Urara-Blog.git
synced 2025-05-04 23:29:30 +08:00
930 lines
30 KiB
Text
930 lines
30 KiB
Text
var __defProp = Object.defineProperty;
|
|
var __defProps = Object.defineProperties;
|
|
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
|
|
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
|
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
var __propIsEnum = Object.prototype.propertyIsEnumerable;
|
|
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
|
|
var __spreadValues = (a, b) => {
|
|
for (var prop in b || (b = {}))
|
|
if (__hasOwnProp.call(b, prop))
|
|
__defNormalProp(a, prop, b[prop]);
|
|
if (__getOwnPropSymbols)
|
|
for (var prop of __getOwnPropSymbols(b)) {
|
|
if (__propIsEnum.call(b, prop))
|
|
__defNormalProp(a, prop, b[prop]);
|
|
}
|
|
return a;
|
|
};
|
|
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
|
|
var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
|
|
get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
|
|
}) : x)(function(x) {
|
|
if (typeof require !== "undefined")
|
|
return require.apply(this, arguments);
|
|
throw new Error('Dynamic require of "' + x + '" is not supported');
|
|
});
|
|
var __objRest = (source, exclude) => {
|
|
var target = {};
|
|
for (var prop in source)
|
|
if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
|
|
target[prop] = source[prop];
|
|
if (source != null && __getOwnPropSymbols)
|
|
for (var prop of __getOwnPropSymbols(source)) {
|
|
if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
|
|
target[prop] = source[prop];
|
|
}
|
|
return target;
|
|
};
|
|
|
|
// src/context.ts
|
|
function createContext(userOptions) {
|
|
return {
|
|
userOptions,
|
|
options: void 0,
|
|
viteConfig: void 0,
|
|
useImportRegister: false
|
|
};
|
|
}
|
|
|
|
// src/constants.ts
|
|
var FILE_SW_REGISTER = "registerSW.js";
|
|
var VIRTUAL_MODULES_MAP = {
|
|
"virtual:pwa-register": "register",
|
|
"virtual:pwa-register/vue": "vue",
|
|
"virtual:pwa-register/svelte": "svelte",
|
|
"virtual:pwa-register/react": "react",
|
|
"virtual:pwa-register/preact": "preact",
|
|
"virtual:pwa-register/solid": "solid"
|
|
};
|
|
var VIRTUAL_MODULES_RESOLVE_PREFIX = "/@vite-plugin-pwa/";
|
|
var VIRTUAL_MODULES = Object.keys(VIRTUAL_MODULES_MAP);
|
|
var defaultInjectManifestVitePlugins = [
|
|
"alias",
|
|
"commonjs",
|
|
"vite:resolve",
|
|
"vite:esbuild",
|
|
"replace",
|
|
"vite:define",
|
|
"rollup-plugin-dynamic-import-variables",
|
|
"vite:esbuild-transpile",
|
|
"vite:json",
|
|
"vite:terser"
|
|
];
|
|
var DEV_SW_NAME = "dev-sw.js?dev-sw";
|
|
|
|
// src/html.ts
|
|
function generateSimpleSWRegister(options2, dev) {
|
|
const path = dev ? `${options2.base}${DEV_SW_NAME}` : `${options2.base}${options2.filename}`;
|
|
if (dev)
|
|
return `if('serviceWorker' in navigator) navigator.serviceWorker.register('${path}', { scope: '${options2.scope}' })`;
|
|
return `
|
|
if('serviceWorker' in navigator) {
|
|
window.addEventListener('load', () => {
|
|
navigator.serviceWorker.register('${path}', { scope: '${options2.scope}' })
|
|
})
|
|
}`.replace(/\n/g, "");
|
|
}
|
|
function injectServiceWorker(html, options2, dev) {
|
|
const crossorigin = options2.useCredentials ? ' crossorigin="use-credentials"' : "";
|
|
let manifest;
|
|
if (dev) {
|
|
const name = options2.devOptions.webManifestUrl ?? `${options2.base}${options2.manifestFilename}`;
|
|
manifest = options2.manifest ? `<link rel="manifest" href="${name}"${crossorigin}>` : "";
|
|
} else {
|
|
manifest = options2.manifest ? `<link rel="manifest" href="${options2.base + options2.manifestFilename}"${crossorigin}>` : "";
|
|
}
|
|
if (!dev) {
|
|
if (options2.injectRegister === "inline") {
|
|
return html.replace("</head>", `${manifest}<script>${generateSimpleSWRegister(options2, dev)}<\/script></head>`);
|
|
}
|
|
if (options2.injectRegister === "script") {
|
|
return html.replace("</head>", `${manifest}<script src="${options2.base + FILE_SW_REGISTER}"><\/script></head>`);
|
|
}
|
|
}
|
|
return html.replace("</head>", `${manifest}</head>`);
|
|
}
|
|
|
|
// src/api.ts
|
|
import { resolve as resolve2 } from "path";
|
|
import { existsSync } from "fs";
|
|
|
|
// src/modules.ts
|
|
import { resolve } from "path";
|
|
import { promises as fs } from "fs";
|
|
|
|
// src/log.ts
|
|
import { relative } from "path";
|
|
|
|
// node_modules/.pnpm/kolorist@1.5.1/node_modules/kolorist/dist/esm/index.mjs
|
|
var enabled = true;
|
|
var globalVar = typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {};
|
|
var supportLevel = 0;
|
|
if (globalVar.process && globalVar.process.env && globalVar.process.stdout) {
|
|
const { FORCE_COLOR, NODE_DISABLE_COLORS, TERM } = globalVar.process.env;
|
|
if (NODE_DISABLE_COLORS || FORCE_COLOR === "0") {
|
|
enabled = false;
|
|
} else if (FORCE_COLOR === "1") {
|
|
enabled = true;
|
|
} else if (TERM === "dumb") {
|
|
enabled = false;
|
|
} else if ("CI" in globalVar.process.env && [
|
|
"TRAVIS",
|
|
"CIRCLECI",
|
|
"APPVEYOR",
|
|
"GITLAB_CI",
|
|
"GITHUB_ACTIONS",
|
|
"BUILDKITE",
|
|
"DRONE"
|
|
].some((vendor) => vendor in globalVar.process.env)) {
|
|
enabled = true;
|
|
} else {
|
|
enabled = process.stdout.isTTY;
|
|
}
|
|
if (enabled) {
|
|
supportLevel = TERM && TERM.endsWith("-256color") ? 2 : 1;
|
|
}
|
|
}
|
|
var options = {
|
|
enabled,
|
|
supportLevel
|
|
};
|
|
function kolorist(start, end, level = 1) {
|
|
const open = `\x1B[${start}m`;
|
|
const close = `\x1B[${end}m`;
|
|
const regex = new RegExp(`\\x1b\\[${end}m`, "g");
|
|
return (str) => {
|
|
return options.enabled && options.supportLevel >= level ? open + ("" + str).replace(regex, open) + close : "" + str;
|
|
};
|
|
}
|
|
var reset = kolorist(0, 0);
|
|
var bold = kolorist(1, 22);
|
|
var dim = kolorist(2, 22);
|
|
var italic = kolorist(3, 23);
|
|
var underline = kolorist(4, 24);
|
|
var inverse = kolorist(7, 27);
|
|
var hidden = kolorist(8, 28);
|
|
var strikethrough = kolorist(9, 29);
|
|
var black = kolorist(30, 39);
|
|
var red = kolorist(31, 39);
|
|
var green = kolorist(32, 39);
|
|
var yellow = kolorist(33, 39);
|
|
var blue = kolorist(34, 39);
|
|
var magenta = kolorist(35, 39);
|
|
var cyan = kolorist(36, 39);
|
|
var white = kolorist(97, 39);
|
|
var gray = kolorist(90, 39);
|
|
var lightGray = kolorist(37, 39);
|
|
var lightRed = kolorist(91, 39);
|
|
var lightGreen = kolorist(92, 39);
|
|
var lightYellow = kolorist(93, 39);
|
|
var lightBlue = kolorist(94, 39);
|
|
var lightMagenta = kolorist(95, 39);
|
|
var lightCyan = kolorist(96, 39);
|
|
var bgBlack = kolorist(40, 49);
|
|
var bgRed = kolorist(41, 49);
|
|
var bgGreen = kolorist(42, 49);
|
|
var bgYellow = kolorist(43, 49);
|
|
var bgBlue = kolorist(44, 49);
|
|
var bgMagenta = kolorist(45, 49);
|
|
var bgCyan = kolorist(46, 49);
|
|
var bgWhite = kolorist(107, 49);
|
|
var bgGray = kolorist(100, 49);
|
|
var bgLightRed = kolorist(101, 49);
|
|
var bgLightGreen = kolorist(102, 49);
|
|
var bgLightYellow = kolorist(103, 49);
|
|
var bgLightBlue = kolorist(104, 49);
|
|
var bgLightMagenta = kolorist(105, 49);
|
|
var bgLightCyan = kolorist(106, 49);
|
|
var bgLightGray = kolorist(47, 49);
|
|
|
|
// package.json
|
|
var version = "0.12.3";
|
|
|
|
// src/log.ts
|
|
function logWorkboxResult(strategy, buildResult, viteOptions) {
|
|
const { root, logLevel = "info" } = viteOptions;
|
|
if (logLevel === "silent")
|
|
return;
|
|
const { count, size, filePaths, warnings } = buildResult;
|
|
if (logLevel === "info") {
|
|
console.info([
|
|
"",
|
|
`${cyan(`PWA v${version}`)}`,
|
|
`mode ${magenta(strategy)}`,
|
|
`precache ${green(`${count} entries`)} ${dim(`(${(size / 1024).toFixed(2)} KiB)`)}`,
|
|
"files generated",
|
|
...filePaths.map((p) => ` ${dim(relative(root, p))}`)
|
|
].join("\n"));
|
|
}
|
|
warnings && warnings.length > 0 && console.warn(yellow([
|
|
"warnings",
|
|
...warnings.map((w) => ` ${w}`),
|
|
""
|
|
].join("\n")));
|
|
}
|
|
|
|
// src/modules.ts
|
|
function loadWorkboxBuild() {
|
|
return __require("workbox-build");
|
|
}
|
|
async function generateRegisterSW(options2, mode, source = "register") {
|
|
const sw = options2.base + options2.filename;
|
|
const scope = options2.scope;
|
|
const content = await fs.readFile(resolve(__dirname, `client/${mode}/${source}.mjs`), "utf-8");
|
|
return content.replace("__SW__", sw).replace("__SCOPE__", scope).replace("__SW_AUTO_UPDATE__", `${options2.registerType === "autoUpdate"}`).replace("__SW_SELF_DESTROYING__", `${options2.selfDestroying}`).replace("__TYPE__", `${options2.devOptions.enabled ? options2.devOptions.type : "classic"}`);
|
|
}
|
|
async function generateServiceWorker(options2, viteOptions) {
|
|
if (options2.selfDestroying) {
|
|
const selfDestroyingSW = `
|
|
self.addEventListener('install', function(e) {
|
|
self.skipWaiting();
|
|
});
|
|
self.addEventListener('activate', function(e) {
|
|
self.registration.unregister()
|
|
.then(function() {
|
|
return self.clients.matchAll();
|
|
})
|
|
.then(function(clients) {
|
|
clients.forEach(client => client.navigate(client.url))
|
|
});
|
|
});
|
|
`;
|
|
await fs.writeFile(options2.swDest.replace(/\\/g, "/"), selfDestroyingSW, { encoding: "utf8" });
|
|
return {
|
|
count: 1,
|
|
size: selfDestroyingSW.length,
|
|
warnings: [],
|
|
filePaths: [options2.filename]
|
|
};
|
|
}
|
|
const { generateSW } = loadWorkboxBuild();
|
|
const buildResult = await generateSW(options2.workbox);
|
|
logWorkboxResult("generateSW", buildResult, viteOptions);
|
|
return buildResult;
|
|
}
|
|
async function generateInjectManifest(options2, viteOptions) {
|
|
const { selfDestroying } = options2;
|
|
if (selfDestroying) {
|
|
await generateServiceWorker(options2, viteOptions);
|
|
return;
|
|
}
|
|
const vitePlugins = options2.vitePlugins;
|
|
const includedPluginNames = [];
|
|
if (typeof vitePlugins === "function")
|
|
includedPluginNames.push(...vitePlugins(viteOptions.plugins.map((p) => p.name)));
|
|
else
|
|
includedPluginNames.push(...vitePlugins);
|
|
if (includedPluginNames.length === 0)
|
|
includedPluginNames.push(...defaultInjectManifestVitePlugins);
|
|
const plugins = viteOptions.plugins.filter((p) => includedPluginNames.includes(p.name));
|
|
const { rollup } = await import("rollup");
|
|
const bundle = await rollup({
|
|
input: options2.swSrc,
|
|
plugins
|
|
});
|
|
try {
|
|
await bundle.write({
|
|
format: "es",
|
|
exports: "none",
|
|
inlineDynamicImports: true,
|
|
file: options2.injectManifest.swDest,
|
|
sourcemap: viteOptions.build.sourcemap
|
|
});
|
|
} finally {
|
|
await bundle.close();
|
|
}
|
|
const injectManifestOptions = __spreadProps(__spreadValues({}, options2.injectManifest), {
|
|
swSrc: options2.injectManifest.swDest
|
|
});
|
|
const { injectManifest } = loadWorkboxBuild();
|
|
const buildResult = await injectManifest(injectManifestOptions);
|
|
logWorkboxResult("injectManifest", buildResult, viteOptions);
|
|
}
|
|
|
|
// src/assets.ts
|
|
import { resolve as resolveFs } from "path";
|
|
import fs2 from "fs";
|
|
import crypto from "crypto";
|
|
import fg from "fast-glob";
|
|
function buildManifestEntry(publicDir, url) {
|
|
return new Promise((resolve5, reject) => {
|
|
const cHash = crypto.createHash("MD5");
|
|
const stream = fs2.createReadStream(resolveFs(publicDir, url));
|
|
stream.on("error", (err) => {
|
|
reject(err);
|
|
});
|
|
stream.on("data", (chunk) => {
|
|
cHash.update(chunk);
|
|
});
|
|
stream.on("end", () => {
|
|
return resolve5({
|
|
url,
|
|
revision: `${cHash.digest("hex")}`
|
|
});
|
|
});
|
|
});
|
|
}
|
|
function lookupAdditionalManifestEntries(useInjectManifest, injectManifest, workbox) {
|
|
return useInjectManifest ? injectManifest.additionalManifestEntries || [] : workbox.additionalManifestEntries || [];
|
|
}
|
|
function normalizeIconPath(path) {
|
|
return path.startsWith("/") ? path.substring(1) : path;
|
|
}
|
|
function includeIcons(icons, globs) {
|
|
Object.keys(icons).forEach((key) => {
|
|
const icon = icons[key];
|
|
const src = normalizeIconPath(icon.src);
|
|
if (!globs.includes(src))
|
|
globs.push(src);
|
|
});
|
|
}
|
|
async function configureStaticAssets(resolvedVitePWAOptions, viteConfig) {
|
|
const {
|
|
manifest,
|
|
strategies,
|
|
injectManifest,
|
|
workbox,
|
|
includeAssets,
|
|
includeManifestIcons,
|
|
manifestFilename
|
|
} = resolvedVitePWAOptions;
|
|
const useInjectManifest = strategies === "injectManifest";
|
|
const { publicDir } = viteConfig;
|
|
const globs = [];
|
|
const manifestEntries = lookupAdditionalManifestEntries(useInjectManifest, injectManifest, workbox);
|
|
if (includeAssets) {
|
|
if (Array.isArray(includeAssets))
|
|
globs.push(...includeAssets.map(normalizeIconPath));
|
|
else
|
|
globs.push(normalizeIconPath(includeAssets));
|
|
}
|
|
if (includeManifestIcons && manifest) {
|
|
manifest.icons && includeIcons(manifest.icons, globs);
|
|
manifest.shortcuts && manifest.shortcuts.forEach((s) => {
|
|
s.icons && includeIcons(s.icons, globs);
|
|
});
|
|
}
|
|
if (globs.length > 0) {
|
|
let assets = await fg(globs, {
|
|
cwd: publicDir,
|
|
onlyFiles: true,
|
|
unique: true
|
|
});
|
|
if (manifestEntries.length > 0) {
|
|
const included = manifestEntries.map((me) => {
|
|
if (typeof me === "string")
|
|
return me;
|
|
else
|
|
return me.url;
|
|
});
|
|
assets = assets.filter((a) => !included.includes(a));
|
|
}
|
|
const assetsEntries = await Promise.all(assets.map((a) => {
|
|
return buildManifestEntry(publicDir, a);
|
|
}));
|
|
manifestEntries.push(...assetsEntries);
|
|
}
|
|
if (manifest) {
|
|
const cHash = crypto.createHash("MD5");
|
|
cHash.update(generateWebManifestFile(resolvedVitePWAOptions));
|
|
manifestEntries.push({
|
|
url: manifestFilename,
|
|
revision: `${cHash.digest("hex")}`
|
|
});
|
|
}
|
|
if (manifestEntries.length > 0) {
|
|
if (useInjectManifest)
|
|
injectManifest.additionalManifestEntries = manifestEntries;
|
|
else
|
|
workbox.additionalManifestEntries = manifestEntries;
|
|
}
|
|
}
|
|
function generateWebManifestFile(options2) {
|
|
return `${JSON.stringify(options2.manifest, null, options2.minify ? 0 : 2)}
|
|
`;
|
|
}
|
|
|
|
// src/api.ts
|
|
async function _generateSW({ options: options2, viteConfig }) {
|
|
if (options2.disable)
|
|
return;
|
|
if (options2.strategies === "injectManifest")
|
|
await generateInjectManifest(options2, viteConfig);
|
|
else
|
|
await generateServiceWorker(options2, viteConfig);
|
|
}
|
|
function _generateBundle({ options: options2, viteConfig, useImportRegister }, bundle) {
|
|
if (options2.disable)
|
|
return;
|
|
if (options2.manifest) {
|
|
bundle[options2.manifestFilename] = {
|
|
isAsset: true,
|
|
type: "asset",
|
|
name: void 0,
|
|
source: generateWebManifestFile(options2),
|
|
fileName: options2.manifestFilename
|
|
};
|
|
}
|
|
if (options2.injectRegister === "auto")
|
|
options2.injectRegister = useImportRegister ? null : "script";
|
|
if (options2.injectRegister === "script" && !existsSync(resolve2(viteConfig.publicDir, FILE_SW_REGISTER))) {
|
|
bundle[FILE_SW_REGISTER] = {
|
|
isAsset: true,
|
|
type: "asset",
|
|
name: void 0,
|
|
source: generateSimpleSWRegister(options2, false),
|
|
fileName: FILE_SW_REGISTER
|
|
};
|
|
}
|
|
return bundle;
|
|
}
|
|
function createAPI(ctx) {
|
|
return {
|
|
get disabled() {
|
|
var _a;
|
|
return (_a = ctx == null ? void 0 : ctx.options) == null ? void 0 : _a.disable;
|
|
},
|
|
generateBundle(bundle) {
|
|
return _generateBundle(ctx, bundle);
|
|
},
|
|
async generateSW() {
|
|
return await _generateSW(ctx);
|
|
},
|
|
extendManifestEntries(fn) {
|
|
const { options: options2 } = ctx;
|
|
if (options2.disable)
|
|
return;
|
|
const configField = options2.strategies === "generateSW" ? "workbox" : "injectManifest";
|
|
const result = fn(options2[configField].additionalManifestEntries || []);
|
|
if (result != null)
|
|
options2[configField].additionalManifestEntries = result;
|
|
}
|
|
};
|
|
}
|
|
|
|
// src/plugins/build.ts
|
|
function BuildPlugin(ctx) {
|
|
return {
|
|
name: "vite-plugin-pwa:build",
|
|
enforce: "post",
|
|
apply: "build",
|
|
transformIndexHtml: {
|
|
enforce: "post",
|
|
transform(html) {
|
|
const { options: options2, useImportRegister } = ctx;
|
|
if (options2.disable)
|
|
return html;
|
|
if (options2.injectRegister === "auto")
|
|
options2.injectRegister = useImportRegister ? null : "script";
|
|
return injectServiceWorker(html, options2, false);
|
|
}
|
|
},
|
|
generateBundle(_, bundle) {
|
|
return _generateBundle(ctx, bundle);
|
|
},
|
|
async closeBundle() {
|
|
if (!ctx.viteConfig.build.ssr && !ctx.options.disable)
|
|
await _generateSW(ctx);
|
|
},
|
|
async buildEnd(error) {
|
|
if (error)
|
|
throw error;
|
|
}
|
|
};
|
|
}
|
|
|
|
// src/plugins/dev.ts
|
|
import { basename, resolve as resolve3 } from "path";
|
|
import { existsSync as existsSync2, promises as fs3, mkdirSync } from "fs";
|
|
|
|
// src/utils.ts
|
|
function resolveBathPath(base) {
|
|
if (isAbsolute(base))
|
|
return base;
|
|
return !base.startsWith("/") && !base.startsWith("./") ? `/${base}` : base;
|
|
}
|
|
function isAbsolute(url) {
|
|
return url.match(/^(?:[a-z]+:)?\/\//i);
|
|
}
|
|
function normalizePath(path) {
|
|
return path.replace(/\\/g, "/");
|
|
}
|
|
|
|
// src/plugins/dev.ts
|
|
var DEV_SW_VIRTUAL = `${VIRTUAL_MODULES_RESOLVE_PREFIX}pwa-entry-point-loaded`;
|
|
var DEV_READY_NAME = "vite-pwa-plugin:dev-ready";
|
|
var DEV_REGISTER_SW_NAME = "vite-plugin-pwa:register-sw";
|
|
var swDevOptions = {
|
|
swUrl: DEV_SW_NAME,
|
|
swDevGenerated: false,
|
|
workboxPaths: /* @__PURE__ */ new Map()
|
|
};
|
|
function DevPlugin(ctx) {
|
|
return {
|
|
name: "vite-plugin-pwa:dev-sw",
|
|
apply: "serve",
|
|
transformIndexHtml: {
|
|
enforce: "post",
|
|
async transform(html) {
|
|
const { options: options2 } = ctx;
|
|
if (options2.disable || !options2.manifest || !options2.devOptions.enabled)
|
|
return html;
|
|
html = injectServiceWorker(html, options2, true);
|
|
return html.replace("</body>", `<script type="module" src="${DEV_SW_VIRTUAL}"><\/script></body>`);
|
|
}
|
|
},
|
|
configureServer(server) {
|
|
const { options: options2 } = ctx;
|
|
if (!options2.disable && options2.manifest && options2.devOptions.enabled) {
|
|
server.ws.on(DEV_READY_NAME, createSWResponseHandler(server, ctx));
|
|
const name = options2.devOptions.webManifestUrl ?? `${options2.base}${options2.manifestFilename}`;
|
|
server.middlewares.use((req, res, next) => {
|
|
if (req.url === name) {
|
|
res.statusCode = 200;
|
|
res.setHeader("Content-Type", "application/manifest+json");
|
|
res.write(generateWebManifestFile(options2), "utf-8");
|
|
res.end();
|
|
} else {
|
|
next();
|
|
}
|
|
});
|
|
}
|
|
},
|
|
resolveId(id) {
|
|
if (id === DEV_SW_VIRTUAL)
|
|
return id;
|
|
const { options: options2 } = ctx;
|
|
if (!options2.disable && options2.devOptions.enabled && options2.strategies === "injectManifest" && !options2.selfDestroying) {
|
|
const name = id.startsWith("/") ? id.slice(1) : id;
|
|
return name === swDevOptions.swUrl || name === options2.injectManifest.swSrc ? options2.injectManifest.swSrc : void 0;
|
|
}
|
|
return void 0;
|
|
},
|
|
async load(id) {
|
|
if (id === DEV_SW_VIRTUAL)
|
|
return generateSWHMR();
|
|
const { options: options2, viteConfig } = ctx;
|
|
if (!options2.disable && options2.devOptions.enabled) {
|
|
if (options2.strategies === "injectManifest" && !options2.selfDestroying) {
|
|
const swSrc = normalizePath(options2.injectManifest.swSrc);
|
|
if (id === swSrc) {
|
|
let content = await fs3.readFile(options2.injectManifest.swSrc, "utf-8");
|
|
const resolvedIP = options2.injectManifest.injectionPoint;
|
|
if (resolvedIP) {
|
|
const ip = new RegExp(resolvedIP, "g");
|
|
const navigateFallback = options2.devOptions.navigateFallback;
|
|
if (navigateFallback)
|
|
content = content.replace(ip, `[{ url: '${navigateFallback}' }]`);
|
|
else
|
|
content = content.replace(ip, "[]");
|
|
}
|
|
return content;
|
|
}
|
|
return void 0;
|
|
}
|
|
if (id.endsWith(swDevOptions.swUrl)) {
|
|
const globDirectory = resolve3(viteConfig.root, "dev-dist");
|
|
if (!existsSync2(globDirectory))
|
|
mkdirSync(globDirectory);
|
|
const swDest = resolve3(globDirectory, "sw.js");
|
|
if (!swDevOptions.swDevGenerated || !existsSync2(swDest)) {
|
|
const navigateFallback = options2.workbox.navigateFallback;
|
|
const webManifestUrl = options2.devOptions.webManifestUrl ?? `${options2.base}${options2.manifestFilename}`;
|
|
const { filePaths } = await generateServiceWorker(Object.assign({}, options2, {
|
|
swDest: options2.selfDestroying ? swDest : options2.swDest,
|
|
workbox: __spreadProps(__spreadValues({}, options2.workbox), {
|
|
navigateFallbackDenylist: [new RegExp(`^${webManifestUrl}$`)],
|
|
runtimeCaching: options2.devOptions.disableRuntimeConfig ? void 0 : options2.workbox.runtimeCaching,
|
|
additionalManifestEntries: navigateFallback ? [navigateFallback] : void 0,
|
|
cleanupOutdatedCaches: true,
|
|
globDirectory: globDirectory.replace(/\\/g, "/"),
|
|
swDest: swDest.replace(/\\/g, "/")
|
|
})
|
|
}), viteConfig);
|
|
filePaths.forEach((we) => {
|
|
const name = basename(we);
|
|
if (name !== "sw.js")
|
|
swDevOptions.workboxPaths.set(normalizePath(`${options2.base}${name}`), we);
|
|
});
|
|
swDevOptions.swDevGenerated = true;
|
|
}
|
|
return await fs3.readFile(swDest, "utf-8");
|
|
}
|
|
if (swDevOptions.workboxPaths.has(id))
|
|
return await fs3.readFile(swDevOptions.workboxPaths.get(id), "utf-8");
|
|
}
|
|
}
|
|
};
|
|
}
|
|
async function createDevRegisterSW(options2, viteConfig) {
|
|
if (options2.injectRegister === "script") {
|
|
const devDist = resolve3(viteConfig.root, "dev-dist");
|
|
if (!existsSync2(devDist))
|
|
mkdirSync(devDist);
|
|
const registerSW = resolve3(devDist, FILE_SW_REGISTER);
|
|
if (existsSync2(registerSW))
|
|
return;
|
|
await fs3.writeFile(registerSW, generateSimpleSWRegister(options2, true), { encoding: "utf8" });
|
|
swDevOptions.workboxPaths.set(normalizePath(`${options2.base}${FILE_SW_REGISTER}`), registerSW);
|
|
}
|
|
}
|
|
function createSWResponseHandler(server, ctx) {
|
|
return async () => {
|
|
const { options: options2, useImportRegister } = ctx;
|
|
const { injectRegister, scope, base } = options2;
|
|
if (!useImportRegister && injectRegister) {
|
|
if (injectRegister === "auto")
|
|
options2.injectRegister = "script";
|
|
await createDevRegisterSW(options2, ctx.viteConfig);
|
|
server.ws.send({
|
|
type: "custom",
|
|
event: DEV_REGISTER_SW_NAME,
|
|
data: {
|
|
inline: options2.injectRegister === "inline",
|
|
scope,
|
|
inlinePath: `${base}${DEV_SW_NAME}`,
|
|
registerPath: `${base}${FILE_SW_REGISTER}`
|
|
}
|
|
});
|
|
}
|
|
};
|
|
}
|
|
function generateSWHMR() {
|
|
return `import.meta.hot.on('${DEV_REGISTER_SW_NAME}', ({ inline, inlinePath, registerPath, scope }) => {
|
|
if (inline) {
|
|
if('serviceWorker' in navigator) {
|
|
navigator.serviceWorker.register(inlinePath, { scope });
|
|
}
|
|
}
|
|
else {
|
|
const registerSW = document.createElement('script');
|
|
registerSW.setAttribute('src', registerPath);
|
|
document.head.appendChild(registerSW);
|
|
}
|
|
});
|
|
|
|
try {
|
|
import.meta.hot.send('${DEV_READY_NAME}');
|
|
} catch (e) {
|
|
console.error('unable to send ${DEV_READY_NAME} message to register service worker in dev mode!', e);
|
|
}`;
|
|
}
|
|
|
|
// src/options.ts
|
|
import fs4 from "fs";
|
|
import { extname, resolve as resolve4 } from "path";
|
|
function resolveSwPaths(injectManifest, root, srcDir, outDir, filename) {
|
|
const swSrc = resolve4(root, srcDir, filename);
|
|
if (injectManifest && extname(filename) === ".ts" && fs4.existsSync(swSrc)) {
|
|
const useFilename = `${filename.substring(0, filename.lastIndexOf("."))}.js`;
|
|
return {
|
|
swSrc,
|
|
swDest: resolve4(root, outDir, useFilename),
|
|
useFilename
|
|
};
|
|
}
|
|
return {
|
|
swSrc,
|
|
swDest: resolve4(root, outDir, filename)
|
|
};
|
|
}
|
|
async function resolveOptions(options2, viteConfig) {
|
|
var _b;
|
|
const root = viteConfig.root;
|
|
const pkg = fs4.existsSync("package.json") ? JSON.parse(fs4.readFileSync("package.json", "utf-8")) : {};
|
|
const {
|
|
mode = process["env"]["NODE_ENV"] || "production",
|
|
srcDir = "public",
|
|
outDir = viteConfig.build.outDir || "dist",
|
|
injectRegister = "auto",
|
|
registerType = "prompt",
|
|
filename = "sw.js",
|
|
manifestFilename = "manifest.webmanifest",
|
|
strategies = "generateSW",
|
|
minify = true,
|
|
base = viteConfig.base,
|
|
includeAssets = void 0,
|
|
includeManifestIcons = true,
|
|
useCredentials = false,
|
|
disable = false,
|
|
devOptions = { enabled: false, type: "classic" },
|
|
selfDestroying = false
|
|
} = options2;
|
|
const basePath = resolveBathPath(base);
|
|
const { swSrc, swDest, useFilename } = resolveSwPaths(strategies === "injectManifest", root, srcDir, outDir, filename);
|
|
const outDirRoot = resolve4(root, outDir);
|
|
const scope = options2.scope || basePath;
|
|
const defaultWorkbox = {
|
|
swDest,
|
|
globDirectory: outDirRoot,
|
|
offlineGoogleAnalytics: false,
|
|
cleanupOutdatedCaches: true,
|
|
dontCacheBustURLsMatching: /\.[a-f0-9]{8}\./,
|
|
mode,
|
|
navigateFallback: "index.html"
|
|
};
|
|
const defaultInjectManifest = {
|
|
swSrc,
|
|
swDest,
|
|
globDirectory: outDirRoot,
|
|
dontCacheBustURLsMatching: /\.[a-f0-9]{8}\./,
|
|
injectionPoint: "self.__WB_MANIFEST"
|
|
};
|
|
const defaultManifest = {
|
|
name: pkg.name,
|
|
short_name: pkg.name,
|
|
start_url: basePath,
|
|
display: "standalone",
|
|
background_color: "#ffffff",
|
|
lang: "en",
|
|
scope
|
|
};
|
|
const workbox = Object.assign({}, defaultWorkbox, options2.workbox || {});
|
|
const manifest = typeof options2.manifest === "boolean" && !options2.manifest ? false : Object.assign({}, defaultManifest, options2.manifest || {});
|
|
const _a = options2.injectManifest || {}, { vitePlugins = defaultInjectManifestVitePlugins } = _a, userInjectManifest = __objRest(_a, ["vitePlugins"]);
|
|
const injectManifest = Object.assign({}, defaultInjectManifest, userInjectManifest);
|
|
if ((injectRegister === "auto" || injectRegister == null) && registerType === "autoUpdate") {
|
|
workbox.skipWaiting = true;
|
|
workbox.clientsClaim = true;
|
|
}
|
|
if (strategies === "generateSW" && workbox.sourcemap === void 0) {
|
|
const sourcemap = (_b = viteConfig.build) == null ? void 0 : _b.sourcemap;
|
|
workbox.sourcemap = sourcemap === true || sourcemap === "inline" || sourcemap === "hidden";
|
|
}
|
|
if (devOptions.enabled && viteConfig.command === "serve") {
|
|
if (strategies === "generateSW")
|
|
devOptions.type = "classic";
|
|
} else {
|
|
devOptions.enabled = false;
|
|
devOptions.type = "classic";
|
|
}
|
|
const resolvedVitePWAOptions = {
|
|
base: basePath,
|
|
mode,
|
|
swSrc,
|
|
swDest,
|
|
srcDir,
|
|
outDir,
|
|
injectRegister,
|
|
registerType,
|
|
filename: useFilename || filename,
|
|
manifestFilename,
|
|
strategies,
|
|
workbox,
|
|
manifest,
|
|
useCredentials,
|
|
injectManifest,
|
|
scope,
|
|
minify,
|
|
includeAssets,
|
|
includeManifestIcons,
|
|
disable,
|
|
devOptions,
|
|
vitePlugins,
|
|
selfDestroying
|
|
};
|
|
await configureStaticAssets(resolvedVitePWAOptions, viteConfig);
|
|
return resolvedVitePWAOptions;
|
|
}
|
|
|
|
// src/plugins/main.ts
|
|
function MainPlugin(ctx) {
|
|
return {
|
|
name: "vite-plugin-pwa",
|
|
enforce: "pre",
|
|
async configResolved(config) {
|
|
ctx.useImportRegister = false;
|
|
ctx.viteConfig = config;
|
|
ctx.options = await resolveOptions(ctx.userOptions, config);
|
|
},
|
|
resolveId(id) {
|
|
return VIRTUAL_MODULES.includes(id) ? VIRTUAL_MODULES_RESOLVE_PREFIX + id : void 0;
|
|
},
|
|
load(id) {
|
|
if (id.startsWith(VIRTUAL_MODULES_RESOLVE_PREFIX))
|
|
id = id.slice(VIRTUAL_MODULES_RESOLVE_PREFIX.length);
|
|
else
|
|
return;
|
|
if (VIRTUAL_MODULES.includes(id)) {
|
|
ctx.useImportRegister = true;
|
|
if (ctx.viteConfig.command === "serve" && ctx.options.devOptions.enabled) {
|
|
return generateRegisterSW(__spreadProps(__spreadValues({}, ctx.options), { filename: swDevOptions.swUrl }), "build", VIRTUAL_MODULES_MAP[id]);
|
|
} else {
|
|
return generateRegisterSW(ctx.options, !ctx.options.disable && ctx.viteConfig.command === "build" ? "build" : "dev", VIRTUAL_MODULES_MAP[id]);
|
|
}
|
|
}
|
|
},
|
|
api: createAPI(ctx)
|
|
};
|
|
}
|
|
|
|
// src/cache.ts
|
|
var cachePreset = [
|
|
{
|
|
urlPattern: /^https:\/\/fonts\.(?:googleapis|gstatic)\.com\/.*/i,
|
|
handler: "CacheFirst",
|
|
options: {
|
|
cacheName: "google-fonts",
|
|
expiration: {
|
|
maxEntries: 4,
|
|
maxAgeSeconds: 365 * 24 * 60 * 60
|
|
}
|
|
}
|
|
},
|
|
{
|
|
urlPattern: /\.(?:eot|otf|ttc|ttf|woff|woff2|font.css)$/i,
|
|
handler: "StaleWhileRevalidate",
|
|
options: {
|
|
cacheName: "static-font-assets",
|
|
expiration: {
|
|
maxEntries: 4,
|
|
maxAgeSeconds: 7 * 24 * 60 * 60
|
|
}
|
|
}
|
|
},
|
|
{
|
|
urlPattern: /\.(?:jpg|jpeg|gif|png|svg|ico|webp)$/i,
|
|
handler: "StaleWhileRevalidate",
|
|
options: {
|
|
cacheName: "static-image-assets",
|
|
expiration: {
|
|
maxEntries: 64,
|
|
maxAgeSeconds: 24 * 60 * 60
|
|
}
|
|
}
|
|
},
|
|
{
|
|
urlPattern: /\.(?:js)$/i,
|
|
handler: "StaleWhileRevalidate",
|
|
options: {
|
|
cacheName: "static-js-assets",
|
|
expiration: {
|
|
maxEntries: 32,
|
|
maxAgeSeconds: 24 * 60 * 60
|
|
}
|
|
}
|
|
},
|
|
{
|
|
urlPattern: /\.(?:css|less)$/i,
|
|
handler: "StaleWhileRevalidate",
|
|
options: {
|
|
cacheName: "static-style-assets",
|
|
expiration: {
|
|
maxEntries: 32,
|
|
maxAgeSeconds: 24 * 60 * 60
|
|
}
|
|
}
|
|
},
|
|
{
|
|
urlPattern: /\.(?:json|xml|csv)$/i,
|
|
handler: "NetworkFirst",
|
|
options: {
|
|
cacheName: "static-data-assets",
|
|
expiration: {
|
|
maxEntries: 32,
|
|
maxAgeSeconds: 24 * 60 * 60
|
|
}
|
|
}
|
|
},
|
|
{
|
|
urlPattern: /\/api\/.*$/i,
|
|
handler: "NetworkFirst",
|
|
method: "GET",
|
|
options: {
|
|
cacheName: "apis",
|
|
expiration: {
|
|
maxEntries: 16,
|
|
maxAgeSeconds: 24 * 60 * 60
|
|
},
|
|
networkTimeoutSeconds: 10
|
|
}
|
|
},
|
|
{
|
|
urlPattern: /.*/i,
|
|
handler: "NetworkFirst",
|
|
options: {
|
|
cacheName: "others",
|
|
expiration: {
|
|
maxEntries: 32,
|
|
maxAgeSeconds: 24 * 60 * 60
|
|
},
|
|
networkTimeoutSeconds: 10
|
|
}
|
|
}
|
|
];
|
|
|
|
// src/index.ts
|
|
function VitePWA(userOptions = {}) {
|
|
const ctx = createContext(userOptions);
|
|
return [
|
|
MainPlugin(ctx),
|
|
BuildPlugin(ctx),
|
|
DevPlugin(ctx)
|
|
];
|
|
}
|
|
export {
|
|
VitePWA,
|
|
cachePreset,
|
|
defaultInjectManifestVitePlugins
|
|
};
|