@vef-framework/core 1.0.97 → 1.0.99

package/es/api/api-client.js

@@ -1,3 +1,544 @@
-/*! VefFramework version: 1.0.97, build time: 2025-03-06T12:24:36.461Z, made by Venus. */
-import{useQuery as e,keepPreviousData as t,useSuspenseQuery as i,useMutation as s,useIsFetching as r,useIsMutating as a,QueryClientProvider as n}from"@tanstack/react-query";import{createElement as u}from"react";import{createQueryClient as c}from"./query-client.js";import{createRequestClient as h}from"./request-client.js";var o,l,y,d,p,g,Q,f,v,A=Object.defineProperty,__typeError=e=>{throw TypeError(e)},__publicField=(e,t,i)=>((e,t,i)=>t in e?A(e,t,{enumerable:!0,configurable:!0,writable:!0,value:i}):e[t]=i)(e,"symbol"!=typeof t?t+"":t,i),__accessCheck=(e,t,i)=>t.has(e)||__typeError("Cannot "+i),__privateGet=(e,t,i)=>(__accessCheck(e,t,"read from private field"),i?i.call(e):t.get(e)),__privateAdd=(e,t,i)=>t.has(e)?__typeError("Cannot add the same private member more than once"):t instanceof WeakSet?t.add(e):t.set(e,i),__privateSet=(e,t,i,s)=>(__accessCheck(e,t,"write to private field"),s?s.call(e,i):t.set(e,i),i),__privateMethod=(e,t,i)=>(__accessCheck(e,t,"access private method"),i);class ApiClient{constructor(v){this.options=v,__privateAdd(this,p),__publicField(this,"useApiQuery"),__publicField(this,"useSuspenseApiQuery"),__publicField(this,"useApiMutation"),__publicField(this,"useIsFetching"),__publicField(this,"useIsMutating"),__publicField(this,"QueryClientProvider"),__privateAdd(this,o),__privateAdd(this,l),__privateAdd(this,y),__privateAdd(this,d),__privateSet(this,o,c(v)),__privateSet(this,l,h(v)),__privateSet(this,y,{get:async(e,t)=>{const i=__privateGet(this,d);return __privateSet(this,d,void 0),await __privateGet(this,l).get(e,{...t,signal:i})},post:async(e,t,i)=>{const s=__privateGet(this,d);return __privateSet(this,d,void 0),await __privateGet(this,l).post(e,t,{...i,signal:s})},put:async(e,t,i)=>{const s=__privateGet(this,d);return __privateSet(this,d,void 0),await __privateGet(this,l).put(e,t,{...i,signal:s})},delete:async(e,t)=>{const i=__privateGet(this,d);return __privateSet(this,d,void 0),await __privateGet(this,l).delete(e,{...t,signal:i})}});const A=this;this.useApiQuery=function useApiQuery(i,s,r){var a;const{keepPreviousData:n,placeholderData:u,initialData:c,...h}=r??{},o=e({queryKey:[i.key,s],queryFn:({signal:e})=>i(s,{signal:e}),select:__privateMethod(A,p,g),placeholderData:u??!0===n?t:void 0,initialData:c?{code:0,message:"ok",data:c}:void 0,...h});return __privateMethod(a=A,p,f).call(a,o)},this.useSuspenseApiQuery=function useSuspenseApiQuery(e,t,s){const{keepPreviousData:r,initialData:a,...n}=s??{},{data:u,refetch:c}=i({queryKey:[e.key,t],queryFn:({signal:i})=>e(t,{signal:i}),select:__privateMethod(A,p,g),initialData:a?{code:0,message:"ok",data:a}:void 0,...n});return{data:u,refetch:__privateMethod(this,p,Q).call(this,c)}},this.useApiMutation=function useApiMutation(e){const{isPending:t,isIdle:i,isError:r,isSuccess:a,error:n,data:u,mutateAsync:c}=s({mutationKey:[e.key],mutationFn:t=>e(t)});return{mutate:async e=>await c(e),isPending:t,isIdle:i,isError:r,isSuccess:a,message:u?.message,error:n??void 0,data:u?.data}},this.useIsFetching=function useIsFetching$1(e,t){return r({queryKey:arguments.length>1?[e,t]:[e],type:"active",exact:!1})>0},this.useIsMutating=function useIsMutating$1(e){return a({mutationKey:[e],exact:!1})>0},this.QueryClientProvider=function QueryClientProvider$1({children:e}){return u(n,{client:__privateGet(A,o)},e)}}async fetchApiQuery(e,t,i){const{initialData:s,...r}=i??{};return(await __privateGet(this,o).fetchQuery({queryKey:[e.key,t],queryFn:({signal:i})=>e(t,{signal:i}),initialData:s?{code:0,message:"ok",data:s}:void 0,...r})).data}createQueryApi(e,t){const i=__privateMethod(this,p,v).call(this,e,t);return i.useQuery=this.useApiQuery.bind(this,i),i.useSuspenseQuery=this.useSuspenseApiQuery.bind(this,i),i.fetchQuery=this.fetchApiQuery.bind(this,i),i.getQueryData=this.getApiQueryData.bind(this,e),i.getQueriesData=this.getApiQueriesData.bind(this,e),i.setQueryData=(t,i)=>this.setApiQueryData(t,e,i),i.ensureQueryData=this.ensureApiQueryData.bind(this,i),i.removeQueries=this.removeApiQueries.bind(this,e),i.invalidateQueries=this.invalidateApiQueries.bind(this,e),i.resetQueries=this.resetApiQueries.bind(this,e),i.refetchQueries=this.refetchApiQueries.bind(this,e),i.cancelQueries=this.cancelApiQueries.bind(this,e),i.isFetching=this.isFetching.bind(this,e),i.useIsFetching=this.useIsFetching.bind(void 0,e),Object.freeze(i)}createMutationApi(e,t,i=[]){const s=__privateMethod(this,p,v).call(this,e,t);return s.relatedQueries=Object.freeze(i),s.useMutation=this.useApiMutation.bind(this,s),s.refetchRelatedQueries=function refetchRelatedQueries(){return Promise.all(i.map((e=>e.refetchQueries())))},s.invalidateRelatedQueries=function invalidateRelatedQueries(){return Promise.all(i.map((e=>e.invalidateQueries())))},s.isMutating=this.isMutating.bind(this,e),s.useIsMutating=this.useIsMutating.bind(void 0,e),Object.freeze(s)}getApiQueryData(e,t){return __privateGet(this,o).getQueryData(arguments.length>1?[e,t]:[e])}getApiQueriesData(e,t){return __privateGet(this,o).getQueriesData({queryKey:arguments.length>1?[e,t]:[e],type:"active",exact:!1})}setApiQueryData(e,t,i){__privateGet(this,o).setQueryData(arguments.length>2?[t,i]:[t],e)}async ensureApiQueryData(e,t,i){const{initialData:s,...r}=i??{};return(await __privateGet(this,o).ensureQueryData({queryKey:[e.key,t],queryFn:({signal:i})=>e(t,{signal:i}),initialData:s?{code:0,message:"ok",data:s}:void 0,...r,revalidateIfStale:!0})).data}removeApiQueries(e,t){__privateGet(this,o).removeQueries({type:"all",exact:!1,queryKey:arguments.length>1?[e,t]:[e]})}invalidateApiQueries(e,t){return __privateGet(this,o).invalidateQueries({queryKey:arguments.length>1?[e,t]:[e],type:"all",exact:!1,stale:!1,refetchType:"active"},{throwOnError:!1,cancelRefetch:!1})}resetApiQueries(e,t){return __privateGet(this,o).resetQueries({queryKey:arguments.length>1?[e,t]:[e],type:"active",exact:!1},{cancelRefetch:!0,throwOnError:!1})}refetchApiQueries(e,t){return __privateGet(this,o).refetchQueries({queryKey:arguments.length>1?[e,t]:[e],type:"active",exact:!1},{throwOnError:!1,cancelRefetch:!1})}cancelApiQueries(e,t){return __privateGet(this,o).cancelQueries({queryKey:arguments.length>1?[e,t]:[e],type:"active",exact:!1},{revert:!0,silent:!0})}isFetching(e,t){return __privateGet(this,o).isFetching({queryKey:arguments.length>1?[e,t]:[e],type:"active",exact:!1})>0}isMutating(e){return __privateGet(this,o).isMutating({mutationKey:[e],exact:!1})>0}}function createApiClient(e){return Object.freeze(new ApiClient(e))}o=new WeakMap,l=new WeakMap,y=new WeakMap,d=new WeakMap,p=new WeakSet,g=function(e){return e.data},Q=function(e){return async t=>{const i=await e(t);return{isSuccess:i.isSuccess,isError:i.isError,error:i.error,data:i.data}}},f=function({isPending:e,isFetching:t,isLoading:i,isRefetching:s,isSuccess:r,isPlaceholderData:a,isError:n,isLoadingError:u,isRefetchError:c,isStale:h,error:o,data:l,refetch:y}){return{isPending:e,isSuccess:r,isError:n,isLoadingError:u,isRefetchError:c,isLoading:i,isFetching:t,isRefetching:s,isPlaceholderData:a,isStale:h,error:o??void 0,data:l,refetch:__privateMethod(this,p,Q).call(this,y)}},v=function(e,t){const i=t(__privateGet(this,y)),apiFn=async(e,t)=>(__privateSet(this,d,t?.signal),await i(e));return apiFn.key=e,apiFn};export{ApiClient,createApiClient};
+/*! VefFramework version: 1.0.99, build time: 2025-03-07T13:41:55.478Z, made by Venus. */
+import { useQuery, keepPreviousData, useSuspenseQuery, useMutation, useIsFetching, useIsMutating, QueryClientProvider } from '@tanstack/react-query';
+import { createElement } from 'react';
+import { createQueryClient } from './query-client.js';
+import { createRequestClient } from './request-client.js';
+
+var __defProp = Object.defineProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var _queryClient, _requestClient, _requestMethods, _currentSignal, _ApiClient_instances, selectData_fn, wrapRefetchFn_fn, createQueryResult_fn, createApi_fn;
+class ApiClient {
+  /**
+   * Create an API client.
+   *
+   * @param options - The options of the API client.
+   */
+  constructor(options) {
+    this.options = options;
+    __privateAdd(this, _ApiClient_instances);
+    /**
+     * The useApiQuery hook.
+     * These hook functions are doing this because React's Hooks cannot be used in class methods,
+     * and this approach can bypass the check.
+     */
+    __publicField(this, "useApiQuery");
+    /**
+     * The useSuspenseApiQuery hook.
+     */
+    __publicField(this, "useSuspenseApiQuery");
+    /**
+     * The useApiMutation hook.
+     * These hook functions are doing this because React's Hooks cannot be used in class methods,
+     * and this approach can bypass the check.
+     */
+    __publicField(this, "useApiMutation");
+    /**
+     * The useIsFetching hook.
+     */
+    __publicField(this, "useIsFetching");
+    /**
+     * The useIsMutating hook.
+     */
+    __publicField(this, "useIsMutating");
+    /**
+     * THe QueryClientProvider component.
+     */
+    __publicField(this, "QueryClientProvider");
+    /**
+     * The query client.
+     */
+    __privateAdd(this, _queryClient);
+    /**
+     * The request client.
+     */
+    __privateAdd(this, _requestClient);
+    /**
+     * The request methods.
+     */
+    __privateAdd(this, _requestMethods);
+    /**
+     * The current signal.
+     */
+    __privateAdd(this, _currentSignal);
+    __privateSet(this, _queryClient, createQueryClient(options));
+    __privateSet(this, _requestClient, createRequestClient(options));
+    __privateSet(this, _requestMethods, {
+      get: async (url, options2) => {
+        const signal = __privateGet(this, _currentSignal);
+        __privateSet(this, _currentSignal, void 0);
+        return await __privateGet(this, _requestClient).get(url, {
+          ...options2,
+          signal
+        });
+      },
+      post: async (url, data, options2) => {
+        const signal = __privateGet(this, _currentSignal);
+        __privateSet(this, _currentSignal, void 0);
+        return await __privateGet(this, _requestClient).post(url, data, {
+          ...options2,
+          signal
+        });
+      },
+      put: async (url, data, options2) => {
+        const signal = __privateGet(this, _currentSignal);
+        __privateSet(this, _currentSignal, void 0);
+        return await __privateGet(this, _requestClient).put(url, data, {
+          ...options2,
+          signal
+        });
+      },
+      delete: async (url, options2) => {
+        const signal = __privateGet(this, _currentSignal);
+        __privateSet(this, _currentSignal, void 0);
+        return await __privateGet(this, _requestClient).delete(url, {
+          ...options2,
+          signal
+        });
+      }
+    });
+    const that = this;
+    this.useApiQuery = function useApiQuery(queryFn, args, options2) {
+      var _a;
+      const {
+        keepPreviousData: keepPreviousData$1,
+        placeholderData,
+        initialData,
+        ...restOptions
+      } = options2 ?? {};
+      const result = useQuery({
+        queryKey: [queryFn.key, args],
+        queryFn: ({ signal }) => queryFn(args, { signal }),
+        select: __privateMethod(that, _ApiClient_instances, selectData_fn),
+        placeholderData: placeholderData ?? keepPreviousData$1 === true ? keepPreviousData : void 0,
+        initialData: initialData ? {
+          code: 0,
+          message: "ok",
+          data: initialData
+        } : void 0,
+        ...restOptions
+      });
+      return __privateMethod(_a = that, _ApiClient_instances, createQueryResult_fn).call(_a, result);
+    };
+    this.useSuspenseApiQuery = function useSuspenseApiQuery(queryFn, args, options2) {
+      const {
+        keepPreviousData,
+        initialData,
+        ...restOptions
+      } = options2 ?? {};
+      const { data, refetch } = useSuspenseQuery({
+        queryKey: [queryFn.key, args],
+        queryFn: ({ signal }) => queryFn(args, { signal }),
+        select: __privateMethod(that, _ApiClient_instances, selectData_fn),
+        initialData: initialData ? {
+          code: 0,
+          message: "ok",
+          data: initialData
+        } : void 0,
+        ...restOptions
+      });
+      return {
+        data,
+        refetch: __privateMethod(this, _ApiClient_instances, wrapRefetchFn_fn).call(this, refetch)
+      };
+    };
+    this.useApiMutation = function useApiMutation(mutationFn) {
+      const {
+        isPending,
+        isIdle,
+        isError,
+        isSuccess,
+        error,
+        data,
+        mutateAsync
+      } = useMutation({
+        mutationKey: [mutationFn.key],
+        mutationFn: (args) => mutationFn(args)
+      });
+      const mutate = async (args) => await mutateAsync(args);
+      return {
+        mutate,
+        isPending,
+        isIdle,
+        isError,
+        isSuccess,
+        message: data?.message,
+        error: error ?? void 0,
+        data: data?.data
+      };
+    };
+    this.useIsFetching = function useIsFetching$1(apiKey, args) {
+      const count = useIsFetching({
+        queryKey: arguments.length > 1 ? [apiKey, args] : [apiKey],
+        type: "active",
+        exact: false
+      });
+      return count > 0;
+    };
+    this.useIsMutating = function useIsMutating$1(apiKey) {
+      const count = useIsMutating({
+        mutationKey: [apiKey],
+        exact: false
+      });
+      return count > 0;
+    };
+    this.QueryClientProvider = function QueryClientProvider$1({ children }) {
+      return createElement(
+        QueryClientProvider,
+        {
+          client: __privateGet(that, _queryClient)
+        },
+        children
+      );
+    };
+  }
+  /**
+   * Fetch the API query.
+   *
+   * @param queryFn - The API function.
+   * @param args - The arguments of the API.
+   * @param options - The options of the API.
+   * @returns The API query.
+   */
+  async fetchApiQuery(queryFn, args, options) {
+    const { initialData, ...restOptions } = options ?? {};
+    const result = await __privateGet(this, _queryClient).fetchQuery({
+      queryKey: [queryFn.key, args],
+      queryFn: ({ signal }) => queryFn(args, { signal }),
+      initialData: initialData ? {
+        code: 0,
+        message: "ok",
+        data: initialData
+      } : void 0,
+      ...restOptions
+    });
+    return result.data;
+  }
+  /**
+   * Create a query API.
+   *
+   * @param key - The key of the API.
+   * @param factory - The factory of the API function.
+   * @returns The query API.
+   */
+  createQueryApi(key, factory) {
+    const apiFn = __privateMethod(this, _ApiClient_instances, createApi_fn).call(this, key, factory);
+    apiFn.useQuery = this.useApiQuery.bind(this, apiFn);
+    apiFn.useSuspenseQuery = this.useSuspenseApiQuery.bind(this, apiFn);
+    apiFn.fetchQuery = this.fetchApiQuery.bind(this, apiFn);
+    apiFn.getQueryData = this.getApiQueryData.bind(this, key);
+    apiFn.getQueriesData = this.getApiQueriesData.bind(this, key);
+    apiFn.setQueryData = (data, args) => this.setApiQueryData(data, key, args);
+    apiFn.ensureQueryData = this.ensureApiQueryData.bind(this, apiFn);
+    apiFn.removeQueries = this.removeApiQueries.bind(this, key);
+    apiFn.invalidateQueries = this.invalidateApiQueries.bind(this, key);
+    apiFn.resetQueries = this.resetApiQueries.bind(this, key);
+    apiFn.refetchQueries = this.refetchApiQueries.bind(this, key);
+    apiFn.cancelQueries = this.cancelApiQueries.bind(this, key);
+    apiFn.isFetching = this.isFetching.bind(this, key);
+    apiFn.useIsFetching = this.useIsFetching.bind(void 0, key);
+    return Object.freeze(apiFn);
+  }
+  /**
+   * Create a mutation API.
+   *
+   * @param key - The key of the API.
+   * @param factory - The factory of the API function.
+   * @param relatedQueries - The related queries.
+   * @returns The mutation API.
+   */
+  createMutationApi(key, factory, relatedQueries = []) {
+    const apiFn = __privateMethod(this, _ApiClient_instances, createApi_fn).call(this, key, factory);
+    apiFn.relatedQueries = Object.freeze(relatedQueries);
+    apiFn.useMutation = this.useApiMutation.bind(this, apiFn);
+    apiFn.refetchRelatedQueries = function refetchRelatedQueries() {
+      return Promise.all(
+        relatedQueries.map((query) => query.refetchQueries())
+      );
+    };
+    apiFn.invalidateRelatedQueries = function invalidateRelatedQueries() {
+      return Promise.all(
+        relatedQueries.map((query) => query.invalidateQueries())
+      );
+    };
+    apiFn.isMutating = this.isMutating.bind(this, key);
+    apiFn.useIsMutating = this.useIsMutating.bind(void 0, key);
+    return Object.freeze(apiFn);
+  }
+  /**
+   * Get the API query data.
+   *
+   * @param apiKey - The key of the API.
+   * @param args - The arguments of the API.
+   * @returns The API query data.
+   */
+  getApiQueryData(apiKey, args) {
+    return __privateGet(this, _queryClient).getQueryData(
+      arguments.length > 1 ? [apiKey, args] : [apiKey]
+    );
+  }
+  /**
+   * Get the API queries data.
+   *
+   * @param apiKey - The key of the API.
+   * @param args - The arguments of the API.
+   * @returns The API queries data.
+   */
+  getApiQueriesData(apiKey, args) {
+    return __privateGet(this, _queryClient).getQueriesData({
+      queryKey: arguments.length > 1 ? [apiKey, args] : [apiKey],
+      type: "active",
+      exact: false
+    });
+  }
+  /**
+   * Set the API query data.
+   *
+   * @param data - The data.
+   * @param apiKey - The key of the API.
+   * @param args - The arguments of the API.
+   */
+  setApiQueryData(data, apiKey, args) {
+    __privateGet(this, _queryClient).setQueryData(
+      arguments.length > 2 ? [apiKey, args] : [apiKey],
+      data
+    );
+  }
+  /**
+   * Ensure the API query data.
+   *
+   * @param queryFn - The API function.
+   * @param args - The arguments of the API.
+   * @param options - The options of the API.
+   * @returns The API query data.
+   */
+  async ensureApiQueryData(queryFn, args, options) {
+    const { initialData, ...restOptions } = options ?? {};
+    const result = await __privateGet(this, _queryClient).ensureQueryData({
+      queryKey: [queryFn.key, args],
+      queryFn: ({ signal }) => queryFn(args, { signal }),
+      initialData: initialData ? {
+        code: 0,
+        message: "ok",
+        data: initialData
+      } : void 0,
+      ...restOptions,
+      revalidateIfStale: true
+    });
+    return result.data;
+  }
+  /**
+   * Remove the API queries.
+   *
+   * @param apiKey - The key of the API.
+   * @param args - The arguments of the API.
+   */
+  removeApiQueries(apiKey, args) {
+    __privateGet(this, _queryClient).removeQueries({
+      type: "all",
+      exact: false,
+      queryKey: arguments.length > 1 ? [apiKey, args] : [apiKey]
+    });
+  }
+  /**
+   * Invalidate the API queries.
+   *
+   * @param apiKey - The key of the API.
+   * @param args - The arguments of the API.
+   */
+  invalidateApiQueries(apiKey, args) {
+    return __privateGet(this, _queryClient).invalidateQueries(
+      {
+        queryKey: arguments.length > 1 ? [apiKey, args] : [apiKey],
+        type: "all",
+        exact: false,
+        stale: false,
+        refetchType: "active"
+      },
+      {
+        throwOnError: false,
+        cancelRefetch: false
+      }
+    );
+  }
+  /**
+   * Reset the API queries.
+   *
+   * @param apiKey - The key of the API.
+   * @param args - The arguments of the API.
+   */
+  resetApiQueries(apiKey, args) {
+    return __privateGet(this, _queryClient).resetQueries(
+      {
+        queryKey: arguments.length > 1 ? [apiKey, args] : [apiKey],
+        type: "active",
+        exact: false
+      },
+      {
+        cancelRefetch: true,
+        throwOnError: false
+      }
+    );
+  }
+  /**
+   * Refetch the API queries.
+   *
+   * @param apiKey - The key of the API.
+   * @param args - The arguments of the API.
+   */
+  refetchApiQueries(apiKey, args) {
+    return __privateGet(this, _queryClient).refetchQueries(
+      {
+        queryKey: arguments.length > 1 ? [apiKey, args] : [apiKey],
+        type: "active",
+        exact: false
+      },
+      {
+        throwOnError: false,
+        cancelRefetch: false
+      }
+    );
+  }
+  /**
+   * Cancel the API queries.
+   *
+   * @param apiKey - The key of the API.
+   * @param args - The arguments of the API.
+   */
+  cancelApiQueries(apiKey, args) {
+    return __privateGet(this, _queryClient).cancelQueries(
+      {
+        queryKey: arguments.length > 1 ? [apiKey, args] : [apiKey],
+        type: "active",
+        exact: false
+      },
+      {
+        revert: true,
+        silent: true
+      }
+    );
+  }
+  /**
+   * Check if the API query/queries is fetching.
+   *
+   * @param apiKey - The key of the API.
+   * @param args - The arguments of the API.
+   * @returns Whether the API query is fetching.
+   */
+  isFetching(apiKey, args) {
+    return __privateGet(this, _queryClient).isFetching({
+      queryKey: arguments.length > 1 ? [apiKey, args] : [apiKey],
+      type: "active",
+      exact: false
+    }) > 0;
+  }
+  /**
+   * Check if the API mutation is mutating.
+   *
+   * @param apiKey - The key of the API.
+   * @returns Whether the API mutation is mutating.
+   */
+  isMutating(apiKey) {
+    return __privateGet(this, _queryClient).isMutating({
+      mutationKey: [apiKey],
+      exact: false
+    }) > 0;
+  }
+}
+_queryClient = new WeakMap();
+_requestClient = new WeakMap();
+_requestMethods = new WeakMap();
+_currentSignal = new WeakMap();
+_ApiClient_instances = new WeakSet();
+/**
+ * Select the data.
+ *
+ * @param data - The data.
+ * @returns The data.
+ */
+selectData_fn = function(data) {
+  return data.data;
+};
+/**
+ * Wrap the refetch function.
+ *
+ * @param refetch - The refetch function.
+ * @returns The refetch result.
+ */
+wrapRefetchFn_fn = function(refetch) {
+  return async (options) => {
+    const result = await refetch(options);
+    return {
+      isSuccess: result.isSuccess,
+      isError: result.isError,
+      error: result.error,
+      data: result.data
+    };
+  };
+};
+/**
+ * Create a query result.
+ *
+ * @returns The query result.
+ */
+createQueryResult_fn = function({
+  isPending,
+  isFetching,
+  isLoading,
+  isRefetching,
+  isSuccess,
+  isPlaceholderData,
+  isError,
+  isLoadingError,
+  isRefetchError,
+  isStale,
+  error,
+  data,
+  refetch
+}) {
+  return {
+    isPending,
+    isSuccess,
+    isError,
+    isLoadingError,
+    isRefetchError,
+    isLoading,
+    isFetching,
+    isRefetching,
+    isPlaceholderData,
+    isStale,
+    error: error ?? void 0,
+    data,
+    refetch: __privateMethod(this, _ApiClient_instances, wrapRefetchFn_fn).call(this, refetch)
+  };
+};
+/**
+ * Create an API.
+ *
+ * @param key - The key of the API.
+ * @param factory - The factory of the API function.
+ * @returns The API.
+ */
+createApi_fn = function(key, factory) {
+  const fn = factory(__privateGet(this, _requestMethods));
+  const apiFn = async (args, apiOptions) => {
+    __privateSet(this, _currentSignal, apiOptions?.signal);
+    return await fn(args);
+  };
+  apiFn.key = key;
+  return apiFn;
+};
+function createApiClient(options) {
+  return Object.freeze(new ApiClient(options));
+}
+
+export { ApiClient, createApiClient };
 /*! VefFramework is a blazingly high-level, modern, flexible, easy-to-use UI framework made by Venus. Follow me on Github: https://github.com/ilxqx! @ilxqx */

package/es/api/api-context.js

@@ -1,3 +1,95 @@
-/*! VefFramework version: 1.0.97, build time: 2025-03-06T12:24:36.461Z, made by Venus. */
-import{VefError as e}from"@vef-framework/shared";import{createContext as i,useMemo as t,createElement as r,useContext as n}from"react";const a=i(null),ApiContextProvider=({client:e,dataDictionaryApi:i,loginApi:n,logoutApi:u,fetchAuthenticatedUserApi:s,children:p})=>{const A=t((()=>{const t=e.createQueryApi("_vefStubQueryApi",(()=>e=>Promise.resolve({code:0,message:"ok",data:e}))),r=e.createQueryApi("_vefAsyncFnQueryApi",(()=>async({args:e,fn:i})=>({code:0,message:"ok",data:await i(...e)}))),a=e.createMutationApi("_vefStubMutationApi",(()=>e=>Promise.resolve({code:0,message:"ok",data:e}))),p=e.createMutationApi("_vefAsyncFnMutationApi",(()=>async({args:e,fn:i})=>({code:0,message:"ok",data:await i(...e)})));return Object.freeze({useApiQuery:e.useApiQuery,useSuspenseApiQuery:e.useSuspenseApiQuery,useApiMutation:e.useApiMutation,useIsFetching:e.useIsFetching,useIsMutating:e.useIsMutating,fetchApiQuery:e.fetchApiQuery.bind(e),createQueryApi:e.createQueryApi.bind(e),createMutationApi:e.createMutationApi.bind(e),getApiQueryData:e.getApiQueryData.bind(e),getApiQueriesData:e.getApiQueriesData.bind(e),setApiQueryData:e.setApiQueryData.bind(e),ensureApiQueryData:e.ensureApiQueryData.bind(e),removeApiQueries:e.removeApiQueries.bind(e),invalidateApiQueries:e.invalidateApiQueries.bind(e),resetApiQueries:e.resetApiQueries.bind(e),refetchApiQueries:e.refetchApiQueries.bind(e),cancelApiQueries:e.cancelApiQueries.bind(e),isFetching:e.isFetching.bind(e),isMutating:e.isMutating.bind(e),stubQueryApi:t,asyncFnQueryApi:r,stubMutationApi:a,asyncFnMutationApi:p,dataDictionaryApi:i,loginApi:n,logoutApi:u,fetchAuthenticatedUserApi:s})}),[e,i,n,u,s]);return r(a.Provider,{value:A},r(e.QueryClientProvider,{},p))};function useApiContext(){const i=n(a);if(null===i)throw new e(-1,"Api context not found: Please ensure useApiContext is called within an ApiContextProvider");return i}export{ApiContextProvider,useApiContext};
+/*! VefFramework version: 1.0.99, build time: 2025-03-07T13:41:55.478Z, made by Venus. */
+import { VefError } from '@vef-framework/shared';
+import { createContext, useMemo, createElement, useContext } from 'react';
+
+const Context = createContext(null);
+const ApiContextProvider = ({
+  client,
+  dataDictionaryApi,
+  loginApi,
+  logoutApi,
+  fetchAuthenticatedUserApi,
+  children
+}) => {
+  const apiContext = useMemo(() => {
+    const stubQueryApi = client.createQueryApi(
+      "_vefStubQueryApi",
+      () => (stubData) => Promise.resolve({
+        code: 0,
+        message: "ok",
+        data: stubData
+      })
+    );
+    const asyncFnQueryApi = client.createQueryApi(
+      "_vefAsyncFnQueryApi",
+      () => async ({ args, fn }) => ({
+        code: 0,
+        message: "ok",
+        data: await fn(...args)
+      })
+    );
+    const stubMutationApi = client.createMutationApi(
+      "_vefStubMutationApi",
+      () => (stubData) => Promise.resolve({
+        code: 0,
+        message: "ok",
+        data: stubData
+      })
+    );
+    const asyncFnMutationApi = client.createMutationApi(
+      "_vefAsyncFnMutationApi",
+      () => async ({ args, fn }) => ({
+        code: 0,
+        message: "ok",
+        data: await fn(...args)
+      })
+    );
+    return Object.freeze({
+      useApiQuery: client.useApiQuery,
+      useSuspenseApiQuery: client.useSuspenseApiQuery,
+      useApiMutation: client.useApiMutation,
+      useIsFetching: client.useIsFetching,
+      useIsMutating: client.useIsMutating,
+      fetchApiQuery: client.fetchApiQuery.bind(client),
+      createQueryApi: client.createQueryApi.bind(client),
+      createMutationApi: client.createMutationApi.bind(client),
+      getApiQueryData: client.getApiQueryData.bind(client),
+      getApiQueriesData: client.getApiQueriesData.bind(client),
+      setApiQueryData: client.setApiQueryData.bind(client),
+      ensureApiQueryData: client.ensureApiQueryData.bind(client),
+      removeApiQueries: client.removeApiQueries.bind(client),
+      invalidateApiQueries: client.invalidateApiQueries.bind(client),
+      resetApiQueries: client.resetApiQueries.bind(client),
+      refetchApiQueries: client.refetchApiQueries.bind(client),
+      cancelApiQueries: client.cancelApiQueries.bind(client),
+      isFetching: client.isFetching.bind(client),
+      isMutating: client.isMutating.bind(client),
+      stubQueryApi,
+      asyncFnQueryApi,
+      stubMutationApi,
+      asyncFnMutationApi,
+      dataDictionaryApi,
+      loginApi,
+      logoutApi,
+      fetchAuthenticatedUserApi
+    });
+  }, [client, dataDictionaryApi, loginApi, logoutApi, fetchAuthenticatedUserApi]);
+  return createElement(
+    Context.Provider,
+    { value: apiContext },
+    createElement(client.QueryClientProvider, {}, children)
+  );
+};
+function useApiContext() {
+  const context = useContext(Context);
+  if (context === null) {
+    throw new VefError(
+      -1,
+      "Api context not found: Please ensure useApiContext is called within an ApiContextProvider"
+    );
+  }
+  return context;
+}
+
+export { ApiContextProvider, useApiContext };
 /*! VefFramework is a blazingly high-level, modern, flexible, easy-to-use UI framework made by Venus. Follow me on Github: https://github.com/ilxqx! @ilxqx */

package/es/api/index.js

@@ -1,3 +1,5 @@
-/*! VefFramework version: 1.0.97, build time: 2025-03-06T12:24:36.461Z, made by Venus. */
-export{ApiClient,createApiClient}from"./api-client.js";export{ApiContextProvider,useApiContext}from"./api-context.js";export{useQueryErrorResetBoundary}from"@tanstack/react-query";
+/*! VefFramework version: 1.0.99, build time: 2025-03-07T13:41:55.478Z, made by Venus. */
+export { ApiClient, createApiClient } from './api-client.js';
+export { ApiContextProvider, useApiContext } from './api-context.js';
+export { useQueryErrorResetBoundary } from '@tanstack/react-query';
 /*! VefFramework is a blazingly high-level, modern, flexible, easy-to-use UI framework made by Venus. Follow me on Github: https://github.com/ilxqx! @ilxqx */