kayto_ts 0.1.3 → 0.1.5

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { type Api, type ClientConfig, type EndpointsMap } from "./types.js";
+export type { Api, ClientConfig, ClientError, ClientHooks, EndpointsMap, EndpointOf, EndpointResult, FetchResult, RequestInput, RequestOptions, } from "./types.js";
+export declare function clientApi<Endpoints extends EndpointsMap>(config?: ClientConfig): Api<Endpoints>;

package/dist/index.js

@@ -0,0 +1,114 @@
+import {} from "./types.js";
+import { buildPath, createBodyAndHeaders, createFetchSignal, HTTP_METHOD, makeClientError, resolveRequestUrl, safeResponseBody, } from "./utils.js";
+export function clientApi(config = {}) {
+    const { baseUrl, onRequest, onResponse, responseInterceptor } = config;
+    const request = async (method, path, input) => {
+        const requestInput = input ?? {};
+        const { signal, cleanup, didTimeout } = createFetchSignal(requestInput);
+        const builtPath = buildPath(path, requestInput.params);
+        const resolvedPath = resolveRequestUrl(builtPath, baseUrl);
+        const { body, headers } = createBodyAndHeaders(requestInput);
+        const init = {
+            method: HTTP_METHOD[method],
+            signal,
+            headers,
+            body,
+        };
+        if (onRequest) {
+            try {
+                await onRequest({ method, path: resolvedPath, init });
+            }
+            catch (err) {
+                cleanup();
+                return {
+                    ok: false,
+                    error: makeClientError("hook", "onRequest hook failed", err),
+                };
+            }
+        }
+        const startedAt = Date.now();
+        let rawResponse;
+        try {
+            rawResponse = await fetch(resolvedPath, init);
+        }
+        catch (err) {
+            if (didTimeout()) {
+                return {
+                    ok: false,
+                    error: makeClientError("timeout", "Request timed out", err),
+                };
+            }
+            if (err instanceof DOMException && err.name === "AbortError") {
+                return {
+                    ok: false,
+                    error: makeClientError("aborted", "Request was aborted", err),
+                };
+            }
+            return {
+                ok: false,
+                error: makeClientError("network", "Network error before response", err),
+            };
+        }
+        finally {
+            cleanup();
+        }
+        let response = rawResponse;
+        if (responseInterceptor) {
+            try {
+                response = await responseInterceptor({
+                    method,
+                    path: resolvedPath,
+                    response: rawResponse,
+                });
+            }
+            catch (err) {
+                return {
+                    ok: false,
+                    error: makeClientError("hook", "responseInterceptor failed", err),
+                    response: rawResponse,
+                };
+            }
+        }
+        if (onResponse) {
+            try {
+                await onResponse({
+                    method,
+                    path: resolvedPath,
+                    response,
+                    durationMs: Date.now() - startedAt,
+                });
+            }
+            catch (err) {
+                return {
+                    ok: false,
+                    error: makeClientError("hook", "onResponse hook failed", err),
+                    response,
+                };
+            }
+        }
+        if (!response.ok) {
+            return {
+                ok: false,
+                error: makeClientError("http", `Request failed with status ${response.status}`, undefined, response.status),
+                response,
+            };
+        }
+        const bodyResult = await safeResponseBody(response);
+        if (!bodyResult.ok) {
+            return {
+                ok: false,
+                error: makeClientError("parse", "Failed to parse response body", bodyResult.error),
+                response,
+            };
+        }
+        const result = bodyResult.result;
+        return { ok: true, result, response };
+    };
+    return {
+        get: (path, ...args) => request("get", path, args[0]),
+        post: (path, ...args) => request("post", path, args[0]),
+        put: (path, ...args) => request("put", path, args[0]),
+        patch: (path, ...args) => request("patch", path, args[0]),
+        delete: (path, ...args) => request("delete", path, args[0]),
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,80 @@
+export type EndpointsMap = {
+    get: Record<PropertyKey, unknown>;
+    post: Record<PropertyKey, unknown>;
+    put: Record<PropertyKey, unknown>;
+    patch: Record<PropertyKey, unknown>;
+    delete: Record<PropertyKey, unknown>;
+};
+export type EndpointOf<Endpoints extends EndpointsMap, Method extends keyof EndpointsMap, Path extends keyof EndpointsMap[Method]> = Endpoints[Method][Path];
+export type EndpointParams<E> = E extends {
+    params: infer P;
+} ? P : never;
+export type EndpointBody<E> = E extends {
+    body: infer B;
+} ? B : never;
+export type EndpointResponses<E> = E extends {
+    responses: infer R;
+} ? R : never;
+export type EndpointResult<E> = [EndpointResponses<E>] extends [never] ? unknown : EndpointResponses<E>[keyof EndpointResponses<E>];
+export type ErrorKind = "network" | "timeout" | "aborted" | "http" | "parse" | "hook";
+export type ClientError = {
+    kind: ErrorKind;
+    message: string;
+    cause?: unknown;
+    status?: number;
+};
+export type FetchResult<R, E = ClientError> = {
+    ok: true;
+    result: R;
+    response: Response;
+} | {
+    ok: false;
+    error: E;
+    response?: Response;
+};
+export type Result<R, E = string> = {
+    ok: true;
+    result: R;
+} | {
+    ok: false;
+    error: E;
+};
+export type MaybePromise<T> = T | Promise<T>;
+export type RequestOptions = {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+    headers?: RequestInit["headers"];
+};
+export type RequestInput<E> = RequestOptions & ([EndpointParams<E>] extends [never] ? {} : {
+    params?: EndpointParams<E>;
+}) & ([EndpointBody<E>] extends [never] ? {} : {
+    body: EndpointBody<E>;
+});
+export type RequestArgs<E> = [EndpointBody<E>] extends [never] ? [input?: RequestInput<E>] : [input: RequestInput<E>];
+export type Api<Endpoints extends EndpointsMap> = {
+    [Method in keyof EndpointsMap]: <Path extends Extract<keyof Endpoints[Method], string>>(path: Path, ...args: RequestArgs<EndpointOf<Endpoints, Method, Path>>) => Promise<FetchResult<EndpointResult<EndpointOf<Endpoints, Method, Path>>>>;
+};
+export type RequestHookContext = {
+    method: keyof EndpointsMap;
+    path: string;
+    init: RequestInit;
+};
+export type ResponseHookContext = {
+    method: keyof EndpointsMap;
+    path: string;
+    response: Response;
+    durationMs: number;
+};
+export type ResponseInterceptorContext = {
+    method: keyof EndpointsMap;
+    path: string;
+    response: Response;
+};
+export type ClientHooks = {
+    onRequest?: (context: RequestHookContext) => MaybePromise<void>;
+    onResponse?: (context: ResponseHookContext) => MaybePromise<void>;
+    responseInterceptor?: (context: ResponseInterceptorContext) => MaybePromise<Response>;
+};
+export type ClientConfig = ClientHooks & {
+    baseUrl?: string;
+};

package/dist/types.js

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

package/dist/utils.d.ts

@@ -0,0 +1,21 @@
+import { type ClientError, type ErrorKind, type RequestInput, type RequestOptions, type Result } from "./types.js";
+export declare const HTTP_METHOD: {
+    readonly get: "GET";
+    readonly post: "POST";
+    readonly put: "PUT";
+    readonly patch: "PATCH";
+    readonly delete: "DELETE";
+};
+export declare function makeClientError(kind: ErrorKind, message: string, cause?: unknown, status?: number): ClientError;
+export declare function createFetchSignal(options: RequestOptions): {
+    signal?: AbortSignal;
+    cleanup: () => void;
+    didTimeout: () => boolean;
+};
+export declare function buildPath(path: string, params: unknown): string;
+export declare function resolveRequestUrl(path: string, baseUrl?: string): string;
+export declare function createBodyAndHeaders(input: RequestInput<unknown>): {
+    body?: NonNullable<RequestInit["body"]>;
+    headers: Headers;
+};
+export declare function safeResponseBody(response: Response): Promise<Result<unknown, unknown>>;

package/dist/utils.js

@@ -0,0 +1,139 @@
+import {} from "./types.js";
+export const HTTP_METHOD = {
+    get: "GET",
+    post: "POST",
+    put: "PUT",
+    patch: "PATCH",
+    delete: "DELETE",
+};
+export function makeClientError(kind, message, cause, status) {
+    return { kind, message, cause, status };
+}
+export function createFetchSignal(options) {
+    const { signal, timeoutMs } = options;
+    if (timeoutMs == null) {
+        return { signal, cleanup: () => { }, didTimeout: () => false };
+    }
+    let timedOut = false;
+    const controller = new AbortController();
+    const onAbort = () => {
+        controller.abort(signal?.reason ?? new DOMException("The operation was aborted", "AbortError"));
+    };
+    if (signal?.aborted) {
+        onAbort();
+    }
+    else if (signal) {
+        signal.addEventListener("abort", onAbort, { once: true });
+    }
+    const timeoutId = setTimeout(() => {
+        timedOut = true;
+        controller.abort(new DOMException(`Timed out after ${timeoutMs}ms`, "TimeoutError"));
+    }, timeoutMs);
+    const cleanup = () => {
+        clearTimeout(timeoutId);
+        if (signal) {
+            signal.removeEventListener("abort", onAbort);
+        }
+    };
+    return { signal: controller.signal, cleanup, didTimeout: () => timedOut };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function isAbsoluteUrl(path) {
+    return /^[a-zA-Z][a-zA-Z\d+.-]*:\/\//.test(path) || path.startsWith("//");
+}
+function appendQueryToUrl(path, query) {
+    const absolute = isAbsoluteUrl(path);
+    const url = absolute ? new URL(path) : new URL(path, "http://localhost");
+    for (const [key, value] of Object.entries(query)) {
+        if (value == null) {
+            continue;
+        }
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                if (item != null) {
+                    url.searchParams.append(key, String(item));
+                }
+            }
+            continue;
+        }
+        url.searchParams.set(key, String(value));
+    }
+    if (absolute) {
+        return url.toString();
+    }
+    return `${url.pathname}${url.search}`;
+}
+export function buildPath(path, params) {
+    if (!isRecord(params)) {
+        return path;
+    }
+    let nextPath = path;
+    if (isRecord(params.path)) {
+        for (const [key, value] of Object.entries(params.path)) {
+            if (value != null) {
+                nextPath = nextPath.replaceAll("{" + key + "}", encodeURIComponent(String(value)));
+            }
+        }
+    }
+    if (isRecord(params.query)) {
+        return appendQueryToUrl(nextPath, params.query);
+    }
+    return nextPath;
+}
+export function resolveRequestUrl(path, baseUrl) {
+    if (!baseUrl || isAbsoluteUrl(path)) {
+        return path;
+    }
+    return new URL(path, baseUrl).toString();
+}
+function isRawBody(body) {
+    return (typeof body === "string"
+        || body instanceof Blob
+        || body instanceof FormData
+        || body instanceof URLSearchParams
+        || body instanceof ArrayBuffer
+        || ArrayBuffer.isView(body)
+        || body instanceof ReadableStream);
+}
+export function createBodyAndHeaders(input) {
+    const headers = new Headers(input.headers);
+    const body = "body" in input ? input.body : undefined;
+    if (body == null) {
+        return { body: undefined, headers };
+    }
+    if (isRawBody(body)) {
+        return { body, headers };
+    }
+    if (!headers.has("content-type")) {
+        headers.set("content-type", "application/json");
+    }
+    return { body: JSON.stringify(body), headers };
+}
+function isJsonContentType(contentType) {
+    return (contentType.includes("application/json")
+        || contentType.includes("application/problem+json")
+        || contentType.includes("+json"));
+}
+function isTextContentType(contentType) {
+    return contentType.startsWith("text/");
+}
+export async function safeResponseBody(response) {
+    const contentType = (response.headers.get("content-type") ?? "").toLowerCase();
+    if (response.status === 204 || response.status === 205 || response.status === 304) {
+        return { ok: true, result: null };
+    }
+    try {
+        if (isJsonContentType(contentType)) {
+            return { ok: true, result: await response.json() };
+        }
+        if (isTextContentType(contentType)) {
+            return { ok: true, result: await response.text() };
+        }
+        return { ok: true, result: await response.blob() };
+    }
+    catch (err) {
+        return { ok: false, error: err };
+    }
+}

package/package.json

@@ -1,16 +1,32 @@
 {
   "name": "kayto_ts",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Type-safe HTTP client for working with kayto-generated endpoint schemas.",
   "repository": "https://github.com/vladislav-yemelyanov/kayto_ts",
   "homepage": "https://www.npmjs.com/package/kayto_ts",
-  "module": "src/index.ts",
   "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
   "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "prepublishOnly": "npm run build",
     "test": "bun test"
   },
   "devDependencies": {
-    "@types/bun": "latest"
+    "@types/bun": "latest",
+    "typescript": "^5.9.3"
   },
   "peerDependencies": {
     "typescript": "^5"

package/bun.lock

@@ -1,26 +0,0 @@
-{
-  "lockfileVersion": 1,
-  "configVersion": 1,
-  "workspaces": {
-    "": {
-      "name": "kayto_ts",
-      "devDependencies": {
-        "@types/bun": "latest",
-      },
-      "peerDependencies": {
-        "typescript": "^5",
-      },
-    },
-  },
-  "packages": {
-    "@types/bun": ["@types/bun@1.3.9", "", { "dependencies": { "bun-types": "1.3.9" } }, "sha512-KQ571yULOdWJiMH+RIWIOZ7B2RXQGpL1YQrBtLIV3FqDcCu6FsbFUBwhdKUlCKUpS3PJDsHlJ1QKlpxoVR+xtw=="],
-
-    "@types/node": ["@types/node@25.3.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-4K3bqJpXpqfg2XKGK9bpDTc6xO/xoUP/RBWS7AtRMug6zZFaRekiLzjVtAoZMquxoAbzBvy5nxQ7veS5eYzf8A=="],
-
-    "bun-types": ["bun-types@1.3.9", "", { "dependencies": { "@types/node": "*" } }, "sha512-+UBWWOakIP4Tswh0Bt0QD0alpTY8cb5hvgiYeWCMet9YukHbzuruIEeXC2D7nMJPB12kbh8C7XJykSexEqGKJg=="],
-
-    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
-
-    "undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="],
-  }
-}

package/publish.sh

@@ -1,10 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-cd "$(dirname "$0")"
-
-npm version patch --no-git-tag-version
-git add .
-git commit -m "upgrade"
-git push
-npm publish

package/src/index.ts

@@ -1,177 +0,0 @@
-import {
-  type Api,
-  type ClientConfig,
-  type EndpointsMap,
-  type EndpointOf,
-  type FetchResult,
-  type RequestInput,
-} from "./types";
-import {
-  buildPath,
-  createBodyAndHeaders,
-  createFetchSignal,
-  HTTP_METHOD,
-  makeClientError,
-  resolveRequestUrl,
-  safeResponseBody,
-} from "./utils";
-
-export type {
-  Api,
-  ClientConfig,
-  ClientError,
-  ClientHooks,
-  EndpointsMap,
-  EndpointOf,
-  FetchResult,
-  RequestInput,
-  RequestOptions,
-} from "./types";
-
-export function clientApi<Endpoints extends EndpointsMap>(
-  config: ClientConfig = {},
-): Api<Endpoints> {
-  const { baseUrl, onRequest, onResponse, responseInterceptor } = config;
-
-  const request = async <
-    Method extends keyof EndpointsMap,
-    Path extends Extract<keyof Endpoints[Method], string>,
-  >(
-    method: Method,
-    path: Path,
-    input?: RequestInput<EndpointOf<Endpoints, Method, Path>>,
-  ): Promise<FetchResult<EndpointOf<Endpoints, Method, Path>>> => {
-    const requestInput =
-      input ?? ({} as RequestInput<EndpointOf<Endpoints, Method, Path>>);
-    const { signal, cleanup, didTimeout } = createFetchSignal(requestInput);
-    const builtPath = buildPath(
-      path,
-      (requestInput as { params?: unknown }).params,
-    );
-    const resolvedPath = resolveRequestUrl(builtPath, baseUrl);
-    const { body, headers } = createBodyAndHeaders(
-      requestInput as RequestInput<unknown>,
-    );
-    const init: RequestInit = {
-      method: HTTP_METHOD[method],
-      signal,
-      headers,
-      body,
-    };
-
-    if (onRequest) {
-      try {
-        await onRequest({ method, path: resolvedPath, init });
-      } catch (err) {
-        cleanup();
-        return {
-          ok: false,
-          error: makeClientError("hook", "onRequest hook failed", err),
-        };
-      }
-    }
-
-    const startedAt = Date.now();
-
-    let rawResponse: Response;
-
-    try {
-      rawResponse = await fetch(resolvedPath, init);
-    } catch (err) {
-      if (didTimeout()) {
-        return {
-          ok: false,
-          error: makeClientError("timeout", "Request timed out", err),
-        };
-      }
-
-      if (err instanceof DOMException && err.name === "AbortError") {
-        return {
-          ok: false,
-          error: makeClientError("aborted", "Request was aborted", err),
-        };
-      }
-
-      return {
-        ok: false,
-        error: makeClientError("network", "Network error before response", err),
-      };
-    } finally {
-      cleanup();
-    }
-
-    let response = rawResponse;
-
-    if (responseInterceptor) {
-      try {
-        response = await responseInterceptor({
-          method,
-          path: resolvedPath,
-          response: rawResponse,
-        });
-      } catch (err) {
-        return {
-          ok: false,
-          error: makeClientError("hook", "responseInterceptor failed", err),
-          response: rawResponse,
-        };
-      }
-    }
-
-    if (onResponse) {
-      try {
-        await onResponse({
-          method,
-          path: resolvedPath,
-          response,
-          durationMs: Date.now() - startedAt,
-        });
-      } catch (err) {
-        return {
-          ok: false,
-          error: makeClientError("hook", "onResponse hook failed", err),
-          response,
-        };
-      }
-    }
-
-    if (!response.ok) {
-      return {
-        ok: false,
-        error: makeClientError(
-          "http",
-          `Request failed with status ${response.status}`,
-          undefined,
-          response.status,
-        ),
-        response,
-      };
-    }
-
-    const bodyResult = await safeResponseBody(response);
-
-    if (!bodyResult.ok) {
-      return {
-        ok: false,
-        error: makeClientError(
-          "parse",
-          "Failed to parse response body",
-          bodyResult.error,
-        ),
-        response,
-      };
-    }
-
-    const result = bodyResult.result as EndpointOf<Endpoints, Method, Path>;
-
-    return { ok: true, result, response };
-  };
-
-  return {
-    get: (path, ...args) => request("get", path, args[0]),
-    post: (path, ...args) => request("post", path, args[0]),
-    put: (path, ...args) => request("put", path, args[0]),
-    patch: (path, ...args) => request("patch", path, args[0]),
-    delete: (path, ...args) => request("delete", path, args[0]),
-  };
-}

package/src/types.ts

@@ -1,95 +0,0 @@
-export type EndpointsMap = {
-  get: Record<PropertyKey, unknown>;
-  post: Record<PropertyKey, unknown>;
-  put: Record<PropertyKey, unknown>;
-  patch: Record<PropertyKey, unknown>;
-  delete: Record<PropertyKey, unknown>;
-};
-
-export type EndpointOf<
-  Endpoints extends EndpointsMap,
-  Method extends keyof EndpointsMap,
-  Path extends keyof EndpointsMap[Method],
-> = Endpoints[Method][Path];
-
-export type EndpointParams<E> = E extends { params: infer P } ? P : never;
-export type EndpointBody<E> = E extends { body: infer B } ? B : never;
-
-export type ErrorKind =
-  | "network"
-  | "timeout"
-  | "aborted"
-  | "http"
-  | "parse"
-  | "hook";
-
-export type ClientError = {
-  kind: ErrorKind;
-  message: string;
-  cause?: unknown;
-  status?: number;
-};
-
-export type FetchResult<R, E = ClientError> =
-  | { ok: true; result: R; response: Response }
-  | { ok: false; error: E; response?: Response };
-
-export type Result<R, E = string> =
-  | { ok: true; result: R }
-  | { ok: false; error: E };
-
-export type MaybePromise<T> = T | Promise<T>;
-
-export type RequestOptions = {
-  signal?: AbortSignal;
-  timeoutMs?: number;
-  headers?: RequestInit["headers"];
-};
-
-export type RequestInput<E> = RequestOptions
-  & ([EndpointParams<E>] extends [never] ? {} : { params?: EndpointParams<E> })
-  & ([EndpointBody<E>] extends [never] ? {} : { body: EndpointBody<E> });
-
-export type RequestArgs<E> = [EndpointBody<E>] extends [never]
-  ? [input?: RequestInput<E>]
-  : [input: RequestInput<E>];
-
-export type Api<Endpoints extends EndpointsMap> = {
-  [Method in keyof EndpointsMap]: <
-    Path extends Extract<keyof Endpoints[Method], string>,
-  >(
-    path: Path,
-    ...args: RequestArgs<EndpointOf<Endpoints, Method, Path>>
-  ) => Promise<FetchResult<EndpointOf<Endpoints, Method, Path>>>;
-};
-
-export type RequestHookContext = {
-  method: keyof EndpointsMap;
-  path: string;
-  init: RequestInit;
-};
-
-export type ResponseHookContext = {
-  method: keyof EndpointsMap;
-  path: string;
-  response: Response;
-  durationMs: number;
-};
-
-export type ResponseInterceptorContext = {
-  method: keyof EndpointsMap;
-  path: string;
-  response: Response;
-};
-
-export type ClientHooks = {
-  onRequest?: (context: RequestHookContext) => MaybePromise<void>;
-  onResponse?: (context: ResponseHookContext) => MaybePromise<void>;
-  responseInterceptor?: (
-    context: ResponseInterceptorContext,
-  ) => MaybePromise<Response>;
-};
-
-export type ClientConfig = ClientHooks & {
-  baseUrl?: string;
-};

package/src/utils.ts

@@ -1,201 +0,0 @@
-import { type ClientError, type ErrorKind, type RequestInput, type RequestOptions, type Result } from "./types";
-
-export const HTTP_METHOD = {
-  get: "GET",
-  post: "POST",
-  put: "PUT",
-  patch: "PATCH",
-  delete: "DELETE",
-} as const;
-
-export function makeClientError(
-  kind: ErrorKind,
-  message: string,
-  cause?: unknown,
-  status?: number,
-): ClientError {
-  return { kind, message, cause, status };
-}
-
-export function createFetchSignal(options: RequestOptions): {
-  signal?: AbortSignal;
-  cleanup: () => void;
-  didTimeout: () => boolean;
-} {
-  const { signal, timeoutMs } = options;
-
-  if (timeoutMs == null) {
-    return { signal, cleanup: () => {}, didTimeout: () => false };
-  }
-
-  let timedOut = false;
-  const controller = new AbortController();
-  const onAbort = () => {
-    controller.abort(
-      signal?.reason ?? new DOMException("The operation was aborted", "AbortError"),
-    );
-  };
-
-  if (signal?.aborted) {
-    onAbort();
-  } else if (signal) {
-    signal.addEventListener("abort", onAbort, { once: true });
-  }
-
-  const timeoutId = setTimeout(() => {
-    timedOut = true;
-    controller.abort(
-      new DOMException(`Timed out after ${timeoutMs}ms`, "TimeoutError"),
-    );
-  }, timeoutMs);
-
-  const cleanup = () => {
-    clearTimeout(timeoutId);
-
-    if (signal) {
-      signal.removeEventListener("abort", onAbort);
-    }
-  };
-
-  return { signal: controller.signal, cleanup, didTimeout: () => timedOut };
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null;
-}
-
-function isAbsoluteUrl(path: string): boolean {
-  return /^[a-zA-Z][a-zA-Z\d+.-]*:\/\//.test(path) || path.startsWith("//");
-}
-
-function appendQueryToUrl(path: string, query: Record<string, unknown>): string {
-  const absolute = isAbsoluteUrl(path);
-  const url = absolute ? new URL(path) : new URL(path, "http://localhost");
-
-  for (const [key, value] of Object.entries(query)) {
-    if (value == null) {
-      continue;
-    }
-
-    if (Array.isArray(value)) {
-      for (const item of value) {
-        if (item != null) {
-          url.searchParams.append(key, String(item));
-        }
-      }
-
-      continue;
-    }
-
-    url.searchParams.set(key, String(value));
-  }
-
-  if (absolute) {
-    return url.toString();
-  }
-
-  return `${url.pathname}${url.search}`;
-}
-
-export function buildPath(path: string, params: unknown): string {
-  if (!isRecord(params)) {
-    return path;
-  }
-
-  let nextPath = path;
-
-  if (isRecord(params.path)) {
-    for (const [key, value] of Object.entries(params.path)) {
-      if (value != null) {
-        nextPath = nextPath.replaceAll(
-          "{" + key + "}",
-          encodeURIComponent(String(value)),
-        );
-      }
-    }
-  }
-
-  if (isRecord(params.query)) {
-    return appendQueryToUrl(nextPath, params.query);
-  }
-
-  return nextPath;
-}
-
-export function resolveRequestUrl(path: string, baseUrl?: string): string {
-  if (!baseUrl || isAbsoluteUrl(path)) {
-    return path;
-  }
-
-  return new URL(path, baseUrl).toString();
-}
-
-function isRawBody(body: unknown): body is NonNullable<RequestInit["body"]> {
-  return (
-    typeof body === "string"
-    || body instanceof Blob
-    || body instanceof FormData
-    || body instanceof URLSearchParams
-    || body instanceof ArrayBuffer
-    || ArrayBuffer.isView(body)
-    || body instanceof ReadableStream
-  );
-}
-
-export function createBodyAndHeaders(input: RequestInput<unknown>): {
-  body?: NonNullable<RequestInit["body"]>;
-  headers: Headers;
-} {
-  const headers = new Headers(input.headers);
-  const body = "body" in input ? (input as { body?: unknown }).body : undefined;
-
-  if (body == null) {
-    return { body: undefined, headers };
-  }
-
-  if (isRawBody(body)) {
-    return { body, headers };
-  }
-
-  if (!headers.has("content-type")) {
-    headers.set("content-type", "application/json");
-  }
-
-  return { body: JSON.stringify(body), headers };
-}
-
-function isJsonContentType(contentType: string): boolean {
-  return (
-    contentType.includes("application/json")
-    || contentType.includes("application/problem+json")
-    || contentType.includes("+json")
-  );
-}
-
-function isTextContentType(contentType: string): boolean {
-  return contentType.startsWith("text/");
-}
-
-export async function safeResponseBody(
-  response: Response,
-): Promise<Result<unknown, unknown>> {
-  const contentType = (response.headers.get("content-type") ?? "").toLowerCase();
-
-  if (response.status === 204 || response.status === 205 || response.status === 304) {
-    return { ok: true, result: null };
-  }
-
-  try {
-    if (isJsonContentType(contentType)) {
-      return { ok: true, result: await response.json() };
-    }
-
-    if (isTextContentType(contentType)) {
-      return { ok: true, result: await response.text() };
-    }
-
-    return { ok: true, result: await response.blob() };
-  } catch (err) {
-    return { ok: false, error: err };
-  }
-}

package/tsconfig.json

@@ -1,29 +0,0 @@
-{
-  "compilerOptions": {
-    // Environment setup & latest features
-    "lib": ["ESNext"],
-    "target": "ESNext",
-    "module": "Preserve",
-    "moduleDetection": "force",
-    "jsx": "react-jsx",
-    "allowJs": true,
-
-    // Bundler mode
-    "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
-    "verbatimModuleSyntax": true,
-    "noEmit": true,
-
-    // Best practices
-    "strict": true,
-    "skipLibCheck": true,
-    "noFallthroughCasesInSwitch": true,
-    "noUncheckedIndexedAccess": true,
-    "noImplicitOverride": true,
-
-    // Some stricter flags (disabled by default)
-    "noUnusedLocals": false,
-    "noUnusedParameters": false,
-    "noPropertyAccessFromIndexSignature": false
-  }
-}