@koine/api 2.0.0-beta.4 → 2.0.0-beta.41

package/index.cjs.d.ts

@@ -0,0 +1 @@
+export * from "./index";

package/index.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./index.cjs.js').default;

package/index.cjs.js

@@ -0,0 +1,12 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var utils = 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),{})};
+
+exports.ApiError = ApiError;
+exports.createApi = createApi;
+exports.createApiResultFail = createApiResultFail;
+exports.createApiResultOk = createApiResultOk;

package/index.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './index.cjs.js';
+export { _default as default } from './index.cjs.default.js';

package/index.d.ts

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

package/index.esm.js

@@ -0,0 +1,5 @@
+import { isFullObject, buildUrlQueryString, errorToString } from '@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),{})};
+
+export { ApiError, createApi, createApiResultFail, createApiResultOk };

package/next.cjs.d.ts

@@ -0,0 +1 @@
+export * from "./next";

package/next.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./next.cjs.js').default;

package/next.cjs.js

@@ -0,0 +1,12 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var server = require('next/server');
+var index = require('./index.cjs.js');
+require('@koine/utils');
+
+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));}});
+
+exports.nextApiResponse = nextApiResponse;
+exports.nextApiResponse12 = nextApiResponse12;

package/next.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './next.cjs.js';
+export { _default as default } from './next.cjs.default.js';

package/next.d.ts

@@ -0,0 +1,10 @@
+import type { NextApiResponse } from "next";
+import { NextResponse } from "next/server";
+export declare let nextApiResponse: {
+    ok<T>(data: T, msg?: string): NextResponse<Koine.Api.ResultOk<T>>;
+    fail<T_1>(data: T_1, msg?: string, status?: number): NextResponse<Koine.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;
+};

package/next.esm.js

@@ -0,0 +1,7 @@
+import { NextResponse } from 'next/server';
+import { createApiResultOk, createApiResultFail } from './index.esm.js';
+import '@koine/utils';
+
+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));}});
+
+export { nextApiResponse, nextApiResponse12 };

package/package.json

@@ -1,27 +1,45 @@
 {
   "name": "@koine/api",
   "sideEffects": false,
+  "dependencies": {
+    "@koine/utils": "2.0.0-beta.41"
+  },
+  "peerDependencies": {
+    "next": "^14.0.4",
+    "swr": "^2.2.4"
+  },
   "peerDependenciesMeta": {
     "next": {
       "optional": true
+    },
+    "swr": {
+      "optional": true
     }
   },
-  "dependencies": {
-    "clsx": "^1.2.1",
-    "next": "^13.4.7",
-    "swr": "^2.2.0",
-    "ts-debounce": "^4.0.0",
-    "type-fest": "^3.12.0"
-  },
-  "peerDependencies": {},
-  "module": "./index.mjs",
-  "main": "./index.js",
   "exports": {
+    "./package.json": "./package.json",
     ".": {
-      "import": "./index.js",
-      "require": "./index.js"
+      "module": "./index.esm.js",
+      "import": "./index.cjs.mjs",
+      "default": "./index.cjs.js"
+    },
+    "./next": {
+      "module": "./next.esm.js",
+      "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"
     }
   },
-  "types": "./index.d.ts",
-  "version": "2.0.0-beta.4"
-}
+  "module": "./index.esm.js",
+  "main": "./index.cjs.js",
+  "version": "2.0.0-beta.41"
+}

package/swr-mutation.cjs.d.ts

@@ -0,0 +1 @@
+export * from "./swr-mutation";

package/swr-mutation.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./swr-mutation.cjs.js').default;

package/swr-mutation.cjs.js

@@ -0,0 +1,17 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var r = require('swr/mutation');
+var index = require('./index.cjs.js');
+var swr = require('./swr.cjs.js');
+require('@koine/utils');
+require('swr');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+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};
+
+exports.createSwrMutationApi = createSwrMutationApi;

package/swr-mutation.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './swr-mutation.cjs.js';
+export { _default as default } from './swr-mutation.cjs.default.js';

package/swr-mutation.d.ts

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

package/swr-mutation.esm.js

@@ -0,0 +1,9 @@
+import r from 'swr/mutation';
+import { createApi } from './index.esm.js';
+import { createUseApi } from './swr.esm.js';
+import '@koine/utils';
+import 'swr';
+
+let a=(t,e)=>(a,o,i)=>r(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(...r);return o.use=createUseApi(o),["post","put","patch","delete"].forEach(r=>{o[`use${r.charAt(0).toUpperCase()+r.slice(1)}`]=a(o,r);}),o};
+
+export { createSwrMutationApi };

package/swr.cjs.d.ts

@@ -0,0 +1 @@
+export * from "./swr";

package/swr.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./swr.cjs.js').default;

package/swr.cjs.js

@@ -0,0 +1,16 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var e = require('swr');
+var utils = require('@koine/utils');
+var index = require('./index.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;

package/swr.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './swr.cjs.js';
+export { _default as default } from './swr.cjs.default.js';

package/swr.d.ts

@@ -0,0 +1,9 @@
+import { type BareFetcher, type SWRConfiguration, type SWRResponse } from "swr";
+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 Koine.Api.Endpoints>(api: Koine.Api.Client<TEndpoints>) => <TEndpoint extends Extract<keyof TEndpoints, string>>(endpoint: TEndpoint, options?: Koine.Api.EndpointOptions<TEndpoints, TEndpoint, "get"> | undefined, config?: SWRConfigurationExtended<Koine.Api.EndpointResponseOk<TEndpoints, TEndpoint, "get">, Koine.Api.EndpointResponseFail<TEndpoints, TEndpoint, "get">, BareFetcher<any>> | undefined) => SWRResponse<Koine.Api.EndpointResponseOk<TEndpoints, TEndpoint, "get">, Koine.Api.EndpointResponseFail<TEndpoints, TEndpoint, "get">, any>;
+export declare let createSwrApi: <TEndpoints extends Koine.Api.Endpoints>(apiName: string, baseUrl: string, options?: Koine.Api.ClientOptions | undefined) => Koine.Api.Client<TEndpoints> & {
+    use: <TEndpoint extends Extract<keyof TEndpoints, string>>(endpoint: TEndpoint, options?: Koine.Api.EndpointOptions<TEndpoints, TEndpoint, "get"> | undefined, config?: SWRConfigurationExtended<Koine.Api.EndpointResponseOk<TEndpoints, TEndpoint, "get">, Koine.Api.EndpointResponseFail<TEndpoints, TEndpoint, "get">, BareFetcher<any>> | undefined) => SWRResponse<Koine.Api.EndpointResponseOk<TEndpoints, TEndpoint, "get">, Koine.Api.EndpointResponseFail<TEndpoints, TEndpoint, "get">, any>;
+};
+export {};

package/swr.esm.js

@@ -0,0 +1,7 @@
+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 };

package/typings.d.ts

@@ -8,14 +8,14 @@ type _Response = Response;
 type ExtractEndpointParams<T extends string> = string extends T
   ? Record<string, string>
   : // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  T extends `${infer _Start}{${infer Param}}${infer Rest}`
-  ? { [k in Param | keyof ExtractEndpointParams<Rest>]: string | number }
-  : // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  T extends `${infer _Start}{${infer Param}}`
-  ? { [k in Param]: string | number }
-  : never;
-
-declare namespace Koine.Api {
+    T extends `${infer _Start}{${infer Param}}${infer Rest}`
+    ? { [k in Param | keyof ExtractEndpointParams<Rest>]: string | number }
+    : // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      T extends `${infer _Start}{${infer Param}}`
+      ? { [k in Param]: string | number }
+      : never;
+
+namespace Koine.Api {
   // @see https://stackoverflow.com/a/60702896/1938970
   // import { Exact } from "type-fest";
 
@@ -28,7 +28,7 @@ declare namespace Koine.Api {
   type ClientCreator<TEndpoints extends Endpoints> = (
     apiName: string,
     baseUrl: string,
-    options?: ClientOptions
+    options?: ClientOptions,
   ) => Client<TEndpoints>;
 
   type ClientOptions = {
@@ -46,7 +46,7 @@ declare namespace Koine.Api {
      *
      * @see RequestInit
      *
-     * @default { credentials: "include", referrerPolicy: "no-referrer" }
+     * @default {}
      */
     request?: Omit<RequestInit, "body" | "headers" | "method">;
     /**
@@ -85,7 +85,7 @@ declare namespace Koine.Api {
 
   type ClientMethod<
     TMethod extends RequestMethod,
-    TEndpoints extends Endpoints
+    TEndpoints extends Endpoints,
   > = <
     TEndpoint extends EndpointUrl<TEndpoints>,
     TOptions extends EndpointOptions<TEndpoints, TEndpoint, TMethod>,
@@ -94,10 +94,10 @@ declare namespace Koine.Api {
       TEndpoints,
       TEndpoint,
       TMethod
-    >
+    >,
   >(
     endpoint: TEndpoint,
-    options?: TOptions
+    options?: TOptions,
   ) => Promise<EndpointResult<TEndpoints, TEndpoint, TMethod>>;
   // ) => Promise<Result<TOk, TFail>>;
 
@@ -117,7 +117,7 @@ declare namespace Koine.Api {
   type EndpointOptions<
     TEndpoints extends Endpoints,
     TEndpoint extends EndpointUrl<TEndpoints>,
-    TMethod extends RequestMethod
+    TMethod extends RequestMethod,
   > = RequestOptions<
     TEndpoints,
     TEndpoint,
@@ -129,31 +129,31 @@ declare namespace Koine.Api {
   type EndpointResultOk<
     TEndpoints extends Endpoints,
     TEndpoint extends EndpointUrl<TEndpoints>,
-    TMethod extends RequestMethod
+    TMethod extends RequestMethod,
   > = ResultOk<TEndpoints[TEndpoint][Uppercase<TMethod>]["ok"]>;
 
   type EndpointResultFail<
     TEndpoints extends Endpoints,
     TEndpoint extends EndpointUrl<TEndpoints>,
-    TMethod extends RequestMethod
+    TMethod extends RequestMethod,
   > = ResultFail<TEndpoints[TEndpoint][Uppercase<TMethod>]["fail"]>;
 
   type EndpointResponseOk<
     TEndpoints extends Endpoints,
     TEndpoint extends EndpointUrl<TEndpoints>,
-    TMethod extends RequestMethod
+    TMethod extends RequestMethod,
   > = TEndpoints[TEndpoint][Uppercase<TMethod>]["ok"];
 
   type EndpointResponseFail<
     TEndpoints extends Endpoints,
     TEndpoint extends EndpointUrl<TEndpoints>,
-    TMethod extends RequestMethod
+    TMethod extends RequestMethod,
   > = TEndpoints[TEndpoint][Uppercase<TMethod>]["fail"];
 
   type EndpointResult<
     TEndpoints extends Endpoints,
     TEndpoint extends EndpointUrl<TEndpoints>,
-    TMethod extends RequestMethod
+    TMethod extends RequestMethod,
   > = Result<
     EndpointResponseOk<TEndpoints, TEndpoint, TMethod>,
     EndpointResponseFail<TEndpoints, TEndpoint, TMethod>
@@ -240,7 +240,7 @@ declare namespace Koine.Api {
     TEndpoint extends EndpointUrl<TEndpoints>,
     TMethod extends RequestMethod,
     TJson extends RequestJson,
-    TQuery extends RequestQuery
+    TQuery extends RequestQuery,
   > = Omit<ClientOptions, "processReq"> & {
     processReq?: EndpointRequestProcessor<TEndpoints, TEndpoint, TMethod>;
     /**
@@ -273,7 +273,7 @@ declare namespace Koine.Api {
   type ResponseFail = unknown;
 
   type ResultShared<
-    T extends Record<string, unknown> = Record<string, unknown>
+    T extends Record<string, unknown> = Record<string, unknown>,
   > = T & {
     status: _Response["status"];
     msg: _Response["statusText"];
@@ -297,7 +297,7 @@ declare namespace Koine.Api {
 
   type Result<
     TResponseOk extends ResponseOk,
-    TResponseFail extends ResponseFail
+    TResponseFail extends ResponseFail,
   > =
     | {
         status: _Response["status"];
@@ -324,13 +324,13 @@ declare namespace Koine.Api {
     query: any,
     json: any,
     params: any,
-    requestInit: RequestInit
+    requestInit: RequestInit,
   ) => [
     string, // url
     RequestQuery, // query
     RequestJson, // json
     RequestParams, // params
-    RequestInit // requestInit
+    RequestInit, // requestInit
   ];
 
   /**
@@ -343,20 +343,20 @@ declare namespace Koine.Api {
   type EndpointRequestProcessor<
     TEndpoints extends Endpoints,
     TEndpoint extends EndpointUrl<TEndpoints>,
-    TMethod extends RequestMethod
+    TMethod extends RequestMethod,
   > = (
     method: TMethod,
     url: string,
     query: EndpointOptions<TEndpoints, TEndpoint, TMethod>["query"],
     json: EndpointOptions<TEndpoints, TEndpoint, TMethod>["json"],
     params: EndpointOptions<TEndpoints, TEndpoint, TMethod>["params"],
-    requestInit: RequestInit
+    requestInit: RequestInit,
   ) => [
     string, // url
     EndpointOptions<TEndpoints, TEndpoint, TMethod>["query"], // query
     EndpointOptions<TEndpoints, TEndpoint, TMethod>["json"], // json
     EndpointOptions<TEndpoints, TEndpoint, TMethod>["params"], // params
-    RequestInit // requestInit
+    RequestInit, // requestInit
   ];
 
   /**
@@ -365,7 +365,7 @@ declare namespace Koine.Api {
    */
   type ResponseProcessorRes = <TResponseOk extends ResponseOk = ResponseOk>(
     response: _Response,
-    options: TOptions
+    options: TOptions,
   ) => Promise<Koine.Api.Result<TResponseOk>>;
 
   /**
@@ -373,10 +373,10 @@ declare namespace Koine.Api {
    * transformations to a single or all endpoint responses
    */
   type ResponseProcessorErr = <
-    TResponseFail extends ResponseFailed = ResponseFailed
+    TResponseFail extends ResponseFailed = ResponseFailed,
   >(
     msg: string,
-    options: TOptions
+    options: TOptions,
   ) => Promise<Koine.Api.Result<TResponseFail>>;
 
   //////////////////////////////////////////////////////////////////////////////
@@ -393,7 +393,7 @@ declare namespace Koine.Api {
    * standalone hooks, see SWR ones to start with.
    */
   type HooksMaps = {
-    [TMethod in RequestMethod]: `use${Capitalize<TMethod>}`;
+    [TMethod in RequestMethod]: `use${TMethod extends "get" ? "" : Capitalize<TMethod>}`;
   };
 
   type HooksMapsByName = { [K in keyof HooksMaps as HooksMaps[K]]: K };
@@ -424,6 +424,30 @@ declare namespace Koine.Api {
     [K in keyof _ShortcutsMaps as _ShortcutsMaps[K]]: K;
   };
 
+  /**
+   * @example
+   * ```ts
+   * // define the type on your `API` types:
+   * type Result = Koine.Api.GenerateResultShortcuts<Endpoints>;
+   *
+   * // consume the type wherever in your app:
+   * type MyResult = API.Result["get"]["my/endpoint"];
+   *
+   * MyResult["ok"];
+   * ^
+   * MyResult["fail"];
+   * ^
+   * ```
+   */
+  type GenerateResultShortcuts<TEndpoints extends Endpoints> = {
+    [TMethod in RequestMethod]: {
+      [TEndpointUrl in keyof TEndpoints]: {
+        ok: TEndpoints[TEndpointUrl][Uppercase<TMethod>]["ok"];
+        fail: TEndpoints[TEndpointUrl][Uppercase<TMethod>]["fail"];
+      };
+    };
+  };
+
   /**
    * @example
    * ```ts

package/ApiError.d.ts

@@ -1,11 +0,0 @@
-/**
- * Custom `ApiError` class extending `Error` to throw in failed response.
- *
- * @see https://eslint.org/docs/rules/no-throw-literal
- * @see https://github.com/sindresorhus/ky/blob/main/source/errors/HTTPError.ts
- *
- */
-export declare class ApiError<TResponseFail extends Koine.Api.ResponseFail = unknown> extends Error {
-    constructor(result: Koine.Api.ResultFail<TResponseFail>);
-}
-export default ApiError;

package/ApiError.js

@@ -1,32 +0,0 @@
-/**
- * Custom `ApiError` class extending `Error` to throw in failed response.
- *
- * @see https://eslint.org/docs/rules/no-throw-literal
- * @see https://github.com/sindresorhus/ky/blob/main/source/errors/HTTPError.ts
- *
- */ "use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    ApiError: function() {
-        return ApiError;
-    },
-    default: function() {
-        return _default;
-    }
-});
-let ApiError = class ApiError extends Error {
-    constructor(result){
-        super(`Request failed with ${result.status} ${result.msg}`);
-        this.name = "ApiError";
-        Object.assign(this, result);
-    }
-};
-const _default = ApiError;

package/ApiError.mjs

@@ -1,14 +0,0 @@
-/**
- * Custom `ApiError` class extending `Error` to throw in failed response.
- *
- * @see https://eslint.org/docs/rules/no-throw-literal
- * @see https://github.com/sindresorhus/ky/blob/main/source/errors/HTTPError.ts
- *
- */ 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.d.ts

@@ -1,8 +0,0 @@
-/**
- * Create api client
- *
- * @param apiName Short name to use in debug logs
- * @param baseUrl Either relativ eor absolute, it must end without trailing slash
- */
-export declare const createApi: <TEndpoints extends Koine.Api.Endpoints>(apiName: string, baseUrl: string, options?: Koine.Api.ClientOptions) => Koine.Api.Client<TEndpoints>;
-export default createApi;

package/createApi.js

@@ -1,142 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    createApi: function() {
-        return createApi;
-    },
-    default: function() {
-        return _default;
-    }
-});
-const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
-const _buildUrlQueryString = /*#__PURE__*/ _interop_require_default._(require("@koine/utils/buildUrlQueryString"));
-const _errorToString = /*#__PURE__*/ _interop_require_default._(require("@koine/utils/errorToString"));
-const _isFullObject = /*#__PURE__*/ _interop_require_default._(require("@koine/utils/isFullObject"));
-const createApi = (apiName, baseUrl, options)=>{
-    const { headers: headersBase = {}, request: requestBase = {
-        referrerPolicy: "no-referrer"
-    }, throwErr: throwErrBase, timeout: timeoutBase = 10000, processReq: processReqBase, processRes: processResBase, processErr: processErrBase } = options || {};
-    return [
-        "get",
-        "post",
-        "put",
-        "patch",
-        "delete"
-    ].reduce((api, method)=>{
-        // @ts-expect-error FIXME: type
-        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 ((0, _isFullObject.default)(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) {
-                // FIXME: ts-expect-error this assertion is not the best, but nevermind for now
-                url += (0, _buildUrlQueryString.default)(query);
-            }
-            let response = null;
-            let result = null;
-            let msg = "";
-            try {
-                response = await fetch(url, requestInit);
-            } catch (e) {
-                msg = (0, _errorToString.default)(e);
-            }
-            if (timeoutId) {
-                clearTimeout(timeoutId);
-            }
-            if (response) {
-                try {
-                    if (processRes) {
-                        result = await processRes(response, options || {});
-                    } else {
-                        result = await response.json();
-                    }
-                } catch (e) {
-                    msg = (0, _errorToString.default)(e);
-                }
-            }
-            if (result === null) {
-                if (processErr) {
-                    result = await processErr(msg, options || {});
-                } else {
-                    // this error should only happen on network errors or wrong API urls
-                    // there is no specific HTTP error for this, we can consider these
-                    // two statuses though:
-                    // - [100 Continue](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/100)
-                    // - [501 Not Implemented](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/501)
-                    result = {
-                        data: null,
-                        msg,
-                        status: 100,
-                        fail: true,
-                        ok: false
-                    };
-                }
-            }
-            if (throwErr && result?.fail) {
-                // throw new ApiError<Failed>(result);
-                // I prefer to throw an object literal despite what eslint says
-                // eslint-disable-next-line no-throw-literal
-                throw result;
-            }
-            if (process.env["NODE_ENV"] !== "production") {
-                const logMsg = `${result?.status}: api[${apiName}] ${method.toUpperCase()} ${url}`;
-                if (result?.ok) {
-                    console.info(`🟢 ${logMsg}`);
-                } else {
-                    console.info(`🔴 ${logMsg}`);
-                }
-            }
-            return result;
-        };
-        return api;
-    }, {});
-};
-const _default = createApi;

package/createApi.mjs

@@ -1,128 +0,0 @@
-import buildUrlQueryString from "@koine/utils/buildUrlQueryString";
-import errorToString from "@koine/utils/errorToString";
-import isFullObject from "@koine/utils/isFullObject";
-/**
- * Create api client
- *
- * @param apiName Short name to use in debug logs
- * @param baseUrl Either relativ eor absolute, it must end without trailing slash
- */ export const createApi = (apiName, baseUrl, options)=>{
-    const { headers: headersBase = {}, request: requestBase = {
-        referrerPolicy: "no-referrer"
-    }, throwErr: throwErrBase, timeout: timeoutBase = 10000, processReq: processReqBase, processRes: processResBase, processErr: processErrBase } = options || {};
-    return [
-        "get",
-        "post",
-        "put",
-        "patch",
-        "delete"
-    ].reduce((api, method)=>{
-        // @ts-expect-error FIXME: type
-        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) {
-                // FIXME: ts-expect-error this assertion is not the best, but nevermind for now
-                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 {
-                    // this error should only happen on network errors or wrong API urls
-                    // there is no specific HTTP error for this, we can consider these
-                    // two statuses though:
-                    // - [100 Continue](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/100)
-                    // - [501 Not Implemented](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/501)
-                    result = {
-                        data: null,
-                        msg,
-                        status: 100,
-                        fail: true,
-                        ok: false
-                    };
-                }
-            }
-            if (throwErr && result?.fail) {
-                // throw new ApiError<Failed>(result);
-                // I prefer to throw an object literal despite what eslint says
-                // eslint-disable-next-line no-throw-literal
-                throw result;
-            }
-            if (process.env["NODE_ENV"] !== "production") {
-                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/createSwrApi.d.ts

@@ -1,34 +0,0 @@
-import { type BareFetcher, // type Fetcher,
-type SWRConfiguration, type SWRResponse } from "swr";
-import { type SWRMutationConfiguration, type SWRMutationResponse } from "swr/mutation";
-type SWRConfigurationExtended<Data = any, Error = any, Fn extends BareFetcher<any> = BareFetcher<any>> = SWRConfiguration<Data, Error, Fn> & {
-    /**
-     * Conditional fetching as option
-     *
-     * Moving this to an option allows us to keep the endpoints typed dictionary,
-     * e.g. we can write:
-     *
-     * ```js
-     * const { data, mutate } = myApi.useGet("User/{id}",
-     *  { params: { id: aVariableMaybeContainingAnId || "" }, },
-     *  { when: !!aVariableMaybeContainingAnId }
-     * );
-     *
-     * // we still have typed `data`, `mutate`
-     * ```
-     * @see https://swr.vercel.app/docs/conditional-fetching
-     */
-    when?: boolean | (() => boolean);
-};
-type KoineApiMethodHookSWR<THookName extends keyof Koine.Api.HooksMapsByName, TEndpoints extends Koine.Api.Endpoints> = <TEndpoint extends Koine.Api.EndpointUrl<TEndpoints>, TMethod extends Koine.Api.RequestMethod = Koine.Api.HooksMapsByName[THookName]>(endpoint: TEndpoint, options?: Koine.Api.EndpointOptions<TEndpoints, TEndpoint, TMethod>, config?: THookName extends "useGet" ? SWRConfigurationExtended<Koine.Api.EndpointResponseOk<TEndpoints, TEndpoint, TMethod>, Koine.Api.EndpointResponseFail<TEndpoints, TEndpoint, TMethod>> : SWRMutationConfiguration<Koine.Api.EndpointResponseOk<TEndpoints, TEndpoint, TMethod>, Koine.Api.EndpointResponseFail<TEndpoints, TEndpoint, TMethod>, Koine.Api.EndpointOptions<TEndpoints, TEndpoint, TMethod>, TEndpoint>) => THookName extends "useGet" ? SWRResponse<Koine.Api.EndpointResponseOk<TEndpoints, TEndpoint, TMethod>, Koine.Api.EndpointResponseFail<TEndpoints, TEndpoint, TMethod>> : SWRMutationResponse<Koine.Api.EndpointResponseOk<TEndpoints, TEndpoint, TMethod>, Koine.Api.EndpointResponseFail<TEndpoints, TEndpoint, TMethod>, Koine.Api.EndpointOptions<TEndpoints, TEndpoint, TMethod>, TEndpoint>;
-/**
- * It creates an api client extended with auto-generated SWR wrapper hooks
- */
-export declare const createSwrApi: <TEndpoints extends Koine.Api.Endpoints>(apiName: string, baseUrl: string, options?: Koine.Api.ClientOptions | undefined) => Koine.Api.Client<TEndpoints> & {
-    useGet: KoineApiMethodHookSWR<"useGet", TEndpoints>;
-    usePost: KoineApiMethodHookSWR<"usePost", TEndpoints>;
-    usePut: KoineApiMethodHookSWR<"usePut", TEndpoints>;
-    usePatch: KoineApiMethodHookSWR<"usePatch", TEndpoints>;
-    useDelete: KoineApiMethodHookSWR<"useDelete", TEndpoints>;
-};
-export default createSwrApi;

package/createSwrApi.js

@@ -1,99 +0,0 @@
-"use client";
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    createSwrApi: function() {
-        return createSwrApi;
-    },
-    default: function() {
-        return _default;
-    }
-});
-const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
-const _swr = /*#__PURE__*/ _interop_require_default._(require("swr"));
-const _mutation = /*#__PURE__*/ _interop_require_default._(require("swr/mutation"));
-const _isFunction = /*#__PURE__*/ _interop_require_default._(require("@koine/utils/isFunction"));
-const _createApi = /*#__PURE__*/ _interop_require_default._(require("./createApi"));
-function createUseApi(api, method) {
-    return function useApi(endpoint, options, _config) {
-        if (method === "get") {
-            // const fetcher = async (_endpoint: TEndpoint) => {
-            //   try {
-            //     const { ok, data } = await api[method](_endpoint, {
-            //         ...(options || {}),
-            //         throwErr: true,
-            //       });
-            //       if (ok) {
-            //         return data;
-            //       }
-            //       throw new Error() as unknown as Koine.Api.EndpointResponseFail<TEndpoints, TEndpoint, TMethod>;
-            //     } catch(e) {
-            //       throw new Error() as unknown as Koine.Api.EndpointResponseFail<TEndpoints, TEndpoint, TMethod>;;
-            //     }
-            //   };
-            // }
-            const fetcher = async ()=>{
-                const { data } = await api[method](endpoint, {
-                    ...options || {},
-                    throwErr: true
-                });
-                return data;
-            };
-            const config = _config;
-            const shouldNotFetch = config?.when === false || (0, _isFunction.default)(config?.when) && config?.when() === false;
-            // <Data = any, Error = any>(key: Key, config: SWRConfigurationExtended<Data, Error, Fetcher<Data>> | undefined): SWRResponse<Data, Error>;
-            // eslint-disable-next-line react-hooks/rules-of-hooks
-            return (0, _swr.default)(shouldNotFetch ? null : options ? [
-                endpoint,
-                options
-            ] : [
-                endpoint
-            ], fetcher, config);
-        }
-        const config = _config;
-        const sender = async (// if the first argument is an array the second tem are the base options
-        // defined when calling the usePost/Put/etc. hook, these will be overriden
-        // by the _options just here below
-        _endpoint, // these are the options arriving when calling `trigger({ json, query, etc... })
-        _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;
-        };
-        // config.fetcher = sender;
-        // eslint-disable-next-line react-hooks/rules-of-hooks
-        return (0, _mutation.default)(// @ts-expect-error FIXME: I can't get it...
-        options ? [
-            endpoint,
-            options
-        ] : endpoint, sender, config);
-    };
-}
-const createSwrApi = (...args)=>{
-    const api = (0, _createApi.default)(...args);
-    [
-        "get",
-        "post",
-        "put",
-        "patch",
-        "delete"
-    ].forEach((method)=>{
-        const hookName = `use${method.charAt(0).toUpperCase() + method.slice(1)}`;
-        api[hookName] = createUseApi(api, method);
-    });
-    return api;
-};
-const _default = createSwrApi;

package/createSwrApi.mjs

@@ -1,82 +0,0 @@
-"use client";
-import useSWR from "swr";
-import useSWRMutation from "swr/mutation";
-import isFunction from "@koine/utils/isFunction";
-import createApi from "./createApi";
-function createUseApi(api, method) {
-    return function useApi(endpoint, options, _config) {
-        if (method === "get") {
-            // const fetcher = async (_endpoint: TEndpoint) => {
-            //   try {
-            //     const { ok, data } = await api[method](_endpoint, {
-            //         ...(options || {}),
-            //         throwErr: true,
-            //       });
-            //       if (ok) {
-            //         return data;
-            //       }
-            //       throw new Error() as unknown as Koine.Api.EndpointResponseFail<TEndpoints, TEndpoint, TMethod>;
-            //     } catch(e) {
-            //       throw new Error() as unknown as Koine.Api.EndpointResponseFail<TEndpoints, TEndpoint, TMethod>;;
-            //     }
-            //   };
-            // }
-            const fetcher = async ()=>{
-                const { data } = await api[method](endpoint, {
-                    ...options || {},
-                    throwErr: true
-                });
-                return data;
-            };
-            const config = _config;
-            const shouldNotFetch = config?.when === false || isFunction(config?.when) && config?.when() === false;
-            // <Data = any, Error = any>(key: Key, config: SWRConfigurationExtended<Data, Error, Fetcher<Data>> | undefined): SWRResponse<Data, Error>;
-            // eslint-disable-next-line react-hooks/rules-of-hooks
-            return useSWR(shouldNotFetch ? null : options ? [
-                endpoint,
-                options
-            ] : [
-                endpoint
-            ], fetcher, config);
-        }
-        const config = _config;
-        const sender = async (// if the first argument is an array the second tem are the base options
-        // defined when calling the usePost/Put/etc. hook, these will be overriden
-        // by the _options just here below
-        _endpoint, // these are the options arriving when calling `trigger({ json, query, etc... })
-        _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;
-        };
-        // config.fetcher = sender;
-        // eslint-disable-next-line react-hooks/rules-of-hooks
-        return useSWRMutation(// @ts-expect-error FIXME: I can't get it...
-        options ? [
-            endpoint,
-            options
-        ] : endpoint, sender, config);
-    };
-}
-/**
- * It creates an api client extended with auto-generated SWR wrapper hooks
- */ export const createSwrApi = (...args)=>{
-    const api = createApi(...args);
-    [
-        "get",
-        "post",
-        "put",
-        "patch",
-        "delete"
-    ].forEach((method)=>{
-        const hookName = `use${method.charAt(0).toUpperCase() + method.slice(1)}`;
-        api[hookName] = createUseApi(api, method);
-    });
-    return api;
-};
-export default createSwrApi;

package/index.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    ApiError: function() {
-        return _ApiError.ApiError;
-    },
-    createApi: function() {
-        return _createApi.createApi;
-    },
-    createSwrApi: function() {
-        return _createSwrApi.createSwrApi;
-    },
-    nextApiResponse: function() {
-        return _nextApiResponse.nextApiResponse;
-    }
-});
-const _ApiError = require("./ApiError");
-const _createApi = require("./createApi");
-const _createSwrApi = require("./createSwrApi");
-const _nextApiResponse = require("./nextApiResponse");

package/index.mjs

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

package/nextApiResponse.d.ts

@@ -1,3 +0,0 @@
-import type { NextApiResponse } from "next";
-export declare const nextApiResponse: (nextRes: NextApiResponse, result: Koine.Api.ResultOk | Koine.Api.ResultFail) => void;
-export default nextApiResponse;

package/nextApiResponse.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    nextApiResponse: function() {
-        return nextApiResponse;
-    },
-    default: function() {
-        return _default;
-    }
-});
-const nextApiResponse = (nextRes, result)=>{
-    // nextRes.status(result.status).json(result.data || result.msg);
-    nextRes.status(result.status).json(result);
-};
-const _default = nextApiResponse;

package/nextApiResponse.mjs

@@ -1,5 +0,0 @@
-export const nextApiResponse = (nextRes, result)=>{
-    // nextRes.status(result.status).json(result.data || result.msg);
-    nextRes.status(result.status).json(result);
-};
-export default nextApiResponse;