@cdfrd/publish-notification-plugin 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1148 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  UpdateNoticeManager: () => UpdateNoticeManager,
+  createUpdateNotice: () => createUpdateNotice,
+  getUpdateNotice: () => getUpdateNotice
+});
+module.exports = __toCommonJS(src_exports);
+
+// node_modules/.pnpm/tsup@8.5.1_postcss@8.5.26_typescript@5.9.3/node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
+// src/constants.ts
+var DIRECTORY_NAME = "update-notice";
+var JSON_FILE_NAME = "version";
+var INJECT_STYLE_TAG_ID = "_cdfrd_un_styles_";
+var CUSTOM_UPDATE_EVENT_NAME = "web_update_notice";
+var NOTIFICATION_ANCHOR_CLASS_NAME = "cdfrd-update-notice-anchor";
+var NOTIFICATION_REFRESH_BTN_CLASS = "cdfrd-update-notice-refresh-btn";
+var NOTIFICATION_DISMISS_BTN_CLASS = "cdfrd-update-notice-dismiss-btn";
+var NOTIFICATION_CLOSE_BTN_CLASS = "cdfrd-update-notice-close-btn";
+var DISMISS_STORAGE_PREFIX = "cdfrd_update_notice_dismiss_";
+var MAX_DISMISSED_VERSIONS = 3;
+var STANDALONE_APP_ID = "__standalone__";
+var DEFAULT_PRIMARY_COLOR = "#1677ff";
+var THEME_RETRY_MAX = 3;
+var THEME_WATCH_DEBOUNCE_MS = 150;
+var PLACEMENT_STYLES = {
+  topLeft: "top:16px;left:24px",
+  topRight: "top:16px;right:24px",
+  bottomLeft: "bottom:16px;left:24px",
+  bottomRight: "bottom:16px;right:24px"
+};
+var DEFAULT_CHECK_INTERVAL = 10 * 60 * 1e3;
+
+// src/build/validate-options.ts
+var MUTUAL_EXCLUSIVE_MSG = "[publish-notification] disableNotification \u4E0E hiddenDefaultNotice \u4E0D\u5F97\u540C\u65F6\u4E3A true\uFF0C\u8BF7\u4E8C\u9009\u4E00\u3002";
+function validateOptions(options = {}) {
+  if (options.disableNotification && options.hiddenDefaultNotice) {
+    throw new Error(MUTUAL_EXCLUSIVE_MSG);
+  }
+  if (options.microApp?.enabled && !options.microApp.appId) {
+    throw new Error("[publish-notification] microApp.enabled \u4E3A true \u65F6\u5FC5\u987B\u63D0\u4F9B microApp.appId");
+  }
+  return options;
+}
+function resolveAppId(options) {
+  if (options.microApp?.enabled) return options.microApp.appId;
+  return void 0;
+}
+function isNotificationFullyDisabled(options) {
+  return options.disableNotification === true;
+}
+function shouldUseCustomEvent(options) {
+  return options.hiddenDefaultNotice === true && !isNotificationFullyDisabled(options);
+}
+function shouldShowDefaultUi(options) {
+  return !options.disableNotification && !options.hiddenDefaultNotice;
+}
+
+// src/core/check-gate.ts
+function isTabVisible() {
+  return typeof document !== "undefined" && document.visibilityState === "visible" && !document.hidden;
+}
+function isAppActive(options, context) {
+  if (!options.microApp?.enabled) return true;
+  return context.activeApp === options.microApp.appId;
+}
+function canCheckUpdate(options, context) {
+  if (isNotificationFullyDisabled(options)) return false;
+  if (options.check?.onTabVisible !== false && !isTabVisible()) return false;
+  if (!isAppActive(options, context)) return false;
+  return true;
+}
+function getRuntimeKey(options) {
+  return resolveAppId(options) ?? STANDALONE_APP_ID;
+}
+function getDismissAppId(options) {
+  return resolveAppId(options) ?? STANDALONE_APP_ID;
+}
+
+// src/core/dismiss-storage.ts
+var DISMISS_STORAGE_KEY = `${DISMISS_STORAGE_PREFIX}entries`;
+function toDismissEntry(appId, version) {
+  return `${appId}+${version}`;
+}
+function readDismissEntries() {
+  try {
+    const raw = localStorage.getItem(DISMISS_STORAGE_KEY);
+    if (!raw) return [];
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed.filter((v) => typeof v === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function writeDismissEntries(entries) {
+  try {
+    localStorage.setItem(DISMISS_STORAGE_KEY, JSON.stringify(entries));
+  } catch {
+  }
+}
+function isVersionDismissed(appId, version) {
+  return readDismissEntries().includes(toDismissEntry(appId, version));
+}
+function rememberDismissedVersion(appId, version) {
+  const entry = toDismissEntry(appId, version);
+  const entries = readDismissEntries().filter((item) => item !== entry);
+  const sameAppEntries = entries.filter((item) => item.startsWith(`${appId}+`));
+  const otherAppEntries = entries.filter((item) => !item.startsWith(`${appId}+`));
+  const nextSameAppEntries = [entry, ...sameAppEntries].slice(0, MAX_DISMISSED_VERSIONS);
+  writeDismissEntries([...otherAppEntries, ...nextSameAppEntries]);
+}
+
+// src/core/version-compare.ts
+function hasNewVersion(localVersion, remoteVersion) {
+  return localVersion !== remoteVersion;
+}
+
+// src/core/version-url.ts
+var import_meta = {};
+function normalizeBase(base) {
+  if (!base) return "";
+  return base.endsWith("/") ? base : `${base}/`;
+}
+function isAbsoluteHttpBase(base) {
+  return /^https?:\/\//i.test(base);
+}
+function readViteBaseUrl() {
+  try {
+    const base = import_meta.env.BASE_URL;
+    if (typeof base === "string") return base;
+  } catch {
+  }
+  return void 0;
+}
+function readRuntimePublicPath() {
+  if (typeof window === "undefined") return void 0;
+  const w = window;
+  const raw = w.__INJECTED_PUBLIC_PATH_BY_QIANKUN__ || w.proxy?.__INJECTED_PUBLIC_PATH_BY_QIANKUN__ || w.__webpack_public_path__ || w.proxy?.__webpack_public_path__;
+  if (typeof raw !== "string" || !raw.trim()) return void 0;
+  try {
+    const href = new URL(
+      raw,
+      typeof location !== "undefined" ? location.href : "http://localhost/"
+    ).href;
+    return normalizeBase(href);
+  } catch {
+    return normalizeBase(raw);
+  }
+}
+function vitePathPrefix(viteBase) {
+  if (!viteBase || viteBase === "/" || viteBase === "./") return "/";
+  if (isAbsoluteHttpBase(viteBase)) {
+    try {
+      const path = new URL(viteBase).pathname;
+      return normalizeBase(path || "/");
+    } catch {
+      return "/";
+    }
+  }
+  return normalizeBase(viteBase);
+}
+function readModuleOriginBase(pathBase) {
+  try {
+    const moduleUrl = new URL(importMetaUrl);
+    if (moduleUrl.protocol !== "http:" && moduleUrl.protocol !== "https:") return void 0;
+    if (!moduleUrl.origin) return void 0;
+    const prefix = pathBase === "/" ? "/" : pathBase;
+    return normalizeBase(`${moduleUrl.origin}${prefix === "/" ? "/" : prefix}`);
+  } catch {
+    return void 0;
+  }
+}
+function resolveMicroVersionBase(explicit) {
+  if (explicit !== void 0 && explicit !== null) {
+    return normalizeBase(explicit);
+  }
+  const runtime = readRuntimePublicPath();
+  if (runtime && isAbsoluteHttpBase(runtime)) return runtime;
+  const viteBase = readViteBaseUrl() ?? "";
+  if (isAbsoluteHttpBase(viteBase)) return normalizeBase(viteBase);
+  return readModuleOriginBase(vitePathPrefix(viteBase));
+}
+function resolveVersionBase(explicit) {
+  if (explicit !== void 0 && explicit !== null) {
+    return normalizeBase(explicit);
+  }
+  const viteBase = readViteBaseUrl() ?? "";
+  if (isAbsoluteHttpBase(viteBase)) {
+    return normalizeBase(viteBase);
+  }
+  const pathBase = vitePathPrefix(viteBase);
+  return pathBase === "/" ? "" : pathBase;
+}
+function buildVersionJsonUrl(versionBase) {
+  const base = resolveVersionBase(versionBase);
+  return `${base}${DIRECTORY_NAME}/${JSON_FILE_NAME}.json`;
+}
+
+// src/core/UpdateNoticeRuntime.ts
+var UpdateNoticeRuntime = class {
+  constructor(manager, options) {
+    /** Baseline version for this page session; set on first successful fetch */
+    this.localVersion = null;
+    this.pendingUpdate = null;
+    this.manager = manager;
+    this.options = options;
+    this.appId = resolveAppId(options);
+    this.appKey = getRuntimeKey(options);
+  }
+  bootstrap() {
+    if (isNotificationFullyDisabled(this.options)) return;
+    this.setupScheduler();
+  }
+  destroy() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = void 0;
+    }
+    if (this.onVisibilityChange) {
+      document.removeEventListener("visibilitychange", this.onVisibilityChange);
+      this.onVisibilityChange = void 0;
+    }
+    if (this.onWindowFocus) {
+      window.removeEventListener("focus", this.onWindowFocus);
+      this.onWindowFocus = void 0;
+    }
+    if (this.onResourceError) {
+      window.removeEventListener("error", this.onResourceError, true);
+      this.onResourceError = void 0;
+    }
+  }
+  checkUpdate() {
+    if (isNotificationFullyDisabled(this.options)) return;
+    if (!canCheckUpdate(this.options, { activeApp: this.manager.activeApp })) {
+      if (this.pendingUpdate) this.tryNotify(this.pendingUpdate);
+      return;
+    }
+    const poweredByQiankun = Boolean(
+      window.__POWERED_BY_QIANKUN__
+    );
+    const versionBase = this.options.versionBase !== void 0 && this.options.versionBase !== null ? this.options.versionBase : this.options.microApp?.enabled && poweredByQiankun ? resolveMicroVersionBase() ?? resolveVersionBase() : resolveVersionBase();
+    const url = `${buildVersionJsonUrl(versionBase)}?t=${Date.now()}`;
+    fetch(url).then((res) => {
+      if (!res.ok) throw new Error("version fetch failed");
+      return res.json();
+    }).then((remote) => {
+      if (!remote?.version) return;
+      if (this.localVersion == null) {
+        this.localVersion = remote.version;
+        return;
+      }
+      if (!hasNewVersion(this.localVersion, remote.version)) {
+        this.pendingUpdate = null;
+        return;
+      }
+      if (!canCheckUpdate(this.options, { activeApp: this.manager.activeApp })) {
+        this.pendingUpdate = remote.version;
+        return;
+      }
+      this.handleUpdateDetected(remote.version);
+    }).catch(() => {
+    });
+  }
+  flushPendingUpdate() {
+    if (this.pendingUpdate) this.tryNotify(this.pendingUpdate);
+  }
+  handleUpdateDetected(version) {
+    const dismissKey = getDismissAppId(this.options);
+    if (isVersionDismissed(dismissKey, version)) return;
+    this.pendingUpdate = null;
+    this.manager.notifyUpdate(this, version);
+    if (shouldUseCustomEvent(this.options)) {
+      window.dispatchEvent(
+        new CustomEvent(CUSTOM_UPDATE_EVENT_NAME, {
+          detail: { appId: this.appId, version, options: this.options }
+        })
+      );
+      return;
+    }
+    if (shouldShowDefaultUi(this.options)) {
+      const shown = this.manager.showDefaultNotice(this, version);
+      if (!shown) this.pendingUpdate = version;
+    }
+  }
+  tryNotify(version) {
+    if (canCheckUpdate(this.options, { activeApp: this.manager.activeApp })) {
+      this.handleUpdateDetected(version);
+    }
+  }
+  dismissVersion(version) {
+    rememberDismissedVersion(getDismissAppId(this.options), version);
+  }
+  setupScheduler() {
+    const check = this.options.check ?? {};
+    const checkInterval = check.interval ?? DEFAULT_CHECK_INTERVAL;
+    const onWindowActive = check.onWindowActive !== false;
+    const onResourceError = check.onResourceError !== false;
+    const checkImmediately = !this.options.microApp?.enabled;
+    const run = () => this.checkUpdate();
+    const flushPending = () => this.flushPendingUpdate();
+    if (checkImmediately) {
+      setTimeout(run, 0);
+    }
+    const startPolling = () => {
+      if (this.intervalId) clearInterval(this.intervalId);
+      if (checkInterval > 0) {
+        this.intervalId = setInterval(run, checkInterval);
+      }
+    };
+    startPolling();
+    this.onVisibilityChange = () => {
+      if (document.visibilityState === "visible") {
+        startPolling();
+        flushPending();
+        if (onWindowActive) run();
+      } else if (this.intervalId) {
+        clearInterval(this.intervalId);
+        this.intervalId = void 0;
+      }
+    };
+    document.addEventListener("visibilitychange", this.onVisibilityChange);
+    if (onWindowActive) {
+      this.onWindowFocus = () => {
+        flushPending();
+        run();
+      };
+      window.addEventListener("focus", this.onWindowFocus);
+    }
+    if (onResourceError) {
+      this.onResourceError = (event) => {
+        const tag = event.target?.tagName;
+        if (tag === "SCRIPT" || tag === "LINK") run();
+      };
+      window.addEventListener("error", this.onResourceError, true);
+    }
+  }
+};
+function ensureNotificationAnchor() {
+  if (typeof document === "undefined") return;
+  const existing = document.body?.querySelector(`:scope > .${NOTIFICATION_ANCHOR_CLASS_NAME}`);
+  if (existing) return;
+  const mount = () => {
+    if (document.body?.querySelector(`:scope > .${NOTIFICATION_ANCHOR_CLASS_NAME}`)) return;
+    if (!document.body) return;
+    const anchor = document.createElement("div");
+    anchor.className = NOTIFICATION_ANCHOR_CLASS_NAME;
+    document.body.appendChild(anchor);
+  };
+  if (!document.body) {
+    document.addEventListener("DOMContentLoaded", mount, { once: true });
+    return;
+  }
+  mount();
+}
+
+// src/core/locale.ts
+var PRESET_LOCALE = {
+  zh_CN: {
+    title: "\u53D1\u73B0\u65B0\u7248\u672C",
+    description: "\u8BF7\u5237\u65B0\u540E\u7EE7\u7EED\u3002",
+    forcedTitle: "\u53D1\u73B0\u65B0\u7248\u672C",
+    forcedDescription: "\u8BF7\u5237\u65B0\u540E\u7EE7\u7EED\u3002",
+    buttonText: "\u5237\u65B0",
+    dismissButtonText: "\u7A0D\u540E"
+  },
+  en_US: {
+    title: "Update available",
+    description: "Please refresh to continue.",
+    forcedTitle: "Update required",
+    forcedDescription: "Please refresh to continue.",
+    buttonText: "Refresh",
+    dismissButtonText: "Later"
+  }
+};
+function resolveNotificationCopy(options, locale) {
+  const builtin = PRESET_LOCALE[locale] ?? PRESET_LOCALE.zh_CN;
+  const fromData = options.locale?.data?.[locale] ?? {};
+  return {
+    title: fromData.title ?? builtin.title,
+    description: fromData.description ?? builtin.description,
+    forcedTitle: fromData.title ?? builtin.forcedTitle,
+    forcedDescription: fromData.forcedDescription ?? builtin.forcedDescription,
+    buttonText: fromData.buttonText ?? builtin.buttonText,
+    dismissButtonText: fromData.dismissButtonText ?? builtin.dismissButtonText
+  };
+}
+
+// src/notification/default-styles.ts
+var DEFAULT_NOTICE_CSS = `
+.cdfrd-update-notice[data-update-notice-theme='light'] {
+  --update-bg: #ffffff;
+  --update-text: rgba(0, 0, 0, 0.88);
+  --update-text-secondary: rgba(0, 0, 0, 0.65);
+  --update-border: #f0f0f0;
+  --update-btn-border: #d9d9d9;
+  --update-btn-hover-bg: rgba(0, 0, 0, 0.04);
+  --update-primary: #1677ff;
+  --update-primary-hover: #4096ff;
+  --update-mask: rgba(0, 0, 0, 0.45);
+  --update-shadow: 0 6px 16px 0 rgba(0, 0, 0, 0.08), 0 3px 6px -4px rgba(0, 0, 0, 0.12),
+    0 9px 28px 8px rgba(0, 0, 0, 0.05);
+}
+
+.cdfrd-update-notice[data-update-notice-theme='dark'] {
+  --update-bg: #1f1f1f;
+  --update-text: rgba(255, 255, 255, 0.85);
+  --update-text-secondary: rgba(255, 255, 255, 0.65);
+  --update-border: #303030;
+  --update-btn-border: #424242;
+  --update-btn-hover-bg: rgba(255, 255, 255, 0.08);
+  --update-primary: #1668dc;
+  --update-primary-hover: #3c89e8;
+  --update-mask: rgba(0, 0, 0, 0.65);
+  --update-shadow: 0 6px 16px 0 rgba(0, 0, 0, 0.32), 0 3px 6px -4px rgba(0, 0, 0, 0.48),
+    0 9px 28px 8px rgba(0, 0, 0, 0.2);
+}
+
+.cdfrd-update-notice {
+  position: fixed;
+  z-index: 99999;
+  box-sizing: border-box;
+  max-width: calc(100vw - 48px);
+  user-select: none;
+  pointer-events: none;
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial,
+    'Noto Sans', 'PingFang SC', 'Hiragino Sans GB', 'Microsoft YaHei', sans-serif;
+}
+
+.cdfrd-update-notice:not(.cdfrd-update-notice--forced) {
+  width: 384px;
+}
+
+.cdfrd-update-notice-panel {
+  pointer-events: auto;
+  position: relative;
+  box-sizing: border-box;
+  width: 100%;
+  padding: 16px 24px;
+  border-radius: 8px;
+  background: var(--update-bg);
+  color: var(--update-text);
+  border: 1px solid var(--update-border);
+  box-shadow: var(--update-shadow);
+}
+
+.cdfrd-update-notice-header {
+  display: flex;
+  align-items: flex-start;
+  gap: 8px;
+  margin-bottom: 4px;
+}
+
+.cdfrd-update-notice-title {
+  flex: 1;
+  min-width: 0;
+  font-size: 16px;
+  font-weight: 600;
+  line-height: 1.5;
+  color: var(--update-text);
+}
+
+.cdfrd-update-notice-close {
+  flex-shrink: 0;
+  cursor: pointer;
+  width: 22px;
+  height: 22px;
+  padding: 0;
+  border: none;
+  border-radius: 4px;
+  background: transparent;
+  color: var(--update-text-secondary);
+  font-size: 16px;
+  line-height: 22px;
+}
+
+.cdfrd-update-notice-close:hover {
+  color: var(--update-text);
+  background: var(--update-btn-hover-bg);
+}
+
+.cdfrd-update-notice-desc {
+  font-size: 14px;
+  line-height: 1.5714;
+  color: var(--update-text-secondary);
+  margin: 0 0 12px;
+}
+
+.cdfrd-update-notice-actions {
+  display: flex;
+  align-items: center;
+  justify-content: flex-end;
+  gap: 8px;
+}
+
+.cdfrd-update-notice-btn {
+  cursor: pointer;
+  font-size: 14px;
+  line-height: 1.5714;
+  height: 32px;
+  padding: 4px 15px;
+  border: 1px solid var(--update-btn-border);
+  border-radius: 6px;
+  background: var(--update-bg);
+  color: var(--update-text);
+  box-sizing: border-box;
+  transition: all 0.2s;
+}
+
+.cdfrd-update-notice-btn:hover {
+  color: var(--update-primary);
+  border-color: var(--update-primary);
+}
+
+.cdfrd-update-notice-btn-primary {
+  background: var(--update-primary);
+  border-color: var(--update-primary);
+  color: #fff;
+}
+
+.cdfrd-update-notice-btn-primary:hover {
+  background: var(--update-primary-hover);
+  border-color: var(--update-primary-hover);
+  color: #fff;
+}
+
+/* Forced centered modal \u2014 Ant Design Modal */
+.cdfrd-update-notice--forced {
+  inset: 0;
+  max-width: none;
+  width: 100%;
+  height: 100%;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  pointer-events: auto;
+  background: var(--update-mask);
+  padding: 24px;
+}
+
+.cdfrd-update-notice--forced .cdfrd-update-notice-panel {
+  width: min(416px, 100%);
+  padding: 20px 24px;
+  border: none;
+  text-align: left;
+}
+
+.cdfrd-update-notice--forced .cdfrd-update-notice-title {
+  margin-bottom: 8px;
+}
+
+.cdfrd-update-notice--forced .cdfrd-update-notice-desc {
+  margin-bottom: 0;
+}
+
+.cdfrd-update-notice--forced .cdfrd-update-notice-actions {
+  margin-top: 12px;
+  justify-content: flex-end;
+}
+`.trim();
+
+// src/notification/inject-styles.ts
+function ensureDefaultStyles() {
+  if (typeof document === "undefined") return;
+  if (document.getElementById(INJECT_STYLE_TAG_ID)) return;
+  if (!document.head) return;
+  const style = document.createElement("style");
+  style.id = INJECT_STYLE_TAG_ID;
+  style.textContent = DEFAULT_NOTICE_CSS;
+  document.head.appendChild(style);
+}
+
+// src/theme/resolve-primary.ts
+var ANT_PRIMARY_VARS = [
+  "--ant-color-primary",
+  "--ant-primary-color",
+  "--colorPrimary"
+];
+function isInvalidColor(color) {
+  if (!color) return true;
+  const c = color.trim().toLowerCase();
+  if (!c || c === "transparent" || c === "rgba(0, 0, 0, 0)" || c === "rgba(0,0,0,0)") return true;
+  if (c === "buttonface" || c === "canvas" || c === "rgba(239, 239, 239, 1)" || c === "rgb(239, 239, 239)") {
+    return true;
+  }
+  return false;
+}
+function readCssVarFromElement(el2) {
+  try {
+    const style = getComputedStyle(el2);
+    for (const name of ANT_PRIMARY_VARS) {
+      const value = style.getPropertyValue(name)?.trim();
+      if (!isInvalidColor(value)) return value;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function readCssVariablePrimary() {
+  if (typeof document === "undefined") return null;
+  const btn = document.querySelector(".ant-btn-primary");
+  if (btn) {
+    let el2 = btn;
+    while (el2) {
+      const value = readCssVarFromElement(el2);
+      if (value) return value;
+      el2 = el2.parentElement;
+    }
+  }
+  for (const root of [document.documentElement, document.body]) {
+    if (!root) continue;
+    const value = readCssVarFromElement(root);
+    if (value) return value;
+  }
+  return null;
+}
+function readExistingPrimaryButtonBg() {
+  if (typeof document === "undefined") return null;
+  const btn = document.querySelector(".ant-btn-primary");
+  if (!btn) return null;
+  try {
+    const color = getComputedStyle(btn).backgroundColor;
+    return isInvalidColor(color) ? null : color;
+  } catch {
+    return null;
+  }
+}
+var suppressThemeWatch = 0;
+function beginSuppressThemeWatch() {
+  suppressThemeWatch += 1;
+}
+function endSuppressThemeWatch() {
+  void Promise.resolve().then(() => {
+    suppressThemeWatch = Math.max(0, suppressThemeWatch - 1);
+  });
+}
+function probePrimaryButton() {
+  if (typeof document === "undefined" || !document.body) return null;
+  beginSuppressThemeWatch();
+  try {
+    const probe = document.createElement("button");
+    probe.className = "ant-btn ant-btn-primary";
+    probe.setAttribute("aria-hidden", "true");
+    probe.tabIndex = -1;
+    probe.style.cssText = "position:absolute;left:0;top:0;opacity:0;pointer-events:none;width:0;height:0;overflow:hidden;";
+    document.body.appendChild(probe);
+    const color = getComputedStyle(probe).backgroundColor;
+    probe.remove();
+    return isInvalidColor(color) ? null : color;
+  } catch {
+    return null;
+  } finally {
+    endSuppressThemeWatch();
+  }
+}
+function tryResolveAntdPrimaryDetailed(options) {
+  try {
+    const allowProbe = options?.allowProbe !== false;
+    const cssVar = readCssVariablePrimary();
+    if (cssVar) return { color: cssVar, source: "cssVar" };
+    const btnBg = readExistingPrimaryButtonBg();
+    if (btnBg) return { color: btnBg, source: "btnBg" };
+    if (allowProbe) {
+      const probed = probePrimaryButton();
+      if (probed) return { color: probed, source: "probe" };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function tryResolveAntdPrimaryColor(options) {
+  return tryResolveAntdPrimaryDetailed(options)?.color ?? null;
+}
+function resolveCssVariablePrimary(config, theme) {
+  const primary = config?.primaryColor;
+  if (!primary) return DEFAULT_PRIMARY_COLOR;
+  if (typeof primary === "string") return primary;
+  return primary[theme] || primary.light || DEFAULT_PRIMARY_COLOR;
+}
+function scheduleFrame(cb) {
+  if (typeof requestAnimationFrame === "function") {
+    requestAnimationFrame(() => cb());
+  } else {
+    setTimeout(cb, 0);
+  }
+}
+function resolvePrimaryColorLazy(config, theme, onDone, maxAttempts = THEME_RETRY_MAX, allowProbe = true) {
+  const type = config?.type ?? "antd";
+  if (type === "cssVariable") {
+    onDone(resolveCssVariablePrimary(config, theme));
+    return;
+  }
+  let attempts = 0;
+  const run = () => {
+    attempts += 1;
+    const found = tryResolveAntdPrimaryColor({ allowProbe });
+    if (found) {
+      onDone(found);
+      return;
+    }
+    if (attempts < maxAttempts) {
+      scheduleFrame(run);
+      return;
+    }
+    onDone(DEFAULT_PRIMARY_COLOR);
+  };
+  run();
+}
+function isUpdateNoticeMutationTarget(node) {
+  if (!node || node.nodeType !== Node.ELEMENT_NODE) return false;
+  const el2 = node;
+  if (el2.id === INJECT_STYLE_TAG_ID) return true;
+  return Boolean(
+    el2.closest?.(".cdfrd-update-notice") || el2.closest?.(`.${NOTIFICATION_ANCHOR_CLASS_NAME}`)
+  );
+}
+function mutationsOnlyAffectNotice(mutations) {
+  if (!mutations.length) return false;
+  return mutations.every((m) => {
+    if (isUpdateNoticeMutationTarget(m.target)) return true;
+    if (m.type === "childList") {
+      const nodes = [...Array.from(m.addedNodes), ...Array.from(m.removedNodes)];
+      return nodes.length > 0 && nodes.every((n) => isUpdateNoticeMutationTarget(n));
+    }
+    return false;
+  });
+}
+function watchThemeChanges(config, getTheme, onChange) {
+  if (typeof document === "undefined") {
+    return () => void 0;
+  }
+  const adapterType = config?.type ?? "antd";
+  if (adapterType === "cssVariable") {
+    return () => void 0;
+  }
+  if (typeof MutationObserver === "undefined") {
+    return () => void 0;
+  }
+  let last = "";
+  let btnBgCandidate = "";
+  let debounceTimer;
+  let settleTimer;
+  const clearTimers = () => {
+    if (debounceTimer !== void 0) clearTimeout(debounceTimer);
+    if (settleTimer !== void 0) clearTimeout(settleTimer);
+    debounceTimer = void 0;
+    settleTimer = void 0;
+  };
+  const evaluate = () => {
+    const found = tryResolveAntdPrimaryDetailed({ allowProbe: false });
+    if (!found) return;
+    const { color, source } = found;
+    if (color === last) {
+      btnBgCandidate = "";
+      return;
+    }
+    if (source === "btnBg" && color !== btnBgCandidate) {
+      btnBgCandidate = color;
+      if (settleTimer !== void 0) clearTimeout(settleTimer);
+      settleTimer = setTimeout(() => {
+        settleTimer = void 0;
+        evaluate();
+      }, THEME_WATCH_DEBOUNCE_MS);
+      return;
+    }
+    last = color;
+    btnBgCandidate = "";
+    onChange(color);
+  };
+  const schedule = (mutations) => {
+    if (suppressThemeWatch > 0) return;
+    if (mutations && mutationsOnlyAffectNotice(mutations)) return;
+    if (debounceTimer !== void 0) clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(() => {
+      debounceTimer = void 0;
+      btnBgCandidate = "";
+      evaluate();
+    }, THEME_WATCH_DEBOUNCE_MS);
+  };
+  const observer = new MutationObserver((mutations) => schedule(mutations));
+  const attrFilter = ["class", "style", "data-theme", "data-update-notice-theme"];
+  observer.observe(document.documentElement, {
+    attributes: true,
+    attributeFilter: attrFilter
+  });
+  if (document.body) {
+    observer.observe(document.body, {
+      attributes: true,
+      attributeFilter: attrFilter,
+      childList: true,
+      subtree: true
+    });
+  }
+  if (document.head) {
+    observer.observe(document.head, { childList: true, subtree: true });
+  }
+  schedule();
+  return () => {
+    clearTimers();
+    observer.disconnect();
+  };
+}
+
+// src/notification/NotificationManager.ts
+var visible = false;
+var lastShowOptions = null;
+var lastLocale = "zh_CN";
+var currentPrimary = "";
+function el(tag, className, text) {
+  const node = document.createElement(tag);
+  node.className = className;
+  if (text !== void 0) node.textContent = text;
+  return node;
+}
+function applyPrimaryToNode(node, primary) {
+  if (!primary) return;
+  node.style.setProperty("--update-primary", primary);
+  node.style.setProperty("--update-primary-hover", primary);
+}
+function applyTheme(theme) {
+  ensureDefaultStyles();
+  document.documentElement.setAttribute("data-update-notice-theme", theme);
+  document.querySelectorAll(".cdfrd-update-notice").forEach((node) => {
+    node.setAttribute("data-update-notice-theme", theme);
+  });
+}
+function applyPrimaryColor(primary) {
+  beginSuppressThemeWatch();
+  try {
+    currentPrimary = primary;
+    document.querySelectorAll(".cdfrd-update-notice").forEach((node) => {
+      applyPrimaryToNode(node, primary);
+    });
+  } finally {
+    endSuppressThemeWatch();
+  }
+}
+function closeDefaultNotice() {
+  document.querySelector(".cdfrd-update-notice")?.remove();
+  visible = false;
+  lastShowOptions = null;
+}
+function applyLocale(locale) {
+  const wrap = document.querySelector(".cdfrd-update-notice");
+  if (!wrap || !lastShowOptions) return;
+  lastLocale = locale;
+  const copy = resolveNotificationCopy(lastShowOptions, locale);
+  const forced = lastShowOptions.forcedUpdate === true;
+  const titleEl = wrap.querySelector(".cdfrd-update-notice-title");
+  const descEl = wrap.querySelector(".cdfrd-update-notice-desc");
+  const refreshEl = wrap.querySelector(`.${NOTIFICATION_REFRESH_BTN_CLASS}`);
+  const dismissEl = wrap.querySelector(`.${NOTIFICATION_DISMISS_BTN_CLASS}`);
+  if (titleEl) titleEl.textContent = forced ? copy.forcedTitle : copy.title;
+  if (descEl) descEl.textContent = forced ? copy.forcedDescription : copy.description;
+  if (refreshEl) refreshEl.textContent = copy.buttonText;
+  if (dismissEl) dismissEl.textContent = copy.dismissButtonText;
+}
+function showDefaultNotice(options) {
+  ensureDefaultStyles();
+  const existing = document.querySelector(".cdfrd-update-notice");
+  if (visible && existing) return false;
+  if (visible && !existing) visible = false;
+  const copy = resolveNotificationCopy(options.options, options.locale);
+  const placement = options.options.placement ?? "topRight";
+  const forced = options.options.forcedUpdate === true;
+  const theme = options.theme ?? "light";
+  const primary = options.primaryColor || currentPrimary;
+  const wrap = document.createElement("div");
+  wrap.className = forced ? "cdfrd-update-notice cdfrd-update-notice--forced" : "cdfrd-update-notice";
+  wrap.setAttribute("data-update-notice-theme", theme);
+  if (!forced) {
+    wrap.style.cssText = PLACEMENT_STYLES[placement] ?? PLACEMENT_STYLES.topRight;
+  }
+  if (primary) applyPrimaryToNode(wrap, primary);
+  const panel = el("div", "cdfrd-update-notice-panel");
+  if (forced) {
+    panel.appendChild(el("div", "cdfrd-update-notice-title", copy.forcedTitle));
+    panel.appendChild(el("div", "cdfrd-update-notice-desc", copy.forcedDescription));
+    const actions = el("div", "cdfrd-update-notice-actions");
+    const refreshBtn = el(
+      "button",
+      `cdfrd-update-notice-btn cdfrd-update-notice-btn-primary ${NOTIFICATION_REFRESH_BTN_CLASS}`,
+      copy.buttonText
+    );
+    refreshBtn.setAttribute("type", "button");
+    actions.appendChild(refreshBtn);
+    panel.appendChild(actions);
+  } else {
+    const header = el("div", "cdfrd-update-notice-header");
+    header.appendChild(el("div", "cdfrd-update-notice-title", copy.title));
+    const closeBtn = el("button", `cdfrd-update-notice-close ${NOTIFICATION_CLOSE_BTN_CLASS}`, "\xD7");
+    closeBtn.setAttribute("type", "button");
+    closeBtn.setAttribute("aria-label", "close");
+    header.appendChild(closeBtn);
+    panel.appendChild(header);
+    panel.appendChild(el("div", "cdfrd-update-notice-desc", copy.description));
+    const actions = el("div", "cdfrd-update-notice-actions");
+    const dismissBtn = el(
+      "button",
+      `cdfrd-update-notice-btn ${NOTIFICATION_DISMISS_BTN_CLASS}`,
+      copy.dismissButtonText
+    );
+    dismissBtn.setAttribute("type", "button");
+    actions.appendChild(dismissBtn);
+    const refreshBtn = el(
+      "button",
+      `cdfrd-update-notice-btn cdfrd-update-notice-btn-primary ${NOTIFICATION_REFRESH_BTN_CLASS}`,
+      copy.buttonText
+    );
+    refreshBtn.setAttribute("type", "button");
+    actions.appendChild(refreshBtn);
+    panel.appendChild(actions);
+  }
+  wrap.appendChild(panel);
+  let anchor = document.body.querySelector(`:scope > .cdfrd-update-notice-anchor`);
+  if (!anchor) {
+    anchor = document.createElement("div");
+    anchor.className = "cdfrd-update-notice-anchor";
+    document.body.appendChild(anchor);
+  }
+  anchor.appendChild(wrap);
+  visible = true;
+  lastShowOptions = options.options;
+  lastLocale = options.locale;
+  wrap.querySelector(`.${NOTIFICATION_REFRESH_BTN_CLASS}`)?.addEventListener("click", () => {
+    options.onRefresh();
+  });
+  wrap.querySelector(`.${NOTIFICATION_DISMISS_BTN_CLASS}`)?.addEventListener("click", () => {
+    options.onDismiss();
+    closeDefaultNotice();
+  });
+  wrap.querySelector(`.${NOTIFICATION_CLOSE_BTN_CLASS}`)?.addEventListener("click", () => {
+    options.onClose?.();
+    closeDefaultNotice();
+  });
+  return true;
+}
+
+// src/manager/UpdateNoticeManager.ts
+var UpdateNoticeManager = class _UpdateNoticeManager {
+  constructor() {
+    this.activeApp = null;
+    this.locale = "zh_CN";
+    this.theme = "light";
+    this.primaryColor = "";
+    /** Bumped on each setTheme so late antd resolve callbacks cannot overwrite newer results. */
+    this.primaryResolveGen = 0;
+    this.runtimes = /* @__PURE__ */ new Map();
+  }
+  static getOrCreate() {
+    if (!window.updateNoticeManager) {
+      window.updateNoticeManager = new _UpdateNoticeManager();
+    }
+    return window.updateNoticeManager;
+  }
+  /** First create applies Manager-level defaults; later creates only register runtimes */
+  register(options, isFirstCreate) {
+    validateOptions(options);
+    if (isFirstCreate) {
+      this.themeAdapter = options.themeAdapter;
+      if (options.locale?.default) this.locale = options.locale.default;
+      applyTheme(this.theme);
+      this.startThemeWatch();
+    }
+    const runtime = new UpdateNoticeRuntime(this, options);
+    const previous = this.runtimes.get(runtime.appKey);
+    if (previous && previous !== runtime) previous.destroy();
+    this.runtimes.set(runtime.appKey, runtime);
+    runtime.bootstrap();
+    if (shouldShowDefaultUi(options)) {
+      ensureNotificationAnchor();
+    }
+    if (this.isRuntimeActive(runtime)) {
+      runtime.checkUpdate();
+    }
+    return runtime;
+  }
+  setActiveApp(appId, options = { immediateCheck: true }) {
+    const changed = this.activeApp !== appId;
+    this.activeApp = appId;
+    if (changed) {
+      closeDefaultNotice();
+      this.startThemeWatch();
+      this.refreshPrimaryColor();
+    }
+    this.flushPendingForActiveApp();
+    const immediateCheck = options.immediateCheck ?? true;
+    if (immediateCheck && changed) {
+      for (const runtime of this.runtimes.values()) {
+        if (this.isRuntimeActive(runtime)) runtime.checkUpdate();
+      }
+    }
+  }
+  checkUpdate() {
+    for (const runtime of this.runtimes.values()) runtime.checkUpdate();
+  }
+  isRuntimeActive(runtime) {
+    if (!runtime.appId) return true;
+    return runtime.appId === this.activeApp;
+  }
+  /** Prefer the active runtime's adapter; fall back to Manager default (first create). */
+  getActiveThemeAdapter() {
+    for (const runtime of this.runtimes.values()) {
+      if (this.isRuntimeActive(runtime)) {
+        return runtime.options.themeAdapter ?? this.themeAdapter;
+      }
+    }
+    return this.themeAdapter;
+  }
+  setLocale(locale) {
+    this.locale = locale;
+    applyLocale(locale);
+  }
+  setTheme(theme) {
+    this.theme = theme;
+    applyTheme(theme);
+    const gen = ++this.primaryResolveGen;
+    const adapter = this.getActiveThemeAdapter();
+    const detailed = (adapter?.type ?? "antd") === "antd" ? tryResolveAntdPrimaryDetailed() : null;
+    if (detailed?.source === "btnBg") {
+      return;
+    }
+    this.refreshPrimaryColor(gen);
+  }
+  notifyUpdate(_runtime, _version) {
+    void _runtime;
+    void _version;
+  }
+  showDefaultNotice(runtime, version) {
+    ensureNotificationAnchor();
+    const adapter = runtime.options.themeAdapter ?? this.themeAdapter;
+    const gen = this.primaryResolveGen;
+    resolvePrimaryColorLazy(adapter, this.theme, (color) => {
+      if (gen !== this.primaryResolveGen) return;
+      this.primaryColor = color;
+      applyPrimaryColor(color);
+      showDefaultNotice({
+        options: runtime.options,
+        version,
+        locale: this.locale,
+        theme: this.theme,
+        primaryColor: color,
+        onRefresh: () => {
+          if (this.onClickRefresh) {
+            this.onClickRefresh(version, runtime.appId);
+            return;
+          }
+          window.location.reload();
+        },
+        onDismiss: () => {
+          if (this.onClickDismiss) {
+            this.onClickDismiss(version, runtime.appId);
+            return;
+          }
+          runtime.dismissVersion(version);
+        }
+      });
+    });
+    return true;
+  }
+  refreshPrimaryColor(gen = this.primaryResolveGen) {
+    const adapter = this.getActiveThemeAdapter();
+    resolvePrimaryColorLazy(adapter, this.theme, (color) => {
+      if (gen !== this.primaryResolveGen) return;
+      this.primaryColor = color;
+      applyPrimaryColor(color);
+    });
+  }
+  startThemeWatch() {
+    this.stopWatchTheme?.();
+    const adapter = this.getActiveThemeAdapter();
+    this.stopWatchTheme = watchThemeChanges(adapter, () => this.theme, (color) => {
+      this.primaryResolveGen += 1;
+      this.primaryColor = color;
+      applyPrimaryColor(color);
+    });
+  }
+  destroy() {
+    this.stopWatchTheme?.();
+    this.stopWatchTheme = void 0;
+    for (const runtime of this.runtimes.values()) runtime.destroy();
+    this.runtimes.clear();
+    closeDefaultNotice();
+    delete window.updateNoticeManager;
+  }
+  flushPendingForActiveApp() {
+    for (const runtime of this.runtimes.values()) runtime.flushPendingUpdate();
+  }
+};
+function createUpdateNotice(options = {}) {
+  validateOptions(options);
+  const stamped = { ...options };
+  if (options.versionBase === void 0 || options.versionBase === null) {
+    const poweredByQiankun = Boolean(
+      window.__POWERED_BY_QIANKUN__ || window.proxy?.__POWERED_BY_QIANKUN__
+    );
+    if (options.microApp?.enabled && poweredByQiankun) {
+      const microBase = resolveMicroVersionBase();
+      if (microBase) stamped.versionBase = microBase;
+    } else if (options.microApp?.enabled) {
+      const microBase = resolveMicroVersionBase();
+      if (microBase && /^https?:\/\//i.test(microBase) && typeof location !== "undefined" && new URL(microBase).origin !== location.origin) {
+        stamped.versionBase = microBase;
+      } else {
+        stamped.versionBase = resolveVersionBase();
+      }
+    } else {
+      stamped.versionBase = resolveVersionBase();
+    }
+  }
+  const existed = Boolean(window.updateNoticeManager);
+  const manager = UpdateNoticeManager.getOrCreate();
+  manager.register(stamped, !existed);
+  return manager;
+}
+function getUpdateNotice() {
+  return window.updateNoticeManager;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  UpdateNoticeManager,
+  createUpdateNotice,
+  getUpdateNotice
+});
+//# sourceMappingURL=index.cjs.map