@lytjs/plugin-data-fetch 6.4.0

package/dist/index.cjs

@@ -0,0 +1,422 @@
+"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, {
+  DefaultCacheStorage: () => DefaultCacheStorage,
+  createFetch: () => createFetch,
+  createFetchManager: () => createFetchManager,
+  default: () => index_default,
+  generateCacheKey: () => generateCacheKey
+});
+module.exports = __toCommonJS(index_exports);
+var import_core = require("@lytjs/core");
+var import_reactivity = require("@lytjs/reactivity");
+var DefaultCacheStorage = 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;
+  }
+};
+function generateCacheKey(url, options = {}) {
+  const { method = "GET", headers, body, requestKey } = options;
+  if (requestKey) {
+    return requestKey;
+  }
+  let headerString = "";
+  if (headers) {
+    const headerEntries = Array.isArray(headers) ? headers : headers instanceof Headers ? Array.from(headers.entries()) : Object.entries(headers);
+    headerString = JSON.stringify(headerEntries.sort());
+  }
+  let bodyString = "";
+  if (body) {
+    bodyString = typeof body === "string" ? body : JSON.stringify(body);
+  }
+  return `${method}:${url}:${headerString}:${bodyString}`;
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function createFetchError(message, config, response, originalError) {
+  const error = new Error(message);
+  error.config = config;
+  error.response = response;
+  error.originalError = originalError;
+  if (response) {
+    error.status = response.status;
+  }
+  return error;
+}
+function createFetch(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);
+  let abortController = 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,
+    cancelDuplicate = 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 (cancelDuplicate && abortController) {
+      abortController.abort();
+    }
+    abortController = new AbortController();
+    const abortSignal = abortController.signal;
+    let currentConfig = { ...options, signal: abortSignal };
+    const requestInterceptors = globalOptions.requestInterceptors || [];
+    for (const interceptor of requestInterceptors) {
+      currentConfig = await interceptor(currentConfig);
+    }
+    if (cacheStrategy === "cache-only") {
+      const cached = cacheStorage.get(cacheKey);
+      if (cached) {
+        return cached.data;
+      }
+      throw createFetchError("Cache miss", currentConfig);
+    }
+    if (cacheStrategy === "cache-first" && cacheStorage.has(cacheKey)) {
+      const cached = cacheStorage.get(cacheKey);
+      if (cached) {
+        return cached.data;
+      }
+    }
+    isLoadingSignal.set(true);
+    errorSignal.set(null);
+    let lastError = null;
+    for (let attempt = 0; attempt <= retries; attempt++) {
+      try {
+        const response = await fetchWithTimeout(fullUrl, currentConfig, timeout, abortSignal);
+        if (!response.ok) {
+          const error = createFetchError(`HTTP ${response.status}`, currentConfig, response);
+          let processedError = error;
+          const errorInterceptors = globalOptions.errorInterceptors || [];
+          for (const interceptor of errorInterceptors) {
+            processedError = await interceptor(processedError);
+          }
+          lastError = processedError;
+          if (options.onError) {
+            await options.onError(processedError);
+          }
+          if (attempt === retries || response.status >= 400 && response.status < 500) {
+            throw processedError;
+          }
+          await delay(retryDelay);
+          continue;
+        }
+        let result;
+        const contentType = response.headers.get("content-type") || "";
+        if (contentType.includes("application/json")) {
+          result = await response.json();
+        } else {
+          result = await response.text();
+        }
+        const responseInterceptors = globalOptions.responseInterceptors || [];
+        for (const interceptor of responseInterceptors) {
+          result = await interceptor(result);
+        }
+        if (cacheStrategy !== "no-cache") {
+          cacheStorage.set(cacheKey, {
+            data: result,
+            createdAt: Date.now(),
+            expiresAt: Date.now() + cacheTime
+          });
+        }
+        dataSignal.set(result);
+        isLoadingSignal.set(false);
+        return result;
+      } catch (error) {
+        if (abortSignal.aborted) {
+          lastError = createFetchError("Request cancelled", currentConfig, void 0, error);
+          break;
+        }
+        if (attempt < retries) {
+          await delay(retryDelay);
+        } else {
+          if (error instanceof Error && !error.config) {
+            lastError = createFetchError(error.message, currentConfig, void 0, error);
+          } else {
+            lastError = error;
+          }
+        }
+      }
+    }
+    if (lastError) {
+      if (cacheStrategy === "network-first" && cacheStorage.has(cacheKey)) {
+        const cached = cacheStorage.get(cacheKey);
+        if (cached) {
+          dataSignal.set(cached.data);
+          isLoadingSignal.set(false);
+          return cached.data;
+        }
+      }
+      errorSignal.set(lastError);
+      isLoadingSignal.set(false);
+      throw lastError;
+    }
+    throw createFetchError("Unknown error", currentConfig);
+  }
+  async function fetchWithTimeout(url2, config, _timeout, _signal) {
+    const response = await fetch(url2, config);
+    return response;
+  }
+  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();
+    },
+    fetch: doFetch,
+    refetch,
+    cancel,
+    setData,
+    setError,
+    reset
+  };
+}
+function createFetchManager(globalOptions = {}) {
+  const cacheStorage = globalOptions.cacheStorage || new DefaultCacheStorage();
+  const requestInterceptors = globalOptions.requestInterceptors || [];
+  const responseInterceptors = globalOptions.responseInterceptors || [];
+  const errorInterceptors = globalOptions.errorInterceptors || [];
+  return {
+    /**
+     * 创建 Fetch 实例
+     */
+    createFetch(url, options = {}) {
+      return createFetch(url, options, {
+        ...globalOptions,
+        cacheStorage,
+        requestInterceptors,
+        responseInterceptors,
+        errorInterceptors
+      });
+    },
+    /**
+     * 简单 GET 请求
+     */
+    async get(url, options = {}) {
+      const instance = createFetch(url, { ...options, method: "GET" }, {
+        ...globalOptions,
+        cacheStorage,
+        requestInterceptors,
+        responseInterceptors,
+        errorInterceptors
+      });
+      return instance.fetch();
+    },
+    /**
+     * 简单 POST 请求
+     */
+    async post(url, body, options = {}) {
+      const instance = createFetch(url, {
+        ...options,
+        method: "POST",
+        body: body ? typeof body === "string" ? body : JSON.stringify(body) : void 0,
+        headers: {
+          "Content-Type": "application/json",
+          ...options.headers
+        }
+      }, {
+        ...globalOptions,
+        cacheStorage,
+        requestInterceptors,
+        responseInterceptors,
+        errorInterceptors
+      });
+      return instance.fetch();
+    },
+    /**
+     * 简单 PUT 请求
+     */
+    async put(url, body, options = {}) {
+      const instance = createFetch(url, {
+        ...options,
+        method: "PUT",
+        body: body ? typeof body === "string" ? body : JSON.stringify(body) : void 0,
+        headers: {
+          "Content-Type": "application/json",
+          ...options.headers
+        }
+      }, {
+        ...globalOptions,
+        cacheStorage,
+        requestInterceptors,
+        responseInterceptors,
+        errorInterceptors
+      });
+      return instance.fetch();
+    },
+    /**
+     * 简单 DELETE 请求
+     */
+    async delete(url, options = {}) {
+      const instance = createFetch(url, { ...options, method: "DELETE" }, {
+        ...globalOptions,
+        cacheStorage,
+        requestInterceptors,
+        responseInterceptors,
+        errorInterceptors
+      });
+      return instance.fetch();
+    },
+    /**
+     * 添加请求拦截器
+     */
+    addRequestInterceptor(interceptor) {
+      requestInterceptors.push(interceptor);
+    },
+    /**
+     * 添加响应拦截器
+     */
+    addResponseInterceptor(interceptor) {
+      responseInterceptors.push(interceptor);
+    },
+    /**
+     * 添加错误拦截器
+     */
+    addErrorInterceptor(interceptor) {
+      errorInterceptors.push(interceptor);
+    },
+    /**
+     * 获取缓存存储
+     */
+    getCacheStorage() {
+      return cacheStorage;
+    },
+    /**
+     * 清除缓存
+     */
+    clearCache() {
+      cacheStorage.clear();
+    },
+    /**
+     * 删除特定缓存
+     */
+    invalidateCache(key) {
+      cacheStorage.delete(key);
+    }
+  };
+}
+var pluginDataFetch = (0, import_core.definePlugin)({
+  name: "data-fetch",
+  version: "6.0.0",
+  description: "LytJS official data fetch plugin with caching, retries, and interceptors",
+  author: "LytJS Team",
+  keywords: ["lytjs", "fetch", "ajax", "cache", "interceptor"],
+  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 }
+      }
+    }
+  },
+  install(app, options) {
+    const fetchManager = createFetchManager(options);
+    app.config.globalProperties.$fetch = fetchManager;
+    app.config.globalProperties.$http = fetchManager;
+    app.provide("lyt-fetch", fetchManager);
+  }
+});
+var index_default = pluginDataFetch;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DefaultCacheStorage,
+  createFetch,
+  createFetchManager,
+  generateCacheKey
+});

package/dist/index.d.cts

@@ -0,0 +1,196 @@
+import * as _lytjs_core from '@lytjs/core';
+
+/**
+ * @lytjs/plugin-data-fetch - 类型定义
+ */
+interface RequestOptions extends RequestInit {
+    /** 基础 URL */
+    baseUrl?: string;
+    /** 超时时间（毫秒） */
+    timeout?: number;
+    /** 重试次数 */
+    retries?: number;
+    /** 重试延迟（毫秒） */
+    retryDelay?: number;
+    /** 缓存策略 */
+    cacheStrategy?: 'no-cache' | 'cache-first' | 'network-first' | 'cache-only';
+    /** 缓存时间（毫秒） */
+    cacheTime?: number;
+    /** 请求标识，用于缓存键生成 */
+    requestKey?: string;
+    /** 是否取消重复请求 */
+    cancelDuplicate?: boolean;
+    /** 自定义错误处理 */
+    onError?: (error: FetchError) => void | Promise<void>;
+}
+interface FetchError extends Error {
+    /** HTTP 状态码 */
+    status?: number;
+    /** 原始响应 */
+    response?: Response;
+    /** 原始错误 */
+    originalError?: Error;
+    /** 请求配置 */
+    config?: RequestOptions;
+}
+interface CacheEntry<T = unknown> {
+    /** 缓存数据 */
+    data: T;
+    /** 过期时间 */
+    expiresAt: number;
+    /** 创建时间 */
+    createdAt: number;
+}
+interface CacheStorage {
+    /** 获取缓存 */
+    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;
+}
+interface Interceptor<T = unknown> {
+    /** 请求拦截器 */
+    request?: (config: RequestOptions) => RequestOptions | Promise<RequestOptions>;
+    /** 响应拦截器 */
+    response?: (response: T) => T | Promise<T>;
+    /** 错误拦截器 */
+    error?: (error: FetchError) => FetchError | Promise<FetchError>;
+}
+interface FetchState<T = unknown> {
+    /** 请求数据 */
+    data: T | null;
+    /** 加载状态 */
+    isLoading: boolean;
+    /** 错误状态 */
+    error: FetchError | null;
+    /** 是否已完成 */
+    isSuccess: boolean;
+    /** 是否失败 */
+    isError: boolean;
+    /** 请求次数 */
+    refetchCount: number;
+}
+interface FetchInstance<T = unknown> {
+    /** 当前状态 */
+    state: Readonly<FetchState<T>>;
+    /** 发起请求 */
+    fetch(): Promise<T>;
+    /** 重新请求 */
+    refetch(): Promise<T>;
+    /** 取消请求 */
+    cancel(): void;
+    /** 手动更新数据 */
+    setData(data: T | ((prev: T | null) => T)): void;
+    /** 手动更新错误 */
+    setError(error: FetchError | null): void;
+    /** 清空状态 */
+    reset(): void;
+}
+interface FetchPluginOptions {
+    /** 基础 URL */
+    baseUrl?: string;
+    /** 默认超时时间 */
+    timeout?: number;
+    /** 默认重试次数 */
+    retries?: number;
+    /** 默认重试延迟 */
+    retryDelay?: number;
+    /** 默认缓存策略 */
+    defaultCacheStrategy?: RequestOptions['cacheStrategy'];
+    /** 默认缓存时间 */
+    defaultCacheTime?: number;
+    /** 请求拦截器 */
+    requestInterceptors?: Interceptor['request'][];
+    /** 响应拦截器 */
+    responseInterceptors?: Interceptor['response'][];
+    /** 错误拦截器 */
+    errorInterceptors?: Interceptor['error'][];
+    /** 自定义缓存存储 */
+    cacheStorage?: CacheStorage;
+}
+interface RequestInterceptor {
+    (config: RequestOptions): RequestOptions | Promise<RequestOptions>;
+}
+interface ResponseInterceptor {
+    <T = unknown>(response: T): T | Promise<T>;
+}
+interface ErrorInterceptor {
+    (error: FetchError): FetchError | Promise<FetchError>;
+}
+
+/**
+ * 默认内存缓存实现
+ */
+declare class DefaultCacheStorage 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;
+}
+/**
+ * 生成缓存键
+ */
+declare function generateCacheKey(url: string, options?: RequestOptions): string;
+/**
+ * 创建数据获取实例
+ */
+declare function createFetch<T = unknown>(url: string, options?: RequestOptions, globalOptions?: FetchPluginOptions): FetchInstance<T>;
+/**
+ * 创建 Fetch 管理器
+ */
+declare function createFetchManager(globalOptions?: FetchPluginOptions): {
+    /**
+     * 创建 Fetch 实例
+     */
+    createFetch<T = unknown>(url: string, options?: RequestOptions): FetchInstance<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: RequestInterceptor): void;
+    /**
+     * 添加响应拦截器
+     */
+    addResponseInterceptor(interceptor: ResponseInterceptor): void;
+    /**
+     * 添加错误拦截器
+     */
+    addErrorInterceptor(interceptor: ErrorInterceptor): void;
+    /**
+     * 获取缓存存储
+     */
+    getCacheStorage(): CacheStorage;
+    /**
+     * 清除缓存
+     */
+    clearCache(): void;
+    /**
+     * 删除特定缓存
+     */
+    invalidateCache(key: string): void;
+};
+declare const pluginDataFetch: _lytjs_core.PluginDefinition<unknown>;
+
+export { type CacheEntry, type CacheStorage, DefaultCacheStorage, type ErrorInterceptor, type FetchError, type FetchInstance, type FetchPluginOptions, type FetchState, type Interceptor, type RequestInterceptor, type RequestOptions, type ResponseInterceptor, createFetch, createFetchManager, pluginDataFetch as default, generateCacheKey };

package/dist/index.d.ts

@@ -0,0 +1,196 @@
+import * as _lytjs_core from '@lytjs/core';
+
+/**
+ * @lytjs/plugin-data-fetch - 类型定义
+ */
+interface RequestOptions extends RequestInit {
+    /** 基础 URL */
+    baseUrl?: string;
+    /** 超时时间（毫秒） */
+    timeout?: number;
+    /** 重试次数 */
+    retries?: number;
+    /** 重试延迟（毫秒） */
+    retryDelay?: number;
+    /** 缓存策略 */
+    cacheStrategy?: 'no-cache' | 'cache-first' | 'network-first' | 'cache-only';
+    /** 缓存时间（毫秒） */
+    cacheTime?: number;
+    /** 请求标识，用于缓存键生成 */
+    requestKey?: string;
+    /** 是否取消重复请求 */
+    cancelDuplicate?: boolean;
+    /** 自定义错误处理 */
+    onError?: (error: FetchError) => void | Promise<void>;
+}
+interface FetchError extends Error {
+    /** HTTP 状态码 */
+    status?: number;
+    /** 原始响应 */
+    response?: Response;
+    /** 原始错误 */
+    originalError?: Error;
+    /** 请求配置 */
+    config?: RequestOptions;
+}
+interface CacheEntry<T = unknown> {
+    /** 缓存数据 */
+    data: T;
+    /** 过期时间 */
+    expiresAt: number;
+    /** 创建时间 */
+    createdAt: number;
+}
+interface CacheStorage {
+    /** 获取缓存 */
+    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;
+}
+interface Interceptor<T = unknown> {
+    /** 请求拦截器 */
+    request?: (config: RequestOptions) => RequestOptions | Promise<RequestOptions>;
+    /** 响应拦截器 */
+    response?: (response: T) => T | Promise<T>;
+    /** 错误拦截器 */
+    error?: (error: FetchError) => FetchError | Promise<FetchError>;
+}
+interface FetchState<T = unknown> {
+    /** 请求数据 */
+    data: T | null;
+    /** 加载状态 */
+    isLoading: boolean;
+    /** 错误状态 */
+    error: FetchError | null;
+    /** 是否已完成 */
+    isSuccess: boolean;
+    /** 是否失败 */
+    isError: boolean;
+    /** 请求次数 */
+    refetchCount: number;
+}
+interface FetchInstance<T = unknown> {
+    /** 当前状态 */
+    state: Readonly<FetchState<T>>;
+    /** 发起请求 */
+    fetch(): Promise<T>;
+    /** 重新请求 */
+    refetch(): Promise<T>;
+    /** 取消请求 */
+    cancel(): void;
+    /** 手动更新数据 */
+    setData(data: T | ((prev: T | null) => T)): void;
+    /** 手动更新错误 */
+    setError(error: FetchError | null): void;
+    /** 清空状态 */
+    reset(): void;
+}
+interface FetchPluginOptions {
+    /** 基础 URL */
+    baseUrl?: string;
+    /** 默认超时时间 */
+    timeout?: number;
+    /** 默认重试次数 */
+    retries?: number;
+    /** 默认重试延迟 */
+    retryDelay?: number;
+    /** 默认缓存策略 */
+    defaultCacheStrategy?: RequestOptions['cacheStrategy'];
+    /** 默认缓存时间 */
+    defaultCacheTime?: number;
+    /** 请求拦截器 */
+    requestInterceptors?: Interceptor['request'][];
+    /** 响应拦截器 */
+    responseInterceptors?: Interceptor['response'][];
+    /** 错误拦截器 */
+    errorInterceptors?: Interceptor['error'][];
+    /** 自定义缓存存储 */
+    cacheStorage?: CacheStorage;
+}
+interface RequestInterceptor {
+    (config: RequestOptions): RequestOptions | Promise<RequestOptions>;
+}
+interface ResponseInterceptor {
+    <T = unknown>(response: T): T | Promise<T>;
+}
+interface ErrorInterceptor {
+    (error: FetchError): FetchError | Promise<FetchError>;
+}
+
+/**
+ * 默认内存缓存实现
+ */
+declare class DefaultCacheStorage 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;
+}
+/**
+ * 生成缓存键
+ */
+declare function generateCacheKey(url: string, options?: RequestOptions): string;
+/**
+ * 创建数据获取实例
+ */
+declare function createFetch<T = unknown>(url: string, options?: RequestOptions, globalOptions?: FetchPluginOptions): FetchInstance<T>;
+/**
+ * 创建 Fetch 管理器
+ */
+declare function createFetchManager(globalOptions?: FetchPluginOptions): {
+    /**
+     * 创建 Fetch 实例
+     */
+    createFetch<T = unknown>(url: string, options?: RequestOptions): FetchInstance<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: RequestInterceptor): void;
+    /**
+     * 添加响应拦截器
+     */
+    addResponseInterceptor(interceptor: ResponseInterceptor): void;
+    /**
+     * 添加错误拦截器
+     */
+    addErrorInterceptor(interceptor: ErrorInterceptor): void;
+    /**
+     * 获取缓存存储
+     */
+    getCacheStorage(): CacheStorage;
+    /**
+     * 清除缓存
+     */
+    clearCache(): void;
+    /**
+     * 删除特定缓存
+     */
+    invalidateCache(key: string): void;
+};
+declare const pluginDataFetch: _lytjs_core.PluginDefinition<unknown>;
+
+export { type CacheEntry, type CacheStorage, DefaultCacheStorage, type ErrorInterceptor, type FetchError, type FetchInstance, type FetchPluginOptions, type FetchState, type Interceptor, type RequestInterceptor, type RequestOptions, type ResponseInterceptor, createFetch, createFetchManager, pluginDataFetch as default, generateCacheKey };

package/dist/index.js

@@ -0,0 +1,394 @@
+// src/index.ts
+import { definePlugin } from "@lytjs/core";
+import { signal, signalComputed as computed } from "@lytjs/reactivity";
+var DefaultCacheStorage = 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;
+  }
+};
+function generateCacheKey(url, options = {}) {
+  const { method = "GET", headers, body, requestKey } = options;
+  if (requestKey) {
+    return requestKey;
+  }
+  let headerString = "";
+  if (headers) {
+    const headerEntries = Array.isArray(headers) ? headers : headers instanceof Headers ? Array.from(headers.entries()) : Object.entries(headers);
+    headerString = JSON.stringify(headerEntries.sort());
+  }
+  let bodyString = "";
+  if (body) {
+    bodyString = typeof body === "string" ? body : JSON.stringify(body);
+  }
+  return `${method}:${url}:${headerString}:${bodyString}`;
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function createFetchError(message, config, response, originalError) {
+  const error = new Error(message);
+  error.config = config;
+  error.response = response;
+  error.originalError = originalError;
+  if (response) {
+    error.status = response.status;
+  }
+  return error;
+}
+function createFetch(url, options = {}, globalOptions = {}) {
+  const dataSignal = signal(null);
+  const isLoadingSignal = signal(false);
+  const errorSignal = signal(null);
+  const refetchCountSignal = signal(0);
+  let abortController = 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,
+    cancelDuplicate = 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 (cancelDuplicate && abortController) {
+      abortController.abort();
+    }
+    abortController = new AbortController();
+    const abortSignal = abortController.signal;
+    let currentConfig = { ...options, signal: abortSignal };
+    const requestInterceptors = globalOptions.requestInterceptors || [];
+    for (const interceptor of requestInterceptors) {
+      currentConfig = await interceptor(currentConfig);
+    }
+    if (cacheStrategy === "cache-only") {
+      const cached = cacheStorage.get(cacheKey);
+      if (cached) {
+        return cached.data;
+      }
+      throw createFetchError("Cache miss", currentConfig);
+    }
+    if (cacheStrategy === "cache-first" && cacheStorage.has(cacheKey)) {
+      const cached = cacheStorage.get(cacheKey);
+      if (cached) {
+        return cached.data;
+      }
+    }
+    isLoadingSignal.set(true);
+    errorSignal.set(null);
+    let lastError = null;
+    for (let attempt = 0; attempt <= retries; attempt++) {
+      try {
+        const response = await fetchWithTimeout(fullUrl, currentConfig, timeout, abortSignal);
+        if (!response.ok) {
+          const error = createFetchError(`HTTP ${response.status}`, currentConfig, response);
+          let processedError = error;
+          const errorInterceptors = globalOptions.errorInterceptors || [];
+          for (const interceptor of errorInterceptors) {
+            processedError = await interceptor(processedError);
+          }
+          lastError = processedError;
+          if (options.onError) {
+            await options.onError(processedError);
+          }
+          if (attempt === retries || response.status >= 400 && response.status < 500) {
+            throw processedError;
+          }
+          await delay(retryDelay);
+          continue;
+        }
+        let result;
+        const contentType = response.headers.get("content-type") || "";
+        if (contentType.includes("application/json")) {
+          result = await response.json();
+        } else {
+          result = await response.text();
+        }
+        const responseInterceptors = globalOptions.responseInterceptors || [];
+        for (const interceptor of responseInterceptors) {
+          result = await interceptor(result);
+        }
+        if (cacheStrategy !== "no-cache") {
+          cacheStorage.set(cacheKey, {
+            data: result,
+            createdAt: Date.now(),
+            expiresAt: Date.now() + cacheTime
+          });
+        }
+        dataSignal.set(result);
+        isLoadingSignal.set(false);
+        return result;
+      } catch (error) {
+        if (abortSignal.aborted) {
+          lastError = createFetchError("Request cancelled", currentConfig, void 0, error);
+          break;
+        }
+        if (attempt < retries) {
+          await delay(retryDelay);
+        } else {
+          if (error instanceof Error && !error.config) {
+            lastError = createFetchError(error.message, currentConfig, void 0, error);
+          } else {
+            lastError = error;
+          }
+        }
+      }
+    }
+    if (lastError) {
+      if (cacheStrategy === "network-first" && cacheStorage.has(cacheKey)) {
+        const cached = cacheStorage.get(cacheKey);
+        if (cached) {
+          dataSignal.set(cached.data);
+          isLoadingSignal.set(false);
+          return cached.data;
+        }
+      }
+      errorSignal.set(lastError);
+      isLoadingSignal.set(false);
+      throw lastError;
+    }
+    throw createFetchError("Unknown error", currentConfig);
+  }
+  async function fetchWithTimeout(url2, config, _timeout, _signal) {
+    const response = await fetch(url2, config);
+    return response;
+  }
+  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();
+    },
+    fetch: doFetch,
+    refetch,
+    cancel,
+    setData,
+    setError,
+    reset
+  };
+}
+function createFetchManager(globalOptions = {}) {
+  const cacheStorage = globalOptions.cacheStorage || new DefaultCacheStorage();
+  const requestInterceptors = globalOptions.requestInterceptors || [];
+  const responseInterceptors = globalOptions.responseInterceptors || [];
+  const errorInterceptors = globalOptions.errorInterceptors || [];
+  return {
+    /**
+     * 创建 Fetch 实例
+     */
+    createFetch(url, options = {}) {
+      return createFetch(url, options, {
+        ...globalOptions,
+        cacheStorage,
+        requestInterceptors,
+        responseInterceptors,
+        errorInterceptors
+      });
+    },
+    /**
+     * 简单 GET 请求
+     */
+    async get(url, options = {}) {
+      const instance = createFetch(url, { ...options, method: "GET" }, {
+        ...globalOptions,
+        cacheStorage,
+        requestInterceptors,
+        responseInterceptors,
+        errorInterceptors
+      });
+      return instance.fetch();
+    },
+    /**
+     * 简单 POST 请求
+     */
+    async post(url, body, options = {}) {
+      const instance = createFetch(url, {
+        ...options,
+        method: "POST",
+        body: body ? typeof body === "string" ? body : JSON.stringify(body) : void 0,
+        headers: {
+          "Content-Type": "application/json",
+          ...options.headers
+        }
+      }, {
+        ...globalOptions,
+        cacheStorage,
+        requestInterceptors,
+        responseInterceptors,
+        errorInterceptors
+      });
+      return instance.fetch();
+    },
+    /**
+     * 简单 PUT 请求
+     */
+    async put(url, body, options = {}) {
+      const instance = createFetch(url, {
+        ...options,
+        method: "PUT",
+        body: body ? typeof body === "string" ? body : JSON.stringify(body) : void 0,
+        headers: {
+          "Content-Type": "application/json",
+          ...options.headers
+        }
+      }, {
+        ...globalOptions,
+        cacheStorage,
+        requestInterceptors,
+        responseInterceptors,
+        errorInterceptors
+      });
+      return instance.fetch();
+    },
+    /**
+     * 简单 DELETE 请求
+     */
+    async delete(url, options = {}) {
+      const instance = createFetch(url, { ...options, method: "DELETE" }, {
+        ...globalOptions,
+        cacheStorage,
+        requestInterceptors,
+        responseInterceptors,
+        errorInterceptors
+      });
+      return instance.fetch();
+    },
+    /**
+     * 添加请求拦截器
+     */
+    addRequestInterceptor(interceptor) {
+      requestInterceptors.push(interceptor);
+    },
+    /**
+     * 添加响应拦截器
+     */
+    addResponseInterceptor(interceptor) {
+      responseInterceptors.push(interceptor);
+    },
+    /**
+     * 添加错误拦截器
+     */
+    addErrorInterceptor(interceptor) {
+      errorInterceptors.push(interceptor);
+    },
+    /**
+     * 获取缓存存储
+     */
+    getCacheStorage() {
+      return cacheStorage;
+    },
+    /**
+     * 清除缓存
+     */
+    clearCache() {
+      cacheStorage.clear();
+    },
+    /**
+     * 删除特定缓存
+     */
+    invalidateCache(key) {
+      cacheStorage.delete(key);
+    }
+  };
+}
+var pluginDataFetch = definePlugin({
+  name: "data-fetch",
+  version: "6.0.0",
+  description: "LytJS official data fetch plugin with caching, retries, and interceptors",
+  author: "LytJS Team",
+  keywords: ["lytjs", "fetch", "ajax", "cache", "interceptor"],
+  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 }
+      }
+    }
+  },
+  install(app, options) {
+    const fetchManager = createFetchManager(options);
+    app.config.globalProperties.$fetch = fetchManager;
+    app.config.globalProperties.$http = fetchManager;
+    app.provide("lyt-fetch", fetchManager);
+  }
+});
+var index_default = pluginDataFetch;
+export {
+  DefaultCacheStorage,
+  createFetch,
+  createFetchManager,
+  index_default as default,
+  generateCacheKey
+};

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@lytjs/plugin-data-fetch",
+  "version": "6.4.0",
+  "description": "LytJS official data fetch plugin with caching, retries, and interceptors",
+  "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"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "type-check": "tsc --noEmit",
+    "lint": "eslint \"src/**/*.ts\"",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@lytjs/core": "^6.4.0",
+    "@lytjs/reactivity": "^6.4.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0",
+    "vitest": "^3.0.0"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://gitee.com/lytjs/lytjs.git",
+    "directory": "packages/plugins/packages/plugin-data-fetch"
+  },
+  "keywords": [
+    "lytjs",
+    "fetch",
+    "ajax",
+    "cache",
+    "interceptor"
+  ]
+}