@koine/api 2.0.0-beta.72 → 2.0.0-beta.74

package/ApiError.d.ts

@@ -0,0 +1,5 @@
+import type { Api } from "./types";
+export declare class ApiError<TResponseFail extends Api.ResponseFail = unknown> extends Error {
+    constructor(result: Api.ResultFail<TResponseFail>);
+}
+export default ApiError;

package/ApiError.js

@@ -0,0 +1,8 @@
+export class ApiError extends Error {
+    constructor(result) {
+        super(`Request failed with ${result.status} ${result.msg}`);
+        this.name = "ApiError";
+        Object.assign(this, result);
+    }
+}
+export default ApiError;

package/createApi.cjs.js

@@ -0,0 +1,7 @@
+'use strict';
+
+var utils = require('@koine/utils');
+
+let o=["get","post","put","patch","delete"];let createApi=(l,a,i)=>{let{headers:s={},request:n={},throwErr:p,timeout:c=1e4,processReq:u,processRes:f,processErr:d}=i||{};return o.reduce((o,i)=>(o[i]=async(o,h)=>{let $,m;let{request:w=n,headers:y=s,timeout:g=c,processReq:b,processRes:E=f,processErr:N=d,throwErr:k=p}=h||{},{params:A,json:C,query:j}=h||{},q=`${a}/${o+"".replace(/^\/*/,"")}`,v={method:i.toUpperCase(),...w,headers:{"content-type":"application/json",...y}};if(u){let e=u(i,q,j,C,A,v);q=e[0],j=e[1],C=e[2],A=e[3],v=e[4];}if(b){let e=b(i,q,j,C,A,v);q=e[0],j=e[1],C=e[2],A=e[3],v=e[4];}if(utils.isFullObject(A))for(let e in A)q=q.replace(`{${e}}`,A[e].toString());let x=Number(g);C&&(v.body=JSON.stringify(C)),x>0&&($=new AbortController,m=setTimeout(()=>$.abort(),x),v.signal=$.signal),j&&(q+=utils.buildUrlQueryString(j));let O=null,R=null,S="";try{O=await fetch(q,v);}catch(e){S=utils.errorToString(e);}if(m&&clearTimeout(m),O)try{R=E?await E(O,h||{}):await O.json();}catch(e){S=utils.errorToString(e);}if(null===R&&(R=N?await N(S,h||{}):{data:null,msg:S,status:100,fail:!0,ok:!1}),k&&R?.fail)throw R;if("development"===process.env.NODE_ENV){let e=`${R?.status}: api[${l}] ${i.toUpperCase()} ${q}`;R?.ok?console.info(`🟢 ${e}`):console.info(`🔴 ${e}`);}return R},o),{})};
+
+exports.createApi = createApi;

package/createApi.d.ts

@@ -0,0 +1,3 @@
+import type { Api } from "./types";
+export declare let createApi: <TEndpoints extends Api.Endpoints>(apiName: string, baseUrl: string, options?: Api.ClientOptions) => Api.Client<TEndpoints>;
+export default createApi;

package/createApi.esm.js

@@ -0,0 +1,5 @@
+import { isFullObject, buildUrlQueryString, errorToString } from '@koine/utils';
+
+let o=["get","post","put","patch","delete"];let createApi=(l,a,i)=>{let{headers:s={},request:n={},throwErr:p,timeout:c=1e4,processReq:u,processRes:f,processErr:d}=i||{};return o.reduce((o,i)=>(o[i]=async(o,h)=>{let $,m;let{request:w=n,headers:y=s,timeout:g=c,processReq:b,processRes:E=f,processErr:N=d,throwErr:k=p}=h||{},{params:A,json:C,query:j}=h||{},q=`${a}/${o+"".replace(/^\/*/,"")}`,v={method:i.toUpperCase(),...w,headers:{"content-type":"application/json",...y}};if(u){let e=u(i,q,j,C,A,v);q=e[0],j=e[1],C=e[2],A=e[3],v=e[4];}if(b){let e=b(i,q,j,C,A,v);q=e[0],j=e[1],C=e[2],A=e[3],v=e[4];}if(isFullObject(A))for(let e in A)q=q.replace(`{${e}}`,A[e].toString());let x=Number(g);C&&(v.body=JSON.stringify(C)),x>0&&($=new AbortController,m=setTimeout(()=>$.abort(),x),v.signal=$.signal),j&&(q+=buildUrlQueryString(j));let O=null,R=null,S="";try{O=await fetch(q,v);}catch(e){S=errorToString(e);}if(m&&clearTimeout(m),O)try{R=E?await E(O,h||{}):await O.json();}catch(e){S=errorToString(e);}if(null===R&&(R=N?await N(S,h||{}):{data:null,msg:S,status:100,fail:!0,ok:!1}),k&&R?.fail)throw R;if("development"===process.env.NODE_ENV){let e=`${R?.status}: api[${l}] ${i.toUpperCase()} ${q}`;R?.ok?console.info(`🟢 ${e}`):console.info(`🔴 ${e}`);}return R},o),{})};
+
+export { createApi as c };

package/createApi.js

@@ -0,0 +1,115 @@
+import { buildUrlQueryString, errorToString, isFullObject, } from "@koine/utils";
+let apiMethods = [
+    "get",
+    "post",
+    "put",
+    "patch",
+    "delete",
+];
+export let createApi = (apiName, baseUrl, options) => {
+    const { headers: headersBase = {}, request: requestBase = {}, throwErr: throwErrBase, timeout: timeoutBase = 10000, processReq: processReqBase, processRes: processResBase, processErr: processErrBase, } = options || {};
+    return apiMethods.reduce((api, method) => {
+        api[method] = async (endpoint, options) => {
+            const { request = requestBase, headers = headersBase, timeout = timeoutBase, processReq, processRes = processResBase, processErr = processErrBase, throwErr = throwErrBase, } = options || {};
+            let { params, json, query } = options || {};
+            let url = `${baseUrl}/${endpoint + "".replace(/^\/*/, "")}`;
+            let requestInit = {
+                method: method.toUpperCase(),
+                ...request,
+                headers: {
+                    "content-type": "application/json",
+                    ...headers,
+                },
+            };
+            if (processReqBase) {
+                const transformed = processReqBase(method, url, query, json, params, requestInit);
+                url = transformed[0];
+                query = transformed[1];
+                json = transformed[2];
+                params = transformed[3];
+                requestInit = transformed[4];
+            }
+            if (processReq) {
+                const transformed = processReq(method, url, query, json, params, requestInit);
+                url = transformed[0];
+                query = transformed[1];
+                json = transformed[2];
+                params = transformed[3];
+                requestInit = transformed[4];
+            }
+            if (isFullObject(params)) {
+                for (const key in params) {
+                    url = url.replace(`{${key}}`, params[key].toString());
+                }
+            }
+            const timeoutNumber = Number(timeout);
+            let controller;
+            let timeoutId;
+            if (json) {
+                requestInit.body = JSON.stringify(json);
+            }
+            if (timeoutNumber > 0) {
+                controller = new AbortController();
+                timeoutId = setTimeout(() => controller.abort(), timeoutNumber);
+                requestInit.signal = controller.signal;
+            }
+            if (query) {
+                url += buildUrlQueryString(query);
+            }
+            let response = null;
+            let result = null;
+            let msg = "";
+            try {
+                response = await fetch(url, requestInit);
+            }
+            catch (e) {
+                msg = errorToString(e);
+            }
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+            if (response) {
+                try {
+                    if (processRes) {
+                        result = await processRes(response, options || {});
+                    }
+                    else {
+                        result = await response.json();
+                    }
+                }
+                catch (e) {
+                    msg = errorToString(e);
+                }
+            }
+            if (result === null) {
+                if (processErr) {
+                    result = await processErr(msg, options || {});
+                }
+                else {
+                    result = {
+                        data: null,
+                        msg,
+                        status: 100,
+                        fail: true,
+                        ok: false,
+                    };
+                }
+            }
+            if (throwErr && result?.fail) {
+                throw result;
+            }
+            if (process.env["NODE_ENV"] === "development") {
+                const logMsg = `${result?.status}: api[${apiName}] ${method.toUpperCase()} ${url}`;
+                if (result?.ok) {
+                    console.info(`🟢 ${logMsg}`);
+                }
+                else {
+                    console.info(`🔴 ${logMsg}`);
+                }
+            }
+            return result;
+        };
+        return api;
+    }, {});
+};
+export default createApi;

package/createApiResultFail.d.ts

@@ -0,0 +1,4 @@
+import type { Api } from "./types";
+export declare let createApiResultOk: <T>(data?: T, msg?: string) => Api.ResultOk<T>;
+export declare let createApiResultFail: <T>(data?: T, msg?: string, status?: number) => Api.ResultFail<T>;
+export default createApiResultFail;

package/createApiResultFail.js

@@ -0,0 +1,14 @@
+export let createApiResultOk = (data = {}, msg) => ({
+    ok: true,
+    fail: false,
+    data,
+    msg: msg || "",
+    status: 200,
+});
+export let createApiResultFail = (data = {}, msg, status) => ({
+    fail: true,
+    data,
+    msg: msg || "",
+    status: status || 404,
+});
+export default createApiResultFail;

package/createApiResultOk.cjs.js

@@ -0,0 +1,8 @@
+'use strict';
+
+let createApiResultFail=(t={},e,a)=>({fail:!0,data:t,msg:e||"",status:a||404});
+
+let createApiResultOk=(e={},t)=>({ok:!0,fail:!1,data:e,msg:t||"",status:200});
+
+exports.createApiResultFail = createApiResultFail;
+exports.createApiResultOk = createApiResultOk;

package/createApiResultOk.d.ts

@@ -0,0 +1,3 @@
+import type { Api } from "./types";
+export declare let createApiResultOk: <T>(data?: T, msg?: string) => Api.ResultOk<T>;
+export default createApiResultOk;

package/createApiResultOk.esm.js

@@ -0,0 +1,5 @@
+let createApiResultFail=(t={},e,a)=>({fail:!0,data:t,msg:e||"",status:a||404});
+
+let createApiResultOk=(e={},t)=>({ok:!0,fail:!1,data:e,msg:t||"",status:200});
+
+export { createApiResultOk as a, createApiResultFail as c };

package/createApiResultOk.js

@@ -0,0 +1,8 @@
+export let createApiResultOk = (data = {}, msg) => ({
+    ok: true,
+    fail: false,
+    data,
+    msg: msg || "",
+    status: 200,
+});
+export default createApiResultOk;

package/createSwrApi.cjs.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var e = require('swr');
+var utils = require('@koine/utils');
+var createApi = require('./createApi.cjs.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var e__default = /*#__PURE__*/_interopDefaultLegacy(e);
+
+let createUseApi=t=>(i,o,p)=>{let a=async()=>{let{data:e}=await t.get(i,{...o||{},throwErr:!0});return e};return e__default["default"](p?.when===!1||utils.isFunction(p?.when)&&p?.when()===!1?null:o?[i,o]:[i],a,p)};let createSwrApi=(...e)=>{let r=createApi.createApi(...e);return r.use=createUseApi(r),r};
+
+exports.createSwrApi = createSwrApi;
+exports.createUseApi = createUseApi;

package/createSwrApi.esm.js

@@ -0,0 +1,7 @@
+import e from 'swr';
+import { isFunction } from '@koine/utils';
+import { c as createApi } from './createApi.esm.js';
+
+let createUseApi=t=>(i,o,p)=>{let a=async()=>{let{data:e}=await t.get(i,{...o||{},throwErr:!0});return e};return e(p?.when===!1||isFunction(p?.when)&&p?.when()===!1?null:o?[i,o]:[i],a,p)};let createSwrApi=(...e)=>{let r=createApi(...e);return r.use=createUseApi(r),r};
+
+export { createUseApi as a, createSwrApi as c };

package/index.cjs.js

@@ -2,11 +2,13 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var utils = require('@koine/utils');
+var createApi = require('./createApi.cjs.js');
+var createApiResultOk = require('./createApiResultOk.cjs.js');
+require('@koine/utils');
 
-class ApiError extends Error{constructor(e){super(`Request failed with ${e.status} ${e.msg}`),this.name="ApiError",Object.assign(this,e);}}let createApiResultOk=(e={},t)=>({ok:!0,fail:!1,data:e,msg:t||"",status:200});let createApiResultFail=(e={},t,r)=>({fail:!0,data:e,msg:t||"",status:r||404});let s=["get","post","put","patch","delete"];let createApi=(o,a,l)=>{let{headers:i={},request:n={},throwErr:p,timeout:c=1e4,processReq:u,processRes:f,processErr:h}=l||{};return s.reduce((s,l)=>(s[l]=async(s,m)=>{let $,d;let{request:g=n,headers:w=i,timeout:E=c,processReq:y,processRes:A=f,processErr:b=h,throwErr:k=p}=m||{},{params:x,json:R,query:N}=m||{},O=`${a}/${s+"".replace(/^\/*/,"")}`,j={method:l.toUpperCase(),...g,headers:{"content-type":"application/json",...w}};if(u){let e=u(l,O,N,R,x,j);O=e[0],N=e[1],R=e[2],x=e[3],j=e[4];}if(y){let e=y(l,O,N,R,x,j);O=e[0],N=e[1],R=e[2],x=e[3],j=e[4];}if(utils.isFullObject(x))for(let e in x)O=O.replace(`{${e}}`,x[e].toString());let q=Number(E);R&&(j.body=JSON.stringify(R)),q>0&&($=new AbortController,d=setTimeout(()=>$.abort(),q),j.signal=$.signal),N&&(O+=utils.buildUrlQueryString(N));let C=null,v=null,S="";try{C=await fetch(O,j);}catch(e){S=utils.errorToString(e);}if(d&&clearTimeout(d),C)try{v=A?await A(C,m||{}):await C.json();}catch(e){S=utils.errorToString(e);}if(null===v&&(v=b?await b(S,m||{}):{data:null,msg:S,status:100,fail:!0,ok:!1}),k&&v?.fail)throw v;if("development"===process.env.NODE_ENV){let e=`${v?.status}: api[${o}] ${l.toUpperCase()} ${O}`;v?.ok?console.info(`🟢 ${e}`):console.info(`🔴 ${e}`);}return v},s),{})};
+class ApiError extends Error{constructor(r){super(`Request failed with ${r.status} ${r.msg}`),this.name="ApiError",Object.assign(this,r);}}
 
+exports.createApi = createApi.createApi;
+exports.createApiResultFail = createApiResultOk.createApiResultFail;
+exports.createApiResultOk = createApiResultOk.createApiResultOk;
 exports.ApiError = ApiError;
-exports.createApi = createApi;
-exports.createApiResultFail = createApiResultFail;
-exports.createApiResultOk = createApiResultOk;

package/index.d.ts

@@ -1,8 +1,5 @@
-import type { Api } from "./types";
-export declare class ApiError<TResponseFail extends Api.ResponseFail = unknown> extends Error {
-    constructor(result: Api.ResultFail<TResponseFail>);
-}
-export declare let createApiResultOk: <T>(data?: T, msg?: string) => Api.ResultOk<T>;
-export declare let createApiResultFail: <T>(data?: T, msg?: string, status?: number) => Api.ResultFail<T>;
-export declare let createApi: <TEndpoints extends Api.Endpoints>(apiName: string, baseUrl: string, options?: Api.ClientOptions) => Api.Client<TEndpoints>;
+export { ApiError } from "./ApiError";
+export { createApi } from "./createApi";
+export { createApiResultFail } from "./createApiResultFail";
+export { createApiResultOk } from "./createApiResultOk";
 export type { Api } from "./types";

package/index.esm.js

@@ -1,5 +1,7 @@
-import { isFullObject, buildUrlQueryString, errorToString } from '@koine/utils';
+export { c as createApi } from './createApi.esm.js';
+export { c as createApiResultFail, a as createApiResultOk } from './createApiResultOk.esm.js';
+import '@koine/utils';
 
-class ApiError extends Error{constructor(e){super(`Request failed with ${e.status} ${e.msg}`),this.name="ApiError",Object.assign(this,e);}}let createApiResultOk=(e={},t)=>({ok:!0,fail:!1,data:e,msg:t||"",status:200});let createApiResultFail=(e={},t,r)=>({fail:!0,data:e,msg:t||"",status:r||404});let s=["get","post","put","patch","delete"];let createApi=(o,a,l)=>{let{headers:i={},request:n={},throwErr:p,timeout:c=1e4,processReq:u,processRes:f,processErr:h}=l||{};return s.reduce((s,l)=>(s[l]=async(s,m)=>{let $,d;let{request:g=n,headers:w=i,timeout:E=c,processReq:y,processRes:A=f,processErr:b=h,throwErr:k=p}=m||{},{params:x,json:R,query:N}=m||{},O=`${a}/${s+"".replace(/^\/*/,"")}`,j={method:l.toUpperCase(),...g,headers:{"content-type":"application/json",...w}};if(u){let e=u(l,O,N,R,x,j);O=e[0],N=e[1],R=e[2],x=e[3],j=e[4];}if(y){let e=y(l,O,N,R,x,j);O=e[0],N=e[1],R=e[2],x=e[3],j=e[4];}if(isFullObject(x))for(let e in x)O=O.replace(`{${e}}`,x[e].toString());let q=Number(E);R&&(j.body=JSON.stringify(R)),q>0&&($=new AbortController,d=setTimeout(()=>$.abort(),q),j.signal=$.signal),N&&(O+=buildUrlQueryString(N));let C=null,v=null,S="";try{C=await fetch(O,j);}catch(e){S=errorToString(e);}if(d&&clearTimeout(d),C)try{v=A?await A(C,m||{}):await C.json();}catch(e){S=errorToString(e);}if(null===v&&(v=b?await b(S,m||{}):{data:null,msg:S,status:100,fail:!0,ok:!1}),k&&v?.fail)throw v;if("development"===process.env.NODE_ENV){let e=`${v?.status}: api[${o}] ${l.toUpperCase()} ${O}`;v?.ok?console.info(`🟢 ${e}`):console.info(`🔴 ${e}`);}return v},s),{})};
+class ApiError extends Error{constructor(r){super(`Request failed with ${r.status} ${r.msg}`),this.name="ApiError",Object.assign(this,r);}}
 
-export { ApiError, createApi, createApiResultFail, createApiResultOk };
+export { ApiError };

package/index.js

@@ -0,0 +1,4 @@
+export { ApiError } from "./ApiError";
+export { createApi } from "./createApi";
+export { createApiResultFail } from "./createApiResultFail";
+export { createApiResultOk } from "./createApiResultOk";

package/next/nextApiResponse.d.ts

@@ -0,0 +1,6 @@
+import { NextResponse } from "next/server";
+export declare let nextApiResponse: {
+    ok<T>(data: T, msg?: string): NextResponse<import("..").Api.ResultOk<T>>;
+    fail<T_1>(data: T_1, msg?: string, status?: number): NextResponse<import("..").Api.ResultFail<T_1>>;
+};
+export default nextApiResponse;

package/next/nextApiResponse.js

@@ -0,0 +1,12 @@
+import { NextResponse } from "next/server";
+import { createApiResultFail } from "../createApiResultFail";
+import { createApiResultOk } from "../createApiResultOk";
+export let nextApiResponse = {
+    ok(data, msg) {
+        return NextResponse.json(createApiResultOk(data, msg));
+    },
+    fail(data, msg, status) {
+        return NextResponse.json(createApiResultFail(data, msg, status));
+    },
+};
+export default nextApiResponse;

package/next/nextApiResponse12.d.ts

@@ -0,0 +1,6 @@
+import type { NextApiResponse } from "next";
+export declare let nextApiResponse12: (nextRes: NextApiResponse) => {
+    ok<T>(data: T, msg?: string): void;
+    fail<T_1>(data: T_1, msg?: string, status?: number): void;
+};
+export default nextApiResponse12;

package/next/nextApiResponse12.js

@@ -0,0 +1,11 @@
+import { createApiResultFail } from "../createApiResultFail";
+import { createApiResultOk } from "../createApiResultOk";
+export let nextApiResponse12 = (nextRes) => ({
+    ok(data, msg) {
+        nextRes.status(200).json(createApiResultOk(data, msg));
+    },
+    fail(data, msg, status) {
+        nextRes.status(status || 404).json(createApiResultFail(data, msg, status));
+    },
+});
+export default nextApiResponse12;

package/next.cjs.js

@@ -3,10 +3,11 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var server = require('next/server');
-var index = require('./index.cjs.js');
-require('@koine/utils');
+var createApiResultOk = require('./createApiResultOk.cjs.js');
 
-let nextApiResponse={ok:(o,t)=>server.NextResponse.json(index.createApiResultOk(o,t)),fail:(s,t,n)=>server.NextResponse.json(index.createApiResultFail(s,t,n))};let nextApiResponse12=e=>({ok(o,t){e.status(200).json(index.createApiResultOk(o,t));},fail(s,t,n){e.status(n||404).json(index.createApiResultFail(s,t,n));}});
+let nextApiResponse={ok:(t,r)=>server.NextResponse.json(createApiResultOk.createApiResultOk(t,r)),fail:(o,r,p)=>server.NextResponse.json(createApiResultOk.createApiResultFail(o,r,p))};
+
+let nextApiResponse12=s=>({ok(e,o){s.status(200).json(createApiResultOk.createApiResultOk(e,o));},fail(t,o,p){s.status(p||404).json(createApiResultOk.createApiResultFail(t,o,p));}});
 
 exports.nextApiResponse = nextApiResponse;
 exports.nextApiResponse12 = nextApiResponse12;

package/next.d.ts

@@ -1,10 +1,2 @@
-import type { NextApiResponse } from "next";
-import { NextResponse } from "next/server";
-export declare let nextApiResponse: {
-    ok<T>(data: T, msg?: string): NextResponse<import("./types").Api.ResultOk<T>>;
-    fail<T_1>(data: T_1, msg?: string, status?: number): NextResponse<import("./types").Api.ResultFail<T_1>>;
-};
-export declare let nextApiResponse12: (nextRes: NextApiResponse) => {
-    ok<T>(data: T, msg?: string): void;
-    fail<T_1>(data: T_1, msg?: string, status?: number): void;
-};
+export { nextApiResponse } from "./next/nextApiResponse";
+export { nextApiResponse12 } from "./next/nextApiResponse12";

package/next.esm.js

@@ -1,7 +1,8 @@
 import { NextResponse } from 'next/server';
-import { createApiResultOk, createApiResultFail } from './index.esm.js';
-import '@koine/utils';
+import { a as createApiResultOk, c as createApiResultFail } from './createApiResultOk.esm.js';
 
-let nextApiResponse={ok:(o,t)=>NextResponse.json(createApiResultOk(o,t)),fail:(s,t,n)=>NextResponse.json(createApiResultFail(s,t,n))};let nextApiResponse12=e=>({ok(o,t){e.status(200).json(createApiResultOk(o,t));},fail(s,t,n){e.status(n||404).json(createApiResultFail(s,t,n));}});
+let nextApiResponse={ok:(t,r)=>NextResponse.json(createApiResultOk(t,r)),fail:(o,r,p)=>NextResponse.json(createApiResultFail(o,r,p))};
+
+let nextApiResponse12=s=>({ok(e,o){s.status(200).json(createApiResultOk(e,o));},fail(t,o,p){s.status(p||404).json(createApiResultFail(t,o,p));}});
 
 export { nextApiResponse, nextApiResponse12 };

package/next.js

@@ -0,0 +1,2 @@
+export { nextApiResponse } from "./next/nextApiResponse";
+export { nextApiResponse12 } from "./next/nextApiResponse12";

package/package.json

@@ -2,7 +2,7 @@
   "name": "@koine/api",
   "sideEffects": false,
   "dependencies": {
-    "@koine/utils": "2.0.0-beta.72"
+    "@koine/utils": "2.0.0-beta.74"
   },
   "peerDependencies": {
     "next": "^14.0.4",
@@ -28,18 +28,18 @@
       "import": "./next.cjs.mjs",
       "default": "./next.cjs.js"
     },
-    "./swr-mutation": {
-      "module": "./swr-mutation.esm.js",
-      "import": "./swr-mutation.cjs.mjs",
-      "default": "./swr-mutation.cjs.js"
-    },
     "./swr": {
       "module": "./swr.esm.js",
       "import": "./swr.cjs.mjs",
       "default": "./swr.cjs.js"
+    },
+    "./swr-mutation": {
+      "module": "./swr-mutation.esm.js",
+      "import": "./swr-mutation.cjs.mjs",
+      "default": "./swr-mutation.cjs.js"
     }
   },
   "module": "./index.esm.js",
   "main": "./index.cjs.js",
-  "version": "2.0.0-beta.72"
+  "version": "2.0.0-beta.74"
 }

package/swr/createSwrApi.d.ts

@@ -0,0 +1,9 @@
+import { type BareFetcher, type SWRConfiguration, type SWRResponse } from "swr";
+import type { Api } from "../types";
+type SWRConfigurationExtended<Data = any, Error = any, Fn extends BareFetcher<any> = BareFetcher<any>> = SWRConfiguration<Data, Error, Fn> & {
+    when?: boolean | (() => boolean);
+};
+export declare let createSwrApi: <TEndpoints extends Api.Endpoints>(apiName: string, baseUrl: string, options?: Api.ClientOptions | undefined) => Api.Client<TEndpoints> & {
+    use: <TEndpoint extends Extract<keyof TEndpoints, string>>(endpoint: TEndpoint, options?: Api.EndpointOptions<TEndpoints, TEndpoint, "get"> | undefined, config?: SWRConfigurationExtended<Api.GetDataType<TEndpoints, TEndpoint, "get", "ok">, Api.GetDataType<TEndpoints, TEndpoint, "get", "fail">, BareFetcher<any>> | undefined) => SWRResponse<Api.GetDataType<TEndpoints, TEndpoint, "get", "ok">, Api.GetDataType<TEndpoints, TEndpoint, "get", "fail">, any>;
+};
+export default createSwrApi;

package/swr/createSwrApi.js

@@ -0,0 +1,22 @@
+"use client";
+import useSWR, {} from "swr";
+import { isFunction } from "@koine/utils";
+import { createApi } from "../createApi";
+export let createUseApi = (api) => (endpoint, options, config) => {
+    const fetcher = async () => {
+        const { data } = await api.get(endpoint, {
+            ...(options || {}),
+            throwErr: true,
+        });
+        return data;
+    };
+    const shouldNotFetch = config?.when === false ||
+        (isFunction(config?.when) && config?.when() === false);
+    return useSWR(shouldNotFetch ? null : options ? [endpoint, options] : [endpoint], fetcher, config);
+};
+export let createSwrApi = (...args) => {
+    const api = createApi(...args);
+    api.use = createUseApi(api);
+    return api;
+};
+export default createSwrApi;

package/swr-mutation/createSwrMutationApi.d.ts

@@ -0,0 +1,19 @@
+import { type SWRMutationConfiguration, type SWRMutationResponse } from "swr/mutation";
+import { createUseApi } from "../swr/createSwrApi";
+import type { Api } from "../types";
+type MutationRequestMethod = Exclude<Api.RequestMethod, "get">;
+type MutationHookName = Exclude<keyof Api.HooksMapsByName, "use">;
+type KoineApiMethodHookSWR<THookName extends MutationHookName, TEndpoints extends Api.Endpoints> = <TEndpoint extends Api.EndpointUrl<TEndpoints>, TMethod extends MutationRequestMethod = Api.HooksMapsByName[THookName]>(endpoint: TEndpoint, options?: Api.EndpointOptions<TEndpoints, TEndpoint, TMethod>, config?: SWRMutationConfiguration<Api.EndpointResponseOk<TEndpoints, TEndpoint, TMethod>, Api.EndpointResponseFail<TEndpoints, TEndpoint, TMethod>, TEndpoint, Api.EndpointOptions<TEndpoints, TEndpoint, TMethod>>) => SWRMutationResponse<Api.EndpointResponseOk<TEndpoints, TEndpoint, TMethod>, Api.EndpointResponseFail<TEndpoints, TEndpoint, TMethod>, TEndpoint, Api.EndpointOptions<TEndpoints, TEndpoint, TMethod>>;
+export declare let createSwrMutationApi: <TEndpoints extends Api.Endpoints>(apiName: string, baseUrl: string, options?: Api.ClientOptions | undefined) => Api.Client<TEndpoints> & {
+    usePost: KoineApiMethodHookSWR<"usePost", TEndpoints>;
+    usePut: KoineApiMethodHookSWR<"usePut", TEndpoints>;
+    usePatch: KoineApiMethodHookSWR<"usePatch", TEndpoints>;
+    useDelete: KoineApiMethodHookSWR<"useDelete", TEndpoints>;
+} & {
+    use: <TEndpoint extends Extract<keyof TEndpoints, string>>(endpoint: TEndpoint, options?: Api.EndpointOptions<TEndpoints, TEndpoint, "get"> | undefined, config?: (Partial<import("swr/dist/_internal").PublicConfiguration<Api.GetDataType<TEndpoints, TEndpoint, "get", "ok">, Api.GetDataType<TEndpoints, TEndpoint, "get", "fail">, import("swr/dist/_internal").BareFetcher<any>>> & Partial<import("swr/dist/_internal").ProviderConfiguration> & {
+        provider?: ((cache: Readonly<import("swr/dist/_internal").Cache<any>>) => import("swr/dist/_internal").Cache<any>) | undefined;
+    } & {
+        when?: boolean | (() => boolean) | undefined;
+    }) | undefined) => import("swr/dist/_internal").SWRResponse<Api.GetDataType<TEndpoints, TEndpoint, "get", "ok">, Api.GetDataType<TEndpoints, TEndpoint, "get", "fail">, any>;
+};
+export default createSwrMutationApi;

package/swr-mutation/createSwrMutationApi.js

@@ -0,0 +1,27 @@
+"use client";
+import useSWRMutation, {} from "swr/mutation";
+import { createApi } from "../createApi";
+import { createUseApi } from "../swr/createSwrApi";
+let createUseMutationApi = (api, method) => (endpoint, options, config) => {
+    const sender = async (_endpoint, _options) => {
+        const endpoint = Array.isArray(_endpoint) ? _endpoint[0] : _endpoint;
+        const options = Array.isArray(_endpoint) ? _endpoint[1] : {};
+        const { ok, data } = await api[method](endpoint, {
+            ...options,
+            ...(_options.arg || {}),
+            throwErr: true,
+        });
+        return ok ? data : data;
+    };
+    return useSWRMutation(options ? [endpoint, options] : endpoint, sender, config);
+};
+export let createSwrMutationApi = (...args) => {
+    const api = createApi(...args);
+    api.use = createUseApi(api);
+    ["post", "put", "patch", "delete"].forEach((method) => {
+        const hookName = `use${method.charAt(0).toUpperCase() + method.slice(1)}`;
+        api[hookName] = createUseMutationApi(api, method);
+    });
+    return api;
+};
+export default createSwrMutationApi;

package/swr-mutation.cjs.js

@@ -3,8 +3,8 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var r = require('swr/mutation');
-var index = require('./index.cjs.js');
-var swr = require('./swr.cjs.js');
+var createApi = require('./createApi.cjs.js');
+var createSwrApi = require('./createSwrApi.cjs.js');
 require('@koine/utils');
 require('swr');
 
@@ -12,6 +12,6 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 
 var r__default = /*#__PURE__*/_interopDefaultLegacy(r);
 
-let a=(t,e)=>(a,o,i)=>r__default["default"](o?[a,o]:a,async(r,a)=>{let o=Array.isArray(r)?r[0]:r,i=Array.isArray(r)?r[1]:{},{ok:p,data:s}=await t[e](o,{...i,...a.arg||{},throwErr:!0});return s},i);let createSwrMutationApi=(...r)=>{let o=index.createApi(...r);return o.use=swr.createUseApi(o),["post","put","patch","delete"].forEach(r=>{o[`use${r.charAt(0).toUpperCase()+r.slice(1)}`]=a(o,r);}),o};
+let a=(t,e)=>(a,o,i)=>r__default["default"](o?[a,o]:a,async(r,a)=>{let o=Array.isArray(r)?r[0]:r,i=Array.isArray(r)?r[1]:{},{ok:p,data:s}=await t[e](o,{...i,...a.arg||{},throwErr:!0});return s},i);let createSwrMutationApi=(...r)=>{let o=createApi.createApi(...r);return o.use=createSwrApi.createUseApi(o),["post","put","patch","delete"].forEach(r=>{o[`use${r.charAt(0).toUpperCase()+r.slice(1)}`]=a(o,r);}),o};
 
 exports.createSwrMutationApi = createSwrMutationApi;

package/swr-mutation.d.ts

@@ -1,17 +1 @@
-import { type SWRMutationConfiguration, type SWRMutationResponse } from "swr/mutation";
-import { createUseApi } from "./swr";
-import type { Api } from "./types";
-type MutationRequestMethod = Exclude<Api.RequestMethod, "get">;
-type MutationHookName = Exclude<keyof Api.HooksMapsByName, "use">;
-type KoineApiMethodHookSWR<THookName extends MutationHookName, TEndpoints extends Api.Endpoints> = <TEndpoint extends Api.EndpointUrl<TEndpoints>, TMethod extends MutationRequestMethod = Api.HooksMapsByName[THookName]>(endpoint: TEndpoint, options?: Api.EndpointOptions<TEndpoints, TEndpoint, TMethod>, config?: SWRMutationConfiguration<Api.EndpointResponseOk<TEndpoints, TEndpoint, TMethod>, Api.EndpointResponseFail<TEndpoints, TEndpoint, TMethod>, TEndpoint, Api.EndpointOptions<TEndpoints, TEndpoint, TMethod>>) => SWRMutationResponse<Api.EndpointResponseOk<TEndpoints, TEndpoint, TMethod>, Api.EndpointResponseFail<TEndpoints, TEndpoint, TMethod>, TEndpoint, Api.EndpointOptions<TEndpoints, TEndpoint, TMethod>>;
-export declare let createSwrMutationApi: <TEndpoints extends Api.Endpoints>(apiName: string, baseUrl: string, options?: Api.ClientOptions | undefined) => Api.Client<TEndpoints> & {
-    usePost: KoineApiMethodHookSWR<"usePost", TEndpoints>;
-    usePut: KoineApiMethodHookSWR<"usePut", TEndpoints>;
-    usePatch: KoineApiMethodHookSWR<"usePatch", TEndpoints>;
-    useDelete: KoineApiMethodHookSWR<"useDelete", TEndpoints>;
-} & {
-    use: <TEndpoint extends Extract<keyof TEndpoints, string>>(endpoint: TEndpoint, options?: Api.EndpointOptions<TEndpoints, TEndpoint, "get"> | undefined, config?: (Partial<import("swr/_internal").PublicConfiguration<Api.EndpointResponseOk<TEndpoints, TEndpoint, "get">, Api.EndpointResponseFail<TEndpoints, TEndpoint, "get">, import("swr/_internal").BareFetcher<any>>> & {
-        when?: boolean | (() => boolean) | undefined;
-    }) | undefined) => import("swr/_internal").SWRResponse<Api.EndpointResponseOk<TEndpoints, TEndpoint, "get">, Api.EndpointResponseFail<TEndpoints, TEndpoint, "get">, any>;
-};
-export {};
+export { createSwrMutationApi } from "./swr-mutation/createSwrMutationApi";

package/swr-mutation.esm.js

@@ -1,6 +1,6 @@
 import r from 'swr/mutation';
-import { createApi } from './index.esm.js';
-import { createUseApi } from './swr.esm.js';
+import { c as createApi } from './createApi.esm.js';
+import { a as createUseApi } from './createSwrApi.esm.js';
 import '@koine/utils';
 import 'swr';
 

package/swr-mutation.js

@@ -0,0 +1 @@
+export { createSwrMutationApi } from "./swr-mutation/createSwrMutationApi";

package/swr.cjs.js

@@ -2,15 +2,11 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var e = require('swr');
-var utils = require('@koine/utils');
-var index = require('./index.cjs.js');
+var createSwrApi = require('./createSwrApi.cjs.js');
+require('swr');
+require('@koine/utils');
+require('./createApi.cjs.js');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-var e__default = /*#__PURE__*/_interopDefaultLegacy(e);
 
-let createUseApi=t=>(i,n,o)=>{let l=async()=>{let{data:e}=await t.get(i,{...n||{},throwErr:!0});return e};return e__default["default"](o?.when===!1||utils.isFunction(o?.when)&&o?.when()===!1?null:n?[i,n]:[i],l,o)};let createSwrApi=(...e)=>{let r=index.createApi(...e);return r.use=createUseApi(r),r};
-
-exports.createSwrApi = createSwrApi;
-exports.createUseApi = createUseApi;
+exports.createSwrApi = createSwrApi.createSwrApi;

package/swr.d.ts

@@ -1,10 +1 @@
-import { type BareFetcher, type SWRConfiguration, type SWRResponse } from "swr";
-import type { Api } from "./types";
-type SWRConfigurationExtended<Data = any, Error = any, Fn extends BareFetcher<any> = BareFetcher<any>> = SWRConfiguration<Data, Error, Fn> & {
-    when?: boolean | (() => boolean);
-};
-export declare let createUseApi: <TEndpoints extends Api.Endpoints>(api: Api.Client<TEndpoints>) => <TEndpoint extends Extract<keyof TEndpoints, string>>(endpoint: TEndpoint, options?: Api.EndpointOptions<TEndpoints, TEndpoint, "get"> | undefined, config?: SWRConfigurationExtended<Api.EndpointResponseOk<TEndpoints, TEndpoint, "get">, Api.EndpointResponseFail<TEndpoints, TEndpoint, "get">, BareFetcher<any>> | undefined) => SWRResponse<Api.EndpointResponseOk<TEndpoints, TEndpoint, "get">, Api.EndpointResponseFail<TEndpoints, TEndpoint, "get">, any>;
-export declare let createSwrApi: <TEndpoints extends Api.Endpoints>(apiName: string, baseUrl: string, options?: Api.ClientOptions | undefined) => Api.Client<TEndpoints> & {
-    use: <TEndpoint extends Extract<keyof TEndpoints, string>>(endpoint: TEndpoint, options?: Api.EndpointOptions<TEndpoints, TEndpoint, "get"> | undefined, config?: SWRConfigurationExtended<Api.EndpointResponseOk<TEndpoints, TEndpoint, "get">, Api.EndpointResponseFail<TEndpoints, TEndpoint, "get">, BareFetcher<any>> | undefined) => SWRResponse<Api.EndpointResponseOk<TEndpoints, TEndpoint, "get">, Api.EndpointResponseFail<TEndpoints, TEndpoint, "get">, any>;
-};
-export {};
+export { createSwrApi } from "./swr/createSwrApi";

package/swr.esm.js

@@ -1,7 +1,4 @@
-import e from 'swr';
-import { isFunction } from '@koine/utils';
-import { createApi } from './index.esm.js';
-
-let createUseApi=t=>(i,n,o)=>{let l=async()=>{let{data:e}=await t.get(i,{...n||{},throwErr:!0});return e};return e(o?.when===!1||isFunction(o?.when)&&o?.when()===!1?null:n?[i,n]:[i],l,o)};let createSwrApi=(...e)=>{let r=createApi(...e);return r.use=createUseApi(r),r};
-
-export { createSwrApi, createUseApi };
+export { c as createSwrApi } from './createSwrApi.esm.js';
+import 'swr';
+import '@koine/utils';
+import './createApi.esm.js';

package/swr.js

@@ -0,0 +1 @@
+export { createSwrApi } from "./swr/createSwrApi";

package/types.js

@@ -0,0 +1 @@
+export {};