@chaochao12138/check-update-sdk 0.0.1

package/LICENSE

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

package/README.md

@@ -0,0 +1,228 @@
+# @dezhen/check-update-sdk
+
+> Frontend automatic update detection SDK for web applications
+
+A lightweight, zero-dependency SDK that automatically detects when a new version of your web application has been deployed and notifies users or refreshes the page.
+
+## Features
+
+- **ETag/Last-Monified Detection** - Monitors HTTP headers to detect deployment changes
+- **Route Change Detection** - Triggers checks when users navigate (optional)
+- **Resource Load Error Detection** - Detects broken scripts/styles (optional)
+- **Zero Runtime Dependencies** - Lightweight and tree-shakeable
+- **TypeScript Support** - Full TypeScript definitions included
+- **Framework Agnostic** - Works with any frontend framework
+
+## Installation
+
+```bash
+npm install @dezhen/check-update-sdk
+# or
+pnpm add @dezhen/check-update-sdk
+# or
+yarn add @dezhen/check-update-sdk
+```
+
+## Quick Start
+
+```typescript
+import { createCheckUpdate } from '@dezhen/check-update-sdk';
+
+const updater = createCheckUpdate({
+  interval: 5 * 60 * 1000,  // Check every 5 minutes
+  onUpdate: () => {
+    // Show update notification to user
+    if (confirm('A new version is available. Refresh now?')) {
+      window.location.reload();
+    }
+  }
+});
+
+// Later, if needed
+updater.destroy();
+```
+
+## Options
+
+```typescript
+interface CheckUpdateOptions {
+  /** Polling interval in milliseconds (default: 10 minutes) */
+  interval?: number;
+
+  /** Callback when update is detected */
+  onUpdate?: () => void;
+
+  /** Auto-refresh when update is detected (default: false) */
+  autoRefresh?: boolean;
+
+  /** Enable route change detection (default: true) */
+  enableRouteDetection?: boolean;
+
+  /** Enable resource load error detection (default: false) */
+  enableLoadErrorDetection?: boolean;
+
+  /** Custom URL to check for updates (default: current page URL) */
+  checkUrl?: string;
+}
+```
+
+## Usage Examples
+
+### Auto-Refresh Mode
+
+```typescript
+import { createCheckUpdate } from '@dezhen/check-update-sdk';
+
+createCheckUpdate({
+  interval: 5 * 60 * 1000,
+  autoRefresh: true  // Automatically refresh when update detected
+});
+```
+
+### Custom Update Notification
+
+```typescript
+import { createCheckUpdate } from '@dezhen/check-update-sdk';
+
+const updater = createCheckUpdate({
+  interval: 10 * 60 * 1000,
+  onUpdate: () => {
+    // Show a custom notification
+    const notification = document.createElement('div');
+    notification.textContent = 'New version available!';
+    notification.style.cssText = `
+      position: fixed;
+      top: 20px;
+      right: 20px;
+      padding: 16px;
+      background: #4CAF50;
+      color: white;
+      border-radius: 8px;
+      cursor: pointer;
+      z-index: 9999;
+    `;
+    notification.onclick = () => window.location.reload();
+    document.body.appendChild(notification);
+  }
+});
+```
+
+### Vue 3 Application
+
+```typescript
+// main.ts
+import { createCheckUpdate } from '@dezhen/check-update-sdk';
+
+const app = createApp(App);
+
+// Initialize update checker
+const updater = createCheckUpdate({
+  interval: 5 * 60 * 1000,
+  onUpdate: () => {
+    // You can use your UI framework's notification system
+    console.log('New version available!');
+  }
+});
+
+// Cleanup on app unmount
+app.config.globalProperties.$updater = updater;
+```
+
+### Disable Route Detection
+
+```typescript
+import { createCheckUpdate } from '@dezhen/check-update-sdk';
+
+createCheckUpdate({
+  enableRouteDetection: false,  // Don't check on route changes
+  interval: 10 * 60 * 1000
+});
+```
+
+### Enable Resource Error Detection
+
+```typescript
+import { createCheckUpdate } from '@dezhen/check-update-sdk';
+
+createCheckUpdate({
+  enableLoadErrorDetection: true,  // Check on script/link load errors
+  onUpdate: () => {
+    console.log('Update detected due to resource error');
+  }
+});
+```
+
+### Manual Check
+
+```typescript
+import { createCheckUpdate } from '@dezhen/check-update-sdk';
+
+const updater = createCheckUpdate();
+
+// Manually trigger a check
+updater.check();
+```
+
+### Cleanup
+
+```typescript
+import { createCheckUpdate } from '@dezhen/check-update-sdk';
+
+const updater = createCheckUpdate();
+
+// Later, when you want to stop checking
+updater.destroy();
+```
+
+## How It Works
+
+The SDK detects updates by:
+
+1. **Initial Check**: Makes a HEAD request to get the current ETag or Last-Modified header
+2. **Periodic Polling**: At configured intervals, checks if the header has changed
+3. **Route Changes**: (Optional) Triggers a check when the user navigates to a new route
+4. **Resource Errors**: (Optional) Triggers a check when scripts or stylesheets fail to load
+5. **Tab Visibility**: Pauses polling when tab is hidden, resumes when visible
+
+When an update is detected:
+- If `autoRefresh` is `true`, the page reloads automatically
+- Otherwise, the `onUpdate` callback is invoked
+
+## Server Configuration
+
+The SDK works by checking the `ETag` or `Last-Modified` HTTP headers. Most web servers (Nginx, Apache, Vercel, Netlify, etc.) generate these headers automatically by default.
+
+### Example Server Responses
+
+**Before Update:**
+```
+HTTP/1.1 200 OK
+ETag: "abc123"
+```
+
+**After Update:**
+```
+HTTP/1.1 200 OK
+ETag: "def456"
+```
+
+The SDK detects the ETag change and triggers the update notification.
+
+## Browser Support
+
+- Chrome/Edge (last 2 versions)
+- Firefox (last 2 versions)
+- Safari (last 2 versions)
+- Modern mobile browsers
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## Support
+
+For issues and questions, please visit the [GitHub Issues](https://github.com/dezhen/check-update-sdk/issues) page.

package/dist/index.d.mts

@@ -0,0 +1,19 @@
+interface CoreOptions {
+    interval?: number;
+    checkUrl?: string;
+    autoRefresh?: boolean;
+    onUpdate?: () => void;
+}
+
+interface CheckUpdateOptions extends CoreOptions {
+    /** 是否开启路由切换检测 (默认 true) */
+    enableRouteDetection?: boolean;
+    /** 是否开启资源加载错误检测 (默认 false) */
+    enableLoadErrorDetection?: boolean;
+}
+declare function createCheckUpdate(options?: CheckUpdateOptions): {
+    check: () => Promise<void>;
+    destroy: () => void;
+};
+
+export { type CheckUpdateOptions, createCheckUpdate };

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+interface CoreOptions {
+    interval?: number;
+    checkUrl?: string;
+    autoRefresh?: boolean;
+    onUpdate?: () => void;
+}
+
+interface CheckUpdateOptions extends CoreOptions {
+    /** 是否开启路由切换检测 (默认 true) */
+    enableRouteDetection?: boolean;
+    /** 是否开启资源加载错误检测 (默认 false) */
+    enableLoadErrorDetection?: boolean;
+}
+declare function createCheckUpdate(options?: CheckUpdateOptions): {
+    check: () => Promise<void>;
+    destroy: () => void;
+};
+
+export { type CheckUpdateOptions, createCheckUpdate };

package/dist/index.js

@@ -0,0 +1,154 @@
+"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 index_exports = {};
+__export(index_exports, {
+  createCheckUpdate: () => createCheckUpdate
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core.ts
+function createUpdateCore(options) {
+  let oldEtag = null;
+  let timer;
+  let isChecking = false;
+  let isDestroyed = false;
+  const getCheckUrl = () => {
+    try {
+      const urlStr = options.checkUrl || window.location.href;
+      const targetUrl = new URL(urlStr, window.location.href);
+      targetUrl.searchParams.set("t", String(Date.now()));
+      return targetUrl.toString();
+    } catch {
+      return `${options.checkUrl || window.location.href}?t=${Date.now()}`;
+    }
+  };
+  const check = async () => {
+    if (isDestroyed || isChecking) return;
+    isChecking = true;
+    try {
+      const response = await fetch(getCheckUrl(), { method: "HEAD", cache: "no-cache" });
+      const newEtag = response.headers.get("etag") || response.headers.get("last-modified");
+      if (!newEtag) return;
+      if (!oldEtag) {
+        oldEtag = newEtag;
+      } else if (newEtag !== oldEtag) {
+        oldEtag = newEtag;
+        if (options.autoRefresh) {
+          window.location.reload();
+        } else {
+          options.onUpdate?.();
+        }
+      }
+    } catch (e) {
+    } finally {
+      if (!isDestroyed) {
+        isChecking = false;
+      }
+    }
+  };
+  const start = () => {
+    check();
+    if (options.interval && options.interval > 0) {
+      timer = setInterval(check, options.interval);
+    }
+  };
+  const destroy = () => {
+    isDestroyed = true;
+    if (timer) {
+      clearInterval(timer);
+      timer = void 0;
+    }
+  };
+  return {
+    check,
+    start,
+    destroy
+  };
+}
+
+// src/plugins.ts
+var createRoutePlugin = (core) => {
+  const patch = (method) => {
+    const original = window.history[method];
+    if (original._isPatched) return;
+    window.history[method] = function(...args) {
+      const result = original.apply(this, args);
+      core.check();
+      return result;
+    };
+    window.history[method]._isPatched = true;
+  };
+  patch("pushState");
+  patch("replaceState");
+  const onPopState = () => core.check();
+  window.addEventListener("popstate", onPopState);
+  return () => {
+    window.removeEventListener("popstate", onPopState);
+  };
+};
+var createResourceErrorPlugin = (core) => {
+  const onError = (event) => {
+    const target = event.target;
+    if (!target || target.tagName !== "SCRIPT" && target.tagName !== "LINK") return;
+    const src = target.src || target.href;
+    if (src) {
+      core.check();
+    }
+  };
+  window.addEventListener("error", onError, true);
+  return () => {
+    window.removeEventListener("error", onError, true);
+  };
+};
+
+// src/index.ts
+function createCheckUpdate(options = {}) {
+  const {
+    interval = 10 * 60 * 1e3,
+    enableRouteDetection = true,
+    enableLoadErrorDetection = false,
+    ...coreOptions
+  } = options;
+  const core = createUpdateCore({ interval, ...coreOptions });
+  const cleanupFns = [];
+  const use = (plugin) => {
+    cleanupFns.push(plugin(core));
+  };
+  if (enableRouteDetection) {
+    use(createRoutePlugin);
+  }
+  if (enableLoadErrorDetection) {
+    use(createResourceErrorPlugin);
+  }
+  core.start();
+  return {
+    check: core.check,
+    destroy: () => {
+      core.destroy();
+      cleanupFns.forEach((fn) => fn());
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createCheckUpdate
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/index.ts", "../src/core.ts", "../src/plugins.ts"],
  "sourcesContent": ["import { createUpdateCore, type CoreOptions } from './core';\r\nimport { createRoutePlugin, createResourceErrorPlugin, type UpdatePlugin } from './plugins';\r\n\r\nexport interface CheckUpdateOptions extends CoreOptions {\r\n    /** \u662F\u5426\u5F00\u542F\u8DEF\u7531\u5207\u6362\u68C0\u6D4B (\u9ED8\u8BA4 true) */\r\n    enableRouteDetection?: boolean;\r\n    /** \u662F\u5426\u5F00\u542F\u8D44\u6E90\u52A0\u8F7D\u9519\u8BEF\u68C0\u6D4B (\u9ED8\u8BA4 false) */\r\n    enableLoadErrorDetection?: boolean;\r\n}\r\n\r\nexport function createCheckUpdate(options: CheckUpdateOptions = {}) {\r\n    // 1. \u5206\u79BB\u914D\u7F6E\r\n    const {\r\n        interval = 10 * 60 * 1000,\r\n        enableRouteDetection = true,\r\n        enableLoadErrorDetection = false,\r\n        ...coreOptions\r\n    } = options;\r\n\r\n    // 2. \u521B\u5EFA\u6838\u5FC3\u5B9E\u4F8B\r\n    const core = createUpdateCore({ interval, ...coreOptions });\r\n\r\n    // 3. \u63D2\u4EF6\u7BA1\u7406\r\n    const cleanupFns: Array<() => void> = [];\r\n\r\n    const use = (plugin: UpdatePlugin) => {\r\n        cleanupFns.push(plugin(core));\r\n    };\r\n\r\n    // 4. \u6309\u9700\u52A0\u8F7D\u63D2\u4EF6\r\n    if (enableRouteDetection) {\r\n        use(createRoutePlugin);\r\n    }\r\n\r\n    if (enableLoadErrorDetection) {\r\n        use(createResourceErrorPlugin);\r\n    }\r\n\r\n    // 5. \u542F\u52A8\u6838\u5FC3\r\n    core.start();\r\n\r\n    // 6. \u8FD4\u56DE\u5BF9\u5916 API\r\n    return {\r\n        check: core.check,\r\n        destroy: () => {\r\n            core.destroy(); // \u9500\u6BC1\u6838\u5FC3\r\n            cleanupFns.forEach(fn => fn()); // \u9500\u6BC1\u6240\u6709\u63D2\u4EF6\r\n        }\r\n    };\r\n}", "export interface CoreOptions {\r\n    interval?: number;\r\n    checkUrl?: string;\r\n    autoRefresh?: boolean;\r\n    onUpdate?: () => void;\r\n}\r\n\r\n// \u5B9A\u4E49\u6838\u5FC3\u5B9E\u4F8B\u5BF9\u5916\u66B4\u9732\u7684\u63A5\u53E3\r\nexport interface UpdateCoreInstance {\r\n    check: () => Promise<void>;\r\n    start: () => void;\r\n    destroy: () => void;\r\n}\r\n\r\nexport function createUpdateCore(options: CoreOptions): UpdateCoreInstance {\r\n    // --- \u79C1\u6709\u72B6\u6001 (\u95ED\u5305) ---\r\n    let oldEtag: string | null = null;\r\n    let timer: ReturnType<typeof setInterval> | undefined;\r\n    let isChecking = false;\r\n    let isDestroyed = false;\r\n\r\n    // --- \u5185\u90E8\u8F85\u52A9\u51FD\u6570 ---\r\n\r\n    const getCheckUrl = (): string => {\r\n        try {\r\n            const urlStr = options.checkUrl || window.location.href;\r\n            const targetUrl = new URL(urlStr, window.location.href);\r\n            targetUrl.searchParams.set('t', String(Date.now()));\r\n            return targetUrl.toString();\r\n        } catch {\r\n            return `${options.checkUrl || window.location.href}?t=${Date.now()}`;\r\n        }\r\n    };\r\n\r\n    // --- \u6838\u5FC3\u65B9\u6CD5 ---\r\n\r\n    const check = async () => {\r\n        if (isDestroyed || isChecking) return;\r\n        isChecking = true;\r\n\r\n        try {\r\n            const response = await fetch(getCheckUrl(), { method: 'HEAD', cache: 'no-cache' });\r\n            const newEtag = response.headers.get('etag') || response.headers.get('last-modified');\r\n\r\n            if (!newEtag) return;\r\n\r\n            if (!oldEtag) {\r\n                // \u521D\u59CB\u5316\u57FA\u51C6\r\n                oldEtag = newEtag;\r\n            } else if (newEtag !== oldEtag) {\r\n                oldEtag = newEtag;\r\n\r\n                if (options.autoRefresh) {\r\n                    window.location.reload();\r\n                } else {\r\n                    options.onUpdate?.();\r\n                }\r\n            }\r\n        } catch (e) {\r\n            // \u7F51\u7EDC\u9519\u8BEF\u5FFD\u7565\r\n        } finally {\r\n            if (!isDestroyed) {\r\n                isChecking = false;\r\n            }\r\n        }\r\n    };\r\n\r\n    const start = () => {\r\n        check(); // \u7ACB\u5373\u68C0\u67E5\u4E00\u6B21\r\n        if (options.interval && options.interval > 0) {\r\n            timer = setInterval(check, options.interval);\r\n        }\r\n    };\r\n\r\n    const destroy = () => {\r\n        isDestroyed = true;\r\n        if (timer) {\r\n            clearInterval(timer);\r\n            timer = undefined;\r\n        }\r\n    };\r\n\r\n    // \u8FD4\u56DE\u6838\u5FC3\u5B9E\u4F8B\r\n    return {\r\n        check,\r\n        start,\r\n        destroy\r\n    };\r\n}", "import type { UpdateCoreInstance } from './core';\r\n\r\n// \u63D2\u4EF6\u7C7B\u578B\u5B9A\u4E49\uFF1A\u63A5\u6536\u6838\u5FC3\u5B9E\u4F8B\uFF0C\u8FD4\u56DE\u6E05\u7406\u51FD\u6570\r\nexport type UpdatePlugin = (core: UpdateCoreInstance) => () => void;\r\n\r\n/** * \uD83D\uDD0C \u63D2\u4EF6\uFF1A\u8DEF\u7531\u5207\u6362\u68C0\u6D4B\r\n */\r\nexport const createRoutePlugin: UpdatePlugin = (core) => {\r\n    const patch = (method: 'pushState' | 'replaceState') => {\r\n        const original = window.history[method];\r\n\r\n        // \u9632\u6B62\u91CD\u590D Patch\r\n        if ((original as any)._isPatched) return;\r\n\r\n        window.history[method] = function (...args) {\r\n            const result = original.apply(this, args);\r\n            core.check(); // \u8C03\u7528\u6838\u5FC3\u68C0\u6D4B\r\n            return result;\r\n        };\r\n        (window.history[method] as any)._isPatched = true;\r\n    };\r\n\r\n    // 1. \u52AB\u6301 History API\r\n    patch('pushState');\r\n    patch('replaceState');\r\n\r\n    // 2. \u76D1\u542C popstate\r\n    const onPopState = () => core.check();\r\n    window.addEventListener('popstate', onPopState);\r\n\r\n    // \u8FD4\u56DE\u6E05\u7406\u51FD\u6570\r\n    return () => {\r\n        window.removeEventListener('popstate', onPopState);\r\n    };\r\n};\r\n\r\n/** * \uD83D\uDD0C \u63D2\u4EF6\uFF1A\u8D44\u6E90\u52A0\u8F7D\u9519\u8BEF\u68C0\u6D4B\r\n */\r\nexport const createResourceErrorPlugin: UpdatePlugin = (core) => {\r\n    const onError = (event: Event) => {\r\n        const target = event.target as HTMLElement;\r\n        if (!target || (target.tagName !== 'SCRIPT' && target.tagName !== 'LINK')) return;\r\n\r\n        const src = (target as HTMLScriptElement).src || (target as HTMLLinkElement).href;\r\n        if (src) {\r\n            core.check(); // \u8D44\u6E90\u6302\u4E86\uFF0C\u7ACB\u5373\u68C0\u67E5\r\n        }\r\n    };\r\n\r\n    // \u6355\u83B7\u9636\u6BB5\u76D1\u542C\r\n    window.addEventListener('error', onError, true);\r\n\r\n    return () => {\r\n        window.removeEventListener('error', onError, true);\r\n    };\r\n};"],
  "mappings": "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",
  "names": []
}


package/dist/index.mjs

@@ -0,0 +1,127 @@
+// src/core.ts
+function createUpdateCore(options) {
+  let oldEtag = null;
+  let timer;
+  let isChecking = false;
+  let isDestroyed = false;
+  const getCheckUrl = () => {
+    try {
+      const urlStr = options.checkUrl || window.location.href;
+      const targetUrl = new URL(urlStr, window.location.href);
+      targetUrl.searchParams.set("t", String(Date.now()));
+      return targetUrl.toString();
+    } catch {
+      return `${options.checkUrl || window.location.href}?t=${Date.now()}`;
+    }
+  };
+  const check = async () => {
+    if (isDestroyed || isChecking) return;
+    isChecking = true;
+    try {
+      const response = await fetch(getCheckUrl(), { method: "HEAD", cache: "no-cache" });
+      const newEtag = response.headers.get("etag") || response.headers.get("last-modified");
+      if (!newEtag) return;
+      if (!oldEtag) {
+        oldEtag = newEtag;
+      } else if (newEtag !== oldEtag) {
+        oldEtag = newEtag;
+        if (options.autoRefresh) {
+          window.location.reload();
+        } else {
+          options.onUpdate?.();
+        }
+      }
+    } catch (e) {
+    } finally {
+      if (!isDestroyed) {
+        isChecking = false;
+      }
+    }
+  };
+  const start = () => {
+    check();
+    if (options.interval && options.interval > 0) {
+      timer = setInterval(check, options.interval);
+    }
+  };
+  const destroy = () => {
+    isDestroyed = true;
+    if (timer) {
+      clearInterval(timer);
+      timer = void 0;
+    }
+  };
+  return {
+    check,
+    start,
+    destroy
+  };
+}
+
+// src/plugins.ts
+var createRoutePlugin = (core) => {
+  const patch = (method) => {
+    const original = window.history[method];
+    if (original._isPatched) return;
+    window.history[method] = function(...args) {
+      const result = original.apply(this, args);
+      core.check();
+      return result;
+    };
+    window.history[method]._isPatched = true;
+  };
+  patch("pushState");
+  patch("replaceState");
+  const onPopState = () => core.check();
+  window.addEventListener("popstate", onPopState);
+  return () => {
+    window.removeEventListener("popstate", onPopState);
+  };
+};
+var createResourceErrorPlugin = (core) => {
+  const onError = (event) => {
+    const target = event.target;
+    if (!target || target.tagName !== "SCRIPT" && target.tagName !== "LINK") return;
+    const src = target.src || target.href;
+    if (src) {
+      core.check();
+    }
+  };
+  window.addEventListener("error", onError, true);
+  return () => {
+    window.removeEventListener("error", onError, true);
+  };
+};
+
+// src/index.ts
+function createCheckUpdate(options = {}) {
+  const {
+    interval = 10 * 60 * 1e3,
+    enableRouteDetection = true,
+    enableLoadErrorDetection = false,
+    ...coreOptions
+  } = options;
+  const core = createUpdateCore({ interval, ...coreOptions });
+  const cleanupFns = [];
+  const use = (plugin) => {
+    cleanupFns.push(plugin(core));
+  };
+  if (enableRouteDetection) {
+    use(createRoutePlugin);
+  }
+  if (enableLoadErrorDetection) {
+    use(createResourceErrorPlugin);
+  }
+  core.start();
+  return {
+    check: core.check,
+    destroy: () => {
+      core.destroy();
+      cleanupFns.forEach((fn) => fn());
+    }
+  };
+}
+export {
+  createCheckUpdate
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/core.ts", "../src/plugins.ts", "../src/index.ts"],
  "sourcesContent": ["export interface CoreOptions {\r\n    interval?: number;\r\n    checkUrl?: string;\r\n    autoRefresh?: boolean;\r\n    onUpdate?: () => void;\r\n}\r\n\r\n// \u5B9A\u4E49\u6838\u5FC3\u5B9E\u4F8B\u5BF9\u5916\u66B4\u9732\u7684\u63A5\u53E3\r\nexport interface UpdateCoreInstance {\r\n    check: () => Promise<void>;\r\n    start: () => void;\r\n    destroy: () => void;\r\n}\r\n\r\nexport function createUpdateCore(options: CoreOptions): UpdateCoreInstance {\r\n    // --- \u79C1\u6709\u72B6\u6001 (\u95ED\u5305) ---\r\n    let oldEtag: string | null = null;\r\n    let timer: ReturnType<typeof setInterval> | undefined;\r\n    let isChecking = false;\r\n    let isDestroyed = false;\r\n\r\n    // --- \u5185\u90E8\u8F85\u52A9\u51FD\u6570 ---\r\n\r\n    const getCheckUrl = (): string => {\r\n        try {\r\n            const urlStr = options.checkUrl || window.location.href;\r\n            const targetUrl = new URL(urlStr, window.location.href);\r\n            targetUrl.searchParams.set('t', String(Date.now()));\r\n            return targetUrl.toString();\r\n        } catch {\r\n            return `${options.checkUrl || window.location.href}?t=${Date.now()}`;\r\n        }\r\n    };\r\n\r\n    // --- \u6838\u5FC3\u65B9\u6CD5 ---\r\n\r\n    const check = async () => {\r\n        if (isDestroyed || isChecking) return;\r\n        isChecking = true;\r\n\r\n        try {\r\n            const response = await fetch(getCheckUrl(), { method: 'HEAD', cache: 'no-cache' });\r\n            const newEtag = response.headers.get('etag') || response.headers.get('last-modified');\r\n\r\n            if (!newEtag) return;\r\n\r\n            if (!oldEtag) {\r\n                // \u521D\u59CB\u5316\u57FA\u51C6\r\n                oldEtag = newEtag;\r\n            } else if (newEtag !== oldEtag) {\r\n                oldEtag = newEtag;\r\n\r\n                if (options.autoRefresh) {\r\n                    window.location.reload();\r\n                } else {\r\n                    options.onUpdate?.();\r\n                }\r\n            }\r\n        } catch (e) {\r\n            // \u7F51\u7EDC\u9519\u8BEF\u5FFD\u7565\r\n        } finally {\r\n            if (!isDestroyed) {\r\n                isChecking = false;\r\n            }\r\n        }\r\n    };\r\n\r\n    const start = () => {\r\n        check(); // \u7ACB\u5373\u68C0\u67E5\u4E00\u6B21\r\n        if (options.interval && options.interval > 0) {\r\n            timer = setInterval(check, options.interval);\r\n        }\r\n    };\r\n\r\n    const destroy = () => {\r\n        isDestroyed = true;\r\n        if (timer) {\r\n            clearInterval(timer);\r\n            timer = undefined;\r\n        }\r\n    };\r\n\r\n    // \u8FD4\u56DE\u6838\u5FC3\u5B9E\u4F8B\r\n    return {\r\n        check,\r\n        start,\r\n        destroy\r\n    };\r\n}", "import type { UpdateCoreInstance } from './core';\r\n\r\n// \u63D2\u4EF6\u7C7B\u578B\u5B9A\u4E49\uFF1A\u63A5\u6536\u6838\u5FC3\u5B9E\u4F8B\uFF0C\u8FD4\u56DE\u6E05\u7406\u51FD\u6570\r\nexport type UpdatePlugin = (core: UpdateCoreInstance) => () => void;\r\n\r\n/** * \uD83D\uDD0C \u63D2\u4EF6\uFF1A\u8DEF\u7531\u5207\u6362\u68C0\u6D4B\r\n */\r\nexport const createRoutePlugin: UpdatePlugin = (core) => {\r\n    const patch = (method: 'pushState' | 'replaceState') => {\r\n        const original = window.history[method];\r\n\r\n        // \u9632\u6B62\u91CD\u590D Patch\r\n        if ((original as any)._isPatched) return;\r\n\r\n        window.history[method] = function (...args) {\r\n            const result = original.apply(this, args);\r\n            core.check(); // \u8C03\u7528\u6838\u5FC3\u68C0\u6D4B\r\n            return result;\r\n        };\r\n        (window.history[method] as any)._isPatched = true;\r\n    };\r\n\r\n    // 1. \u52AB\u6301 History API\r\n    patch('pushState');\r\n    patch('replaceState');\r\n\r\n    // 2. \u76D1\u542C popstate\r\n    const onPopState = () => core.check();\r\n    window.addEventListener('popstate', onPopState);\r\n\r\n    // \u8FD4\u56DE\u6E05\u7406\u51FD\u6570\r\n    return () => {\r\n        window.removeEventListener('popstate', onPopState);\r\n    };\r\n};\r\n\r\n/** * \uD83D\uDD0C \u63D2\u4EF6\uFF1A\u8D44\u6E90\u52A0\u8F7D\u9519\u8BEF\u68C0\u6D4B\r\n */\r\nexport const createResourceErrorPlugin: UpdatePlugin = (core) => {\r\n    const onError = (event: Event) => {\r\n        const target = event.target as HTMLElement;\r\n        if (!target || (target.tagName !== 'SCRIPT' && target.tagName !== 'LINK')) return;\r\n\r\n        const src = (target as HTMLScriptElement).src || (target as HTMLLinkElement).href;\r\n        if (src) {\r\n            core.check(); // \u8D44\u6E90\u6302\u4E86\uFF0C\u7ACB\u5373\u68C0\u67E5\r\n        }\r\n    };\r\n\r\n    // \u6355\u83B7\u9636\u6BB5\u76D1\u542C\r\n    window.addEventListener('error', onError, true);\r\n\r\n    return () => {\r\n        window.removeEventListener('error', onError, true);\r\n    };\r\n};", "import { createUpdateCore, type CoreOptions } from './core';\r\nimport { createRoutePlugin, createResourceErrorPlugin, type UpdatePlugin } from './plugins';\r\n\r\nexport interface CheckUpdateOptions extends CoreOptions {\r\n    /** \u662F\u5426\u5F00\u542F\u8DEF\u7531\u5207\u6362\u68C0\u6D4B (\u9ED8\u8BA4 true) */\r\n    enableRouteDetection?: boolean;\r\n    /** \u662F\u5426\u5F00\u542F\u8D44\u6E90\u52A0\u8F7D\u9519\u8BEF\u68C0\u6D4B (\u9ED8\u8BA4 false) */\r\n    enableLoadErrorDetection?: boolean;\r\n}\r\n\r\nexport function createCheckUpdate(options: CheckUpdateOptions = {}) {\r\n    // 1. \u5206\u79BB\u914D\u7F6E\r\n    const {\r\n        interval = 10 * 60 * 1000,\r\n        enableRouteDetection = true,\r\n        enableLoadErrorDetection = false,\r\n        ...coreOptions\r\n    } = options;\r\n\r\n    // 2. \u521B\u5EFA\u6838\u5FC3\u5B9E\u4F8B\r\n    const core = createUpdateCore({ interval, ...coreOptions });\r\n\r\n    // 3. \u63D2\u4EF6\u7BA1\u7406\r\n    const cleanupFns: Array<() => void> = [];\r\n\r\n    const use = (plugin: UpdatePlugin) => {\r\n        cleanupFns.push(plugin(core));\r\n    };\r\n\r\n    // 4. \u6309\u9700\u52A0\u8F7D\u63D2\u4EF6\r\n    if (enableRouteDetection) {\r\n        use(createRoutePlugin);\r\n    }\r\n\r\n    if (enableLoadErrorDetection) {\r\n        use(createResourceErrorPlugin);\r\n    }\r\n\r\n    // 5. \u542F\u52A8\u6838\u5FC3\r\n    core.start();\r\n\r\n    // 6. \u8FD4\u56DE\u5BF9\u5916 API\r\n    return {\r\n        check: core.check,\r\n        destroy: () => {\r\n            core.destroy(); // \u9500\u6BC1\u6838\u5FC3\r\n            cleanupFns.forEach(fn => fn()); // \u9500\u6BC1\u6240\u6709\u63D2\u4EF6\r\n        }\r\n    };\r\n}"],
  "mappings": "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",
  "names": []
}


package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@chaochao12138/check-update-sdk",
+  "version": "0.0.1",
+  "description": "Frontend automatic update detection SDK for web applications",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean --sourcemap inline",
+    "prepublishOnly": "npm run build",
+    "release": "pnpm build && npm publish",
+    "test": "vitest",
+    "test:coverage": "vitest --coverage"
+  },
+  "peerDependencies": {
+    "vue": "^3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "vue": {
+      "optional": true
+    }
+  },
+  "keywords": [
+    "update",
+    "notification",
+    "version-check",
+    "auto-refresh",
+    "etag",
+    "hot-reload",
+    "frontend",
+    "vue3"
+  ],
+  "author": {
+    "name": "Dezhen"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dezhen/check-update-sdk.git"
+  },
+  "bugs": {
+    "url": "https://github.com/dezhen/check-update-sdk/issues"
+  },
+  "homepage": "https://github.com/dezhen/check-update-sdk#readme",
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "devDependencies": {
+    "@vitest/coverage-v8": "^4.0.16",
+    "@vitest/ui": "4.0.16",
+    "happy-dom": "^20.0.11",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.16"
+  }
+}