@kevisual/query 0.0.40 → 0.0.42

package/dist/query-adapter.js

@@ -1,131 +1,114 @@
-const methods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS', 'HEAD'];
-const isTextForContentType = (contentType) => {
-    if (!contentType)
-        return false;
-    const textTypes = ['text/', 'xml', 'html', 'javascript', 'css', 'csv', 'plain', 'x-www-form-urlencoded', 'md'];
-    return textTypes.some((type) => contentType.includes(type));
+// src/adapter.ts
+var methods = ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD"];
+var isTextForContentType = (contentType) => {
+  if (!contentType)
+    return false;
+  const textTypes = ["text/", "xml", "html", "javascript", "css", "csv", "plain", "x-www-form-urlencoded", "md"];
+  return textTypes.some((type) => contentType.includes(type));
 };
-/**
- *
- * @param opts
- * @param overloadOpts 覆盖fetch的默认配置
- * @returns
- */
-const adapter = async (opts = {}, overloadOpts) => {
-    const controller = new AbortController();
-    const signal = controller.signal;
-    const isPostFile = opts.isPostFile || false; // 是否为文件上传
-    let responseType = opts.responseType || 'json'; // 响应类型
-    if (opts.isBlob) {
-        responseType = 'blob';
-    }
-    else if (opts.isText) {
-        responseType = 'text';
-    }
-    const timeout = opts.timeout || 60000 * 3; // 默认超时时间为 60s * 3
-    const timer = setTimeout(() => {
-        controller.abort();
-    }, timeout);
-    let method = overloadOpts?.method || opts?.method || 'POST';
-    let headers = { ...opts?.headers, ...overloadOpts?.headers };
-    let origin = '';
-    let url;
-    if (opts?.url?.startsWith('http')) {
-        url = new URL(opts.url);
-    }
-    else {
-        origin = window?.location?.origin || 'http://localhost:51515';
-        url = new URL(opts?.url || '', origin);
-    }
-    const isGet = method === 'GET';
-    const oldSearchParams = url.searchParams;
-    if (isGet) {
-        let searchParams = new URLSearchParams({ ...Object.fromEntries(oldSearchParams), ...opts?.params, ...opts?.body });
-        url.search = searchParams.toString();
-    }
-    else {
-        const params = {
-            ...Object.fromEntries(oldSearchParams),
-            ...opts.params,
-        };
-        const searchParams = new URLSearchParams(params);
-        if (typeof opts.body === 'object' && opts.body !== null) {
-            // 浏览器环境下，自动将 body 中的 path 和 key 提取到查询参数中, 更容易排查问题
-            let body = opts.body || {};
-            if (!params.path && body?.path) {
-                searchParams.set('path', body.path);
-                if (body?.key) {
-                    searchParams.set('key', body.key);
-                }
-            }
+var adapter = async (opts = {}, overloadOpts) => {
+  const controller = new AbortController;
+  const signal = controller.signal;
+  const isPostFile = opts.isPostFile || false;
+  let responseType = opts.responseType || "json";
+  if (opts.isBlob) {
+    responseType = "blob";
+  } else if (opts.isText) {
+    responseType = "text";
+  }
+  const timeout = opts.timeout || 60000 * 3;
+  const timer = setTimeout(() => {
+    controller.abort();
+  }, timeout);
+  let method = overloadOpts?.method || opts?.method || "POST";
+  let headers = { ...opts?.headers, ...overloadOpts?.headers };
+  let origin = "";
+  let url;
+  if (opts?.url?.startsWith("http")) {
+    url = new URL(opts.url);
+  } else {
+    origin = globalThis?.location?.origin || "http://localhost:51515";
+    url = new URL(opts?.url || "", origin);
+  }
+  const isGet = method === "GET";
+  const oldSearchParams = url.searchParams;
+  if (isGet) {
+    let searchParams = new URLSearchParams({ ...Object.fromEntries(oldSearchParams), ...opts?.params, ...opts?.body });
+    url.search = searchParams.toString();
+  } else {
+    const params = {
+      ...Object.fromEntries(oldSearchParams),
+      ...opts.params
+    };
+    const searchParams = new URLSearchParams(params);
+    if (typeof opts.body === "object" && opts.body !== null) {
+      let body2 = opts.body || {};
+      if (!params.path && body2?.path) {
+        searchParams.set("path", body2.path);
+        if (body2?.key) {
+          searchParams.set("key", body2.key);
         }
-        url.search = searchParams.toString();
+      }
     }
-    let body = undefined;
-    if (isGet) {
-        body = undefined;
+    url.search = searchParams.toString();
+  }
+  let body = undefined;
+  if (isGet) {
+    body = undefined;
+  } else if (isPostFile) {
+    body = opts.body;
+  } else {
+    if (opts.body && typeof opts.body === "object" && !(opts.body instanceof FormData)) {
+      headers = {
+        "Content-Type": "application/json",
+        ...headers
+      };
+      body = JSON.stringify(opts.body);
     }
-    else if (isPostFile) {
-        body = opts.body; // 如果是文件上传，直接使用 FormData
+  }
+  return fetch(url, {
+    method: method.toUpperCase(),
+    signal,
+    body,
+    ...overloadOpts,
+    headers
+  }).then(async (response) => {
+    const contentType = response.headers.get("Content-Type");
+    if (responseType === "blob") {
+      return await response.blob();
     }
-    else {
-        if (opts.body && typeof opts.body === 'object' && !(opts.body instanceof FormData)) {
-            headers = {
-                'Content-Type': 'application/json',
-                ...headers,
-            };
-            body = JSON.stringify(opts.body); // 否则将对象转换为 JSON 字符串
-        }
+    const isText = responseType === "text";
+    const isJson = contentType && contentType.includes("application/json");
+    if (isJson && !isText) {
+      return await response.json();
+    } else if (isTextForContentType(contentType)) {
+      return {
+        code: response.status,
+        status: response.status,
+        data: await response.text()
+      };
+    } else {
+      return response;
     }
-    return fetch(url, {
-        method: method.toUpperCase(),
-        signal,
-        body: body,
-        ...overloadOpts,
-        headers: headers,
-    })
-        .then(async (response) => {
-        // 获取 Content-Type 头部信息
-        const contentType = response.headers.get('Content-Type');
-        if (responseType === 'blob') {
-            return await response.blob(); // 直接返回 Blob 对象
-        }
-        const isText = responseType === 'text';
-        const isJson = contentType && contentType.includes('application/json');
-        // 判断返回的数据类型
-        if (isJson && !isText) {
-            return await response.json(); // 解析为 JSON
-        }
-        else if (isTextForContentType(contentType)) {
-            return {
-                code: response.status,
-                status: response.status,
-                data: await response.text(), // 直接返回文本内容
-            };
-        }
-        else {
-            return response;
-        }
-    })
-        .catch((err) => {
-        if (err.name === 'AbortError') {
-            return {
-                code: 408,
-                message: '请求超时',
-            };
-        }
-        return {
-            code: 500,
-            message: err.message || '网络错误',
-        };
-    })
-        .finally(() => {
-        clearTimeout(timer);
-    });
+  }).catch((err) => {
+    if (err.name === "AbortError") {
+      return {
+        code: 408,
+        message: "请求超时"
+      };
+    }
+    return {
+      code: 500,
+      message: err.message || "网络错误"
+    };
+  }).finally(() => {
+    clearTimeout(timer);
+  });
+};
+var queryFetch = adapter;
+export {
+  queryFetch,
+  methods,
+  isTextForContentType,
+  adapter
 };
-/**
- * adapter
- */
-const queryFetch = adapter;
-
-export { adapter, isTextForContentType, methods, queryFetch };

package/dist/query-api.d.ts

@@ -0,0 +1,317 @@
+import { StoreApi } from 'zustand/vanilla';
+import { z } from 'zod';
+
+declare const methods: readonly ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD"];
+type Method = (typeof methods)[number];
+type AdapterOpts = {
+    url?: string;
+    headers?: Record<string, string>;
+    /**
+     * 只用户POST请求，传递的查询参数，
+     * GET请求默认方body自己转化为查询参数
+     */
+    params?: Record<string, any>;
+    body?: Record<string, any> | FormData;
+    timeout?: number;
+    method?: Method;
+    /**
+     * @deprecated use responseType
+     */
+    isBlob?: boolean;
+    /**
+     * @deprecated use responseType
+     */
+    isText?: boolean;
+    /**
+     * 响应类型,
+     * */
+    responseType?: 'json' | 'text' | 'blob';
+    isPostFile?: boolean;
+};
+/**
+ *
+ * @param opts
+ * @param overloadOpts 覆盖fetch的默认配置
+ * @returns
+ */
+declare const adapter: (opts?: AdapterOpts, overloadOpts?: RequestInit) => Promise<any>;
+
+type QueryWsStore = {
+    connected: boolean;
+    status: 'connecting' | 'connected' | 'disconnected';
+    setConnected: (connected: boolean) => void;
+    setStatus: (status: QuerySelectState) => void;
+};
+type QuerySelectState = 'connecting' | 'connected' | 'disconnected';
+type QueryWsOpts = {
+    url?: string;
+    store?: StoreApi<QueryWsStore>;
+    ws?: WebSocket;
+};
+declare class QueryWs {
+    url: string;
+    store: StoreApi<QueryWsStore>;
+    ws: WebSocket;
+    constructor(opts?: QueryWsOpts);
+    /**
+     * 连接 WebSocket
+     */
+    connect(opts?: {
+        timeout?: number;
+    }): Promise<unknown>;
+    /**
+     * ws.onopen 必须用这个去获取，否者会丢失链接信息
+     * @param callback
+     * @returns
+     */
+    listenConnect(callback: () => void): () => void;
+    listenClose(callback: () => void): () => void;
+    onMessage<T = any, U = any>(fn: (data: U, event: MessageEvent) => void, opts?: {
+        /**
+         * 是否将数据转换为 JSON
+         */
+        isJson?: boolean;
+        /**
+         * 选择器
+         */
+        selector?: (data: T) => U;
+    }): () => void;
+    close(): void;
+    /**
+     * 发送消息
+     *
+     * @param data
+     * @param opts
+     * @returns
+     */
+    send<T = any, U = any>(data: T, opts?: {
+        /**
+         * 是否将数据转换为 JSON
+         */
+        isJson?: boolean;
+        /**
+         * 包装数据
+         */
+        wrapper?: (data: T) => U;
+    }): void;
+    getOpen(): boolean;
+}
+
+/**
+ * 请求前处理函数
+ * @param opts 请求配置
+ * @returns 请求配置
+ */
+type Fn = (opts: {
+    url?: string;
+    headers?: Record<string, string>;
+    body?: Record<string, any>;
+    [key: string]: any;
+    timeout?: number;
+}) => Promise<Record<string, any> | false>;
+type QueryOpts = {
+    adapter?: typeof adapter;
+    [key: string]: any;
+} & AdapterOpts;
+type QueryOptions = {
+    url?: string;
+    adapter?: typeof adapter;
+    headers?: Record<string, string>;
+    timeout?: number;
+    isClient?: boolean;
+    beforeRequest?: Fn;
+};
+type Data = {
+    path?: string;
+    key?: string;
+    payload?: Record<string, any>;
+    [key: string]: any;
+};
+type Result<S = any, U = {}> = {
+    code: number;
+    data?: S;
+    message?: string;
+} & U;
+type DataOpts = Partial<QueryOpts> & {
+    beforeRequest?: Fn;
+    afterResponse?: <S = any>(result: Result<S>, ctx?: {
+        req?: any;
+        res?: any;
+        fetch?: any;
+    }) => Promise<Result<S>>;
+    /**
+     * 是否在stop的时候不请求
+     */
+    noStop?: boolean;
+};
+/**
+ * const query = new Query();
+ * const res = await query.post({
+ *   path: 'demo',
+ *   key: '1',
+ *  });
+ *
+ * U是参数 V是返回值
+ */
+declare class Query {
+    adapter: typeof adapter;
+    url: string;
+    /**
+     * 请求前处理函数
+     */
+    beforeRequest?: DataOpts['beforeRequest'];
+    /**
+     *  请求后处理函数
+     */
+    afterResponse?: DataOpts['afterResponse'];
+    headers?: Record<string, string>;
+    timeout?: number;
+    /**
+     * 需要突然停止请求，比如401的时候
+     */
+    stop?: boolean;
+    qws: QueryWs;
+    /**
+     * 默认是 /client/router或者 默认是 /api/router
+     */
+    isClient: boolean;
+    constructor(opts?: QueryOptions);
+    setQueryWs(qws: QueryWs): void;
+    /**
+     * 突然停止请求
+     */
+    setStop(stop: boolean): void;
+    /**
+     * 发送 get 请求，转到 post 请求
+     *  T是请求类型自定义
+     *  S是返回类型自定义
+     * @param params 请求参数
+     * @param options 请求配置
+     * @returns 请求结果
+     */
+    get<R = any, P = any>(params: Data & P, options?: DataOpts): Promise<Result<R>>;
+    /**
+     * 发送 post 请求
+     *  T是请求类型自定义
+     *  S是返回类型自定义
+     * @param body 请求体
+     * @param options 请求配置
+     * @returns 请求结果
+     */
+    post<R = any, P = any>(body: Data & P, options?: DataOpts): Promise<Result<R>>;
+    /**
+     * 设置请求前处理，设置请求前处理函数
+     * @param fn 处理函数
+     */
+    before(fn: DataOpts['beforeRequest']): void;
+    /**
+     * 设置请求后处理，设置请求后处理函数
+     * @param fn 处理函数
+     */
+    after(fn: DataOpts['afterResponse']): void;
+    fetchText(urlOrOptions?: string | QueryOpts, options?: QueryOpts): Promise<Result<any>>;
+}
+
+type RouteInfo = {
+    path: string;
+    key: string;
+    id: string;
+    description?: string;
+    metadata?: {
+        summary?: string;
+        args?: Record<string, any>;
+        viewItem?: {
+            type?: string;
+            api?: {
+                query?: any;
+            };
+            worker?: {
+                worker?: any;
+            };
+            context?: {
+                router?: any;
+            };
+        };
+    };
+};
+declare const createQueryByRoutes: (list: RouteInfo[]) => string;
+
+type Pos = {
+    path?: string;
+    key?: string;
+    id?: string;
+    metadata?: {
+        args?: Record<string, any>;
+    };
+};
+type InferFromJSONSchema<T> = T extends {
+    type: "string";
+    enum: readonly (infer E)[];
+} ? E : T extends {
+    type: "string";
+    enum: (infer E)[];
+} ? E : T extends {
+    type: "string";
+} ? string : T extends {
+    type: "number";
+} ? number : T extends {
+    type: "integer";
+} ? number : T extends {
+    type: "boolean";
+} ? boolean : T extends {
+    type: "object";
+    properties: infer P;
+} ? {
+    [K in keyof P]: InferFromJSONSchema<P[K]>;
+} : T extends {
+    type: "array";
+    items: infer I;
+} ? Array<InferFromJSONSchema<I>> : unknown;
+type InferType<T> = T extends z.ZodType<infer U> ? U : T extends {
+    type: infer TType;
+} ? InferFromJSONSchema<T> : T;
+type ExtractArgsFromMetadata<T> = T extends {
+    metadata?: {
+        args?: infer A;
+    };
+} ? A extends Record<string, any> ? {
+    [K in keyof A]: InferType<A[K]>;
+} : never : never;
+type ApiMethods<P extends {
+    [path: string]: {
+        [key: string]: Pos;
+    };
+}> = {
+    [Path in keyof P]: {
+        [Key in keyof P[Path]]: (data?: Partial<ExtractArgsFromMetadata<P[Path][Key]>>, opts?: DataOpts) => ReturnType<Query['post']>;
+    };
+};
+type QueryApiOpts<P extends {
+    [path: string]: {
+        [key: string]: Pos;
+    };
+} = {}> = {
+    query?: Query;
+    api?: P;
+};
+declare class QueryApi<P extends {
+    [path: string]: {
+        [key: string]: Pos;
+    };
+} = {}> {
+    query: Query;
+    constructor(opts?: QueryApiOpts<P>);
+    post<T extends Pos>(pos: T, data?: Partial<ExtractArgsFromMetadata<T>>, opts?: DataOpts): Promise<{
+        code: number;
+        data?: any;
+        message?: string;
+    }>;
+    createApi(api: P): asserts this is this & ApiMethods<P>;
+}
+declare function createQueryApi<P extends {
+    [path: string]: {
+        [key: string]: Pos;
+    };
+}>(opts?: QueryApiOpts<P>): QueryApi<P> & ApiMethods<P>;
+
+export { QueryApi, createQueryApi, createQueryByRoutes };