listpage-next 0.0.2 → 0.0.4

package/dist/http-client/client/base_url.d.ts

@@ -0,0 +1,3 @@
+import { ClientOptions } from './types';
+export declare function setupBaseUrl(HttpClient: typeof import('./index').HttpClient): void;
+export declare function mergeServerConfig(server: ClientOptions['server']): ClientOptions['server'];

package/dist/http-client/client/base_url.js

@@ -0,0 +1,16 @@
+function setupBaseUrl(HttpClient) {
+    HttpClient.prototype.getBaseURL = function() {
+        const { server } = this.options;
+        return `${server?.protocol}//${server?.host}:${server?.port}${server?.publicPath}`;
+    };
+}
+function mergeServerConfig(server) {
+    if (server?.protocol && !server?.protocol?.endsWith(':')) server.protocol += ':';
+    return {
+        protocol: server?.protocol || location.protocol,
+        host: server?.host || location.hostname,
+        port: server?.port || location.port,
+        publicPath: server?.publicPath || '/api/v1'
+    };
+}
+export { mergeServerConfig, setupBaseUrl };

package/dist/http-client/client/client.d.ts

@@ -0,0 +1 @@
+export declare function setupClient(HttpClient: typeof import('./index').HttpClient): void;

package/dist/http-client/client/client.js

@@ -0,0 +1,107 @@
+import axios from "axios";
+import { notification } from "antd";
+function setupClient(HttpClient) {
+    HttpClient.prototype.createAxiosInstance = function() {
+        const { config } = this.options;
+        const baseURL = config?.baseURL || this.getBaseURL();
+        const headers = config?.headers || this.getHeaders();
+        return axios.create({
+            ...config,
+            baseURL: baseURL,
+            headers: headers
+        });
+    };
+    HttpClient.prototype.setup = function() {
+        const successCodes = this.options.successCodes || [
+            10000,
+            200
+        ];
+        const apiClient = this.createAxiosInstance();
+        apiClient.interceptors.request.use((config)=>{
+            config.headers.Authorization = `Bearer ${this.getToken()}`;
+            return config;
+        }, (error)=>{
+            console.error('Request Error:', error);
+            return Promise.reject(error);
+        });
+        apiClient.interceptors.response.use((response)=>{
+            if ('blob' === response.config.responseType) return response;
+            if (!successCodes.includes(response.data.code)) {
+                const error = {
+                    code: response.data.code,
+                    message: response.data.message,
+                    data: response.data.data
+                };
+                notification.error({
+                    message: error.code,
+                    description: error.message
+                });
+                return Promise.reject(error);
+            }
+            return response;
+        }, (error)=>{
+            console.error('Response Error:', error);
+            if (error.response) {
+                const apiError = {
+                    code: error.response.status,
+                    message: error.response.data?.message || error.message,
+                    data: error.response.data
+                };
+                return Promise.reject(apiError);
+            }
+            const networkError = {
+                code: 0,
+                message: '网络连接失败，请检查网络设置'
+            };
+            return Promise.reject(networkError);
+        });
+        this.client = apiClient;
+    };
+    HttpClient.prototype.post = function(url, data, config) {
+        const client = this.client;
+        return client.post(url, data, config);
+    };
+    HttpClient.prototype.get = function(url, config) {
+        const client = this.client;
+        return client.get(url, config);
+    };
+    HttpClient.prototype.patch = function(url, data, config) {
+        const client = this.client;
+        return client.patch(url, data, config);
+    };
+    HttpClient.prototype.delete = function(url, config) {
+        const client = this.client;
+        return client.delete(url, config);
+    };
+    HttpClient.prototype.download = async function(url, params, downloadOptions, config) {
+        let { filename, type } = downloadOptions || {};
+        const client = this.client;
+        const response = await client.post(url, params, {
+            ...config,
+            headers: {
+                Accept: type,
+                ...config?.headers
+            },
+            responseType: 'blob'
+        });
+        const blob = new Blob([
+            response.data
+        ], {
+            type
+        });
+        const downloadUrl = window.URL.createObjectURL(blob);
+        const link = document.createElement('a');
+        link.href = downloadUrl;
+        const contentDisposition = response.headers['content-disposition'];
+        if (contentDisposition) {
+            const filenameMatch = contentDisposition.match(/filename[^;=\n]*=((['"]).*?\2|[^;\n]*)/);
+            if (filenameMatch && filenameMatch[1]) filename = decodeURIComponent(filenameMatch[1].replace(/['"]/g, ''));
+        }
+        link.download = filename;
+        document.body.appendChild(link);
+        link.click();
+        document.body.removeChild(link);
+        window.URL.revokeObjectURL(url);
+    };
+}
+export { setupClient };

package/dist/http-client/client/headers.d.ts

@@ -0,0 +1 @@
+export declare function setupHeaders(HttpClient: typeof import('./index').HttpClient): void;

package/dist/http-client/client/headers.js

@@ -0,0 +1,8 @@
+function setupHeaders(HttpClient) {
+    HttpClient.prototype.getHeaders = function() {
+        return {
+            'Content-Type': 'application/json'
+        };
+    };
+}
+export { setupHeaders };

package/dist/http-client/client/index.d.ts

@@ -0,0 +1,22 @@
+import { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
+import { ClientOptions, IHttpClient } from './types';
+import { ApiResponse } from '../types';
+export declare class HttpClient implements IHttpClient {
+    options: ClientOptions;
+    client?: AxiosInstance;
+    constructor(options: ClientOptions);
+    getToken(): string;
+    setToken(token: string): void;
+    getBaseURL(): string;
+    getHeaders(): Record<string, string>;
+    createAxiosInstance(): AxiosInstance;
+    setup(): void;
+    get<T = any, D = any>(url: string, config?: AxiosRequestConfig<D>): Promise<AxiosResponse<ApiResponse<T>>>;
+    post<T = any, D = any>(url: string, data?: D, config?: AxiosRequestConfig<D>): Promise<AxiosResponse<ApiResponse<T>>>;
+    patch<T = any, D = any>(url: string, data?: D, config?: AxiosRequestConfig<D>): Promise<AxiosResponse<ApiResponse<T>>>;
+    delete<T = any, D = any>(url: string, config?: AxiosRequestConfig<D>): Promise<AxiosResponse<ApiResponse<T>>>;
+    download<D = any>(url: string, params?: D, downloadOptions?: {
+        filename?: string;
+        type?: string;
+    }, config?: AxiosRequestConfig<D>): Promise<void>;
+}

package/dist/http-client/client/index.js

@@ -0,0 +1,55 @@
+import { setupToken } from "./token.js";
+import { mergeServerConfig, setupBaseUrl } from "./base_url.js";
+import { setupHeaders } from "./headers.js";
+import { setupClient } from "./client.js";
+class HttpClient {
+    options;
+    client;
+    constructor(options){
+        const mergedOptions = {
+            ...options,
+            tokenKey: options.tokenKey || '__REQUEST_TOKEN__',
+            server: mergeServerConfig(options.server),
+            config: options.config || {}
+        };
+        this.options = mergedOptions;
+        setupToken(HttpClient);
+        setupBaseUrl(HttpClient);
+        setupHeaders(HttpClient);
+        setupClient(HttpClient);
+    }
+    getToken() {
+        throw new Error('Method should be implemented by setupToken');
+    }
+    setToken(token) {
+        throw new Error('Method should be implemented by setupToken');
+    }
+    getBaseURL() {
+        throw new Error('Method should be implemented by setupBaseUrl');
+    }
+    getHeaders() {
+        throw new Error('Method should be implemented by setupHeaders');
+    }
+    createAxiosInstance() {
+        throw new Error('Method should be implemented by setupClient');
+    }
+    setup() {
+        throw new Error('Method should be implemented by setupClient');
+    }
+    get(url, config) {
+        throw new Error('Method should be implemented by setupClient');
+    }
+    post(url, data, config) {
+        throw new Error('Method should be implemented by setupClient');
+    }
+    patch(url, data, config) {
+        throw new Error('Method should be implemented by setupClient');
+    }
+    delete(url, config) {
+        throw new Error('Method should be implemented by setupClient');
+    }
+    download(url, params, downloadOptions, config) {
+        throw new Error('Method should be implemented by setupClient');
+    }
+}
+export { HttpClient };

package/dist/http-client/client/token.d.ts

@@ -0,0 +1 @@
+export declare function setupToken(HttpClient: typeof import('./index').HttpClient): void;

package/dist/http-client/client/token.js

@@ -0,0 +1,10 @@
+function setupToken(HttpClient) {
+    HttpClient.prototype.getToken = function() {
+        const API_TOKEN = localStorage.getItem(this.options.tokenKey);
+        return API_TOKEN || '';
+    };
+    HttpClient.prototype.setToken = function(token) {
+        localStorage.setItem(this.options.tokenKey, token);
+    };
+}
+export { setupToken };

package/dist/http-client/client/types.d.ts

@@ -0,0 +1,31 @@
+import { AxiosRequestConfig, AxiosInstance, AxiosResponse } from 'axios';
+import { ApiResponse } from '../types';
+export interface ClientOptions {
+    tokenKey?: string;
+    successCodes?: number[];
+    server?: {
+        protocol?: string;
+        host?: string;
+        port?: string;
+        publicPath?: string;
+    };
+    config?: AxiosRequestConfig;
+}
+export interface IHttpClient {
+    options: ClientOptions;
+    client?: AxiosInstance;
+    getToken(): string;
+    setToken(token: string): void;
+    getBaseURL(): string;
+    getHeaders(): Record<string, string>;
+    createAxiosInstance(): AxiosInstance;
+    setup(): void;
+    get<T = any, D = any>(url: string, config?: AxiosRequestConfig<D>): Promise<AxiosResponse<ApiResponse<T>>>;
+    post<T = any, D = any>(url: string, data?: D, config?: AxiosRequestConfig<D>): Promise<AxiosResponse<ApiResponse<T>>>;
+    patch<T = any, D = any>(url: string, data?: D, config?: AxiosRequestConfig<D>): Promise<AxiosResponse<ApiResponse<T>>>;
+    delete<T = any, D = any>(url: string, config?: AxiosRequestConfig<D>): Promise<AxiosResponse<ApiResponse<T>>>;
+    download<D = any>(url: string, params?: D, downloadOptions?: {
+        filename?: string;
+        type?: string;
+    }, config?: AxiosRequestConfig<D>): Promise<void>;
+}

package/dist/http-client/index.d.ts

@@ -0,0 +1,3 @@
+export { HttpClient } from './client';
+export type { ClientOptions } from './client/types';
+export type { ApiResponse, ApiError, PaginationData, PaginatedResponse, BaseQueryParams, } from './types';

package/dist/http-client/index.js

@@ -0,0 +1,2 @@
+import { HttpClient } from "./client/index.js";
+export { HttpClient };

package/dist/http-client/types.d.ts

@@ -0,0 +1,23 @@
+export interface ApiResponse<T = any> {
+    code: number;
+    message: string;
+    data?: T;
+}
+export interface ApiError {
+    code: number;
+    message: string;
+    data?: any;
+}
+export interface PaginationData<T> {
+    total: number;
+    pageSize: number;
+    current: number;
+    list: T[];
+}
+export interface PaginatedResponse<T> extends ApiResponse<PaginationData<T>> {
+}
+export interface BaseQueryParams {
+    current?: number;
+    pageSize?: number;
+    sort?: string;
+}

package/dist/index.d.ts

@@ -1,2 +1,3 @@
 import '@ant-design/v5-patch-for-react-19';
-export { FilterForm } from './components/FilterGroup';
+export * from './components/FilterGroup';
+export * from './http-client';

package/dist/index.js

@@ -1,3 +1,3 @@
 import "@ant-design/v5-patch-for-react-19";
-import { FilterForm } from "./components/FilterGroup/index.js";
-export { FilterForm };
+export * from "./components/FilterGroup/index.js";
+export * from "./http-client/index.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "listpage-next",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "A React component library for creating filter forms with Ant Design",
   "type": "module",
   "main": "./dist/index.js",
@@ -31,10 +31,12 @@
     "prepublishOnly": "npm run build"
   },
   "devDependencies": {
+    "@ant-design/v5-patch-for-react-19": "^1.0.3",
     "@rsbuild/core": "^1.5.7",
     "@rsbuild/plugin-react": "^1.4.0",
     "@rslib/core": "^0.13.3",
     "@storybook/addon-essentials": "^8.6.14",
+    "@storybook/test": "^8.6.14",
     "@types/lodash": "^4.17.20",
     "@types/react": "^19.1.13",
     "@types/styled-components": "^5.1.34",
@@ -43,8 +45,6 @@
     "storybook": "^8.6.14",
     "storybook-addon-rslib": "^1.0.3",
     "storybook-react-rsbuild": "^1.0.3",
-    "@storybook/test": "^8.6.14",
-    "@ant-design/v5-patch-for-react-19": "^1.0.3",
     "typescript": "^5.9.2"
   },
   "peerDependencies": {
@@ -54,6 +54,7 @@
   "dependencies": {
     "ahooks": "^3.9.5",
     "antd": "^5.27.3",
+    "axios": "^1.12.2",
     "dayjs": "^1.11.18",
     "lodash": "^4.17.21",
     "styled-components": "^6.1.19"