unplugin-version-injector 2.1.1 → 2.2.1

package/dist/vite.mjs

@@ -1,73 +1,345 @@
+import { createVitePlugin } from 'unplugin';
+import { createRequire } from 'module';
 import fs from 'fs';
 import path from 'path';
 
-// src/shared/utils.ts
+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 Error('Dynamic require of "' + x + '" is not supported');
+});
+var cachedPkg = null;
 function getPackageVersion(startDir) {
+  if (cachedPkg) return cachedPkg;
   try {
     let dir = startDir || process.cwd();
-    while (dir !== path.parse(dir).root) {
+    while (true) {
       const pkgPath = path.join(dir, "package.json");
       if (fs.existsSync(pkgPath)) {
         const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-        return { version: pkg.version || "0.0.0", name: pkg.name || "unknown" };
+        cachedPkg = { version: pkg.version || "0.0.0", name: pkg.name || "unknown" };
+        return cachedPkg;
       }
-      dir = path.dirname(dir);
+      const parent = path.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
     }
     console.warn("[VersionInjector] package.json not found");
-    return { version: "0.0.0", name: "unknown" };
+    cachedPkg = { version: "0.0.0", name: "unknown" };
+    return cachedPkg;
   } catch (err) {
     console.warn("[VersionInjector] Failed to read package.json:", err);
-    return { version: "0.0.0", name: "unknown" };
+    cachedPkg = { version: "0.0.0", name: "unknown" };
+    return cachedPkg;
   }
 }
 function defaultFormatDate(date) {
   return date.toISOString();
 }
+var WEEKDAYS_SHORT = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+var WEEKDAYS_FULL = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+var MONTHS_SHORT = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+var MONTHS_FULL = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
+function pad(num) {
+  return num < 10 ? "0" + num : String(num);
+}
+function formatDate(date, format) {
+  const year = date.getFullYear();
+  const month = date.getMonth();
+  const day = date.getDate();
+  const hours = date.getHours();
+  const minutes = date.getMinutes();
+  const seconds = date.getSeconds();
+  const ms = date.getMilliseconds();
+  const dayOfWeek = date.getDay();
+  const tokens = {
+    YYYY: String(year),
+    YY: String(year).slice(-2),
+    MMMM: MONTHS_FULL[month],
+    MMM: MONTHS_SHORT[month],
+    MM: pad(month + 1),
+    M: String(month + 1),
+    DD: pad(day),
+    D: String(day),
+    dddd: WEEKDAYS_FULL[dayOfWeek],
+    ddd: WEEKDAYS_SHORT[dayOfWeek],
+    dd: WEEKDAYS_SHORT[dayOfWeek].slice(0, 2),
+    d: String(dayOfWeek),
+    HH: pad(hours),
+    H: String(hours),
+    hh: pad(hours % 12 || 12),
+    h: String(hours % 12 || 12),
+    mm: pad(minutes),
+    m: String(minutes),
+    ss: pad(seconds),
+    s: String(seconds),
+    SSS: pad(ms),
+    SS: pad(Math.floor(ms / 10)),
+    S: String(Math.floor(ms / 100)),
+    A: hours < 12 ? "AM" : "PM",
+    a: hours < 12 ? "am" : "pm"
+  };
+  return format.replace(/YYYY|YY|MMMM|MMM|MM|M|DD|D|dddd|ddd|dd|d|HH|H|hh|h|mm|m|ss|s|SSS|SS|S|A|a/g, (match) => tokens[match]);
+}
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function toScriptString(value) {
+  return JSON.stringify(value).replace(/</g, "\\u003C");
+}
 
 // src/core.ts
+var INJECTED_MARK = 'data-injected="unplugin-version-injector"';
+var HEADERS_INJECTED_MARK = 'data-injected="unplugin-version-injector-headers"';
+var HEADER_NAME_RE = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+var DEFAULT_VERSION_HEADER = "X-Client-Version";
+var DEFAULT_BUILD_TIME_HEADER = "X-Client-Build-Time";
+function normalizeRequestHeaders(opt) {
+  if (!opt) return null;
+  const o = typeof opt === "object" ? opt : {};
+  const pickHeaderName = (value, fallback) => {
+    if (value == null) return fallback;
+    if (HEADER_NAME_RE.test(value)) return value;
+    console.warn(
+      `[VersionInjector] invalid request header name "${value}", falling back to "${fallback}"`
+    );
+    return fallback;
+  };
+  const include = (Array.isArray(o.include) ? o.include : []).filter(
+    (p) => typeof p === "string" || p instanceof RegExp
+  );
+  return {
+    versionHeaderName: pickHeaderName(o.versionHeaderName, DEFAULT_VERSION_HEADER),
+    buildTimeHeaderName: pickHeaderName(o.buildTimeHeaderName, DEFAULT_BUILD_TIME_HEADER),
+    include
+  };
+}
+function sanitizeHeaderValue(value) {
+  return value.replace(/[^\t\x20-\x7E]/g, "").trim();
+}
+function serializeInclude(patterns) {
+  const items = patterns.map(
+    (p) => typeof p === "string" ? toScriptString(p) : `new RegExp(${toScriptString(p.source)}, ${toScriptString(p.flags)})`
+  );
+  return `[${items.join(", ")}]`;
+}
 function createVersionInjector(options = {}) {
-  var _a;
-  const { version, name } = options.version && options.name ? options : getPackageVersion();
-  const buildTime = ((_a = options.formatDate) != null ? _a : defaultFormatDate)(/* @__PURE__ */ new Date());
-  const metaTag = `<meta name="version" content="${version}">
-<meta name="project" content="${name}">
+  const pkg = options.version && options.name ? { version: options.version, name: options.name } : getPackageVersion();
+  const version = options.version || pkg.version;
+  const name = options.name || pkg.name;
+  const formatDateOpt = options.formatDate;
+  const formatDate2 = typeof formatDateOpt === "string" ? (date) => formatDate(date, formatDateOpt) : formatDateOpt != null ? formatDateOpt : defaultFormatDate;
+  const headersConfig = normalizeRequestHeaders(options.requestHeaders);
+  const metaTag = `<meta name="version" content="${escapeHtml(version)}">
+<meta name="project" content="${escapeHtml(name)}">
 `;
-  const logScript = `
-<script data-injected="unplugin-version-injector">
+  const buildLogScript = (buildTime) => `
+<script ${INJECTED_MARK}>
   (function () {
-    var isDark = window.matchMedia('(prefers-color-scheme: dark)').matches;
-    var bg = isDark ? '#ffffff' : '#1e1e1e' ;
-    var border = 'border-radius: 4px; padding: 4px; font-size: 12px;';
-    var styles = {
-      version: \`background: \${bg}; color: #00c853; \${border}\`,
-      time:    \`background: \${bg}; color: #ffab00; \${border}\`,
-    };
-    console.log("%c ${name}@${version} ", styles.version);
-    console.log("%c Build Time: ${buildTime} ", styles.time);
+    try {
+      var isDark = window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches;
+      var bg = isDark ? '#ffffff' : '#1e1e1e';
+      var base = 'background: ' + bg + '; border-radius: 4px; padding: 4px; font-size: 12px;';
+      console.log('%c' + ${toScriptString(` ${name}@${version} `)}, base + ' color: #00c853;');
+      console.log('%c' + ${toScriptString(` Build Time: ${buildTime} `)}, base + ' color: #ffab00;');
+    } catch (e) {}
   })();
 </script>`;
-  return function processHtml(html) {
-    if (!html.includes('<meta name="version"')) {
-      html = html.replace(/<head>/i, `<head>
-  ${metaTag}`);
+  const buildHeaderScript = (buildTime, cfg) => {
+    const versionValue = sanitizeHeaderValue(`${name}/${version}`);
+    const buildValue = sanitizeHeaderValue(buildTime);
+    return `
+<script ${HEADERS_INJECTED_MARK}>
+  (function () {
+    try {
+    if (window.__UVI_HEADERS_PATCHED__) return;
+    window.__UVI_HEADERS_PATCHED__ = true;
+    var VERSION_HEADER = ${toScriptString(cfg.versionHeaderName)};
+    var BUILD_HEADER = ${toScriptString(cfg.buildTimeHeaderName)};
+    var VERSION_VALUE = ${toScriptString(versionValue)};
+    var BUILD_VALUE = ${toScriptString(buildValue)};
+    var INCLUDE = ${serializeInclude(cfg.include)};
+
+    function resolveUrl(url) {
+      try {
+        if (typeof URL === 'function') return new URL(url, location.href);
+      } catch (e) {
+        return null;
+      }
+      try {
+        var a = document.createElement('a');
+        a.href = url;
+        return { protocol: a.protocol, host: a.host, href: a.href };
+      } catch (e2) {
+        return null;
+      }
+    }
+
+    function shouldInject(url) {
+      var u = resolveUrl(url == null ? '' : String(url));
+      if (!u || (u.protocol !== 'http:' && u.protocol !== 'https:')) return false;
+      if (u.protocol === location.protocol && u.host === location.host) return true;
+      for (var i = 0; i < INCLUDE.length; i++) {
+        var p = INCLUDE[i];
+        if (typeof p === 'string' ? u.href.indexOf(p) === 0 : p.test(u.href)) return true;
+      }
+      return false;
+    }
+
+    if (typeof window.fetch === 'function' && typeof Headers === 'function') {
+      var originalFetch = window.fetch;
+      window.fetch = function (input, init) {
+        try {
+          var isRequest = typeof Request === 'function' && input instanceof Request;
+          var url = isRequest ? input.url : String(input);
+          if (shouldInject(url)) {
+            var headers = new Headers(
+              (init && init.headers) || (isRequest ? input.headers : undefined)
+            );
+            headers.set(VERSION_HEADER, VERSION_VALUE);
+            headers.set(BUILD_HEADER, BUILD_VALUE);
+            var copy = {};
+            if (init) for (var k in init) copy[k] = init[k];
+            copy.headers = headers;
+            init = copy;
+          }
+        } catch (e) {}
+        return originalFetch.call(this, input, init);
+      };
     }
-    if (options.log !== false && !html.includes('data-injected="unplugin-version-injector"')) {
-      html = html.replace(/<\/body>/i, `  ${logScript}
+
+    if (window.XMLHttpRequest && XMLHttpRequest.prototype) {
+      var proto = XMLHttpRequest.prototype;
+      var originalOpen = proto.open;
+      var originalSend = proto.send;
+      if (originalOpen && originalSend) {
+        proto.open = function (method, url) {
+          try {
+            this.__uviInject = shouldInject(url);
+          } catch (e) {}
+          return originalOpen.apply(this, arguments);
+        };
+        proto.send = function () {
+          if (this.__uviInject) {
+            try {
+              this.setRequestHeader(VERSION_HEADER, VERSION_VALUE);
+              this.setRequestHeader(BUILD_HEADER, BUILD_VALUE);
+            } catch (e) {}
+          }
+          return originalSend.apply(this, arguments);
+        };
+      }
+    }
+    } catch (e) {}
+  })();
+</script>`;
+  };
+  const processHtml = function processHtml2(html) {
+    const original = html;
+    try {
+      const buildTime = formatDate2(/* @__PURE__ */ new Date());
+      if (!html.includes('<meta name="version"')) {
+        html = html.replace(/<head[^>]*>/i, (match) => `${match}
+  ${metaTag}`);
+      }
+      if (headersConfig && !html.includes(HEADERS_INJECTED_MARK)) {
+        const headerScript = buildHeaderScript(buildTime, headersConfig);
+        html = html.replace(/<head[^>]*>/i, (match) => `${match}
+  ${headerScript}
+`);
+      }
+      if (options.log !== false && !html.includes(INJECTED_MARK)) {
+        const logScript = buildLogScript(buildTime);
+        html = html.replace(/<\/body>/i, () => `  ${logScript}
 </body>`);
+      }
+      return html;
+    } catch (err) {
+      console.warn("[VersionInjector] injection failed, returning original HTML unchanged:", err);
+      return original;
     }
-    return html;
   };
+  processHtml.resetBuildTime = () => {
+  };
+  return processHtml;
 }
 
-// src/vite.ts
-function versionInjectorPlugin(options = {}) {
+// src/index.ts
+var import_meta = {};
+var PLUGIN_NAME = "unplugin-version-injector";
+function injectBundleHtml(bundle, inject) {
+  for (const file of Object.values(bundle)) {
+    if (file.type === "asset" && file.fileName.endsWith(".html")) {
+      const source = typeof file.source === "string" ? file.source : Buffer.from(file.source).toString("utf-8");
+      file.source = inject(source);
+    }
+  }
+}
+function applyWebpackLike(compiler, inject) {
+  var _a;
+  const api = (_a = compiler.webpack) != null ? _a : compiler.rspack;
+  if ((api == null ? void 0 : api.Compilation) && (api == null ? void 0 : api.sources)) {
+    compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+      compilation.hooks.processAssets.tap(
+        {
+          name: PLUGIN_NAME,
+          // html-webpack-plugin 在 OPTIMIZE_INLINE 阶段产出 HTML，SUMMARIZE 保证跑在它之后
+          stage: api.Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE
+        },
+        (assets) => {
+          for (const name of Object.keys(assets)) {
+            if (name.endsWith(".html")) {
+              const html = assets[name].source().toString();
+              compilation.updateAsset(name, new api.sources.RawSource(inject(html)));
+            }
+          }
+        }
+      );
+    });
+  } else {
+    const requireFn = typeof __require === "function" ? __require : createRequire(import_meta.url);
+    const { RawSource } = requireFn("webpack-sources");
+    compiler.hooks.emit.tapAsync(PLUGIN_NAME, (compilation, callback) => {
+      for (const name of Object.keys(compilation.assets)) {
+        if (name.endsWith(".html")) {
+          const html = compilation.assets[name].source().toString();
+          compilation.assets[name] = new RawSource(inject(html));
+        }
+      }
+      callback();
+    });
+  }
+}
+var unpluginFactory = (options = {}) => {
   const inject = createVersionInjector(options);
   return {
-    name: "vite-version-injector",
-    transformIndexHtml(html) {
-      return inject(html);
+    name: PLUGIN_NAME,
+    vite: {
+      transformIndexHtml(html) {
+        return inject(html);
+      }
+    },
+    rollup: {
+      generateBundle(_outputOptions, bundle) {
+        injectBundleHtml(bundle, inject);
+      }
+    },
+    rolldown: {
+      generateBundle(_outputOptions, bundle) {
+        injectBundleHtml(bundle, inject);
+      }
+    },
+    webpack(compiler) {
+      applyWebpackLike(compiler, inject);
+    },
+    rspack(compiler) {
+      applyWebpackLike(compiler, inject);
     }
   };
-}
+};
+
+// src/vite.ts
+var vite_default = createVitePlugin(unpluginFactory);
 
-export { versionInjectorPlugin as default };
+export { vite_default as default };

package/dist/webpack.d.mts

@@ -1,7 +1,6 @@
-import { Compiler } from 'webpack';
+import * as webpack from 'webpack';
+import { V as VersionInjectorOptions } from './types-Cc-nzIS0.mjs';
 
-declare function versionInjectorPlugin(options?: {}): {
-    apply(compiler: Compiler): void;
-};
+declare const _default: (options?: VersionInjectorOptions | undefined) => webpack.WebpackPluginInstance;
 
-export { versionInjectorPlugin as default };
+export { _default as default };

package/dist/webpack.d.ts

@@ -1,7 +1,6 @@
-import { Compiler } from 'webpack';
+import * as webpack from 'webpack';
+import { V as VersionInjectorOptions } from './types-Cc-nzIS0.js';
 
-declare function versionInjectorPlugin(options?: {}): {
-    apply(compiler: Compiler): void;
-};
+declare const _default: (options?: VersionInjectorOptions | undefined) => webpack.WebpackPluginInstance;
 
-export { versionInjectorPlugin as default };
+export { _default as default };