klaim 1.0.0

package/.release-it.json

@@ -0,0 +1,19 @@
+{
+    "$schema": "https://unpkg.com/release-it/schema/release-it.json",
+    "github": {
+        "release": true
+    },
+    "npm": {
+        "publish": true
+    },
+    "git": {
+        "requiredBranch": "main",
+        "commitMessage": "chore: release v%s"
+    },
+    "hooks": {
+        "before:init": [
+            "git pull",
+            "npm run lint"
+        ]
+    }
+}

package/Makefile

@@ -0,0 +1,5 @@
+dev:
+	nr dev
+
+dev-test:
+	cd ../klaim-test && nr dev

package/README.md

@@ -0,0 +1,15 @@
+# klaim
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run index.ts
+```
+
+This project was created using `bun init` in bun v1.1.17. [Bun](https://bun.sh) is a fast all-in-one JavaScript runtime.

package/dist/klaim.es.js

@@ -0,0 +1,298 @@
+var f = Object.defineProperty;
+var A = (n, t, e) => t in n ? f(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e;
+var i = (n, t, e) => A(n, typeof t != "symbol" ? t + "" : t, e);
+function l(n) {
+  return n.trim().replace(/^\/|\/$/g, "");
+}
+function p(n) {
+  return n.replace(/([-_][a-z])/gi, (t) => t.toUpperCase().replace("-", "").replace("_", "")).replace(/(^\w)/, (t) => t.toLowerCase());
+}
+var m = /* @__PURE__ */ ((n) => (n.GET = "GET", n.POST = "POST", n.PUT = "PUT", n.DELETE = "DELETE", n.PATCH = "PATCH", n.OPTIONS = "OPTIONS", n))(m || {});
+class d {
+  /**
+   * Constructor
+   *
+   * @param name - The name of the route
+   * @param url - The URL of the route
+   * @param headers - The headers to be sent with the request
+   * @param method - The HTTP method of the route
+   */
+  constructor(t, e, r, a = "GET") {
+    i(this, "api", "undefined");
+    i(this, "name");
+    i(this, "url");
+    i(this, "method");
+    i(this, "headers");
+    i(this, "arguments", /* @__PURE__ */ new Set());
+    this.name = p(t), this.name !== t && console.warn(`Route name "${t}" has been camelCased to "${this.name}"`), this.url = l(e), this.headers = r || {}, this.method = a, this.detectArguments();
+  }
+  /**
+   * Creates a new route
+   *
+   * @param name - The name of the route
+   * @param url - The URL of the route
+   * @param headers - The headers to be sent with the request
+   * @param method - The HTTP method of the route
+   * @returns The new route
+   */
+  static createRoute(t, e, r, a) {
+    const s = new d(t, e, r, a);
+    return o.i.registerRoute(s), s;
+  }
+  /**
+   * Creates a new route with the GET method
+   *
+   * @param name - The name of the route
+   * @param url - The URL of the route
+   * @param headers - The headers to be sent with the request
+   * @returns The new route
+   */
+  static get(t, e, r = {}) {
+    return this.createRoute(
+      t,
+      e,
+      r,
+      "GET"
+      /* GET */
+    );
+  }
+  /**
+   * Creates a new route with the POST method
+   *
+   * @param name - The name of the route
+   * @param url - The URL of the route
+   * @param headers - The headers to be sent with the request
+   * @returns The new route
+   */
+  static post(t, e, r) {
+    return this.createRoute(
+      t,
+      e,
+      r,
+      "POST"
+      /* POST */
+    );
+  }
+  /**
+   * Creates a new route with the PUT method
+   *
+   * @param name - The name of the route
+   * @param url - The URL of the route
+   * @param headers - The headers to be sent with the request
+   * @returns The new route
+   */
+  static put(t, e, r) {
+    return this.createRoute(
+      t,
+      e,
+      r,
+      "PUT"
+      /* PUT */
+    );
+  }
+  /**
+   * Creates a new route with the DELETE method
+   *
+   * @param name - The name of the route
+   * @param url - The URL of the route
+   * @param headers - The headers to be sent with the request
+   * @returns The new route
+   */
+  static delete(t, e, r) {
+    return this.createRoute(
+      t,
+      e,
+      r,
+      "DELETE"
+      /* DELETE */
+    );
+  }
+  /**
+   * Creates a new route with the PATCH method
+   *
+   * @param name - The name of the route
+   * @param url - The URL of the route
+   * @param headers - The headers to be sent with the request
+   * @returns The new route
+   */
+  static patch(t, e, r) {
+    return this.createRoute(
+      t,
+      e,
+      r,
+      "PATCH"
+      /* PATCH */
+    );
+  }
+  /**
+   * Creates a new route with the OPTIONS method
+   *
+   * @param name - The name of the route
+   * @param url - The URL of the route
+   * @param headers - The headers to be sent with the request
+   * @returns The new route
+   */
+  static options(t, e, r) {
+    return this.createRoute(
+      t,
+      e,
+      r,
+      "OPTIONS"
+      /* OPTIONS */
+    );
+  }
+  /**
+   * Detects the arguments in the URL
+   */
+  detectArguments() {
+    const t = this.url.match(/\[([^\]]+)]/g);
+    t && t.forEach((e) => {
+      const r = e.replace(/\[|]/g, "");
+      this.arguments.add(r);
+    });
+  }
+}
+const h = {};
+async function T(n, t, e = {}, r = {}) {
+  const a = g(`${n.url}/${t.url}`, t, e), s = {};
+  return r && t.method !== m.GET && (s.body = JSON.stringify(r)), s.headers = {
+    "Content-Type": "application/json",
+    ...n.headers,
+    ...t.headers
+  }, s.method = t.method, await (await fetch(a, s)).json();
+}
+function g(n, t, e) {
+  let r = n;
+  return t.arguments.forEach((a) => {
+    if (e[a] === void 0)
+      throw new Error(`Argument ${a} is missing`);
+    r = r.replace(`[${a}]`, e[a]);
+  }), r;
+}
+const c = class c {
+  /**
+   * Constructor
+   */
+  constructor() {
+    i(this, "_apis", /* @__PURE__ */ new Map());
+    i(this, "_currentApi", null);
+  }
+  /**
+   * Singleton instance
+   *
+   * @returns The singleton instance
+   */
+  static get i() {
+    return c._instance || (c._instance = new c()), c._instance;
+  }
+  /**
+   * Registers an API
+   *
+   * @param api - The API to register
+   */
+  registerApi(t) {
+    this._apis.set(t.name, t), h[t.name] = {};
+  }
+  /**
+   * Sets the current API
+   *
+   * @param name - The name of the API
+   */
+  setCurrent(t) {
+    const e = this._apis.get(t);
+    if (!e)
+      throw new Error(`API ${t} not found`);
+    this._currentApi = e;
+  }
+  /**
+   * Clears the current API
+   */
+  clearCurrent() {
+    this._currentApi = null;
+  }
+  /**
+   * Registers a route
+   *
+   * @param route - The route to register
+   */
+  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);
+  }
+  /**
+   * Gets an API
+   *
+   * @param name - The name of the API
+   * @returns The API
+   */
+  getApi(t) {
+    return this._apis.get(t);
+  }
+  /**
+   * Gets a route
+   *
+   * @param api - The name of the API
+   * @param name - The name of the route
+   * @returns The route
+   */
+  getRoute(t, e) {
+    const r = this._apis.get(t);
+    if (!r)
+      throw new Error(`API ${t} not found`);
+    return r.routes.get(e);
+  }
+  /**
+   * Adds a route to Klaim object
+   *
+   * @param apiName - The name of the API
+   * @param route - The route to add
+   */
+  addToKlaimRoute(t, e) {
+    h[t][e.name] = async (r = {}, a = {}) => {
+      const s = c.i._apis.get(t);
+      if (!s)
+        throw new Error(`API ${e.api} not found`);
+      return T(s, e, r, a);
+    };
+  }
+};
+i(c, "_instance");
+let o = c;
+class w {
+  /**
+   * Constructor
+   *
+   * @param name - The name of the API
+   * @param url - The base URL of the API
+   * @param headers - The headers to be sent with each request
+   */
+  constructor(t, e, r) {
+    i(this, "name");
+    i(this, "url");
+    i(this, "headers");
+    i(this, "routes", /* @__PURE__ */ new Map());
+    this.name = t, this.url = l(e), this.headers = r || {};
+  }
+  /**
+   * Creates a new API
+   *
+   * @param name - The name of the API
+   * @param url - The base URL of the API
+   * @param callback - The callback to define the routes
+   * @param headers - The headers to be sent with each request
+   * @returns The new API
+   */
+  static create(t, e, r, a = {}) {
+    const s = p(t);
+    s !== t && console.warn(`API name "${t}" has been camelCased to "${s}"`);
+    const u = new w(s, e, a);
+    return o.i.registerApi(u), o.i.setCurrent(s), r(), o.i.clearCurrent(), u;
+  }
+}
+export {
+  w as Api,
+  h as Klaim,
+  o as Registry,
+  d as Route
+};

package/dist/klaim.umd.js

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

package/eslint.config.mjs

@@ -0,0 +1,210 @@
+// @ts-check
+import stylistic from "@stylistic/eslint-plugin";
+import simpleImportSort from "eslint-plugin-simple-import-sort";
+import JSdoc from "eslint-plugin-jsdoc";
+
+
+import eslint from '@eslint/js';
+import tseslint from 'typescript-eslint';
+
+export default tseslint.config(
+    eslint.configs.recommended,
+    ...tseslint.configs.recommended,
+    {
+        plugins: {
+            "@stylistic": stylistic,
+            "simple-import-sort": simpleImportSort,
+            "jsdoc": JSdoc
+        },
+        files: ["src/**/*.ts"],
+        rules: {
+            // ----------------------------------------
+            // ---------------------- Simple Import Sort
+            // ----------------------------------------
+            "simple-import-sort/exports": "error",
+            "simple-import-sort/imports": [
+                "error",
+                {
+                    "groups": [
+                        ["^\u0000"],
+                        ["^@?\\w"],
+                        ["^/"],
+                        ["^\\.\\.(?!/?$)", "^\\.\\./?$"],
+                        [
+                            "^\\./(?=.*/)(?!/?$)",
+                            "^\\.(?!/?$)",
+                            "^\\./?$"
+                        ],
+                        ["^.+\\.s?css$"]
+                    ]
+                }
+            ],
+            // ----------------------------------------
+            // ---------------------- TypeScript
+            // ----------------------------------------
+            "@typescript-eslint/no-explicit-any": "off",
+            "@typescript-eslint/ban-ts-comment": "off",
+            "@typescript-eslint/no-dynamic-delete": "off",
+            "@typescript-eslint/no-namespace": "off",
+            "@typescript-eslint/ban-types": "error",
+            "@typescript-eslint/explicit-function-return-type": "error",
+            "@typescript-eslint/consistent-indexed-object-style": "error",
+
+            // ----------------------------------------
+            // ---------------------- Stylistic
+            // ----------------------------------------
+            "@stylistic/array-bracket-spacing": ["error", "always"],
+            "@stylistic/function-paren-newline": ["error", "multiline"],
+            "@stylistic/multiline-ternary": ["error", "always-multiline"],
+            "@stylistic/quotes": [
+                "error",
+                "double",
+                {
+                    "avoidEscape": true, "allowTemplateLiterals": true
+                }
+            ],
+            "@stylistic/semi": [
+                "error",
+                "always",
+                {
+                    "omitLastInOneLineBlock": true, "omitLastInOneLineClassBody": true
+                }
+            ],
+            "@stylistic/space-before-function-paren": ["error", "always"],
+            "@stylistic/space-in-parens": ["error", "never"],
+            "@stylistic/space-infix-ops": ["error", {"int32Hint": false}],
+            "@stylistic/space-before-blocks": ["error", "always"],
+            "@stylistic/space-unary-ops": ["error", {"words": true, "nonwords": false}],
+            "@stylistic/keyword-spacing": ["error", {"before": true, "after": true}],
+            "@stylistic/block-spacing": ["error", "always"],
+            "@stylistic/comma-dangle": ["error", "never"],
+            "@stylistic/array-bracket-newline": ["error", {"multiline": true}],
+            "@stylistic/array-element-newline": ["error", {"multiline": true, "minItems": 3}],
+            "@stylistic/object-curly-newline": ["error", {"multiline": true, "consistent": true}],
+            "@stylistic/max-len": [
+                "error",
+                {
+                    "code": 120,
+                    "tabWidth": 4,
+                    "ignoreComments": true,
+                    "ignoreUrls": true,
+                    "ignoreStrings": true,
+                    "ignoreTemplateLiterals": true,
+                    "ignoreRegExpLiterals": true,
+                    "ignorePattern": "d=.*"
+                }
+            ],
+            "@stylistic/padded-blocks": ["error", "never"],
+            "@stylistic/no-multiple-empty-lines": ["error", {"max": 1, "maxEOF": 0}],
+            "@stylistic/eol-last": ["error", "always"],
+            "@stylistic/lines-between-class-members": ["error", "always"],
+            "@stylistic/brace-style": [
+                "error",
+                "1tbs",
+                {"allowSingleLine": true}
+            ],
+            "@stylistic/object-curly-spacing": ["error", "always"],
+            "@stylistic/arrow-spacing": ["error", {"before": true, "after": true}],
+            "@stylistic/implicit-arrow-linebreak": ["error", "beside"],
+            "@stylistic/arrow-parens": ["error", "as-needed"],
+            "@stylistic/no-trailing-spaces": ["error"],
+            "@stylistic/no-tabs": ["error"],
+            "@stylistic/no-whitespace-before-property": ["error"],
+            "@stylistic/template-curly-spacing": ["error", "never"],
+            "@stylistic/rest-spread-spacing": ["error", "never"],
+            "@stylistic/operator-linebreak": ["error", "before"],
+            "@stylistic/type-annotation-spacing": [
+                "error",
+                {
+                    "before": false, "after": true, "overrides": {
+                        "arrow": {
+                            "before": true, "after": true
+                        }
+                    }
+                }
+            ],
+            "@stylistic/type-generic-spacing": ["error"],
+            "@stylistic/type-named-tuple-spacing": ["error"],
+
+            // ----------------------------------------
+            // ---------------------- JSdoc
+            // ----------------------------------------
+            "jsdoc/check-access": "error",
+            "jsdoc/check-alignment": "error",
+            "jsdoc/check-param-names": "error",
+            "jsdoc/check-property-names": "error",
+            "jsdoc/check-tag-names": "error",
+            "jsdoc/check-types": "error",
+            "jsdoc/check-values": "error",
+            "jsdoc/empty-tags": "error",
+            "jsdoc/implements-on-classes": "error",
+            "jsdoc/multiline-blocks": "error",
+            "jsdoc/no-defaults": "error",
+            "jsdoc/no-multi-asterisks": "error",
+            "jsdoc/require-jsdoc": [
+                "error",
+                {
+                    "require": {
+                        "FunctionDeclaration": true,
+                        "MethodDefinition": true,
+                        "ClassDeclaration": true,
+                        "ArrowFunctionExpression": true,
+                        "FunctionExpression": true
+                    }
+                }
+            ],
+            "jsdoc/require-param": "error",
+            "jsdoc/require-param-description": "error",
+            "jsdoc/require-param-name": "error",
+            "jsdoc/require-property": "error",
+            "jsdoc/require-property-description": "error",
+            "jsdoc/require-property-name": "error",
+            "jsdoc/require-returns": "error",
+            "jsdoc/require-returns-check": "error",
+            "jsdoc/require-returns-description": "error",
+            "jsdoc/require-yields": "error",
+            "jsdoc/require-yields-check": "error",
+            "jsdoc/tag-lines": [
+                "error",
+                "never",
+                {
+                    "applyToEndTag": false,
+                    "count": 1,
+                    "startLines": 1,
+                    "endLines": 0
+                }
+            ],
+            "jsdoc/valid-types": "error",
+
+            // ----------------------------------------
+            // ---------------------- General
+            // ----------------------------------------
+
+            "no-void": "off",
+            "no-undef": "off",
+            "indent": ["error", 4],
+            "no-console": [
+                "error",
+                {
+                    allow: [
+                        "warn",
+                        "error",
+                        "info",
+                        "table"
+                    ]
+                }
+            ],
+            "camelcase": [
+                "error",
+                {
+                    "properties": "never", "ignoreDestructuring": true, "allow": ["^_[a-z]+_[a-z]+$"]
+                }
+            ],
+            "dot-notation": "off",
+            "no-underscore-dangle": "off",
+            "func-style": ["error", "declaration"]
+
+        }
+    }
+);
+

package/index.ts

@@ -0,0 +1,5 @@
+// src/index.ts
+
+export function getHello (): string {
+    return 'Hello, world! ???';
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+    "name": "klaim",
+    "type": "module",
+    "version": "1.0.0",
+    "main": "dist/klaim.cjs.js",
+    "module": "dist/klaim.es.js",
+    "types": "dist/index.d.ts",
+    "scripts": {
+        "build": "vite build",
+        "dev": "vite build --watch",
+        "test": "vitest",
+        "lint": "eslint src --fix",
+        "release": "release-it"
+    },
+    "devDependencies": {
+        "@eslint/js": "^9.6.0",
+        "@stylistic/eslint-plugin": "^2.3.0",
+        "@types/bun": "latest",
+        "@types/eslint__js": "^8.42.3",
+        "@types/node": "^20.14.9",
+        "@vitest/coverage-v8": "^1.6.0",
+        "eslint": "^9.6.0",
+        "eslint-plugin-jsdoc": "^48.5.0",
+        "eslint-plugin-simple-import-sort": "^12.1.0",
+        "jsdom": "^24.1.0",
+        "release-it": "^17.4.1",
+        "typescript-eslint": "^7.15.0",
+        "vite": "^5.3.2",
+        "vitest": "^1.6.0"
+    },
+    "peerDependencies": {
+        "typescript": "^5.5.3"
+    }
+}

package/src/core/Api.ts

@@ -0,0 +1,63 @@
+import cleanUrl from "../tools/cleanUrl";
+import toCamelCase from "../tools/toCamelCase";
+
+import { Registry } from "./Registry";
+import { Route } from "./Route";
+
+interface IApi {
+    name: string;
+    url: string;
+    headers: IHeaders;
+    routes: Map<string, Route>;
+}
+
+export type IApiCallback = () => void;
+export type IHeaders = Record<string, string>;
+
+/**
+ * Represents an API
+ */
+export class Api implements IApi {
+    public name: string;
+
+    public url: string;
+
+    public headers: IHeaders;
+
+    public routes: Map<string, Route> = new Map<string, Route>();
+
+    /**
+     * Constructor
+     *
+     * @param name - The name of the API
+     * @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) {
+        this.name = name;
+        this.url = cleanUrl(url);
+        this.headers = headers || {};
+    }
+
+    /**
+     * Creates a new API
+     *
+     * @param name - The name of the API
+     * @param url - The base URL of the API
+     * @param callback - The callback to define the routes
+     * @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 {
+        const newName = toCamelCase(name);
+        if (newName !== name) {
+            console.warn(`API name "${name}" has been camelCased to "${newName}"`);
+        }
+        const api = new Api(newName, url, headers);
+        Registry.i.registerApi(api);
+        Registry.i.setCurrent(newName);
+        callback();
+        Registry.i.clearCurrent();
+        return api;
+    }
+}

package/src/core/Klaim.ts

@@ -0,0 +1,66 @@
+import { Api } from "./Api";
+import { Route, RouteMethod } from "./Route";
+
+export type IArgs = Record<string, unknown>;
+
+export type IBody = Record<string, unknown>;
+
+export type IRouteReference = Record<string, <T>(args?: IArgs, body?: IBody) => Promise<T>>;
+
+export type IApiReference = Record<string, IRouteReference>;
+
+export const Klaim: IApiReference = {};
+
+/**
+ * Calls an API route
+ *
+ * @param api - The API to call
+ * @param route - The route to call
+ * @param args - The arguments to pass to the route
+ * @param body - The body to pass to the route
+ * @returns The response
+ */
+export async function callApi<T> (api: Api, route: Route, args: IArgs = {}, body: IBody = {}): Promise<T> {
+    const url = applyArgs(`${api.url}/${route.url}`, route, args);
+
+    const config: Record<string, unknown> = {};
+
+    if (body && route.method !== RouteMethod.GET) {
+        config.body = JSON.stringify(body);
+    }
+
+    config.headers = {
+        "Content-Type": "application/json",
+        ...api.headers,
+        ...route.headers
+    };
+
+    config.method = route.method;
+
+    const response = await fetch(url, config);
+
+    const data = await response.json();
+    return data as T;
+}
+
+/**
+ * Applies the arguments to the URL
+ *
+ * @param url - The URL to apply the arguments to
+ * @param route - The route to apply the arguments to
+ * @param args - The arguments to apply
+ * @returns The new URL
+ */
+function applyArgs (url: string, route: Route, args: IArgs): string {
+    let newUrl = url;
+    route.arguments.forEach(arg => {
+        const value = args[arg];
+        if (value === undefined) {
+            throw new Error(`Argument ${arg} is missing`);
+        }
+
+        newUrl = newUrl.replace(`[${arg}]`, <string>args[arg]);
+    });
+
+    return newUrl;
+}

package/src/core/Registry.ts

@@ -0,0 +1,126 @@
+import { Api } from "./Api";
+import { callApi, IArgs, IBody, Klaim } from "./Klaim";
+import { Route } from "./Route";
+
+/**
+ * Represents the registry
+ */
+export class Registry {
+    private static _instance: Registry;
+
+    private _apis: Map<string, Api> = new Map<string, Api>();
+
+    private _currentApi: Api | null = null;
+
+    /**
+     * Constructor
+     */
+    private constructor () {
+    }
+
+    /**
+     * Singleton instance
+     *
+     * @returns The singleton instance
+     */
+    public static get i (): Registry {
+        if (!Registry._instance) {
+            Registry._instance = new Registry();
+        }
+        return Registry._instance;
+    }
+
+    /**
+     * Registers an API
+     *
+     * @param api - The API to register
+     */
+    public registerApi (api: Api): void {
+        this._apis.set(api.name, api);
+        Klaim[api.name] = {};
+    }
+
+    /**
+     * Sets the current API
+     *
+     * @param name - The name of the API
+     */
+    public setCurrent (name: string): void {
+        const api = this._apis.get(name);
+        if (!api) {
+            throw new Error(`API ${name} not found`);
+        }
+        this._currentApi = api;
+    }
+
+    /**
+     * Clears the current API
+     */
+    public clearCurrent (): void {
+        this._currentApi = null;
+    }
+
+    /**
+     * Registers a route
+     *
+     * @param route - The route to register
+     */
+    public registerRoute (route: Route): void {
+        if (!this._currentApi) {
+            throw new Error(`No current API set, use Route only inside Api.create callback`);
+        }
+
+        route.api = this._currentApi.name;
+        this._currentApi.routes.set(route.name, route);
+
+        this.addToKlaimRoute(route.api, route);
+    }
+
+    /**
+     * Gets an API
+     *
+     * @param name - The name of the API
+     * @returns The API
+     */
+    public getApi (name: string): Api | undefined {
+        return this._apis.get(name);
+    }
+
+    /**
+     * Gets a route
+     *
+     * @param api - The name of the API
+     * @param name - The name of the route
+     * @returns The route
+     */
+    public getRoute (api: string, name: string): Route | undefined {
+        const apiObj = this._apis.get(api);
+        if (!apiObj) {
+            throw new Error(`API ${api} not found`);
+        }
+        return apiObj.routes.get(name) as Route;
+    }
+
+    /**
+     * Adds a route to Klaim object
+     *
+     * @param apiName - The name of the API
+     * @param route - The route to add
+     */
+    private addToKlaimRoute (apiName: string, route: Route): void {
+        /**
+         * The route function
+         *
+         * @param args - The arguments to pass to the route
+         * @param body - The body to pass to the route
+         * @returns The response
+         */
+        Klaim[apiName][route.name] = async <T>(args: IArgs = {}, body: IBody = {}): Promise<T> => {
+            const api = Registry.i._apis.get(apiName);
+            if (!api) {
+                throw new Error(`API ${route.api} not found`);
+            }
+            return callApi(api, route, args, body);
+        };
+    }
+}

package/src/core/Route.ts

@@ -0,0 +1,161 @@
+import cleanUrl from "../tools/cleanUrl";
+import toCamelCase from "../tools/toCamelCase";
+
+import { Api, IHeaders } from "./Api";
+import { Registry } from "./Registry";
+
+export enum RouteMethod {
+    GET = "GET",
+    POST = "POST",
+    PUT = "PUT",
+    DELETE = "DELETE",
+    PATCH = "PATCH",
+    OPTIONS = "OPTIONS"
+}
+
+interface IRoute {
+    api: Api["name"];
+    name: string;
+    url: string;
+    method: RouteMethod;
+    headers: IHeaders;
+    arguments: Set<string>;
+}
+
+/**
+ * Represents a route
+ */
+export class Route implements IRoute {
+    public api: Api["name"] = "undefined";
+
+    public name: string;
+
+    public url: string;
+
+    public method: RouteMethod;
+
+    public headers: IHeaders;
+
+    public arguments: Set<string> = new Set<string>();
+
+    /**
+     * Constructor
+     *
+     * @param name - The name of the route
+     * @param url - The URL of the route
+     * @param headers - The headers to be sent with the request
+     * @param method - The HTTP method of the route
+     */
+    private constructor (name: string, url: string, headers: IHeaders, method: RouteMethod = RouteMethod.GET) {
+        this.name = toCamelCase(name);
+        if (this.name !== name) {
+            console.warn(`Route name "${name}" has been camelCased to "${this.name}"`);
+        }
+
+        this.url = cleanUrl(url);
+        this.headers = headers || {};
+        this.method = method;
+
+        this.detectArguments();
+    }
+
+    /**
+     * Creates a new route
+     *
+     * @param name - The name of the route
+     * @param url - The URL of the route
+     * @param headers - The headers to be sent with the request
+     * @param method - The HTTP method of the route
+     * @returns The new route
+     */
+    private static createRoute (name: string, url: string, headers: IHeaders, method: RouteMethod): Route {
+        const route = new Route(name, url, headers, method);
+        Registry.i.registerRoute(route as Route);
+        return route;
+    }
+
+    /**
+     * Creates a new route with the GET method
+     *
+     * @param name - The name of the route
+     * @param url - The URL of the route
+     * @param headers - The headers to be sent with the request
+     * @returns The new route
+     */
+    public static get (name: string, url: string, headers: IHeaders = {}): Route {
+        return this.createRoute(name, url, headers, RouteMethod.GET);
+    }
+
+    /**
+     * Creates a new route with the POST method
+     *
+     * @param name - The name of the route
+     * @param url - The URL of the route
+     * @param headers - The headers to be sent with the request
+     * @returns The new route
+     */
+    public static post (name: string, url: string, headers: IHeaders): Route {
+        return this.createRoute(name, url, headers, RouteMethod.POST);
+    }
+
+    /**
+     * Creates a new route with the PUT method
+     *
+     * @param name - The name of the route
+     * @param url - The URL of the route
+     * @param headers - The headers to be sent with the request
+     * @returns The new route
+     */
+    public static put (name: string, url: string, headers: IHeaders): Route {
+        return this.createRoute(name, url, headers, RouteMethod.PUT);
+    }
+
+    /**
+     * Creates a new route with the DELETE method
+     *
+     * @param name - The name of the route
+     * @param url - The URL of the route
+     * @param headers - The headers to be sent with the request
+     * @returns The new route
+     */
+    public static delete (name: string, url: string, headers: IHeaders): Route {
+        return this.createRoute(name, url, headers, RouteMethod.DELETE);
+    }
+
+    /**
+     * Creates a new route with the PATCH method
+     *
+     * @param name - The name of the route
+     * @param url - The URL of the route
+     * @param headers - The headers to be sent with the request
+     * @returns The new route
+     */
+    public static patch (name: string, url: string, headers: IHeaders): Route {
+        return this.createRoute(name, url, headers, RouteMethod.PATCH);
+    }
+
+    /**
+     * Creates a new route with the OPTIONS method
+     *
+     * @param name - The name of the route
+     * @param url - The URL of the route
+     * @param headers - The headers to be sent with the request
+     * @returns The new route
+     */
+    public static options (name: string, url: string, headers: IHeaders): Route {
+        return this.createRoute(name, url, headers, RouteMethod.OPTIONS);
+    }
+
+    /**
+     * Detects the arguments in the URL
+     */
+    private detectArguments (): void {
+        const matches = this.url.match(/\[([^\]]+)]/g);
+        if (matches) {
+            matches.forEach(match => {
+                const key = match.replace(/\[|]/g, "");
+                this.arguments.add(key);
+            });
+        }
+    }
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export { Api, type IApi } from "./core/Api";
+export { Klaim } from "./core/Klaim";
+export { Registry } from "./core/Registry";
+export { type IRoute,Route } from "./core/Route";

package/src/tools/cleanUrl.ts

@@ -0,0 +1,12 @@
+/**
+ * Clean the URL by removing slashes at the beginning and end of the string.
+ *
+ * @param url - The URL to clean
+ * @returns The cleaned URL
+ */
+export default function (url: string): string {
+    return url
+        .trim()
+        // remove slashes at the beginning and end of the string
+        .replace(/^\/|\/$/g, "");
+}

package/src/tools/slugify.ts

@@ -0,0 +1,17 @@
+/**
+ * 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/toCamelCase.ts

@@ -0,0 +1,11 @@
+/**
+ * Convert a string to camel case
+ *
+ * @param text - The text to convert
+ * @returns The text in camel case
+ */
+export default function (text: string): string {
+    return text
+        .replace(/([-_][a-z])/gi, match => match.toUpperCase().replace("-", "").replace("_", ""))
+        .replace(/(^\w)/, match => match.toLowerCase());
+}

package/src/tools/token.ts

@@ -0,0 +1,14 @@
+/**
+ * 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

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

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "lib": ["ESNext", "DOM"],
+    "declaration": true,
+    "outDir": "dist",
+    "strict": true,
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src"]
+}

package/vite.config.ts

@@ -0,0 +1,26 @@
+import { defineConfig } from 'vite';
+import { configDefaults } from 'vitest/config';
+
+export default defineConfig({
+    build: {
+        lib: {
+            entry: 'src/index.ts',
+            name: 'klaim',
+            fileName: format => `klaim.${format}.js`
+        },
+        rollupOptions: {
+            external: [],
+            output: {
+                globals: {}
+            }
+        }
+    },
+    test: {
+        globals: true,
+        environment: 'jsdom',
+        coverage: {
+            provider: 'v8'
+        },
+        exclude: [...configDefaults.exclude, 'tests/e2e/**'],
+    },
+});