@lytjs/plugin-data 6.5.0

package/README.md

@@ -0,0 +1,82 @@
+# @lytjs/plugin-data
+
+LytJS 官方增强版数据获取插件，提供乐观更新、缓存策略、请求去重等功能。
+
+## 安装
+
+```bash
+pnpm add @lytjs/plugin-data
+```
+
+## 快速开始
+
+### 作为插件使用
+
+```typescript
+import { createApp } from '@lytjs/core';
+import pluginData from '@lytjs/plugin-data';
+
+const app = createApp();
+app.use(pluginData);
+```
+
+### 独立使用
+
+```typescript
+import { createData } from '@lytjs/plugin-data';
+
+// 创建数据实例
+const data = createData('/api/users');
+
+// 监听数据变化
+data.on('data', (users) => {
+  console.log('数据已更新：', users);
+});
+
+// 手动刷新
+await data.refresh();
+```
+
+## 特性
+
+- 乐观更新
+- 请求去重
+- 多种缓存策略（TTL、LRU）
+- 自动重试
+- 与 @lytjs/plugin-data-fetch 深度集成
+- 零外部依赖
+
+## API
+
+### createData(url, options, globalOptions)
+
+创建数据获取实例。
+
+```typescript
+import { createData } from '@lytjs/plugin-data';
+
+const data = createData('/api/users', {
+  method: 'GET',
+  cache: 'ttl',
+  ttl: 60000,
+});
+```
+
+### createDataManager(globalOptions)
+
+创建全局数据管理器。
+
+```typescript
+import { createDataManager } from '@lytjs/plugin-data';
+
+const manager = createDataManager({
+  defaultCache: 'ttl',
+  defaultTTL: 60000,
+});
+
+const data = manager.create('/api/users');
+```
+
+## 许可证
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,427 @@
+"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, {
+  LRUCache: () => LRUCache,
+  TTLCache: () => TTLCache,
+  createData: () => createData,
+  createDataManager: () => createDataManager,
+  default: () => index_default,
+  generateCacheKey: () => import_plugin_data_fetch.generateCacheKey
+});
+module.exports = __toCommonJS(index_exports);
+var import_core = require("@lytjs/core");
+var import_reactivity = require("@lytjs/reactivity");
+var import_plugin_data_fetch = require("@lytjs/plugin-data-fetch");
+
+// src/cache/ttl.ts
+var TTLCache = class {
+  constructor() {
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return null;
+    if (Date.now() > entry.expiresAt) {
+      this.cache.delete(key);
+      return null;
+    }
+    return entry;
+  }
+  set(key, value) {
+    this.cache.set(key, value);
+  }
+  delete(key) {
+    this.cache.delete(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  has(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return false;
+    if (Date.now() > entry.expiresAt) {
+      this.cache.delete(key);
+      return false;
+    }
+    return true;
+  }
+  /**
+   * 获取缓存大小
+   */
+  size() {
+    return this.cache.size;
+  }
+  /**
+   * 获取所有缓存键
+   */
+  keys() {
+    return Array.from(this.cache.keys());
+  }
+};
+
+// src/cache/lru.ts
+var LRUCache = class {
+  constructor(maxSize = 100) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.maxSize = maxSize;
+  }
+  get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return null;
+    if (Date.now() > entry.expiresAt) {
+      this.cache.delete(key);
+      return null;
+    }
+    entry.lastAccessed = Date.now();
+    this.cache.delete(key);
+    this.cache.set(key, entry);
+    return entry;
+  }
+  set(key, value) {
+    if (this.cache.size >= this.maxSize) {
+      this.evict();
+    }
+    const lruEntry = {
+      ...value,
+      lastAccessed: Date.now()
+    };
+    this.cache.set(key, lruEntry);
+  }
+  delete(key) {
+    this.cache.delete(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  has(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return false;
+    if (Date.now() > entry.expiresAt) {
+      this.cache.delete(key);
+      return false;
+    }
+    return true;
+  }
+  evict() {
+    const keys = Array.from(this.cache.keys());
+    if (keys.length > 0) {
+      this.cache.delete(keys[0]);
+    }
+  }
+  /**
+   * 获取缓存大小
+   */
+  size() {
+    return this.cache.size;
+  }
+  /**
+   * 获取最大缓存大小
+   */
+  getMaxSize() {
+    return this.maxSize;
+  }
+};
+
+// src/index.ts
+var pendingRequests = /* @__PURE__ */ new Map();
+var activeInstances = /* @__PURE__ */ new Set();
+function createData(url, options = {}, globalOptions = {}) {
+  const dataSignal = (0, import_reactivity.signal)(null);
+  const isLoadingSignal = (0, import_reactivity.signal)(false);
+  const errorSignal = (0, import_reactivity.signal)(null);
+  const refetchCountSignal = (0, import_reactivity.signal)(0);
+  const isPrefetchingSignal = (0, import_reactivity.signal)(false);
+  let abortController = null;
+  let lastRollbackData = null;
+  const state = (0, import_reactivity.signalComputed)(() => ({
+    data: dataSignal(),
+    isLoading: isLoadingSignal(),
+    error: errorSignal(),
+    isSuccess: !isLoadingSignal() && dataSignal() !== null && errorSignal() === null,
+    isError: !isLoadingSignal() && errorSignal() !== null,
+    refetchCount: refetchCountSignal()
+  }));
+  const {
+    baseUrl = globalOptions.baseUrl || "",
+    timeout = globalOptions.timeout || 3e4,
+    retries = globalOptions.retries || 0,
+    retryDelay = globalOptions.retryDelay || 1e3,
+    cacheStrategy = globalOptions.defaultCacheStrategy || "no-cache",
+    cacheTime = globalOptions.defaultCacheTime || 3e5,
+    dedupe = globalOptions.defaultDedupe || false,
+    optimisticData,
+    prefetch = false
+  } = options;
+  const cacheStorage = globalOptions.cacheStorage || new import_plugin_data_fetch.DefaultCacheStorage();
+  const fullUrl = baseUrl ? baseUrl.endsWith("/") ? baseUrl + url.slice(1) : baseUrl + url : url;
+  const cacheKey = (0, import_plugin_data_fetch.generateCacheKey)(fullUrl, options);
+  async function executeFetch() {
+    if (dedupe) {
+      const existing = pendingRequests.get(cacheKey);
+      if (existing && Date.now() - existing.timestamp < 1e4) {
+        return existing.promise;
+      }
+    }
+    if (optimisticData !== void 0) {
+      optimisticUpdate(optimisticData);
+    }
+    if (abortController) {
+      abortController.abort();
+    }
+    abortController = new AbortController();
+    const abortSignal = abortController.signal;
+    const manager = (0, import_plugin_data_fetch.createFetchManager)({
+      ...globalOptions,
+      cacheStorage
+    });
+    const instance = manager.createFetch(url, {
+      ...options,
+      signal: abortSignal
+    });
+    const promise = instance.fetch().then(
+      (result) => {
+        dataSignal.set(result);
+        if (globalOptions.storeIntegration?.onUpdate) {
+          globalOptions.storeIntegration.onUpdate(cacheKey, result);
+        }
+        pendingRequests.delete(cacheKey);
+        return result;
+      },
+      (error) => {
+        if (lastRollbackData !== null) {
+          rollbackOptimistic();
+        }
+        pendingRequests.delete(cacheKey);
+        throw error;
+      }
+    );
+    if (dedupe) {
+      pendingRequests.set(cacheKey, { promise, timestamp: Date.now() });
+    }
+    activeInstances.add({ cancel: instance.cancel });
+    return promise;
+  }
+  const optimisticUpdate = (data) => {
+    lastRollbackData = dataSignal();
+    dataSignal.set(data);
+  };
+  const rollbackOptimistic = () => {
+    if (lastRollbackData !== null) {
+      dataSignal.set(lastRollbackData);
+    }
+  };
+  const doFetch = async () => {
+    return executeFetch();
+  };
+  const refetch = async () => {
+    refetchCountSignal.update((v) => v + 1);
+    return executeFetch();
+  };
+  const cancel = () => {
+    if (abortController) {
+      abortController.abort();
+      abortController = null;
+    }
+    isLoadingSignal.set(false);
+  };
+  const setData = (data) => {
+    if (typeof data === "function") {
+      dataSignal.update((prev) => data(prev));
+    } else {
+      dataSignal.set(data);
+    }
+  };
+  const setError = (error) => {
+    errorSignal.set(error);
+  };
+  const reset = () => {
+    dataSignal.set(null);
+    isLoadingSignal.set(false);
+    errorSignal.set(null);
+    refetchCountSignal.set(0);
+    abortController = null;
+  };
+  return {
+    get state() {
+      return state();
+    },
+    get isPrefetching() {
+      return isPrefetchingSignal();
+    },
+    fetch: doFetch,
+    refetch,
+    cancel,
+    setData,
+    setError,
+    reset,
+    optimisticUpdate,
+    rollbackOptimistic
+  };
+}
+function createDataManager(globalOptions = {}) {
+  const cacheStorage = globalOptions.cacheStorage || new import_plugin_data_fetch.DefaultCacheStorage();
+  const manager = (0, import_plugin_data_fetch.createFetchManager)(globalOptions);
+  return {
+    createData(url, options = {}) {
+      return createData(url, options, {
+        ...globalOptions,
+        cacheStorage
+      });
+    },
+    async get(url, options = {}) {
+      const instance = createData(
+        url,
+        { ...options, method: "GET" },
+        {
+          ...globalOptions,
+          cacheStorage
+        }
+      );
+      return instance.fetch();
+    },
+    async post(url, body, options = {}) {
+      const instance = createData(
+        url,
+        {
+          ...options,
+          method: "POST",
+          body: body ? typeof body === "string" ? body : JSON.stringify(body) : void 0,
+          headers: {
+            "Content-Type": "application/json",
+            ...options.headers
+          }
+        },
+        {
+          ...globalOptions,
+          cacheStorage
+        }
+      );
+      return instance.fetch();
+    },
+    async put(url, body, options = {}) {
+      const instance = createData(
+        url,
+        {
+          ...options,
+          method: "PUT",
+          body: body ? typeof body === "string" ? body : JSON.stringify(body) : void 0,
+          headers: {
+            "Content-Type": "application/json",
+            ...options.headers
+          }
+        },
+        {
+          ...globalOptions,
+          cacheStorage
+        }
+      );
+      return instance.fetch();
+    },
+    async delete(url, options = {}) {
+      const instance = createData(
+        url,
+        { ...options, method: "DELETE" },
+        {
+          ...globalOptions,
+          cacheStorage
+        }
+      );
+      return instance.fetch();
+    },
+    addRequestInterceptor(interceptor) {
+      manager.addRequestInterceptor(interceptor);
+    },
+    addResponseInterceptor(interceptor) {
+      manager.addResponseInterceptor(interceptor);
+    },
+    addErrorInterceptor(interceptor) {
+      manager.addErrorInterceptor(interceptor);
+    },
+    getCacheStorage() {
+      return manager.getCacheStorage();
+    },
+    clearCache() {
+      manager.clearCache();
+    },
+    invalidateCache(key) {
+      manager.invalidateCache(key);
+    },
+    async prefetch(url, options = {}) {
+      const instance = createData(
+        url,
+        { ...options, prefetch: true },
+        {
+          ...globalOptions,
+          cacheStorage
+        }
+      );
+      return instance.fetch();
+    },
+    getPendingRequests() {
+      return new Set(pendingRequests.keys());
+    },
+    cancelAllRequests() {
+      for (const instance of activeInstances) {
+        instance.cancel();
+      }
+      activeInstances.clear();
+      pendingRequests.clear();
+    }
+  };
+}
+var pluginData = (0, import_core.definePlugin)({
+  name: "data",
+  version: "6.0.0",
+  description: "LytJS official enhanced data plugin with optimistic updates, deduplication, and store integration",
+  author: "LytJS Team",
+  keywords: ["lytjs", "data", "fetch", "optimistic", "store"],
+  schema: {
+    type: "object",
+    object: {
+      properties: {
+        baseUrl: { type: "string" },
+        timeout: { type: "number", default: 3e4 },
+        retries: { type: "number", default: 0 },
+        retryDelay: { type: "number", default: 1e3 },
+        defaultCacheStrategy: { type: "string", default: "no-cache" },
+        defaultCacheTime: { type: "number", default: 3e5 },
+        defaultDedupe: { type: "boolean", default: false },
+        offlineMode: { type: "boolean", default: false }
+      }
+    }
+  },
+  install(app, options) {
+    const dataManager = createDataManager(options);
+    app.config.globalProperties.$data = dataManager;
+    app.config.globalProperties.$dataManager = dataManager;
+    app.provide("lyt-data", dataManager);
+  }
+});
+var index_default = pluginData;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LRUCache,
+  TTLCache,
+  createData,
+  createDataManager,
+  generateCacheKey
+});

package/dist/index.d.cts

@@ -0,0 +1,131 @@
+import * as _lytjs_core from '@lytjs/core';
+import { FetchInstance, RequestOptions as RequestOptions$1, FetchError, CacheStorage, FetchPluginOptions, CacheEntry } from '@lytjs/plugin-data-fetch';
+export { CacheEntry, CacheStorage, FetchError, generateCacheKey } from '@lytjs/plugin-data-fetch';
+
+/**
+ * @lytjs/plugin-data - 类型定义
+ */
+
+interface RequestOptions extends RequestOptions$1 {
+    /** 是否启用请求去重 */
+    dedupe?: boolean;
+    /** 乐观更新数据 */
+    optimisticData?: unknown;
+    /** 预取相关配置 */
+    prefetch?: boolean;
+}
+
+interface DataPluginOptions extends FetchPluginOptions {
+    /** 默认去重设置 */
+    defaultDedupe?: boolean;
+    /** 离线模式 */
+    offlineMode?: boolean;
+    /** 与 store 的集成配置 */
+    storeIntegration?: {
+        /** 数据同步时的钩子 */
+        onSync?: (key: string, data: unknown) => void;
+        /** 数据更新时的钩子 */
+        onUpdate?: (key: string, data: unknown) => void;
+    };
+}
+interface DataManager {
+    /** 创建数据实例 */
+    createData<T = unknown>(url: string, options?: RequestOptions): DataInstance<T>;
+    /** 执行简单 GET 请求 */
+    get<T = unknown>(url: string, options?: RequestOptions): Promise<T>;
+    /** 执行简单 POST 请求 */
+    post<T = unknown>(url: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    /** 执行简单 PUT 请求 */
+    put<T = unknown>(url: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    /** 执行简单 DELETE 请求 */
+    delete<T = unknown>(url: string, options?: RequestOptions): Promise<T>;
+    /** 添加请求拦截器 */
+    addRequestInterceptor(interceptor: (config: RequestOptions) => RequestOptions | Promise<RequestOptions>): void;
+    /** 添加响应拦截器 */
+    addResponseInterceptor(interceptor: <T = unknown>(response: T) => T | Promise<T>): void;
+    /** 添加错误拦截器 */
+    addErrorInterceptor(interceptor: (error: FetchError) => FetchError | Promise<FetchError>): void;
+    /** 获取缓存存储 */
+    getCacheStorage(): CacheStorage;
+    /** 清空缓存 */
+    clearCache(): void;
+    /** 清除特定缓存 */
+    invalidateCache(key: string): void;
+    /** 预取数据 */
+    prefetch<T = unknown>(url: string, options?: RequestOptions): Promise<T>;
+    /** 获取当前的请求队列 */
+    getPendingRequests(): Set<string>;
+    /** 取消所有请求 */
+    cancelAllRequests(): void;
+}
+interface DataInstance<T = unknown> extends FetchInstance<T> {
+    /** 乐观更新数据 */
+    optimisticUpdate(data: T): void;
+    /** 回滚乐观更新 */
+    rollbackOptimistic(): void;
+    /** 获取预取状态 */
+    isPrefetching: boolean;
+}
+
+/**
+ * TTL (Time To Live) 缓存策略实现
+ */
+
+declare class TTLCache implements CacheStorage {
+    private cache;
+    get<T = unknown>(key: string): CacheEntry<T> | null;
+    set<T = unknown>(key: string, value: CacheEntry<T>): void;
+    delete(key: string): void;
+    clear(): void;
+    has(key: string): boolean;
+    /**
+     * 获取缓存大小
+     */
+    size(): number;
+    /**
+     * 获取所有缓存键
+     */
+    keys(): string[];
+}
+
+/**
+ * LRU (Least Recently Used) 缓存策略实现
+ */
+
+interface LRUEntry<T = unknown> extends CacheEntry<T> {
+    lastAccessed: number;
+}
+declare class LRUCache implements CacheStorage {
+    private cache;
+    private readonly maxSize;
+    constructor(maxSize?: number);
+    get<T = unknown>(key: string): LRUEntry<T> | null;
+    set<T = unknown>(key: string, value: CacheEntry<T>): void;
+    delete(key: string): void;
+    clear(): void;
+    has(key: string): boolean;
+    private evict;
+    /**
+     * 获取缓存大小
+     */
+    size(): number;
+    /**
+     * 获取最大缓存大小
+     */
+    getMaxSize(): number;
+}
+
+/**
+ * 创建数据实例
+ */
+declare function createData<T = unknown>(url: string, options?: RequestOptions, globalOptions?: DataPluginOptions): DataInstance<T>;
+/**
+ * 创建数据管理器
+ */
+declare function createDataManager(globalOptions?: DataPluginOptions): DataManager;
+/**
+ * 定义插件
+ */
+declare const pluginData: _lytjs_core.PluginDefinition<unknown>;
+
+export { type DataInstance, type DataManager, type DataPluginOptions, LRUCache, type RequestOptions, TTLCache, createData, createDataManager, pluginData as default };

package/dist/index.d.ts

@@ -0,0 +1,131 @@
+import * as _lytjs_core from '@lytjs/core';
+import { FetchInstance, RequestOptions as RequestOptions$1, FetchError, CacheStorage, FetchPluginOptions, CacheEntry } from '@lytjs/plugin-data-fetch';
+export { CacheEntry, CacheStorage, FetchError, generateCacheKey } from '@lytjs/plugin-data-fetch';
+
+/**
+ * @lytjs/plugin-data - 类型定义
+ */
+
+interface RequestOptions extends RequestOptions$1 {
+    /** 是否启用请求去重 */
+    dedupe?: boolean;
+    /** 乐观更新数据 */
+    optimisticData?: unknown;
+    /** 预取相关配置 */
+    prefetch?: boolean;
+}
+
+interface DataPluginOptions extends FetchPluginOptions {
+    /** 默认去重设置 */
+    defaultDedupe?: boolean;
+    /** 离线模式 */
+    offlineMode?: boolean;
+    /** 与 store 的集成配置 */
+    storeIntegration?: {
+        /** 数据同步时的钩子 */
+        onSync?: (key: string, data: unknown) => void;
+        /** 数据更新时的钩子 */
+        onUpdate?: (key: string, data: unknown) => void;
+    };
+}
+interface DataManager {
+    /** 创建数据实例 */
+    createData<T = unknown>(url: string, options?: RequestOptions): DataInstance<T>;
+    /** 执行简单 GET 请求 */
+    get<T = unknown>(url: string, options?: RequestOptions): Promise<T>;
+    /** 执行简单 POST 请求 */
+    post<T = unknown>(url: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    /** 执行简单 PUT 请求 */
+    put<T = unknown>(url: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    /** 执行简单 DELETE 请求 */
+    delete<T = unknown>(url: string, options?: RequestOptions): Promise<T>;
+    /** 添加请求拦截器 */
+    addRequestInterceptor(interceptor: (config: RequestOptions) => RequestOptions | Promise<RequestOptions>): void;
+    /** 添加响应拦截器 */
+    addResponseInterceptor(interceptor: <T = unknown>(response: T) => T | Promise<T>): void;
+    /** 添加错误拦截器 */
+    addErrorInterceptor(interceptor: (error: FetchError) => FetchError | Promise<FetchError>): void;
+    /** 获取缓存存储 */
+    getCacheStorage(): CacheStorage;
+    /** 清空缓存 */
+    clearCache(): void;
+    /** 清除特定缓存 */
+    invalidateCache(key: string): void;
+    /** 预取数据 */
+    prefetch<T = unknown>(url: string, options?: RequestOptions): Promise<T>;
+    /** 获取当前的请求队列 */
+    getPendingRequests(): Set<string>;
+    /** 取消所有请求 */
+    cancelAllRequests(): void;
+}
+interface DataInstance<T = unknown> extends FetchInstance<T> {
+    /** 乐观更新数据 */
+    optimisticUpdate(data: T): void;
+    /** 回滚乐观更新 */
+    rollbackOptimistic(): void;
+    /** 获取预取状态 */
+    isPrefetching: boolean;
+}
+
+/**
+ * TTL (Time To Live) 缓存策略实现
+ */
+
+declare class TTLCache implements CacheStorage {
+    private cache;
+    get<T = unknown>(key: string): CacheEntry<T> | null;
+    set<T = unknown>(key: string, value: CacheEntry<T>): void;
+    delete(key: string): void;
+    clear(): void;
+    has(key: string): boolean;
+    /**
+     * 获取缓存大小
+     */
+    size(): number;
+    /**
+     * 获取所有缓存键
+     */
+    keys(): string[];
+}
+
+/**
+ * LRU (Least Recently Used) 缓存策略实现
+ */
+
+interface LRUEntry<T = unknown> extends CacheEntry<T> {
+    lastAccessed: number;
+}
+declare class LRUCache implements CacheStorage {
+    private cache;
+    private readonly maxSize;
+    constructor(maxSize?: number);
+    get<T = unknown>(key: string): LRUEntry<T> | null;
+    set<T = unknown>(key: string, value: CacheEntry<T>): void;
+    delete(key: string): void;
+    clear(): void;
+    has(key: string): boolean;
+    private evict;
+    /**
+     * 获取缓存大小
+     */
+    size(): number;
+    /**
+     * 获取最大缓存大小
+     */
+    getMaxSize(): number;
+}
+
+/**
+ * 创建数据实例
+ */
+declare function createData<T = unknown>(url: string, options?: RequestOptions, globalOptions?: DataPluginOptions): DataInstance<T>;
+/**
+ * 创建数据管理器
+ */
+declare function createDataManager(globalOptions?: DataPluginOptions): DataManager;
+/**
+ * 定义插件
+ */
+declare const pluginData: _lytjs_core.PluginDefinition<unknown>;
+
+export { type DataInstance, type DataManager, type DataPluginOptions, LRUCache, type RequestOptions, TTLCache, createData, createDataManager, pluginData as default };

package/dist/index.mjs

@@ -0,0 +1,402 @@
+// src/index.ts
+import { definePlugin } from "@lytjs/core";
+import { signal, signalComputed as computed } from "@lytjs/reactivity";
+import {
+  createFetchManager,
+  DefaultCacheStorage,
+  generateCacheKey
+} from "@lytjs/plugin-data-fetch";
+
+// src/cache/ttl.ts
+var TTLCache = class {
+  constructor() {
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return null;
+    if (Date.now() > entry.expiresAt) {
+      this.cache.delete(key);
+      return null;
+    }
+    return entry;
+  }
+  set(key, value) {
+    this.cache.set(key, value);
+  }
+  delete(key) {
+    this.cache.delete(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  has(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return false;
+    if (Date.now() > entry.expiresAt) {
+      this.cache.delete(key);
+      return false;
+    }
+    return true;
+  }
+  /**
+   * 获取缓存大小
+   */
+  size() {
+    return this.cache.size;
+  }
+  /**
+   * 获取所有缓存键
+   */
+  keys() {
+    return Array.from(this.cache.keys());
+  }
+};
+
+// src/cache/lru.ts
+var LRUCache = class {
+  constructor(maxSize = 100) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.maxSize = maxSize;
+  }
+  get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return null;
+    if (Date.now() > entry.expiresAt) {
+      this.cache.delete(key);
+      return null;
+    }
+    entry.lastAccessed = Date.now();
+    this.cache.delete(key);
+    this.cache.set(key, entry);
+    return entry;
+  }
+  set(key, value) {
+    if (this.cache.size >= this.maxSize) {
+      this.evict();
+    }
+    const lruEntry = {
+      ...value,
+      lastAccessed: Date.now()
+    };
+    this.cache.set(key, lruEntry);
+  }
+  delete(key) {
+    this.cache.delete(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  has(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return false;
+    if (Date.now() > entry.expiresAt) {
+      this.cache.delete(key);
+      return false;
+    }
+    return true;
+  }
+  evict() {
+    const keys = Array.from(this.cache.keys());
+    if (keys.length > 0) {
+      this.cache.delete(keys[0]);
+    }
+  }
+  /**
+   * 获取缓存大小
+   */
+  size() {
+    return this.cache.size;
+  }
+  /**
+   * 获取最大缓存大小
+   */
+  getMaxSize() {
+    return this.maxSize;
+  }
+};
+
+// src/index.ts
+var pendingRequests = /* @__PURE__ */ new Map();
+var activeInstances = /* @__PURE__ */ new Set();
+function createData(url, options = {}, globalOptions = {}) {
+  const dataSignal = signal(null);
+  const isLoadingSignal = signal(false);
+  const errorSignal = signal(null);
+  const refetchCountSignal = signal(0);
+  const isPrefetchingSignal = signal(false);
+  let abortController = null;
+  let lastRollbackData = null;
+  const state = computed(() => ({
+    data: dataSignal(),
+    isLoading: isLoadingSignal(),
+    error: errorSignal(),
+    isSuccess: !isLoadingSignal() && dataSignal() !== null && errorSignal() === null,
+    isError: !isLoadingSignal() && errorSignal() !== null,
+    refetchCount: refetchCountSignal()
+  }));
+  const {
+    baseUrl = globalOptions.baseUrl || "",
+    timeout = globalOptions.timeout || 3e4,
+    retries = globalOptions.retries || 0,
+    retryDelay = globalOptions.retryDelay || 1e3,
+    cacheStrategy = globalOptions.defaultCacheStrategy || "no-cache",
+    cacheTime = globalOptions.defaultCacheTime || 3e5,
+    dedupe = globalOptions.defaultDedupe || false,
+    optimisticData,
+    prefetch = false
+  } = options;
+  const cacheStorage = globalOptions.cacheStorage || new DefaultCacheStorage();
+  const fullUrl = baseUrl ? baseUrl.endsWith("/") ? baseUrl + url.slice(1) : baseUrl + url : url;
+  const cacheKey = generateCacheKey(fullUrl, options);
+  async function executeFetch() {
+    if (dedupe) {
+      const existing = pendingRequests.get(cacheKey);
+      if (existing && Date.now() - existing.timestamp < 1e4) {
+        return existing.promise;
+      }
+    }
+    if (optimisticData !== void 0) {
+      optimisticUpdate(optimisticData);
+    }
+    if (abortController) {
+      abortController.abort();
+    }
+    abortController = new AbortController();
+    const abortSignal = abortController.signal;
+    const manager = createFetchManager({
+      ...globalOptions,
+      cacheStorage
+    });
+    const instance = manager.createFetch(url, {
+      ...options,
+      signal: abortSignal
+    });
+    const promise = instance.fetch().then(
+      (result) => {
+        dataSignal.set(result);
+        if (globalOptions.storeIntegration?.onUpdate) {
+          globalOptions.storeIntegration.onUpdate(cacheKey, result);
+        }
+        pendingRequests.delete(cacheKey);
+        return result;
+      },
+      (error) => {
+        if (lastRollbackData !== null) {
+          rollbackOptimistic();
+        }
+        pendingRequests.delete(cacheKey);
+        throw error;
+      }
+    );
+    if (dedupe) {
+      pendingRequests.set(cacheKey, { promise, timestamp: Date.now() });
+    }
+    activeInstances.add({ cancel: instance.cancel });
+    return promise;
+  }
+  const optimisticUpdate = (data) => {
+    lastRollbackData = dataSignal();
+    dataSignal.set(data);
+  };
+  const rollbackOptimistic = () => {
+    if (lastRollbackData !== null) {
+      dataSignal.set(lastRollbackData);
+    }
+  };
+  const doFetch = async () => {
+    return executeFetch();
+  };
+  const refetch = async () => {
+    refetchCountSignal.update((v) => v + 1);
+    return executeFetch();
+  };
+  const cancel = () => {
+    if (abortController) {
+      abortController.abort();
+      abortController = null;
+    }
+    isLoadingSignal.set(false);
+  };
+  const setData = (data) => {
+    if (typeof data === "function") {
+      dataSignal.update((prev) => data(prev));
+    } else {
+      dataSignal.set(data);
+    }
+  };
+  const setError = (error) => {
+    errorSignal.set(error);
+  };
+  const reset = () => {
+    dataSignal.set(null);
+    isLoadingSignal.set(false);
+    errorSignal.set(null);
+    refetchCountSignal.set(0);
+    abortController = null;
+  };
+  return {
+    get state() {
+      return state();
+    },
+    get isPrefetching() {
+      return isPrefetchingSignal();
+    },
+    fetch: doFetch,
+    refetch,
+    cancel,
+    setData,
+    setError,
+    reset,
+    optimisticUpdate,
+    rollbackOptimistic
+  };
+}
+function createDataManager(globalOptions = {}) {
+  const cacheStorage = globalOptions.cacheStorage || new DefaultCacheStorage();
+  const manager = createFetchManager(globalOptions);
+  return {
+    createData(url, options = {}) {
+      return createData(url, options, {
+        ...globalOptions,
+        cacheStorage
+      });
+    },
+    async get(url, options = {}) {
+      const instance = createData(
+        url,
+        { ...options, method: "GET" },
+        {
+          ...globalOptions,
+          cacheStorage
+        }
+      );
+      return instance.fetch();
+    },
+    async post(url, body, options = {}) {
+      const instance = createData(
+        url,
+        {
+          ...options,
+          method: "POST",
+          body: body ? typeof body === "string" ? body : JSON.stringify(body) : void 0,
+          headers: {
+            "Content-Type": "application/json",
+            ...options.headers
+          }
+        },
+        {
+          ...globalOptions,
+          cacheStorage
+        }
+      );
+      return instance.fetch();
+    },
+    async put(url, body, options = {}) {
+      const instance = createData(
+        url,
+        {
+          ...options,
+          method: "PUT",
+          body: body ? typeof body === "string" ? body : JSON.stringify(body) : void 0,
+          headers: {
+            "Content-Type": "application/json",
+            ...options.headers
+          }
+        },
+        {
+          ...globalOptions,
+          cacheStorage
+        }
+      );
+      return instance.fetch();
+    },
+    async delete(url, options = {}) {
+      const instance = createData(
+        url,
+        { ...options, method: "DELETE" },
+        {
+          ...globalOptions,
+          cacheStorage
+        }
+      );
+      return instance.fetch();
+    },
+    addRequestInterceptor(interceptor) {
+      manager.addRequestInterceptor(interceptor);
+    },
+    addResponseInterceptor(interceptor) {
+      manager.addResponseInterceptor(interceptor);
+    },
+    addErrorInterceptor(interceptor) {
+      manager.addErrorInterceptor(interceptor);
+    },
+    getCacheStorage() {
+      return manager.getCacheStorage();
+    },
+    clearCache() {
+      manager.clearCache();
+    },
+    invalidateCache(key) {
+      manager.invalidateCache(key);
+    },
+    async prefetch(url, options = {}) {
+      const instance = createData(
+        url,
+        { ...options, prefetch: true },
+        {
+          ...globalOptions,
+          cacheStorage
+        }
+      );
+      return instance.fetch();
+    },
+    getPendingRequests() {
+      return new Set(pendingRequests.keys());
+    },
+    cancelAllRequests() {
+      for (const instance of activeInstances) {
+        instance.cancel();
+      }
+      activeInstances.clear();
+      pendingRequests.clear();
+    }
+  };
+}
+var pluginData = definePlugin({
+  name: "data",
+  version: "6.0.0",
+  description: "LytJS official enhanced data plugin with optimistic updates, deduplication, and store integration",
+  author: "LytJS Team",
+  keywords: ["lytjs", "data", "fetch", "optimistic", "store"],
+  schema: {
+    type: "object",
+    object: {
+      properties: {
+        baseUrl: { type: "string" },
+        timeout: { type: "number", default: 3e4 },
+        retries: { type: "number", default: 0 },
+        retryDelay: { type: "number", default: 1e3 },
+        defaultCacheStrategy: { type: "string", default: "no-cache" },
+        defaultCacheTime: { type: "number", default: 3e5 },
+        defaultDedupe: { type: "boolean", default: false },
+        offlineMode: { type: "boolean", default: false }
+      }
+    }
+  },
+  install(app, options) {
+    const dataManager = createDataManager(options);
+    app.config.globalProperties.$data = dataManager;
+    app.config.globalProperties.$dataManager = dataManager;
+    app.provide("lyt-data", dataManager);
+  }
+});
+var index_default = pluginData;
+export {
+  LRUCache,
+  TTLCache,
+  createData,
+  createDataManager,
+  index_default as default,
+  generateCacheKey
+};

package/package.json

@@ -0,0 +1,66 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "@lytjs/plugin-data",
+  "version": "6.5.0",
+  "description": "LytJS official enhanced data plugin with optimistic updates, deduplication, and store integration",
+  "author": "lytjs",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "dev": "tsup --watch",
+    "build": "tsup",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "type-check": "tsc --noEmit",
+    "clean": "rm -rf dist node_modules .turbo"
+  },
+  "dependencies": {
+    "@lytjs/core": "^6.5.0",
+    "@lytjs/reactivity": "^6.5.0",
+    "@lytjs/plugin-data-fetch": "^6.5.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.3.6",
+    "typescript": "^5.7.3",
+    "vitest": "^3.0.0"
+  },
+  "peerDependencies": {},
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://gitee.com/lytjs/lytjs.git",
+    "directory": "packages/plugins/packages/plugin-data"
+  },
+  "keywords": [
+    "lytjs",
+    "data",
+    "fetch",
+    "optimistic",
+    "store"
+  ],
+  "homepage": "https://gitee.com/lytjs/lytjs/tree/develop/packages/plugins/packages/plugin-data#readme",
+  "bugs": {
+    "url": "https://gitee.com/lytjs/lytjs/issues"
+  }
+}