akanjs 0.0.1 → 2.0.0-beta.0

package/client/translator.ts

@@ -0,0 +1,43 @@
+import { pathGet } from "akanjs/common";
+
+export interface Dictionary {
+  [key: string]: {
+    [key: string]: unknown;
+  };
+}
+export interface AllDictionary {
+  [key: string]: Dictionary;
+}
+
+export class Translator {
+  static #langDictionaryMap = new Map<string, Dictionary>();
+  constructor(dictionary: Record<string, Record<string, Record<string, unknown>>>) {
+    Object.entries(dictionary).forEach(([lang, dictionary]) => {
+      this.#setDictionary(lang, dictionary);
+    });
+  }
+  hasDictionary(lang: string) {
+    return Translator.#langDictionaryMap.has(lang);
+  }
+  #setDictionary(lang: string, dict: Dictionary) {
+    const existingDictionary = Translator.#langDictionaryMap.get(lang);
+    const dictionary = existingDictionary ?? {};
+    Object.entries(dict).forEach(([key, modelDict]) => {
+      if (dictionary[key]) Object.assign(dictionary[key], modelDict);
+      else dictionary[key] = modelDict;
+    });
+    Translator.#langDictionaryMap.set(lang, dictionary);
+    return dictionary;
+  }
+  translate(lang: string, key: string, param?: Record<string, string | number>): string {
+    const dictionary = Translator.#langDictionaryMap.get(lang);
+    if (!dictionary) return key;
+    const msg = (pathGet(key, dictionary, ".", { t: key }) as { t: string }).t;
+    return param ? msg.replace(/{([^}]+)}/g, (_, key: string) => param[key] as string) : msg;
+  }
+  async getDictionary(lang: string) {
+    const dictionary = Translator.#langDictionaryMap.get(lang);
+    if (!dictionary) throw new Error(`Dictionary for language ${lang} not found`);
+    return dictionary;
+  }
+}

package/client/types.ts

@@ -0,0 +1,228 @@
+import type { BaseInsight } from "akanjs/constant";
+import type { FetchInitForm, SliceMeta } from "akanjs/fetch";
+import { type ClassValue, clsx as clsxLib } from "clsx";
+import type { ReactElement, ReactNode } from "react";
+
+/** Composes class names with the shared clsx implementation. */
+export const clsx = (...args: ClassValue[]) => clsxLib(...args);
+
+export type ReactFontStyle = "normal" | "italic" | "oblique";
+export type ReactFontDisplay = "auto" | "block" | "swap" | "fallback" | "optional";
+export type ReactFontCategory = "monospace" | "sans-serif" | "serif" | "display";
+export type ReactFontSubset = "latin" | "latin-ext" | "ks-x-1001" | "auto" | (string & {});
+
+export interface ReactFontDeclaration {
+  prop: string;
+  value: string;
+}
+
+export interface ReactFontPath {
+  src: string;
+  weight: number | string;
+  style?: ReactFontStyle;
+  declarations?: ReactFontDeclaration[];
+}
+
+export interface ReactFontFace {
+  font: ReactFont;
+  path: ReactFontPath;
+  src: string;
+  weight: number | string;
+  style: ReactFontStyle;
+  optimizedSrc: string;
+}
+
+export const loadFonts = <T extends ReactFont[]>(fonts: T) =>
+  fonts.map((font) => ({ ...font, subsets: font.subsets ?? ["latin"] })) as T;
+
+const FONT_URL_PREFIX = "/_akan/fonts";
+
+export const getFontVariableName = (font: ReactFont) => font.variable ?? `--font-${font.name}`;
+export const getFontFallbackName = (font: ReactFont) => font.fallbackName ?? `${font.name} fallback`;
+export const isFontOptimizationEnabled = (font: ReactFont) => font.optimize !== false;
+export const isFontPreloadEnabled = (font: ReactFont) => font.preload !== false;
+
+export const getFontStyles = (font: ReactFont): ReactFontStyle[] => {
+  const styles: ReactFontStyle[] = font.styles?.length ? font.styles : ["normal"];
+  return [...new Set(styles)];
+};
+
+export const getFontFaces = (font: ReactFont): ReactFontFace[] => {
+  const enabledStyles = new Set(getFontStyles(font));
+  return font.paths
+    .map((path) => {
+      const style = path.style ?? "normal";
+      return {
+        font,
+        path,
+        src: path.src,
+        weight: path.weight,
+        style,
+        optimizedSrc: getOptimizedFontSrc(font, path),
+      };
+    })
+    .filter((face) => enabledStyles.has(face.style));
+};
+
+export const getOptimizedFontSrc = (font: ReactFont, path: ReactFontPath) => {
+  const style = path.style ?? "normal";
+  const hash = hashFontConfig({
+    name: font.name,
+    src: path.src,
+    weight: path.weight,
+    style,
+    display: font.display,
+    subset: font.subset,
+    subsets: font.subsets,
+    subsetText: font.subsetText,
+    subsetFiles: font.subsetFiles,
+    declarations: [...(font.declarations ?? []), ...(path.declarations ?? [])],
+  });
+  return `${FONT_URL_PREFIX}/${slugFontPart(font.name)}-${slugFontPart(String(path.weight))}-${style}-${hash}.woff2`;
+};
+
+const hashFontConfig = (value: unknown) => {
+  const input = stableStringify(value);
+  let hash = 0x811c9dc5;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = Math.imul(hash, 0x01000193);
+  }
+  return (hash >>> 0).toString(36);
+};
+
+const stableStringify = (value: unknown): string => {
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value as Record<string, unknown>)
+      .filter(([, v]) => v !== undefined)
+      .sort(([a], [b]) => a.localeCompare(b));
+    return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+};
+
+const slugFontPart = (value: string) =>
+  value
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "") || "font";
+
+/** Common props for list/zone components that render many model records. */
+export interface ModelsProps<M extends { id: string }> {
+  className?: string;
+  slice?: SliceMeta;
+  query?: Record<string, unknown>;
+  init?: FetchInitForm<any, any>;
+  onClickItem?: (model: M) => unknown;
+}
+
+/** Common props for unit/view components that render one named model record. */
+export type ModelProps<T extends string, L extends { id: string }> = { [key in T]: L } & {
+  className?: string;
+  slice?: SliceMeta;
+  onClick?: (model: L) => unknown;
+  actions?: DataAction[];
+  columns?: DataColumn<L>[];
+  href?: string;
+};
+
+export interface ModelDashboardProps<Summary> {
+  className?: string;
+  summary: Summary;
+  queryMap?: Record<string, unknown>;
+  columns?: (keyof Summary)[];
+  hidePresents?: boolean;
+  slice?: SliceMeta;
+}
+
+export interface ModelInsightProps<Insight = BaseInsight> {
+  className?: string;
+  insight: Insight;
+  slice?: SliceMeta;
+}
+
+export interface ModelEditProps {
+  slice?: SliceMeta;
+}
+
+export interface ModelViewProps {
+  id?: string;
+  slice?: SliceMeta;
+}
+export type DataAction = "edit" | "view" | "remove" | null | undefined | ReactElement;
+export interface DataTool {
+  key: string;
+  render: () => ReactNode;
+}
+
+export type DataColumn<L> =
+  | string
+  | {
+      key: keyof L;
+      title?: string;
+      value?: (value: any, model: L) => string | number | boolean | undefined | null | object;
+      responsive?: boolean;
+      render?: (value: any, model: L) => ReactNode;
+      only?: "user" | "admin";
+    };
+
+export interface DataMenuItem {
+  key: string;
+  icon: ReactNode;
+  label?: string;
+  render: () => ReactNode;
+}
+export interface DataMenu {
+  [key: string]: DataMenuItem;
+}
+
+export interface UserMenuItem {
+  title: string | ReactNode;
+  icon?: ReactNode;
+  path: string;
+  query?: Record<string, unknown>;
+  children?: UserMenuItem[];
+  onClick?: () => void;
+}
+
+export interface MenuItem {
+  icon?: ReactNode;
+  title: string | ReactNode;
+  href: string;
+  hide?: "mobile" | "pc";
+  children?: MenuItem[];
+  onClick?: () => void;
+}
+
+export interface ReactFont {
+  name: string;
+  default?: boolean;
+  paths: ReactFontPath[];
+  styles?: ReactFontStyle[];
+  display?: ReactFontDisplay;
+  preload?: boolean;
+  fallbacks?: string[];
+  fallbackName?: string;
+  subsets?: ReactFontSubset[];
+  subsetText?: string;
+  subsetFiles?: string[];
+  subset?: false;
+  category?: ReactFontCategory;
+  variable?: string;
+  className?: string;
+  declarations?: ReactFontDeclaration[];
+  adjustFontFallback?: boolean;
+  optimize?: boolean;
+}
+
+/** Font declaration consumed by Akan layout modules and font optimization. */
+export type Font = ReactFont;
+
+export interface RootLayoutProps {
+  children: ReactNode;
+  params: {
+    lang: "en" | "ko" | (string & {});
+  };
+}

package/client/useClient.ts

@@ -0,0 +1 @@
+export { Err, fetch, msg, sig, usePage } from "./clientRuntime";

package/common/Logger.ts

@@ -0,0 +1,177 @@
+import dayjs from "dayjs";
+
+const logLevels = ["trace", "verbose", "debug", "log", "info", "warn", "error"] as const;
+export type LogLevel = (typeof logLevels)[number];
+
+export interface LoggerSinkEntry {
+  stream: "stdout" | "stderr";
+  level?: LogLevel;
+  message: string;
+  plainMessage: string;
+}
+
+export type LoggerSink = (entry: LoggerSinkEntry) => void | Promise<void>;
+
+const clc = {
+  bold: (text: string) => `\x1B[1m${text}\x1B[0m`,
+  green: (text: string) => `\x1B[32m${text}\x1B[39m`,
+  yellow: (text: string) => `\x1B[33m${text}\x1B[39m`,
+  red: (text: string) => `\x1B[31m${text}\x1B[39m`,
+  magentaBright: (text: string) => `\x1B[95m${text}\x1B[39m`,
+  cyanBright: (text: string) => `\x1B[96m${text}\x1B[39m`,
+};
+
+const colorizeMap: { [key in LogLevel]: (text: string) => string } = {
+  trace: clc.bold,
+  verbose: clc.cyanBright,
+  debug: clc.magentaBright,
+  log: clc.green,
+  info: clc.green,
+  warn: clc.yellow,
+  error: clc.red,
+};
+
+const ansiPattern = new RegExp(`${String.fromCharCode(27)}\\[[0-?]*[ -/]*[@-~]`, "g");
+
+/** Log-level aware logger used by Akan runtime, CLI, and application services. */
+export class Logger {
+  static level: LogLevel = (process.env?.AKAN_PUBLIC_LOG_LEVEL as LogLevel | undefined) ?? "log";
+  static #levelIdx = logLevels.findIndex((l) => l === (process.env?.AKAN_PUBLIC_LOG_LEVEL ?? "log"));
+  static fileLevel: LogLevel = (process.env?.AKAN_LOG_FILE_LEVEL as LogLevel | undefined) ?? "trace";
+  static #fileLevelIdx = logLevels.findIndex((l) => l === (process.env?.AKAN_LOG_FILE_LEVEL ?? "trace"));
+  static #startAt = dayjs();
+  static #sinks = new Set<LoggerSink>();
+
+  static setLevel(level: LogLevel) {
+    Logger.level = level;
+    Logger.#levelIdx = logLevels.indexOf(level);
+  }
+  static addSink(sink: LoggerSink) {
+    Logger.#sinks.add(sink);
+    return () => Logger.removeSink(sink);
+  }
+  static removeSink(sink: LoggerSink) {
+    Logger.#sinks.delete(sink);
+  }
+  static setFileLevel(level: LogLevel) {
+    Logger.fileLevel = level;
+    Logger.#fileLevelIdx = logLevels.indexOf(level);
+  }
+  static isVerbose() {
+    return Logger.#levelIdx <= 1;
+  }
+
+  name?: string;
+  constructor(name?: string) {
+    this.name = name;
+  }
+  trace(msg: string, context = "", name = this.name ?? "App") {
+    if (Logger.#shouldLog("trace")) Logger.#printMessages(name, msg, context, "trace");
+  }
+  verbose(msg: string, context = "", name = this.name ?? "App") {
+    if (Logger.#shouldLog("verbose")) Logger.#printMessages(name, msg, context, "verbose");
+  }
+  debug(msg: string, context = "", name = this.name ?? "App") {
+    if (Logger.#shouldLog("debug")) Logger.#printMessages(name, msg, context, "debug");
+  }
+  log(msg: string, context = "", name = this.name ?? "App") {
+    if (Logger.#shouldLog("log")) Logger.#printMessages(name, msg, context, "log");
+  }
+  info(msg: string, context = "", name = this.name ?? "App") {
+    if (Logger.#shouldLog("info")) Logger.#printMessages(name, msg, context, "info");
+  }
+  warn(msg: string, context = "", name = this.name ?? "App") {
+    if (Logger.#shouldLog("warn")) Logger.#printMessages(name, msg, context, "warn");
+  }
+  error(msg: string, context = "", name = this.name ?? "App") {
+    if (Logger.#shouldLog("error")) Logger.#printMessages(name, msg, context, "error");
+  }
+  raw(msg: string, method?: "console" | "process") {
+    Logger.rawLog(msg, method);
+  }
+  rawLog(msg: string, method?: "console" | "process") {
+    Logger.rawLog(msg, method);
+  }
+  
+  static trace(msg: string, context = "", name = "App") {
+    if (Logger.#shouldLog("trace")) Logger.#printMessages(name, msg, context, "trace");
+  }
+  static verbose(msg: string, context = "", name = "App") {
+    if (Logger.#shouldLog("verbose")) Logger.#printMessages(name, msg, context, "verbose");
+  }
+  static debug(msg: string, context = "", name = "App") {
+    if (Logger.#shouldLog("debug")) Logger.#printMessages(name, msg, context, "debug");
+  }
+  static log(msg: string, context = "", name = "App") {
+    if (Logger.#shouldLog("log")) Logger.#printMessages(name, msg, context, "log");
+  }
+  static info(msg: string, context = "", name = "App") {
+    if (Logger.#shouldLog("info")) Logger.#printMessages(name, msg, context, "info");
+  }
+  static warn(msg: string, context = "", name = "App") {
+    if (Logger.#shouldLog("warn")) Logger.#printMessages(name, msg, context, "warn");
+  }
+  static error(msg: string, context = "", name = "App") {
+    if (Logger.#shouldLog("error")) Logger.#printMessages(name, msg, context, "error");
+  }
+  static #colorize(msg: string, logLevel: LogLevel) {
+    return colorizeMap[logLevel](msg);
+  }
+  static #stripAnsi(msg: string) {
+    return msg.replace(ansiPattern, "");
+  }
+  static #shouldLog(logLevel: LogLevel) {
+    return Logger.#shouldWriteConsole(logLevel) || Logger.#shouldEmitSink(logLevel);
+  }
+  static #shouldWriteConsole(logLevel: LogLevel) {
+    return Logger.#levelIdx <= logLevels.indexOf(logLevel);
+  }
+  static #shouldEmitSink(logLevel: LogLevel) {
+    return Logger.#sinks.size > 0 && Logger.#fileLevelIdx <= logLevels.indexOf(logLevel);
+  }
+  static #emit(entry: LoggerSinkEntry) {
+    for (const sink of Logger.#sinks) {
+      try {
+        void Promise.resolve(sink(entry)).catch(() => undefined);
+      } catch {
+      }
+    }
+  }
+  static #printMessages(
+    name: string | undefined,
+    content: string,
+    context: string,
+    logLevel: LogLevel,
+    writeStreamType: "stdout" | "stderr" = logLevel === "error" ? "stderr" : "stdout",
+  ) {
+    const now = dayjs();
+    const replicaIdx = (process as unknown as NodeJS.Process | undefined)?.env?.AKAN_REPLICA_IDX;
+    const replicaMsg = replicaIdx === undefined ? "" : `#${replicaIdx} `;
+    const processMsg = Logger.#colorize(
+      `[${name ?? "App"}] ${replicaMsg}${(process as unknown as NodeJS.Process | undefined)?.pid ?? "window"} -`,
+      logLevel,
+    );
+    const timestampMsg = now.format("MM/DD/YYYY, HH:mm:ss A");
+    const logLevelMsg = Logger.#colorize(logLevel.toUpperCase().padStart(7, " "), logLevel);
+    const contextMsg = context ? clc.yellow(`[${context}] `) : "";
+    const contentMsg = Logger.#colorize(content, logLevel);
+    const timeDiffMsg = clc.yellow(`+${now.diff(Logger.#startAt, "ms")}ms`);
+    const message = `${processMsg} ${timestampMsg} ${logLevelMsg} ${contextMsg} ${contentMsg} ${timeDiffMsg}\n`;
+    if (Logger.#shouldEmitSink(logLevel))
+      Logger.#emit({ stream: writeStreamType, level: logLevel, message, plainMessage: Logger.#stripAnsi(message) });
+    if (!Logger.#shouldWriteConsole(logLevel)) return;
+    if (typeof window === "undefined")
+      (process[writeStreamType] as unknown as NodeJS.WriteStream | undefined)?.write(message);
+    else console.log(message);
+  }
+  static rawLog(msg = "", method?: "console" | "process", outputStream?: "log" | "error") {
+    Logger.raw(`${msg}\n`, method, outputStream);
+  }
+  static raw(msg = "", method?: "console" | "process", outputStream?: "log" | "error") {
+    const stream = outputStream === "error" ? "stderr" : "stdout";
+    Logger.#emit({ stream, message: msg, plainMessage: Logger.#stripAnsi(msg) });
+    if (typeof window === "undefined" && method !== "console" && (process as unknown as NodeJS.Process | undefined))
+      process[stream].write(msg);
+    else console[outputStream === "error" ? "error" : "log"](msg.trim());
+  }
+}

package/common/applyMixins.ts

@@ -0,0 +1,14 @@
+import { getAllPropertyDescriptors } from "./getAllPropertyDescriptors";
+
+type Cls<T = unknown> = new (...args: never[]) => T;
+
+export const applyMixins = (derivedCtor: Cls, constructors: (Cls | undefined)[], avoidKeys?: Set<string>) => {
+  constructors.forEach((baseCtor) => {
+    if (!baseCtor) return;
+    Object.entries(getAllPropertyDescriptors(baseCtor)).forEach(([name, descriptor]) => {
+      if (name === "constructor" || avoidKeys?.has(name)) return;
+      Object.defineProperty(derivedCtor.prototype, name, { ...descriptor, configurable: true });
+    });
+  });
+  return derivedCtor;
+};

package/common/capitalize.ts

@@ -0,0 +1,4 @@
+/** Uppercases only the first character of a string. */
+export const capitalize = (str: string) => {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+};

package/common/deepObjectify.ts

@@ -0,0 +1,27 @@
+import { isDayjs } from "./isDayjs";
+
+export const deepObjectify = <T = unknown>(
+  obj: T | null | undefined,
+  option: { serializable?: boolean; convertDate?: "string" | "number" } = {},
+): T => {
+  if (isDayjs(obj) || obj?.constructor === Date) {
+    if (!option.serializable && !option.convertDate) return obj as T;
+    if (option.convertDate === "string") return obj.toISOString() as T;
+    else if (option.convertDate === "number")
+      return (isDayjs(obj) ? obj.toDate().getTime() : (obj as Date).getTime()) as T;
+    else return (isDayjs(obj) ? obj.toDate() : obj) as T;
+  } else if (Array.isArray(obj)) {
+    return obj.map((o: unknown) => deepObjectify(o, option)) as T;
+  } else if (obj && typeof obj === "object") {
+    const val: Record<string, unknown> = {};
+    const objRecord = obj as Record<string, unknown>;
+    Object.keys(obj).forEach((key) => {
+      const fieldValue = objRecord[key] as { __ModelType__: string } | null | undefined;
+      if (fieldValue?.__ModelType__ && !option.serializable) val[key] = fieldValue;
+      else if (typeof objRecord[key] !== "function") val[key] = deepObjectify(fieldValue, option);
+    });
+    return val as T;
+  } else {
+    return obj as unknown as T;
+  }
+};

package/common/formatNumber.ts

@@ -0,0 +1,14 @@
+export const formatNumber = (numString: string) => {
+  
+  if (typeof numString !== "string") {
+    numString = String(numString);
+  }
+
+  const parts = numString.split(".");
+  const integerPart = parts[0]?.replace(/[^\d]/g, "") ?? ""; 
+  const decimalPart = parts.length > 1 ? `.${parts[1]}` : "";
+
+  const formattedInteger = Number(integerPart).toLocaleString("ko-KR");
+
+  return formattedInteger + decimalPart;
+};

package/common/formatPhone.ts

@@ -0,0 +1,7 @@
+/** Formats supported phone-number strings into dashed display form. */
+export const formatPhone = (value: string) => {
+  if (!value) return "";
+  if (value.length === 10) return value.replace(/(\d{3})(\d{3})(\d{4})/, "$1-$2-$3");
+  else if (value.length === 13) return value.replace(/-/g, "").replace(/(\d{3})(\d{4})(\d{4})/, "$1-$2-$3");
+  else return value;
+};

package/common/getAllPropertyDescriptors.ts

@@ -0,0 +1,13 @@
+type Cls<T = unknown> = new (...args: never[]) => T;
+export const getAllPropertyDescriptors = (objRef: Cls): { [key: string]: PropertyDescriptor } => {
+  const descriptors: Record<string, PropertyDescriptor> = {};
+  let current = objRef.prototype as object | null;
+  while (current) {
+    Object.getOwnPropertyNames(current).forEach((name) => {
+      const descriptor = Object.getOwnPropertyDescriptor(current, name);
+      if (descriptor) descriptors[name] ??= descriptor;
+    });
+    current = Object.getPrototypeOf(current) as Cls | object;
+  }
+  return descriptors;
+};

package/common/hmrPhase.ts

@@ -0,0 +1,17 @@
+export type AkanHmrPhase = "refresh-import" | "react-refresh" | null;
+
+declare global {
+  
+  var __AKAN_HMR_PHASE__: AkanHmrPhase | undefined;
+}
+
+export function getAkanHmrPhase(): AkanHmrPhase {
+  if (typeof globalThis === "undefined") return null;
+  const phase = globalThis.__AKAN_HMR_PHASE__;
+  if (phase === "refresh-import" || phase === "react-refresh") return phase;
+  return null;
+}
+
+export function isAkanHmrApplying(): boolean {
+  return getAkanHmrPhase() !== null;
+}

package/common/httpClient.ts

@@ -0,0 +1,101 @@
+export interface HttpClientOptions {
+  baseUrl?: string;
+  headers?: HeadersInit;
+  timeout?: number;
+}
+
+export interface HttpRequestOptions extends Omit<RequestInit, "body" | "headers" | "method"> {
+  headers?: HeadersInit;
+  timeout?: number;
+}
+
+export class HttpClient {
+  readonly baseUrl: string;
+  readonly headers: Headers;
+  readonly timeout: number | undefined;
+
+  constructor(options: string | HttpClientOptions = {}) {
+    const normalized = typeof options === "string" ? { baseUrl: options } : options;
+    this.baseUrl = normalized.baseUrl?.replace(/\/+$/, "") ?? "";
+    this.headers = new Headers(normalized.headers);
+    this.timeout = normalized.timeout;
+  }
+
+  async get<Returns>(url: string, options?: HttpRequestOptions): Promise<Returns> {
+    return await this.#request<Returns>("GET", url, undefined, options);
+  }
+
+  async post<Returns>(url: string, data?: unknown, options?: HttpRequestOptions): Promise<Returns> {
+    return await this.#request<Returns>("POST", url, data, options);
+  }
+
+  async put<Returns>(url: string, data?: unknown, options?: HttpRequestOptions): Promise<Returns> {
+    return await this.#request<Returns>("PUT", url, data, options);
+  }
+
+  async delete<Returns>(url: string, options?: HttpRequestOptions): Promise<Returns> {
+    return await this.#request<Returns>("DELETE", url, undefined, options);
+  }
+
+  async #request<Returns>(
+    method: string,
+    url: string,
+    data?: unknown,
+    options: HttpRequestOptions = {},
+  ): Promise<Returns> {
+    const { body, headers } = this.#makeBody(data);
+    const timeout = options.timeout ?? this.timeout;
+    const response = await fetch(this.#makeUrl(url), {
+      ...options,
+      method,
+      body,
+      headers: this.#makeHeaders(headers, options.headers),
+      signal: timeout ? AbortSignal.timeout(timeout) : undefined,
+    });
+
+    if (!response.ok) {
+      throw new Error(await response.text());
+    }
+
+    if (response.status === 204) {
+      return undefined as Returns;
+    }
+
+    const contentType = response.headers.get("content-type") ?? "";
+    if (contentType.includes("application/json")) {
+      return (await response.json()) as Returns;
+    }
+
+    const text = await response.text();
+    return (text.length > 0 ? text : undefined) as Returns;
+  }
+
+  #makeUrl(url: string) {
+    if (/^https?:\/\//.test(url) || !this.baseUrl) return url;
+    return `${this.baseUrl}${url.startsWith("/") ? url : `/${url}`}`;
+  }
+
+  #makeHeaders(...headersList: Array<HeadersInit | undefined>) {
+    const headers = new Headers(this.headers);
+    for (const headerList of headersList) {
+      new Headers(headerList).forEach((value, key) => {
+        headers.set(key, value);
+      });
+    }
+    return headers;
+  }
+
+  #makeBody(data: unknown): { body?: BodyInit; headers?: HeadersInit } {
+    if (data === undefined) return {};
+    if (data instanceof FormData) return { body: data };
+    if (typeof data === "string") return { body: data };
+    if (data instanceof URLSearchParams) return { body: data };
+    if (data instanceof Blob) return { body: data };
+    if (data instanceof ArrayBuffer) return { body: data };
+
+    return {
+      body: JSON.stringify(data),
+      headers: { "Content-Type": "application/json" },
+    };
+  }
+}