klaim 1.2.33 → 1.3.0

package/deno.json

@@ -1,6 +1,6 @@
 {
     "name": "@antharuu/klaim",
-    "version": "1.2.33",
+    "version": "1.3.0",
     "description": "Klaim is a lightweight TypeScript library designed to manage APIs and record requests, optimized for an optimal user experience.",
     "repository": {
         "type": "git",

package/dist/klaim.cjs

@@ -1 +1 @@
-"use strict";var $=Object.defineProperty;var k=(a,t,e)=>t in a?$(a,t,{enumerable:!0,configurable:!0,writable:!0,value:e}):a[t]=e;var i=(a,t,e)=>k(a,typeof t!="symbol"?t+"":t,e);Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function d(a){return a.trim().replace(/^\/|\/$/g,"")}function A(a){return a.replace(/([-_][a-z])/gi,t=>t.toUpperCase().replace("-","").replace("_","")).replace(/(^\w)/,t=>t.toLowerCase())}class p{static subscribe(t,e){this._callbacks.set(t,e)}static run(t){const e=this._callbacks.get(t);e&&e()}}i(p,"_callbacks",new Map);var g=(a=>(a.GET="GET",a.POST="POST",a.PUT="PUT",a.DELETE="DELETE",a.PATCH="PATCH",a.OPTIONS="OPTIONS",a))(g||{});class h{constructor(t,e,n,r="GET"){i(this,"api","undefined");i(this,"name");i(this,"url");i(this,"method");i(this,"headers");i(this,"arguments",new Set);i(this,"callbacks",{before:null,after:null});this.name=A(t),this.name!==t&&console.warn(`Route name "${t}" has been camelCased to "${this.name}"`),this.url=d(e),this.headers=n||{},this.method=r,this.detectArguments()}static createRoute(t,e,n,r){const s=new h(t,e,n,r);return o.i.registerRoute(s),s}static get(t,e,n={}){return this.createRoute(t,e,n,"GET")}static post(t,e,n){return this.createRoute(t,e,n,"POST")}static put(t,e,n){return this.createRoute(t,e,n,"PUT")}static delete(t,e,n){return this.createRoute(t,e,n,"DELETE")}static patch(t,e,n){return this.createRoute(t,e,n,"PATCH")}static options(t,e,n){return this.createRoute(t,e,n,"OPTIONS")}before(t){return this.callbacks.before=t,this}after(t){return this.callbacks.after=t,this}detectArguments(){const t=this.url.match(/\[([^\]]+)]/g);t&&t.forEach(e=>{const n=e.replace(/\[|]/g,"");this.arguments.add(n)})}}const l={};async function O(a,t,e={},n={}){let r=_(`${a.url}/${t.url}`,t,e),s={};n&&t.method!==g.GET&&(s.body=JSON.stringify(n)),s.headers={"Content-Type":"application/json",...a.headers,...t.headers},s.method=t.method;const{beforeRoute:u,beforeApi:w,beforeUrl:T,beforeConfig:b}=y({route:t,api:a,url:r,config:s});r=T,s=b,a=o.updateApi(w),t=o.updateRoute(u);const m=await fetch(r,s),{afterRoute:E,afterApi:P,afterData:C}=S({route:t,api:a,response:m,data:await m.json()});return o.updateApi(P),o.updateRoute(E),p.run(`${a.name}.${t.name}`),C}function _(a,t,e){let n=a;return t.arguments.forEach(r=>{if(e[r]===void 0)throw new Error(`Argument ${r} is missing`);n=n.replace(`[${r}]`,e[r])}),n}function y({route:a,api:t,url:e,config:n}){var s,u;const r=(u=(s=a.callbacks).before)==null?void 0:u.call(s,{route:a,api:t,url:e,config:n});return{beforeRoute:(r==null?void 0:r.route)||a,beforeApi:(r==null?void 0:r.api)||t,beforeUrl:(r==null?void 0:r.url)||e,beforeConfig:(r==null?void 0:r.config)||n}}function S({route:a,api:t,response:e,data:n}){var s,u;const r=(u=(s=a.callbacks).after)==null?void 0:u.call(s,{route:a,api:t,response:e,data:n});return{afterRoute:(r==null?void 0:r.route)||a,afterApi:(r==null?void 0:r.api)||t,afterResponse:(r==null?void 0:r.response)||e,afterData:(r==null?void 0:r.data)||n}}const c=class c{constructor(){i(this,"_apis",new Map);i(this,"_currentApi",null)}static get i(){return c._instance||(c._instance=new c),c._instance}registerApi(t){this._apis.set(t.name,t),l[t.name]={}}setCurrent(t){const e=this._apis.get(t);if(!e)throw new Error(`API ${t} not found`);this._currentApi=e}clearCurrent(){this._currentApi=null}registerRoute(t){if(!this._currentApi)throw new Error("No current API set, use Route only inside Api.create callback");t.api=this._currentApi.name,this._currentApi.routes.set(t.name,t),this.addToKlaimRoute(t.api,t)}getApi(t){return this._apis.get(t)}getRoute(t,e){const n=this._apis.get(t);if(!n)throw new Error(`API ${t} not found`);return n.routes.get(e)}static updateApi(t){return c.i._apis.has(t.name)||c.i.registerApi(t),c.i._apis.set(t.name,t),t}static updateRoute(t){const e=c.i._apis.get(t.api);if(!e)throw new Error(`API ${t.api} not found`);return e.routes.set(t.name,t),t}addToKlaimRoute(t,e){l[t][e.name]=async(n={},r={})=>{const s=c.i._apis.get(t);if(!s)throw new Error(`API ${e.api} not found`);return O(s,e,n,r)}}};i(c,"_instance");let o=c;class f{constructor(t,e,n){i(this,"name");i(this,"url");i(this,"headers");i(this,"routes",new Map);this.name=t,this.url=d(e),this.headers=n||{}}static create(t,e,n,r={}){const s=A(t);s!==t&&console.warn(`API name "${t}" has been camelCased to "${s}"`);const u=new f(s,e,r);return o.i.registerApi(u),o.i.setCurrent(s),n(),o.i.clearCurrent(),u}}exports.Api=f;exports.Hook=p;exports.Klaim=l;exports.Registry=o;exports.Route=h;
+"use strict";var $=Object.defineProperty;var k=(a,t,e)=>t in a?$(a,t,{enumerable:!0,configurable:!0,writable:!0,value:e}):a[t]=e;var i=(a,t,e)=>k(a,typeof t!="symbol"?t+"":t,e);Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function d(a){return a.trim().replace(/^\/|\/$/g,"")}function A(a){return a.replace(/([-_][a-z])/gi,t=>t.toUpperCase().replace("-","").replace("_","")).replace(/(^\w)/,t=>t.toLowerCase())}class p{static subscribe(t,e){this._callbacks.set(t,e)}static run(t){const e=this._callbacks.get(t);e&&e()}}i(p,"_callbacks",new Map);var g=(a=>(a.GET="GET",a.POST="POST",a.PUT="PUT",a.DELETE="DELETE",a.PATCH="PATCH",a.OPTIONS="OPTIONS",a))(g||{});class h{constructor(t,e,n,r="GET"){i(this,"api","undefined");i(this,"name");i(this,"url");i(this,"method");i(this,"headers");i(this,"arguments",new Set);i(this,"callbacks",{before:null,after:null});this.name=A(t),this.name!==t&&console.warn(`Route name "${t}" has been camelCased to "${this.name}"`),this.url=d(e),this.headers=n||{},this.method=r,this.detectArguments()}static createRoute(t,e,n,r){const s=new h(t,e,n,r);return o.i.registerRoute(s),s}static get(t,e,n={}){return this.createRoute(t,e,n,"GET")}static post(t,e,n){return this.createRoute(t,e,n,"POST")}static put(t,e,n){return this.createRoute(t,e,n,"PUT")}static delete(t,e,n){return this.createRoute(t,e,n,"DELETE")}static patch(t,e,n){return this.createRoute(t,e,n,"PATCH")}static options(t,e,n){return this.createRoute(t,e,n,"OPTIONS")}before(t){return this.callbacks.before=t,this}after(t){return this.callbacks.after=t,this}detectArguments(){const t=this.url.match(/\[([^\]]+)]/g);t&&t.forEach(e=>{const n=e.replace(/\[|]/g,"");this.arguments.add(n)})}}const l={};async function O(a,t,e={},n={}){let r=_(`${a.url}/${t.url}`,t,e),s={};n&&t.method!==g.GET&&(s.body=JSON.stringify(n)),s.headers={"Content-Type":"application/json",...a.headers,...t.headers},s.method=t.method;const{beforeRoute:u,beforeApi:w,beforeUrl:T,beforeConfig:b}=y({route:t,api:a,url:r,config:s});r=T,s=b,a=o.updateApi(w),t=o.updateRoute(u);const m=await fetch(r,s),{afterRoute:E,afterApi:P,afterData:C}=S({route:t,api:a,response:m,data:await m.json()});return o.updateApi(P),o.updateRoute(E),p.run(`${a.name}.${t.name}`),C}function _(a,t,e){let n=a;return t.arguments.forEach(r=>{if(e[r]===void 0)throw new Error(`Argument ${r} is missing`);n=n.replace(`[${r}]`,e[r])}),n}function y({route:a,api:t,url:e,config:n}){var s,u;const r=(u=(s=a.callbacks).before)==null?void 0:u.call(s,{route:a,api:t,url:e,config:n});return{beforeRoute:(r==null?void 0:r.route)||a,beforeApi:(r==null?void 0:r.api)||t,beforeUrl:(r==null?void 0:r.url)||e,beforeConfig:(r==null?void 0:r.config)||n}}function S({route:a,api:t,response:e,data:n}){var s,u;const r=(u=(s=a.callbacks).after)==null?void 0:u.call(s,{route:a,api:t,response:e,data:n});return{afterRoute:(r==null?void 0:r.route)||a,afterApi:(r==null?void 0:r.api)||t,afterResponse:(r==null?void 0:r.response)||e,afterData:(r==null?void 0:r.data)||n}}const c=class c{constructor(){i(this,"_apis",new Map);i(this,"_currentApi",null)}static get i(){return c._instance||(c._instance=new c),c._instance}registerApi(t){this._apis.set(t.name,t),l[t.name]={}}setCurrent(t){const e=this._apis.get(t);if(!e)throw new Error(`API ${t} not found`);this._currentApi=e}clearCurrent(){this._currentApi=null}registerRoute(t){if(!this._currentApi)throw new Error("No current API set, use Route only inside Api.create callback");t.api=this._currentApi.name,this._currentApi.routes.set(t.name,t),this.addToKlaimRoute(t.api,t)}getApi(t){return this._apis.get(t)}getRoute(t,e){const n=this._apis.get(t);if(!n)throw new Error(`API ${t} not found`);return n.routes.get(e)}static updateApi(t){return c.i._apis.has(t.name)||c.i.registerApi(t),c.i._apis.set(t.name,t),t}static updateRoute(t){const e=c.i._apis.get(t.api);if(!e)throw new Error(`API ${t.api} not found`);return e.routes.set(t.name,t),t}addToKlaimRoute(t,e){l[t][e.name]=async(n={},r={})=>{const s=c.i._apis.get(t);if(!s)throw new Error(`API ${e.api} not found`);return O(s,e,n,r)}}};i(c,"_instance");let o=c;class f{constructor(t,e,n={}){i(this,"name");i(this,"url");i(this,"headers");i(this,"routes",new Map);this.name=t,this.url=d(e),this.headers=n}static create(t,e,n,r={}){const s=A(t);s!==t&&console.warn(`API name "${t}" has been camelCased to "${s}"`);const u=new f(s,e,r);return o.i.registerApi(u),o.i.setCurrent(s),n(),o.i.clearCurrent(),u}}exports.Api=f;exports.Hook=p;exports.Klaim=l;exports.Registry=o;exports.Route=h;

package/dist/klaim.es.js

@@ -370,12 +370,12 @@ class w {
    * @param url - The base URL of the API
    * @param headers - The headers to be sent with each request
    */
-  constructor(t, e, n) {
+  constructor(t, e, n = {}) {
     i(this, "name");
     i(this, "url");
     i(this, "headers");
     i(this, "routes", /* @__PURE__ */ new Map());
-    this.name = t, this.url = h(e), this.headers = n || {};
+    this.name = t, this.url = h(e), this.headers = n;
   }
   /**
    * Creates a new API

package/dist/klaim.umd.js

@@ -1 +1 @@
-(function(s,o){typeof exports=="object"&&typeof module<"u"?o(exports):typeof define=="function"&&define.amd?define(["exports"],o):(s=typeof globalThis<"u"?globalThis:s||self,o(s.klaim={}))})(this,function(s){"use strict";var S=Object.defineProperty;var I=(s,o,h)=>o in s?S(s,o,{enumerable:!0,configurable:!0,writable:!0,value:h}):s[o]=h;var c=(s,o,h)=>I(s,typeof o!="symbol"?o+"":o,h);function o(i){return i.trim().replace(/^\/|\/$/g,"")}function h(i){return i.replace(/([-_][a-z])/gi,t=>t.toUpperCase().replace("-","").replace("_","")).replace(/(^\w)/,t=>t.toLowerCase())}class f{static subscribe(t,e){this._callbacks.set(t,e)}static run(t){const e=this._callbacks.get(t);e&&e()}}c(f,"_callbacks",new Map);var g=(i=>(i.GET="GET",i.POST="POST",i.PUT="PUT",i.DELETE="DELETE",i.PATCH="PATCH",i.OPTIONS="OPTIONS",i))(g||{});class d{constructor(t,e,r,n="GET"){c(this,"api","undefined");c(this,"name");c(this,"url");c(this,"method");c(this,"headers");c(this,"arguments",new Set);c(this,"callbacks",{before:null,after:null});this.name=h(t),this.name!==t&&console.warn(`Route name "${t}" has been camelCased to "${this.name}"`),this.url=o(e),this.headers=r||{},this.method=n,this.detectArguments()}static createRoute(t,e,r,n){const a=new d(t,e,r,n);return l.i.registerRoute(a),a}static get(t,e,r={}){return this.createRoute(t,e,r,"GET")}static post(t,e,r){return this.createRoute(t,e,r,"POST")}static put(t,e,r){return this.createRoute(t,e,r,"PUT")}static delete(t,e,r){return this.createRoute(t,e,r,"DELETE")}static patch(t,e,r){return this.createRoute(t,e,r,"PATCH")}static options(t,e,r){return this.createRoute(t,e,r,"OPTIONS")}before(t){return this.callbacks.before=t,this}after(t){return this.callbacks.after=t,this}detectArguments(){const t=this.url.match(/\[([^\]]+)]/g);t&&t.forEach(e=>{const r=e.replace(/\[|]/g,"");this.arguments.add(r)})}}const m={};async function T(i,t,e={},r={}){let n=b(`${i.url}/${t.url}`,t,e),a={};r&&t.method!==g.GET&&(a.body=JSON.stringify(r)),a.headers={"Content-Type":"application/json",...i.headers,...t.headers},a.method=t.method;const{beforeRoute:p,beforeApi:C,beforeUrl:$,beforeConfig:k}=E({route:t,api:i,url:n,config:a});n=$,a=k,i=l.updateApi(C),t=l.updateRoute(p);const w=await fetch(n,a),{afterRoute:y,afterApi:O,afterData:_}=P({route:t,api:i,response:w,data:await w.json()});return l.updateApi(O),l.updateRoute(y),f.run(`${i.name}.${t.name}`),_}function b(i,t,e){let r=i;return t.arguments.forEach(n=>{if(e[n]===void 0)throw new Error(`Argument ${n} is missing`);r=r.replace(`[${n}]`,e[n])}),r}function E({route:i,api:t,url:e,config:r}){var a,p;const n=(p=(a=i.callbacks).before)==null?void 0:p.call(a,{route:i,api:t,url:e,config:r});return{beforeRoute:(n==null?void 0:n.route)||i,beforeApi:(n==null?void 0:n.api)||t,beforeUrl:(n==null?void 0:n.url)||e,beforeConfig:(n==null?void 0:n.config)||r}}function P({route:i,api:t,response:e,data:r}){var a,p;const n=(p=(a=i.callbacks).after)==null?void 0:p.call(a,{route:i,api:t,response:e,data:r});return{afterRoute:(n==null?void 0:n.route)||i,afterApi:(n==null?void 0:n.api)||t,afterResponse:(n==null?void 0:n.response)||e,afterData:(n==null?void 0:n.data)||r}}const u=class u{constructor(){c(this,"_apis",new Map);c(this,"_currentApi",null)}static get i(){return u._instance||(u._instance=new u),u._instance}registerApi(t){this._apis.set(t.name,t),m[t.name]={}}setCurrent(t){const e=this._apis.get(t);if(!e)throw new Error(`API ${t} not found`);this._currentApi=e}clearCurrent(){this._currentApi=null}registerRoute(t){if(!this._currentApi)throw new Error("No current API set, use Route only inside Api.create callback");t.api=this._currentApi.name,this._currentApi.routes.set(t.name,t),this.addToKlaimRoute(t.api,t)}getApi(t){return this._apis.get(t)}getRoute(t,e){const r=this._apis.get(t);if(!r)throw new Error(`API ${t} not found`);return r.routes.get(e)}static updateApi(t){return u.i._apis.has(t.name)||u.i.registerApi(t),u.i._apis.set(t.name,t),t}static updateRoute(t){const e=u.i._apis.get(t.api);if(!e)throw new Error(`API ${t.api} not found`);return e.routes.set(t.name,t),t}addToKlaimRoute(t,e){m[t][e.name]=async(r={},n={})=>{const a=u.i._apis.get(t);if(!a)throw new Error(`API ${e.api} not found`);return T(a,e,r,n)}}};c(u,"_instance");let l=u;class A{constructor(t,e,r){c(this,"name");c(this,"url");c(this,"headers");c(this,"routes",new Map);this.name=t,this.url=o(e),this.headers=r||{}}static create(t,e,r,n={}){const a=h(t);a!==t&&console.warn(`API name "${t}" has been camelCased to "${a}"`);const p=new A(a,e,n);return l.i.registerApi(p),l.i.setCurrent(a),r(),l.i.clearCurrent(),p}}s.Api=A,s.Hook=f,s.Klaim=m,s.Registry=l,s.Route=d,Object.defineProperty(s,Symbol.toStringTag,{value:"Module"})});
+(function(s,o){typeof exports=="object"&&typeof module<"u"?o(exports):typeof define=="function"&&define.amd?define(["exports"],o):(s=typeof globalThis<"u"?globalThis:s||self,o(s.klaim={}))})(this,function(s){"use strict";var S=Object.defineProperty;var I=(s,o,h)=>o in s?S(s,o,{enumerable:!0,configurable:!0,writable:!0,value:h}):s[o]=h;var c=(s,o,h)=>I(s,typeof o!="symbol"?o+"":o,h);function o(i){return i.trim().replace(/^\/|\/$/g,"")}function h(i){return i.replace(/([-_][a-z])/gi,t=>t.toUpperCase().replace("-","").replace("_","")).replace(/(^\w)/,t=>t.toLowerCase())}class f{static subscribe(t,e){this._callbacks.set(t,e)}static run(t){const e=this._callbacks.get(t);e&&e()}}c(f,"_callbacks",new Map);var g=(i=>(i.GET="GET",i.POST="POST",i.PUT="PUT",i.DELETE="DELETE",i.PATCH="PATCH",i.OPTIONS="OPTIONS",i))(g||{});class d{constructor(t,e,r,n="GET"){c(this,"api","undefined");c(this,"name");c(this,"url");c(this,"method");c(this,"headers");c(this,"arguments",new Set);c(this,"callbacks",{before:null,after:null});this.name=h(t),this.name!==t&&console.warn(`Route name "${t}" has been camelCased to "${this.name}"`),this.url=o(e),this.headers=r||{},this.method=n,this.detectArguments()}static createRoute(t,e,r,n){const a=new d(t,e,r,n);return l.i.registerRoute(a),a}static get(t,e,r={}){return this.createRoute(t,e,r,"GET")}static post(t,e,r){return this.createRoute(t,e,r,"POST")}static put(t,e,r){return this.createRoute(t,e,r,"PUT")}static delete(t,e,r){return this.createRoute(t,e,r,"DELETE")}static patch(t,e,r){return this.createRoute(t,e,r,"PATCH")}static options(t,e,r){return this.createRoute(t,e,r,"OPTIONS")}before(t){return this.callbacks.before=t,this}after(t){return this.callbacks.after=t,this}detectArguments(){const t=this.url.match(/\[([^\]]+)]/g);t&&t.forEach(e=>{const r=e.replace(/\[|]/g,"");this.arguments.add(r)})}}const m={};async function T(i,t,e={},r={}){let n=b(`${i.url}/${t.url}`,t,e),a={};r&&t.method!==g.GET&&(a.body=JSON.stringify(r)),a.headers={"Content-Type":"application/json",...i.headers,...t.headers},a.method=t.method;const{beforeRoute:p,beforeApi:C,beforeUrl:$,beforeConfig:k}=E({route:t,api:i,url:n,config:a});n=$,a=k,i=l.updateApi(C),t=l.updateRoute(p);const w=await fetch(n,a),{afterRoute:y,afterApi:O,afterData:_}=P({route:t,api:i,response:w,data:await w.json()});return l.updateApi(O),l.updateRoute(y),f.run(`${i.name}.${t.name}`),_}function b(i,t,e){let r=i;return t.arguments.forEach(n=>{if(e[n]===void 0)throw new Error(`Argument ${n} is missing`);r=r.replace(`[${n}]`,e[n])}),r}function E({route:i,api:t,url:e,config:r}){var a,p;const n=(p=(a=i.callbacks).before)==null?void 0:p.call(a,{route:i,api:t,url:e,config:r});return{beforeRoute:(n==null?void 0:n.route)||i,beforeApi:(n==null?void 0:n.api)||t,beforeUrl:(n==null?void 0:n.url)||e,beforeConfig:(n==null?void 0:n.config)||r}}function P({route:i,api:t,response:e,data:r}){var a,p;const n=(p=(a=i.callbacks).after)==null?void 0:p.call(a,{route:i,api:t,response:e,data:r});return{afterRoute:(n==null?void 0:n.route)||i,afterApi:(n==null?void 0:n.api)||t,afterResponse:(n==null?void 0:n.response)||e,afterData:(n==null?void 0:n.data)||r}}const u=class u{constructor(){c(this,"_apis",new Map);c(this,"_currentApi",null)}static get i(){return u._instance||(u._instance=new u),u._instance}registerApi(t){this._apis.set(t.name,t),m[t.name]={}}setCurrent(t){const e=this._apis.get(t);if(!e)throw new Error(`API ${t} not found`);this._currentApi=e}clearCurrent(){this._currentApi=null}registerRoute(t){if(!this._currentApi)throw new Error("No current API set, use Route only inside Api.create callback");t.api=this._currentApi.name,this._currentApi.routes.set(t.name,t),this.addToKlaimRoute(t.api,t)}getApi(t){return this._apis.get(t)}getRoute(t,e){const r=this._apis.get(t);if(!r)throw new Error(`API ${t} not found`);return r.routes.get(e)}static updateApi(t){return u.i._apis.has(t.name)||u.i.registerApi(t),u.i._apis.set(t.name,t),t}static updateRoute(t){const e=u.i._apis.get(t.api);if(!e)throw new Error(`API ${t.api} not found`);return e.routes.set(t.name,t),t}addToKlaimRoute(t,e){m[t][e.name]=async(r={},n={})=>{const a=u.i._apis.get(t);if(!a)throw new Error(`API ${e.api} not found`);return T(a,e,r,n)}}};c(u,"_instance");let l=u;class A{constructor(t,e,r={}){c(this,"name");c(this,"url");c(this,"headers");c(this,"routes",new Map);this.name=t,this.url=o(e),this.headers=r}static create(t,e,r,n={}){const a=h(t);a!==t&&console.warn(`API name "${t}" has been camelCased to "${a}"`);const p=new A(a,e,n);return l.i.registerApi(p),l.i.setCurrent(a),r(),l.i.clearCurrent(),p}}s.Api=A,s.Hook=f,s.Klaim=m,s.Registry=l,s.Route=d,Object.defineProperty(s,Symbol.toStringTag,{value:"Module"})});

package/package.json

@@ -20,7 +20,7 @@
     },
     "homepage": "https://github.com/antharuu/klaim#readme",
     "type": "module",
-    "version": "1.2.33",
+    "version": "1.3.0",
     "main": "dist/klaim.cjs.js",
     "module": "dist/klaim.es.js",
     "types": "dist/index.d.ts",
@@ -28,6 +28,8 @@
         "build": "vite build",
         "dev": "vite build --watch",
         "test": "vitest",
+        "test:ui": "vitest --ui --coverage.enabled=true",
+        "test:cover": "vitest --coverage",
         "lint": "eslint src",
         "lint:fix": "eslint src **/*.ts --fix",
         "release": "dotenv release-it -- patch --config release-it.config.cjs --ci",
@@ -41,14 +43,15 @@
         "@types/eslint__js": "^8.42.3",
         "@types/node": "^20.14.9",
         "@vitest/coverage-v8": "^1.6.0",
+        "@vitest/ui": "^1.6.0",
         "dotenv-cli": "^7.4.2",
         "eslint": "^9.6.0",
         "eslint-plugin-jsdoc": "^48.5.0",
-        "eslint-plugin-simple-import-sort": "^12.1.0",
+        "eslint-plugin-simple-import-sort": "^12.1.1",
         "jsdom": "^24.1.0",
         "release-it": "^17.4.1",
         "typescript-eslint": "^7.15.0",
-        "vite": "^5.3.2",
+        "vite": "^5.3.3",
         "vitest": "^1.6.0"
     },
     "peerDependencies": {

package/src/core/Api.ts

@@ -33,10 +33,10 @@ export class Api implements IApi {
      * @param url - The base URL of the API
      * @param headers - The headers to be sent with each request
      */
-    private constructor (name: string, url: string, headers: IHeaders) {
+    private constructor (name: string, url: string, headers: IHeaders = {}) {
         this.name = name;
         this.url = cleanUrl(url);
-        this.headers = headers || {};
+        this.headers = headers;
     }
 
     /**
@@ -48,7 +48,12 @@ export class Api implements IApi {
      * @param headers - The headers to be sent with each request
      * @returns The new API
      */
-    public static create (name: string, url: string, callback: IApiCallback, headers: IHeaders = {}): Api {
+    public static create (
+        name: string,
+        url: string,
+        callback: IApiCallback,
+        headers: IHeaders = {}
+    ): Api {
         const newName = toCamelCase(name);
         if (newName !== name) {
             console.warn(`API name "${name}" has been camelCased to "${newName}"`);

package/tests/01.api.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, it } from "vitest";
+import { Api, Klaim, Registry } from "../src/index.ts";
+
+describe("Api", () => {
+    it("should create an API instance with correct properties", () => {
+        const name = "testApi";
+        const url = "https://jsonplaceholder.typicode.com";
+
+        const api = Api.create(name, url, () => {});
+
+        expect(Registry.i.getApi(name)).toBe(api);
+    });
+
+    it("should format the URL correctly", () => {
+        const name = "testApi";
+        const url = "https://jsonplaceholder.typicode.com/";
+        const waitingUrl = "https://jsonplaceholder.typicode.com";
+
+        const api = Api.create(name, url, () => {});
+
+        expect(api.url).toBe(waitingUrl);
+    });
+
+    it("should format the name to camelCase", () => {
+        const name = "test-api";
+        const waitingName = "testApi";
+
+        const api = Api.create(
+            name,
+            "https://jsonplaceholder.typicode.com",
+            () => {},
+        );
+
+        expect(api.name).toBe(waitingName);
+    });
+
+    it("should access the API instance from Klaim", () => {
+        const name = "testApi";
+
+        Api.create(name, "https://jsonplaceholder.typicode.com", () => {});
+
+        expect(Klaim[name]).toBeDefined();
+    });
+
+    it("should set the headers correctly", () => {
+        const name = "testApi";
+        const headers = {
+            "Authorization": "Bearer token 123",
+        };
+
+        const api = Api.create(
+            name,
+            "https://jsonplaceholder.typicode.com",
+            () => {},
+            headers,
+        );
+
+        expect(api.headers).toBe(headers);
+    });
+});

package/tests/02.route.test.ts

@@ -0,0 +1,186 @@
+import { describe, expect, it } from "vitest";
+import { Api, Klaim, Registry, Route } from "../src/index.ts";
+
+const apiName = "testApi";
+const apiUrl = "https://jsonplaceholder.typicode.com";
+
+await describe("Route", async () => {
+    it("should create an route instance with correct properties", () => {
+        const name = "testRoute";
+        const routePath = "/posts";
+
+        Api.create(apiName, apiUrl, () => {
+            Route.get(name, routePath);
+        });
+
+        expect(Registry.i.getRoute(apiName, name)).toBeDefined();
+    });
+
+    it("should format the path correctly", () => {
+        const name = "testRoute";
+        const routePath = "/posts/";
+        const waitingPath = "posts";
+
+        Api.create(apiName, apiUrl, () => {
+            Route.get(name, routePath);
+        });
+
+        expect(Registry.i.getRoute(apiName, name).url).toBe(waitingPath);
+    });
+
+    it("should format the name to camelCase", () => {
+        const name = "test-route";
+        const waitingName = "testRoute";
+
+        Api.create(apiName, apiUrl, () => {
+            Route.get(name, "/posts");
+        });
+
+        expect(Registry.i.getRoute(apiName, waitingName)).toBeDefined();
+    });
+
+    it("should access the route instance from Klaim", () => {
+        const name = "testRoute";
+
+        Api.create(apiName, apiUrl, () => {
+            Route.get(name, "/posts");
+        });
+
+        expect(Klaim[apiName][name]).toBeDefined();
+    });
+
+    it("should set the headers correctly", () => {
+        const name = "testRoute";
+        const routePath = "/posts";
+        const headers = {
+            "Authorization": "Bearer token 123",
+        };
+
+        Api.create(apiName, apiUrl, () => {
+            Route.get(name, routePath, headers);
+        });
+
+        expect(Registry.i.getRoute(apiName, name).headers).toEqual(headers);
+    });
+
+    describe("Methods", () => {
+        it("should create a GET route instance with correct properties", () => {
+            const name = "testRoute";
+            const routePath = "/posts";
+
+            Api.create(apiName, apiUrl, () => {
+                Route.get(name, routePath);
+            });
+
+            expect(Registry.i.getRoute(apiName, name)).toBeDefined();
+        });
+
+        it("should create a POST route instance with correct properties", () => {
+            const name = "testRoute";
+            const routePath = "/posts";
+
+            Api.create(apiName, apiUrl, () => {
+                Route.post(name, routePath);
+            });
+
+            expect(Registry.i.getRoute(apiName, name)).toBeDefined();
+        });
+
+        it("should create a PUT route instance with correct properties", () => {
+            const name = "testRoute";
+            const routePath = "/posts";
+
+            Api.create(apiName, apiUrl, () => {
+                Route.put(name, routePath);
+            });
+
+            expect(Registry.i.getRoute(apiName, name)).toBeDefined();
+        });
+
+        it("should create a DELETE route instance with correct properties", () => {
+            const name = "testRoute";
+            const routePath = "/posts";
+
+            Api.create(apiName, apiUrl, () => {
+                Route.delete(name, routePath);
+            });
+
+            expect(Registry.i.getRoute(apiName, name)).toBeDefined();
+        });
+
+        it("should create a PATCH route instance with correct properties", () => {
+            const name = "testRoute";
+            const routePath = "/posts";
+
+            Api.create(apiName, apiUrl, () => {
+                Route.patch(name, routePath);
+            });
+
+            expect(Registry.i.getRoute(apiName, name)).toBeDefined();
+        });
+
+        it("should create a OPTIONS route instance with correct properties", () => {
+            const name = "testRoute";
+            const routePath = "/posts";
+
+            Api.create(apiName, apiUrl, () => {
+                Route.options(name, routePath);
+            });
+
+            expect(Registry.i.getRoute(apiName, name)).toBeDefined();
+        });
+    });
+
+    describe("Arguments", () => {
+        it("should set the arguments correctly", () => {
+            const name = "testRoute";
+            const routePath = "/post/[id]";
+            const args = new Set(["id"]);
+
+            Api.create(apiName, apiUrl, () => {
+                Route.get(name, routePath, {});
+            });
+
+            expect(Registry.i.getRoute(apiName, name).arguments).toEqual(args);
+        });
+
+        it("should set the arguments correctly with multiple arguments", () => {
+            const name = "testRoute";
+            const routePath = "/post/[id]/[name]";
+            const args = new Set(["id", "name"]);
+
+            Api.create(apiName, apiUrl, () => {
+                Route.get(name, routePath, {});
+            });
+
+            expect(Registry.i.getRoute(apiName, name).arguments).toEqual(args);
+        });
+    });
+
+    await describe("Middlewares", async () => {
+        it("should set the before middleware correctly", () => {
+            const name = "testRoute";
+            const routePath = "/posts";
+            const before = () => {};
+
+            Api.create(apiName, apiUrl, () => {
+                Route.get(name, routePath, {}).before(before);
+            });
+
+            expect(Registry.i.getRoute(apiName, name).callbacks.before)
+                .toEqual(before);
+        });
+        it("should set the after middleware correctly", () => {
+            const name = "testRoute";
+            const routePath = "/posts";
+            const after = () => {};
+
+            Api.create(apiName, apiUrl, () => {
+                Route.get(name, routePath, {}).after(after);
+            });
+
+            expect(Registry.i.getRoute(apiName, name).callbacks.after)
+                .toEqual(after);
+        });
+    });
+});

package/tests/03.hook.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it } from "vitest";
+import { Hook } from "../src/index.ts";
+
+await describe("Route", async () => {
+    it("should subscribe to a hook", () => {
+        let a = 1;
+
+        Hook.subscribe("testHook", () => {
+            a++;
+        });
+
+        Hook.run("testHook");
+        expect(a).toBe(2);
+
+        Hook.run("testHook");
+        expect(a).toBe(3);
+    });
+
+    it("should not run a hook if it is not subscribed", () => {
+        const a = 1;
+
+        Hook.run("testHook");
+        expect(a).toBe(1);
+    });
+
+    it("should not subscribe to a hook if no callback is provided", () => {
+        const a = 1;
+        Hook.subscribe("testHook", undefined);
+
+        Hook.run("testHook");
+
+        expect(a).toBe(1);
+    });
+});

package/tests/04.klaim.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, it } from "vitest";
+import { Api, Klaim, Registry, Route } from "../src/index.ts";
+
+const apiName = "testApi";
+const apiUrl = "https://jsonplaceholder.typicode.com";
+
+const routeName = "testRoute";
+const routeUrl = "/todos/1";
+const routeUrlWithArg = "/todos/[id]";
+const res = {
+    userId: 1,
+    id: 1,
+    title: "delectus aut autem",
+    completed: false,
+};
+
+const res2 = {
+    userId: 1,
+    id: 2,
+    title: "quis ut nam facilis et officia qui",
+    completed: false,
+};
+
+await describe("Route", async () => {
+    it("should call the API", async () => {
+        Api.create(apiName, apiUrl, () => {
+            Route.get(routeName, routeUrl);
+        });
+
+        expect(Klaim[apiName]).toBeDefined();
+        expect(Klaim[apiName][routeName]).toBeDefined();
+        expect(Klaim[apiName][routeName]).toBeInstanceOf(Function);
+        expect(Klaim[apiName][routeName]()).toBeInstanceOf(Promise);
+        expect(Klaim[apiName][routeName]()).resolves.toEqual(res);
+    });
+
+    it("should have a body if post but not if get", async () => {
+        const apiNameA = `${apiName}A`;
+        const routeNameA = `${routeName}A`;
+
+        const apiNameB = `${apiName}B`;
+        const routeNameB = `${routeName}B`;
+
+        Api.create(apiNameA, apiUrl, () => {
+            Route.get(routeNameA, routeUrl);
+        });
+
+        Api.create(apiNameB, apiUrl, () => {
+            Route.post(routeNameB, routeUrl);
+        });
+
+        expect(Klaim[apiNameA][routeNameA]()).resolves.toEqual(res);
+        expect(Klaim[apiNameB][routeNameB]()).resolves.toEqual({});
+    });
+
+    it("should can have arguments", async () => {
+        Api.create(apiName, apiUrl, () => {
+            Route.get(routeName, routeUrlWithArg);
+        });
+
+        expect(Klaim[apiName][routeName]({ id: 1 })).resolves.toEqual(res);
+        expect(Klaim[apiName][routeName]({ id: 2 })).resolves.toEqual(res2);
+        // if pass no argument, it should fail
+        expect(Klaim[apiName][routeName]()).rejects.toThrow();
+    });
+
+    it("should call the before and after hooks", async () => {
+        let a = 0;
+        Api.create(apiName, apiUrl, () => {
+            Route.get(routeName, routeUrl)
+                .before(() => {
+                    a = 1;
+                });
+        });
+
+        expect(a).toEqual(0);
+        Klaim[apiName][routeName]();
+        expect(a).toEqual(1);
+    });
+
+    it("should call the after hook", async () => {
+        let a = 0;
+        Api.create(apiName, apiUrl, () => {
+            Route.get(routeName, routeUrl)
+                .after(() => {
+                    a = 1;
+                });
+        });
+
+        expect(a).toEqual(0);
+        Klaim[apiName][routeName]();
+        expect(a).toEqual(0);
+        await Klaim[apiName][routeName]();
+        expect(a).toEqual(1);
+    });
+});

package/vite.config.ts

@@ -1,31 +1,40 @@
-import {defineConfig} from 'vite';
-import {configDefaults} from 'vitest/config';
-import * as path from 'path';
+import { defineConfig } from "vite";
+import { configDefaults } from "vitest/config";
+import * as path from "path";
 
 export default defineConfig({
     build: {
         lib: {
-            entry: path.resolve(__dirname, 'src/index.ts'),
-            name: 'klaim',
-            fileName: format => {
-                if (format === 'cjs') return `klaim.${format}`;
+            entry: path.resolve(__dirname, "src/index.ts"),
+            name: "klaim",
+            fileName: (format) => {
+                if (format === "cjs") return `klaim.${format}`;
                 return `klaim.${format}.js`;
             },
-            formats: ['es', 'cjs', 'umd']
+            formats: ["es", "cjs", "umd"],
         },
         rollupOptions: {
             external: [],
             output: {
-                globals: {}
-            }
-        }
+                globals: {},
+            },
+        },
     },
     test: {
         globals: true,
-        environment: 'jsdom',
+        environment: "jsdom",
+        exclude: [
+            ...configDefaults.exclude,
+            "tests/e2e/**",
+        ],
         coverage: {
-            provider: 'v8'
+            provider: "v8",
+            exclude: [
+                "**/*.cjs",
+                "index.ts",
+                "mod.ts",
+                "src/core/Registry.ts",
+            ],
         },
-        exclude: [...configDefaults.exclude, 'tests/e2e/**'],
     },
 });

package/src/tools/slugify.ts

@@ -1,17 +0,0 @@
-/**
- * Slugify a text
- *
- * @param text - The text to slugify
- * @param splitCharacter - The character to use to split the text
- * @returns The slugified text
- */
-export default function (text: string, splitCharacter: string = "_"): string {
-    return text
-        .toString()
-        .normalize("NFD") // split an accented letter in the base letter and the acent
-        .replace(/[\u0300-\u036f]/g, "") // remove all previously split accents
-        .toLowerCase()
-        .trim()
-        .replace(/[^a-z0-9 ]/g, "") // remove all chars not letters, numbers and spaces (to be replaced)
-        .replace(/\s+/g, splitCharacter); // separator
-}

package/src/tools/token.ts

@@ -1,14 +0,0 @@
-/**
- * Generate a new token
- *
- * @param {number} length The length of the token
- * @returns {string} The generated token
- */
-export default function (length?: number): string {
-    const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-    let token = "";
-    for (let i = 0; i < (length || 32); i++) {
-        token += chars.charAt(Math.floor(Math.random() * chars.length));
-    }
-    return token;
-}

package/tests/arguments.test.ts

@@ -1,89 +0,0 @@
-import {describe, expect, it, vi} from 'vitest';
-import {Route, RouteArgumentType} from '../src/core/Route';
-
-// Mocks
-vi.mock('../tools/token', () => ({
-    default: vi.fn(() => 'mocked-token'),
-}));
-
-vi.mock('../tools/slugify', () => ({
-    default: vi.fn((str: string) => str.replace(/\s+/g, '-').toLowerCase()),
-}));
-
-describe('Route.detectArgumentsOfUrl', () => {
-    it('should detect arguments of type ANY', () => {
-        const route = new Route('/user/[id]');
-        const args = route._arguments;
-
-        expect(args.size).toBe(1);
-        expect(Array.from(args)).toEqual([
-            {name: 'id', type: RouteArgumentType.ANY, default: null, required: true},
-        ]);
-    });
-
-    it('should detect multiple arguments', () => {
-        const route = new Route('/posts/[post]/comments/[comment]');
-        const args = route._arguments;
-
-        expect(args.size).toBe(2);
-        expect(Array.from(args)).toEqual([
-            {name: 'post', type: RouteArgumentType.ANY, default: null, required: true},
-            {name: 'comment', type: RouteArgumentType.ANY, default: null, required: true},
-        ]);
-    });
-
-    it('should detect arguments with specific types', () => {
-        const route = new Route('/user/[id:number]');
-        const args = route._arguments;
-
-        expect(args.size).toBe(1);
-        expect(Array.from(args)).toEqual([
-            {name: 'id', type: RouteArgumentType.NUMBER, default: null, required: true},
-        ]);
-    });
-
-    it('should detect arguments with default values', () => {
-        const route = new Route('/user/[id:number=1]');
-        const args = route._arguments;
-
-        expect(args.size).toBe(1);
-        expect(Array.from(args)).toEqual([
-            {name: 'id', type: RouteArgumentType.NUMBER, default: 1, required: true},
-        ]);
-    });
-
-    it('should detect optional arguments', () => {
-        const route = new Route('/user/[name?]');
-        const args = route._arguments;
-
-        expect(args.size).toBe(1);
-        expect(Array.from(args)).toEqual([
-            {name: 'name', type: RouteArgumentType.ANY, default: null, required: false},
-        ]);
-    });
-
-    it('should detect multiple arguments with different types', () => {
-        const route = new Route('/profile/[user:string]/settings/[setting:boolean]');
-        const args = route._arguments;
-
-        expect(args.size).toBe(2);
-        expect(Array.from(args)).toEqual([
-            {name: 'user', type: RouteArgumentType.STRING, default: null, required: true},
-            {name: 'setting', type: RouteArgumentType.BOOLEAN, default: null, required: true},
-        ]);
-    });
-
-    it('should handle invalid JSON in default value gracefully', () => {
-        const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {
-        });
-        const route = new Route('/user/[id:number=invalid]');
-        const args = route._arguments;
-
-        expect(args.size).toBe(1);
-        expect(Array.from(args)).toEqual([
-            {name: 'id', type: RouteArgumentType.NUMBER, default: 'invalid', required: true},
-        ]);
-        expect(consoleSpy).toHaveBeenCalled();
-        consoleSpy.mockRestore();
-    });
-});