@kevisual/query 0.0.2 → 0.0.4

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { adapter } from './adapter.ts';
+export { QueryWs } from './ws.ts';
 type Fn = (opts: {
     url?: string;
     headers?: Record<string, string>;
@@ -15,20 +16,37 @@ type QueryOpts = {
 type Data = {
     path?: string;
     key?: string;
+    payload?: Record<string, any>;
     [key: string]: any;
 };
+type Result<S = any> = {
+    code: number;
+    data?: S;
+    message?: string;
+    success: boolean;
+};
 type DataOpts = Partial<QueryOpts> & {
     beforeRequest?: Fn;
+    afterResponse?: (result: Result) => Promise<any>;
 };
-export declare class Query {
+/**
+ * const query = new Query();
+ * const res = await query.post({
+ *   path: 'demo',
+ *   key: '1',
+ *  });
+ */
+export declare class Query<U = any, V = any> {
     adapter: typeof adapter;
     url: string;
     beforeRequest?: Fn;
+    afterResponse?: (result: Result) => Promise<any>;
     headers?: Record<string, string>;
     timeout?: number;
-    constructor(opts: QueryOpts);
-    get<T>(params: Record<string, any> & Data & T, options?: DataOpts): Promise<any>;
-    post<T>(body: Record<string, any> & Data & T, options?: DataOpts): Promise<any>;
+    constructor(opts?: QueryOpts);
+    get<T = any, S = any>(params: Record<string, any> & Data & U & T, options?: DataOpts): Promise<Result<V & S>>;
+    post<T = any, S = any>(body: Record<string, any> & Data & T, options?: DataOpts): Promise<Result<S>>;
     before(fn: Fn): void;
+    after(fn: (result: Result) => Promise<any>): void;
 }
 export { adapter };

package/dist/index.js

@@ -39,19 +39,194 @@ const adapter = async (opts) => {
     });
 };
 
+const createStoreImpl = (createState) => {
+  let state;
+  const listeners = /* @__PURE__ */ new Set();
+  const setState = (partial, replace) => {
+    const nextState = typeof partial === "function" ? partial(state) : partial;
+    if (!Object.is(nextState, state)) {
+      const previousState = state;
+      state = (replace != null ? replace : typeof nextState !== "object" || nextState === null) ? nextState : Object.assign({}, state, nextState);
+      listeners.forEach((listener) => listener(state, previousState));
+    }
+  };
+  const getState = () => state;
+  const getInitialState = () => initialState;
+  const subscribe = (listener) => {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+  };
+  const destroy = () => {
+    if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production") {
+      console.warn(
+        "[DEPRECATED] The `destroy` method will be unsupported in a future version. Instead use unsubscribe function returned by subscribe. Everything will be garbage-collected if store is garbage-collected."
+      );
+    }
+    listeners.clear();
+  };
+  const api = { setState, getState, getInitialState, subscribe, destroy };
+  const initialState = state = createState(setState, getState, api);
+  return api;
+};
+const createStore = (createState) => createState ? createStoreImpl(createState) : createStoreImpl;
+
+const parseWsUrl = (url) => {
+    try {
+        new URL(url);
+        return url;
+    }
+    catch (e) {
+        const _url = new URL(url, location.origin);
+        if (_url.protocol === 'http:') {
+            _url.protocol = 'ws:';
+        }
+        if (_url.protocol === 'https:') {
+            _url.protocol = 'wss:';
+        }
+        return _url.href;
+    }
+};
+
+class QueryWs {
+    url;
+    store;
+    ws;
+    constructor(opts) {
+        const url = opts?.url || '/api/router';
+        if (opts?.store) {
+            this.store = opts.store;
+        }
+        else {
+            const store = createStore((set) => ({
+                connected: false,
+                status: 'connecting',
+                setConnected: (connected) => set({ connected }),
+                setStatus: (status) => set({ status }),
+            }));
+            this.store = store;
+        }
+        const wsUrl = parseWsUrl(url);
+        if (opts?.ws && opts.ws instanceof WebSocket) {
+            this.ws = opts.ws;
+        }
+        else {
+            this.ws = new WebSocket(wsUrl);
+        }
+        this.connect();
+    }
+    /**
+     * 连接 WebSocket
+     */
+    connect() {
+        const store = this.store;
+        const connected = store.getState().connected;
+        if (connected) {
+            return;
+        }
+        const ws = this.ws || new WebSocket(this.url);
+        ws.onopen = () => {
+            store.getState().setConnected(true);
+            store.getState().setStatus('connected');
+        };
+        ws.onclose = () => {
+            store.getState().setConnected(false);
+            this.ws = null;
+        };
+    }
+    listenConnect(callback) {
+        const store = this.store;
+        const { connected } = store.getState();
+        if (connected) {
+            callback();
+            return;
+        }
+        const subscriptionOne = (selector, listener) => {
+            const unsubscribe = store.subscribe((newState, oldState) => {
+                if (selector(newState) !== selector(oldState)) {
+                    listener(newState, oldState);
+                    unsubscribe();
+                }
+            });
+            return unsubscribe;
+        };
+        const cancel = subscriptionOne((state) => state.connected, () => {
+            callback();
+        });
+        return cancel;
+    }
+    onMessage(fn, opts) {
+        const ws = this.ws;
+        const isJson = opts?.isJson ?? true;
+        const selector = opts?.selector;
+        const parseIfJson = (data) => {
+            try {
+                return JSON.parse(data);
+            }
+            catch (e) {
+                return data;
+            }
+        };
+        const listener = (event) => {
+            const received = parseIfJson(event.data);
+            if (typeof received === 'string' && !isJson) {
+                fn(received, event);
+            }
+            else if (typeof received === 'object' && isJson) {
+                fn(selector ? selector(received) : received, event);
+            }
+            else ;
+        };
+        ws.addEventListener('message', listener);
+        return () => {
+            ws.removeEventListener('message', listener);
+        };
+    }
+    close() {
+        const ws = this.ws;
+        const store = this.store;
+        ws?.close?.();
+        this.ws = null;
+        store.getState().setConnected(false);
+        store.getState().setStatus('disconnected');
+    }
+    send(data, opts) {
+        const ws = this.ws;
+        const isJson = opts?.isJson ?? true;
+        const wrapper = opts?.wrapper;
+        if (!ws || ws.readyState !== WebSocket.OPEN) {
+            console.error('WebSocket is not open');
+            return;
+        }
+        if (isJson) {
+            ws.send(JSON.stringify(wrapper ? wrapper(data) : data));
+        }
+        else {
+            ws.send(data);
+        }
+    }
+}
+
+/**
+ * const query = new Query();
+ * const res = await query.post({
+ *   path: 'demo',
+ *   key: '1',
+ *  });
+ */
 class Query {
     adapter;
     url;
     beforeRequest;
+    afterResponse;
     headers;
     timeout;
     constructor(opts) {
-        this.adapter = opts.adapter || adapter;
-        this.url = opts.url || '/api/router';
-        this.headers = opts.headers || {
+        this.adapter = opts?.adapter || adapter;
+        this.url = opts?.url || '/api/router';
+        this.headers = opts?.headers || {
             'Content-Type': 'application/json',
         };
-        this.timeout = opts.timeout || 60000; // 默认超时时间为 60s
+        this.timeout = opts?.timeout || 60000; // 默认超时时间为 60s
     }
     async get(params, options) {
         return this.post(params, options);
@@ -71,11 +246,20 @@ class Query {
         if (beforeRequest) {
             await beforeRequest(req);
         }
-        return adapter(req);
+        return adapter(req).then(async (res) => {
+            res.success = res.code === 200;
+            if (options?.afterResponse) {
+                return await options.afterResponse(res);
+            }
+            return res;
+        });
     }
     before(fn) {
         this.beforeRequest = fn;
     }
+    after(fn) {
+        this.afterResponse = fn;
+    }
 }
 
-export { Query, adapter };
+export { Query, QueryWs, adapter };

package/dist/utils.d.ts

@@ -0,0 +1,2 @@
+export declare const parseUrl: (url: string) => string;
+export declare const parseWsUrl: (url: string) => string;

package/dist/ws.d.ts

@@ -0,0 +1,43 @@
+import { StoreApi } from 'zustand/vanilla';
+type QueryWsStore = {
+    connected: boolean;
+    status: 'connecting' | 'connected' | 'disconnected';
+    setConnected: (connected: boolean) => void;
+    setStatus: (status: QuerySelectState) => void;
+};
+export type QuerySelectState = 'connecting' | 'connected' | 'disconnected';
+export type QueryWsStoreListener = (newState: QueryWsStore, oldState: QueryWsStore) => void;
+type QueryWsOpts = {
+    url?: string;
+    store?: StoreApi<QueryWsStore>;
+    ws?: WebSocket;
+};
+export type WsSend<T = any, U = any> = (data: T, opts?: {
+    isJson?: boolean;
+    wrapper?: (data: T) => U;
+}) => any;
+export type WsOnMessage<T = any, U = any> = (fn: (data: U, event: MessageEvent) => void, opts?: {
+    isJson?: boolean;
+    selector?: (data: T) => U;
+}) => any;
+export declare class QueryWs {
+    url: string;
+    store: StoreApi<QueryWsStore>;
+    ws: WebSocket;
+    constructor(opts?: QueryWsOpts);
+    /**
+     * 连接 WebSocket
+     */
+    connect(): void;
+    listenConnect(callback: () => void): () => void;
+    onMessage<T = any, U = any>(fn: (data: U, event: MessageEvent) => void, opts?: {
+        isJson?: boolean;
+        selector?: (data: T) => U;
+    }): () => void;
+    close(): void;
+    send<T = any, U = any>(data: T, opts?: {
+        isJson?: boolean;
+        wrapper?: (data: T) => U;
+    }): void;
+}
+export {};

package/dist/ws.js

@@ -0,0 +1,168 @@
+const createStoreImpl = (createState) => {
+  let state;
+  const listeners = /* @__PURE__ */ new Set();
+  const setState = (partial, replace) => {
+    const nextState = typeof partial === "function" ? partial(state) : partial;
+    if (!Object.is(nextState, state)) {
+      const previousState = state;
+      state = (replace != null ? replace : typeof nextState !== "object" || nextState === null) ? nextState : Object.assign({}, state, nextState);
+      listeners.forEach((listener) => listener(state, previousState));
+    }
+  };
+  const getState = () => state;
+  const getInitialState = () => initialState;
+  const subscribe = (listener) => {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+  };
+  const destroy = () => {
+    if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production") {
+      console.warn(
+        "[DEPRECATED] The `destroy` method will be unsupported in a future version. Instead use unsubscribe function returned by subscribe. Everything will be garbage-collected if store is garbage-collected."
+      );
+    }
+    listeners.clear();
+  };
+  const api = { setState, getState, getInitialState, subscribe, destroy };
+  const initialState = state = createState(setState, getState, api);
+  return api;
+};
+const createStore = (createState) => createState ? createStoreImpl(createState) : createStoreImpl;
+
+const parseWsUrl = (url) => {
+    try {
+        new URL(url);
+        return url;
+    }
+    catch (e) {
+        const _url = new URL(url, location.origin);
+        if (_url.protocol === 'http:') {
+            _url.protocol = 'ws:';
+        }
+        if (_url.protocol === 'https:') {
+            _url.protocol = 'wss:';
+        }
+        return _url.href;
+    }
+};
+
+class QueryWs {
+    url;
+    store;
+    ws;
+    constructor(opts) {
+        const url = opts?.url || '/api/router';
+        if (opts?.store) {
+            this.store = opts.store;
+        }
+        else {
+            const store = createStore((set) => ({
+                connected: false,
+                status: 'connecting',
+                setConnected: (connected) => set({ connected }),
+                setStatus: (status) => set({ status }),
+            }));
+            this.store = store;
+        }
+        const wsUrl = parseWsUrl(url);
+        if (opts?.ws && opts.ws instanceof WebSocket) {
+            this.ws = opts.ws;
+        }
+        else {
+            this.ws = new WebSocket(wsUrl);
+        }
+        this.connect();
+    }
+    /**
+     * 连接 WebSocket
+     */
+    connect() {
+        const store = this.store;
+        const connected = store.getState().connected;
+        if (connected) {
+            return;
+        }
+        const ws = this.ws || new WebSocket(this.url);
+        ws.onopen = () => {
+            store.getState().setConnected(true);
+            store.getState().setStatus('connected');
+        };
+        ws.onclose = () => {
+            store.getState().setConnected(false);
+            this.ws = null;
+        };
+    }
+    listenConnect(callback) {
+        const store = this.store;
+        const { connected } = store.getState();
+        if (connected) {
+            callback();
+            return;
+        }
+        const subscriptionOne = (selector, listener) => {
+            const unsubscribe = store.subscribe((newState, oldState) => {
+                if (selector(newState) !== selector(oldState)) {
+                    listener(newState, oldState);
+                    unsubscribe();
+                }
+            });
+            return unsubscribe;
+        };
+        const cancel = subscriptionOne((state) => state.connected, () => {
+            callback();
+        });
+        return cancel;
+    }
+    onMessage(fn, opts) {
+        const ws = this.ws;
+        const isJson = opts?.isJson ?? true;
+        const selector = opts?.selector;
+        const parseIfJson = (data) => {
+            try {
+                return JSON.parse(data);
+            }
+            catch (e) {
+                return data;
+            }
+        };
+        const listener = (event) => {
+            const received = parseIfJson(event.data);
+            if (typeof received === 'string' && !isJson) {
+                fn(received, event);
+            }
+            else if (typeof received === 'object' && isJson) {
+                fn(selector ? selector(received) : received, event);
+            }
+            else ;
+        };
+        ws.addEventListener('message', listener);
+        return () => {
+            ws.removeEventListener('message', listener);
+        };
+    }
+    close() {
+        const ws = this.ws;
+        const store = this.store;
+        ws?.close?.();
+        this.ws = null;
+        store.getState().setConnected(false);
+        store.getState().setStatus('disconnected');
+    }
+    send(data, opts) {
+        const ws = this.ws;
+        const isJson = opts?.isJson ?? true;
+        const wrapper = opts?.wrapper;
+        if (!ws || ws.readyState !== WebSocket.OPEN) {
+            console.error('WebSocket is not open');
+            return;
+        }
+        if (isJson) {
+            ws.send(JSON.stringify(wrapper ? wrapper(data) : data));
+        }
+        else {
+            ws.send(data);
+        }
+    }
+}
+
+export { QueryWs };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kevisual/query",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "main": "dist/index.js",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -21,17 +21,28 @@
   "devDependencies": {
     "@rollup/plugin-node-resolve": "^15.2.3",
     "@rollup/plugin-typescript": "^11.1.6",
-    "@types/jest": "^29.5.12",
-    "jest": "^29.7.0",
-    "jest-config": "^29.7.0",
     "rollup": "^4.21.2",
-    "ts-jest": "^29.2.5",
     "ts-node": "^10.9.2",
     "tslib": "^2.7.0",
+    "zustand": "^4.5.5",
     "typescript": "^5.5.4"
   },
   "packageManager": "yarn@1.22.19+sha1.4ba7fc5c6e704fce2066ecbfb0b0d8976fe62447",
   "publishConfig": {
     "access": "public"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    },
+    "./node": {
+      "import": "./dist/node-adapter.js",
+      "require": "./dist/node-adapter.js"
+    },
+    "./ws": {
+      "import": "./dist/ws.js",
+      "require": "./dist/ws.js"
+    }
   }
-}
+}