@kaito-http/core 2.9.5 → 3.0.0-beta.10

package/dist/index.js

@@ -0,0 +1,256 @@
+// src/error.ts
+var WrappedError = class _WrappedError extends Error {
+  constructor(data) {
+    super("Something was thrown, but it was not an instance of Error, so a WrappedError was created.");
+    this.data = data;
+  }
+  static maybe(maybeError) {
+    if (maybeError instanceof Error) {
+      return maybeError;
+    }
+    return _WrappedError.from(maybeError);
+  }
+  static from(data) {
+    return new _WrappedError(data);
+  }
+};
+var KaitoError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+};
+
+// src/request.ts
+var KaitoRequest = class {
+  request;
+  _url;
+  constructor(request) {
+    this.request = request;
+  }
+  get headers() {
+    return this.request.headers;
+  }
+  get method() {
+    return this.request.method;
+  }
+  get url() {
+    return this.request.url;
+  }
+  parseURL() {
+    if (!this._url) {
+      this._url = new URL(this.url);
+    }
+    return this._url;
+  }
+  async arrayBuffer() {
+    return this.request.arrayBuffer();
+  }
+  async blob() {
+    return this.request.blob();
+  }
+  async formData() {
+    return this.request.formData();
+  }
+  async bytes() {
+    const buffer = await this.arrayBuffer();
+    return new Uint8Array(buffer);
+  }
+  async json() {
+    return this.request.json();
+  }
+  async text() {
+    return this.request.text();
+  }
+};
+
+// src/util.ts
+function apiresponse(status, response) {
+  return Response.json(response, {
+    status
+  });
+}
+function createUtilities(getContext) {
+  return {
+    getContext,
+    router: () => Router.create()
+  };
+}
+function parsable(parse) {
+  return {
+    parse
+  };
+}
+
+// src/router/router.ts
+var Router = class _Router {
+  state;
+  static create = () => new _Router({
+    through: async (context) => context,
+    routes: /* @__PURE__ */ new Set()
+  });
+  static parseQuery(schema, url) {
+    if (!schema) {
+      return {};
+    }
+    const result = {};
+    for (const [key, parsable2] of Object.entries(schema)) {
+      const value = url.searchParams.get(key);
+      result[key] = parsable2.parse(value);
+    }
+    return result;
+  }
+  constructor(options) {
+    this.state = options;
+  }
+  get routes() {
+    return this.state.routes;
+  }
+  add = (method, path, route) => {
+    const merged = {
+      ...typeof route === "object" ? route : { run: route },
+      method,
+      path,
+      through: this.state.through
+    };
+    return new _Router({
+      ...this.state,
+      routes: /* @__PURE__ */ new Set([...this.state.routes, merged])
+    });
+  };
+  merge = (pathPrefix, other) => {
+    const newRoutes = [...other.state.routes].map((route) => ({
+      ...route,
+      path: `${pathPrefix}${route.path}`
+    }));
+    return new _Router({
+      ...this.state,
+      routes: /* @__PURE__ */ new Set([...this.state.routes, ...newRoutes])
+    });
+  };
+  freeze = (server) => {
+    const routes = /* @__PURE__ */ new Map();
+    for (const route of this.state.routes) {
+      if (!routes.has(route.path)) {
+        routes.set(route.path, /* @__PURE__ */ new Map());
+      }
+      routes.get(route.path).set(route.method, route);
+    }
+    const findRoute = (method, path) => {
+      const params = {};
+      const pathParts = path.split("/").filter(Boolean);
+      for (const [routePath, methodHandlers] of routes) {
+        const routeParts = routePath.split("/").filter(Boolean);
+        if (routeParts.length !== pathParts.length) continue;
+        let matches = true;
+        for (let i = 0; i < routeParts.length; i++) {
+          const routePart = routeParts[i];
+          const pathPart = pathParts[i];
+          if (routePart && pathPart && routePart.startsWith(":")) {
+            params[routePart.slice(1)] = pathPart;
+          } else if (routePart !== pathPart) {
+            matches = false;
+            break;
+          }
+        }
+        if (matches) {
+          const route = methodHandlers.get(method);
+          if (route) return { route, params };
+        }
+      }
+      return { params };
+    };
+    return async (req) => {
+      const url = new URL(req.url);
+      const method = req.method;
+      const { route, params } = findRoute(method, url.pathname);
+      if (!route) {
+        return apiresponse(404, {
+          success: false,
+          data: null,
+          message: `Cannot ${method} ${url.pathname}`
+        });
+      }
+      const request = new KaitoRequest(req);
+      try {
+        const rootCtx = await server.getContext(request);
+        const ctx = await route.through(rootCtx);
+        const body = route.body ? await route.body.parse(await req.json()) : void 0;
+        const query = _Router.parseQuery(route.query, url);
+        const result = await route.run({
+          ctx,
+          body,
+          query,
+          params
+        });
+        return apiresponse(200, {
+          success: true,
+          data: result,
+          message: "OK"
+        });
+      } catch (e) {
+        const error = WrappedError.maybe(e);
+        if (error instanceof KaitoError) {
+          return apiresponse(error.status, {
+            success: false,
+            data: null,
+            message: error.message
+          });
+        }
+        const { status, message } = await server.onError({ error, req: request }).catch(() => ({ status: 500, message: "Internal Server Error" }));
+        return apiresponse(status, {
+          success: false,
+          data: null,
+          message
+        });
+      }
+    };
+  };
+  method = (method) => (path, route) => {
+    return this.add(method, path, route);
+  };
+  get = this.method("GET");
+  post = this.method("POST");
+  put = this.method("PUT");
+  patch = this.method("PATCH");
+  delete = this.method("DELETE");
+  head = this.method("HEAD");
+  options = this.method("OPTIONS");
+  through = (transform) => new _Router({
+    routes: this.state.routes,
+    through: async (context) => {
+      const fromCurrentRouter = await this.state.through(context);
+      return transform(fromCurrentRouter);
+    }
+  });
+};
+
+// src/server.ts
+function createKaitoHandler(config) {
+  const match = config.router.freeze(config);
+  return async (request) => {
+    let before = void 0;
+    if (config.before) {
+      const result = await config.before(request);
+      if (result instanceof Response) {
+        return result;
+      }
+      before = result;
+    }
+    const response = await match(request);
+    if ("after" in config && config.after) {
+      await config.after(before, response);
+    }
+    return response;
+  };
+}
+export {
+  KaitoError,
+  KaitoRequest,
+  Router,
+  WrappedError,
+  apiresponse,
+  createKaitoHandler,
+  createUtilities,
+  parsable
+};

package/package.json

@@ -1,41 +1,38 @@
 {
   "name": "@kaito-http/core",
-  "version": "2.9.5",
+  "version": "3.0.0-beta.10",
+  "type": "module",
+  "author": "Alistair Smith <hi@alistair.sh>",
   "description": "Functional HTTP Framework for TypeScript",
+  "scripts": {
+    "build": "tsup"
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "homepage": "https://github.com/kaito-http/kaito",
   "repository": "https://github.com/kaito-http/kaito",
-  "author": "Alistair Smith <hi@alistair.sh>",
+  "keywords": [
+    "typescript",
+    "http",
+    "framework"
+  ],
   "license": "MIT",
-  "main": "dist/kaito-http-core.cjs.js",
-  "module": "dist/kaito-http-core.esm.js",
-  "types": "dist/kaito-http-core.cjs.d.ts",
   "devDependencies": {
-    "@types/content-type": "^1.1.5",
-    "@types/cookie": "^0.5.1",
-    "@types/node": "^18.11.9",
-    "typescript": "4.9",
-    "zod": "^3.19.1"
+    "@types/node": "^22.10.2",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2"
   },
   "files": [
     "package.json",
-    "readme.md",
+    "README.md",
     "dist"
   ],
   "bugs": {
     "url": "https://github.com/kaito-http/kaito/issues"
-  },
-  "homepage": "https://github.com/kaito-http/kaito",
-  "peerDependencies": {
-    "zod": "*"
-  },
-  "keywords": [
-    "typescript",
-    "http",
-    "framework"
-  ],
-  "dependencies": {
-    "content-type": "^1.0.4",
-    "cookie": "^0.5.0",
-    "find-my-way": "^7.3.1",
-    "raw-body": "^2.5.1"
   }
 }

package/dist/declarations/src/error.d.ts

@@ -1,10 +0,0 @@
-export declare class WrappedError<T> extends Error {
-    readonly data: T;
-    static maybe<T>(maybeError: T): (T & Error) | WrappedError<T>;
-    static from<T>(data: T): WrappedError<T>;
-    private constructor();
-}
-export declare class KaitoError extends Error {
-    readonly status: number;
-    constructor(status: number, message: string);
-}

package/dist/declarations/src/index.d.ts

@@ -1,8 +0,0 @@
-export type { HTTPMethod } from 'find-my-way';
-export * from './error';
-export * from './req';
-export * from './res';
-export * from './route';
-export * from './router';
-export * from './server';
-export * from './util';

package/dist/declarations/src/req.d.ts

@@ -1,33 +0,0 @@
-/// <reference types="node" />
-import type { HTTPMethod } from 'find-my-way';
-import type { IncomingMessage } from 'node:http';
-export declare class KaitoRequest {
-    readonly raw: IncomingMessage;
-    private _url;
-    constructor(raw: IncomingMessage);
-    /**
-     * The full URL of the request, including the protocol, hostname, and path.
-     * Note: does not include the query string or hash
-     */
-    get fullURL(): string;
-    /**
-     * A new URL instance for the full URL of the request.
-     */
-    get url(): URL;
-    /**
-     * The HTTP method of the request.
-     */
-    get method(): HTTPMethod;
-    /**
-     * The protocol of the request, either `http` or `https`.
-     */
-    get protocol(): 'http' | 'https';
-    /**
-     * The request headers
-     */
-    get headers(): import("http").IncomingHttpHeaders;
-    /**
-     * The hostname of the request.
-     */
-    get hostname(): string;
-}

package/dist/declarations/src/res.d.ts

@@ -1,46 +0,0 @@
-/// <reference types="node" />
-import type { ServerResponse } from 'node:http';
-import type { CookieSerializeOptions } from 'cookie';
-export type ErroredAPIResponse = {
-    success: false;
-    data: null;
-    message: string;
-};
-export type SuccessfulAPIResponse<T> = {
-    success: true;
-    data: T;
-    message: 'OK';
-};
-export type APIResponse<T> = ErroredAPIResponse | SuccessfulAPIResponse<T>;
-export type AnyResponse = APIResponse<unknown>;
-export declare class KaitoResponse<T = unknown> {
-    readonly raw: ServerResponse;
-    constructor(raw: ServerResponse);
-    /**
-     * Send a response
-     * @param key The key of the header
-     * @param value The value of the header
-     * @returns The response object
-     */
-    header(key: string, value: string | readonly string[]): this;
-    /**
-     * Set the status code of the response
-     * @param code The status code
-     * @returns The response object
-     */
-    status(code: number): this;
-    /**
-     * Set a cookie
-     * @param name The name of the cookie
-     * @param value The value of the cookie
-     * @param options The options for the cookie
-     * @returns The response object
-     */
-    cookie(name: string, value: string, options: CookieSerializeOptions): this;
-    /**
-     * Send a JSON APIResponse body
-     * @param data The data to send
-     * @returns The response object
-     */
-    json(data: APIResponse<T>): this;
-}

package/dist/declarations/src/route.d.ts

@@ -1,18 +0,0 @@
-import type { z } from 'zod';
-import type { ExtractRouteParams, KaitoMethod } from './util';
-export type RouteArgument<Path extends string, Context, QueryOutput, BodyOutput> = {
-    ctx: Context;
-    body: BodyOutput;
-    query: QueryOutput;
-    params: ExtractRouteParams<Path>;
-};
-export type AnyQueryDefinition = Record<string, z.ZodTypeAny>;
-export type Route<ContextFrom, ContextTo, Result, Path extends string, Method extends KaitoMethod, Query extends AnyQueryDefinition, BodyOutput, BodyDef extends z.ZodTypeDef, BodyInput> = {
-    through: (context: ContextFrom) => Promise<ContextTo>;
-    body?: z.ZodType<BodyOutput, BodyDef, BodyInput>;
-    query?: Query;
-    path: Path;
-    method: Method;
-    run(args: RouteArgument<Path, ContextTo, z.infer<z.ZodObject<Query>>, BodyOutput>): Promise<Result>;
-};
-export type AnyRoute<FromContext = any, ToContext = any> = Route<FromContext, ToContext, any, any, any, AnyQueryDefinition, any, any, any>;

package/dist/declarations/src/router.d.ts

@@ -1,41 +0,0 @@
-import fmw from 'find-my-way';
-import { z } from 'zod';
-import type { AnyQueryDefinition, AnyRoute, Route } from './route';
-import type { ServerConfig } from './server';
-import type { KaitoMethod } from './util';
-type Routes = readonly AnyRoute[];
-type RemapRoutePrefix<R extends AnyRoute, Prefix extends `/${string}`> = R extends Route<infer ContextFrom, infer ContextTo, infer Result, infer Path, infer Method, infer Query, infer BodyOutput, infer BodyDef, infer BodyInput> ? Route<ContextFrom, ContextTo, Result, `${Prefix}${Path}`, Method, Query, BodyOutput, BodyDef, BodyInput> : never;
-type PrefixRoutesPath<Prefix extends `/${string}`, R extends Routes> = R extends [infer First, ...infer Rest] ? [
-    RemapRoutePrefix<Extract<First, AnyRoute>, Prefix>,
-    ...PrefixRoutesPath<Prefix, Extract<Rest, readonly AnyRoute[]>>
-] : [];
-export type RouterOptions<ContextFrom, ContextTo> = {
-    through: (context: ContextFrom) => Promise<ContextTo>;
-};
-export declare class Router<ContextFrom, ContextTo, R extends Routes> {
-    private readonly routerOptions;
-    readonly routes: R;
-    static create: <Context>() => Router<Context, Context, []>;
-    private static handle;
-    constructor(routes: R, options: RouterOptions<ContextFrom, ContextTo>);
-    /**
-     * Adds a new route to the router
-     * @param method The HTTP method to add a route for
-     * @param path The path to add a route for
-     * @param route The route specification to add to this router
-     * @returns A new router with this route added
-     */
-    add: <Result, Path extends string, Method extends KaitoMethod, Query extends AnyQueryDefinition = {}, BodyOutput = never, BodyDef extends z.ZodTypeDef = z.ZodTypeDef, BodyInput = BodyOutput>(method: Method, path: Path, route: ((args: import("./route").RouteArgument<Path, ContextTo, z.objectUtil.addQuestionMarks<{ [k_1 in keyof Query]: Query[k_1]["_output"]; }> extends infer T extends object ? { [k in keyof T]: z.objectUtil.addQuestionMarks<{ [k_1 in keyof Query]: Query[k_1]["_output"]; }>[k]; } : never, BodyOutput>) => Promise<Result>) | (Method extends "GET" ? Omit<Route<ContextFrom, ContextTo, Result, Path, Method, Query, BodyOutput, BodyDef, BodyInput>, "path" | "body" | "method" | "through"> : Omit<Route<ContextFrom, ContextTo, Result, Path, Method, Query, BodyOutput, BodyDef, BodyInput>, "path" | "method" | "through">)) => Router<ContextFrom, ContextTo, [...R, Route<ContextFrom, ContextTo, Result, Path, Method, Query, BodyOutput, BodyDef, BodyInput>]>;
-    readonly merge: <PathPrefix extends `/${string}`, OtherRoutes extends Routes>(pathPrefix: PathPrefix, other: Router<ContextFrom, unknown, OtherRoutes>) => Router<ContextFrom, ContextTo, [...R, ...PrefixRoutesPath<PathPrefix, OtherRoutes>]>;
-    freeze: (server: ServerConfig<ContextFrom, any>) => fmw.Instance<fmw.HTTPVersion.V1>;
-    private readonly method;
-    get: <Result, Path extends string, Query extends AnyQueryDefinition = {}, BodyOutput = never, BodyDef extends z.ZodTypeDef = z.ZodTypeDef, BodyInput = BodyOutput>(path: Path, route: ((args: import("./route").RouteArgument<Path, ContextTo, z.objectUtil.addQuestionMarks<{ [k_1 in keyof Query]: Query[k_1]["_output"]; }> extends infer T extends object ? { [k in keyof T]: z.objectUtil.addQuestionMarks<{ [k_1 in keyof Query]: Query[k_1]["_output"]; }>[k]; } : never, BodyOutput>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "GET", Query, BodyOutput, BodyDef, BodyInput>, "path" | "body" | "method" | "through">) => Router<ContextFrom, ContextTo, [...R, Route<ContextFrom, ContextTo, Result, Path, "GET", Query, BodyOutput, BodyDef, BodyInput>]>;
-    post: <Result, Path extends string, Query extends AnyQueryDefinition = {}, BodyOutput = never, BodyDef extends z.ZodTypeDef = z.ZodTypeDef, BodyInput = BodyOutput>(path: Path, route: ((args: import("./route").RouteArgument<Path, ContextTo, z.objectUtil.addQuestionMarks<{ [k_1 in keyof Query]: Query[k_1]["_output"]; }> extends infer T extends object ? { [k in keyof T]: z.objectUtil.addQuestionMarks<{ [k_1 in keyof Query]: Query[k_1]["_output"]; }>[k]; } : never, BodyOutput>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "POST", Query, BodyOutput, BodyDef, BodyInput>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, [...R, Route<ContextFrom, ContextTo, Result, Path, "POST", Query, BodyOutput, BodyDef, BodyInput>]>;
-    put: <Result, Path extends string, Query extends AnyQueryDefinition = {}, BodyOutput = never, BodyDef extends z.ZodTypeDef = z.ZodTypeDef, BodyInput = BodyOutput>(path: Path, route: ((args: import("./route").RouteArgument<Path, ContextTo, z.objectUtil.addQuestionMarks<{ [k_1 in keyof Query]: Query[k_1]["_output"]; }> extends infer T extends object ? { [k in keyof T]: z.objectUtil.addQuestionMarks<{ [k_1 in keyof Query]: Query[k_1]["_output"]; }>[k]; } : never, BodyOutput>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "PUT", Query, BodyOutput, BodyDef, BodyInput>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, [...R, Route<ContextFrom, ContextTo, Result, Path, "PUT", Query, BodyOutput, BodyDef, BodyInput>]>;
-    patch: <Result, Path extends string, Query extends AnyQueryDefinition = {}, BodyOutput = never, BodyDef extends z.ZodTypeDef = z.ZodTypeDef, BodyInput = BodyOutput>(path: Path, route: ((args: import("./route").RouteArgument<Path, ContextTo, z.objectUtil.addQuestionMarks<{ [k_1 in keyof Query]: Query[k_1]["_output"]; }> extends infer T extends object ? { [k in keyof T]: z.objectUtil.addQuestionMarks<{ [k_1 in keyof Query]: Query[k_1]["_output"]; }>[k]; } : never, BodyOutput>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "PATCH", Query, BodyOutput, BodyDef, BodyInput>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, [...R, Route<ContextFrom, ContextTo, Result, Path, "PATCH", Query, BodyOutput, BodyDef, BodyInput>]>;
-    delete: <Result, Path extends string, Query extends AnyQueryDefinition = {}, BodyOutput = never, BodyDef extends z.ZodTypeDef = z.ZodTypeDef, BodyInput = BodyOutput>(path: Path, route: ((args: import("./route").RouteArgument<Path, ContextTo, z.objectUtil.addQuestionMarks<{ [k_1 in keyof Query]: Query[k_1]["_output"]; }> extends infer T extends object ? { [k in keyof T]: z.objectUtil.addQuestionMarks<{ [k_1 in keyof Query]: Query[k_1]["_output"]; }>[k]; } : never, BodyOutput>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "DELETE", Query, BodyOutput, BodyDef, BodyInput>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, [...R, Route<ContextFrom, ContextTo, Result, Path, "DELETE", Query, BodyOutput, BodyDef, BodyInput>]>;
-    head: <Result, Path extends string, Query extends AnyQueryDefinition = {}, BodyOutput = never, BodyDef extends z.ZodTypeDef = z.ZodTypeDef, BodyInput = BodyOutput>(path: Path, route: ((args: import("./route").RouteArgument<Path, ContextTo, z.objectUtil.addQuestionMarks<{ [k_1 in keyof Query]: Query[k_1]["_output"]; }> extends infer T extends object ? { [k in keyof T]: z.objectUtil.addQuestionMarks<{ [k_1 in keyof Query]: Query[k_1]["_output"]; }>[k]; } : never, BodyOutput>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "HEAD", Query, BodyOutput, BodyDef, BodyInput>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, [...R, Route<ContextFrom, ContextTo, Result, Path, "HEAD", Query, BodyOutput, BodyDef, BodyInput>]>;
-    options: <Result, Path extends string, Query extends AnyQueryDefinition = {}, BodyOutput = never, BodyDef extends z.ZodTypeDef = z.ZodTypeDef, BodyInput = BodyOutput>(path: Path, route: ((args: import("./route").RouteArgument<Path, ContextTo, z.objectUtil.addQuestionMarks<{ [k_1 in keyof Query]: Query[k_1]["_output"]; }> extends infer T extends object ? { [k in keyof T]: z.objectUtil.addQuestionMarks<{ [k_1 in keyof Query]: Query[k_1]["_output"]; }>[k]; } : never, BodyOutput>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "OPTIONS", Query, BodyOutput, BodyDef, BodyInput>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, [...R, Route<ContextFrom, ContextTo, Result, Path, "OPTIONS", Query, BodyOutput, BodyDef, BodyInput>]>;
-    through: <NextContext>(transform: (context: ContextTo) => Promise<NextContext>) => Router<ContextFrom, NextContext, R>;
-}
-export {};

package/dist/declarations/src/server.d.ts

@@ -1,46 +0,0 @@
-/// <reference types="node" />
-import * as http from 'node:http';
-import type { KaitoError } from './error';
-import type { KaitoRequest } from './req';
-import type { KaitoResponse } from './res';
-import type { Router } from './router';
-import type { GetContext, KaitoMethod } from './util';
-export type Before<BeforeAfterContext> = (req: http.IncomingMessage, res: http.ServerResponse) => Promise<BeforeAfterContext>;
-export type HandlerResult = {
-    success: true;
-    data: unknown;
-} | {
-    success: false;
-    data: {
-        status: number;
-        message: string;
-    };
-};
-export type After<BeforeAfterContext> = (ctx: BeforeAfterContext, result: HandlerResult) => Promise<void>;
-export type ServerConfigWithBefore<BeforeAfterContext> = {
-    before: Before<BeforeAfterContext>;
-    after?: After<BeforeAfterContext>;
-} | {
-    before?: undefined;
-};
-export type ServerConfig<ContextFrom, BeforeAfterContext> = ServerConfigWithBefore<BeforeAfterContext> & {
-    router: Router<ContextFrom, unknown, any>;
-    getContext: GetContext<ContextFrom>;
-    rawRoutes?: Partial<Record<KaitoMethod, Array<{
-        path: string;
-        handler: (request: http.IncomingMessage, response: http.ServerResponse) => unknown;
-    }>>>;
-    onError(arg: {
-        error: Error;
-        req: KaitoRequest;
-        res: KaitoResponse;
-    }): Promise<KaitoError | {
-        status: number;
-        message: string;
-    }>;
-};
-export declare function createFMWServer<Context, BeforeAfterContext = null>(config: ServerConfig<Context, BeforeAfterContext>): {
-    readonly server: http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
-    readonly fmw: import("find-my-way").Instance<import("find-my-way").HTTPVersion.V1>;
-};
-export declare function createServer<Context, BeforeAfterContext = null>(config: ServerConfig<Context, BeforeAfterContext>): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;

package/dist/declarations/src/util.d.ts

@@ -1,46 +0,0 @@
-import type { HTTPMethod } from 'find-my-way';
-import type { KaitoRequest } from './req';
-import type { KaitoResponse } from './res';
-import { Router } from './router';
-export type ExtractRouteParams<T extends string> = string extends T ? Record<string, string> : T extends `${string}:${infer Param}/${infer Rest}` ? {
-    [k in Param | keyof ExtractRouteParams<Rest>]: string;
-} : T extends `${string}:${infer Param}` ? {
-    [k in Param]: string;
-} : {};
-export type KaitoMethod = HTTPMethod | '*';
-export type GetContext<Result> = (req: KaitoRequest, res: KaitoResponse) => Promise<Result>;
-/**
- * @deprecated use `createUtilities` instead
- */
-export declare function createGetContext<Context>(callback: GetContext<Context>): GetContext<Context>;
-/**
- * A helper function to create typed necessary functions
- *
- * @example
- * ```ts
- * const {router, getContext} = createUtilities(async (req, res) => {
- *   // Return context here
- * })
- *
- * const app = router().get('/', async () => "hello");
- *
- * const server = createServer({
- *   router: app,
- *   getContext,
- *   // ...
- * });
- * ```
- */
-export declare function createUtilities<Context>(getContext: GetContext<Context>): {
-    getContext: GetContext<Context>;
-    router: () => Router<Context, Context, []>;
-};
-export type InferContext<T> = T extends (req: KaitoRequest, res: KaitoResponse) => Promise<infer U> ? U : never;
-export declare function getLastEntryInMultiHeaderValue(headerValue: string | string[]): string;
-type RemoveEndSlashes<T extends string> = T extends `${infer U}/` ? U : T;
-type AddStartSlashes<T extends string> = T extends `/${infer U}` ? `/${U}` : `/${T}`;
-export type NormalizePath<T extends string> = AddStartSlashes<RemoveEndSlashes<T>>;
-export type Values<T> = T[keyof T];
-export type NoEmpty<T> = [keyof T] extends [never] ? never : T;
-export declare function getBody(req: KaitoRequest): Promise<unknown>;
-export {};

package/dist/kaito-http-core.cjs.d.ts

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