unfee 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Ayoub Chaaoui <ayoubchaaoui02@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,67 @@
+//#region src/http-error.d.ts
+declare class HTTPError extends Error {
+  readonly response: Response;
+  readonly request: Request;
+  readonly options: FetchOptions;
+  readonly status: number;
+  readonly statusText: string;
+  constructor(response: Response, request: Request, options: FetchOptions);
+}
+//#endregion
+//#region src/types.d.ts
+type Input = string | URL;
+interface Fetch {
+  <T = any>(input: Input, options?: FetchOptions): Promise<FetchResponse<T>>;
+  extend: (options: ExtendOptions) => Fetch;
+}
+interface FetchResponse<T> {
+  headers: Headers;
+  data: T;
+  status: number;
+  statusText: string;
+}
+interface ExtendOptions {
+  baseUrl?: string;
+  headers?: HeadersInit;
+  query?: Record<string, any>;
+  hooks?: Hooks;
+}
+interface FetchOptions {
+  method?: RequestHttpVerbs;
+  query?: Record<string, any>;
+  headers?: HeadersInit;
+  data?: string | FormData | URLSearchParams | object;
+  hooks?: Hooks;
+}
+interface Hooks {
+  beforeRequest?: (options: Omit<FetchOptions, "hooks">) => void;
+  afterResponse?: (request: Request, response: Response, options: Readonly<FetchOptions>) => void;
+  onRequestError?: (error: unknown, request: Request, options: Readonly<FetchOptions>) => void;
+  onResponseError?: (error: HTTPError, response: Response, request: Request, options: Readonly<FetchOptions>) => void;
+  onResponseParseError?: (error: unknown, response: Response, request: Request, options: Readonly<FetchOptions>) => void;
+}
+interface Context {
+  method: string;
+  url: string;
+  headers: HeadersInit;
+  query: URLSearchParams;
+  data: BodyInit | undefined;
+  options: FetchOptions;
+  hooks: {
+    beforeRequest: Hooks["beforeRequest"][];
+    afterResponse: Hooks["afterResponse"][];
+    onRequestError: Hooks["onRequestError"][];
+    onResponseError: Hooks["onResponseError"][];
+    onResponseParseError: Hooks["onResponseParseError"][];
+  };
+}
+type RequestHttpVerbs = "get" | "post" | "put" | "patch" | "head" | "delete" | "options" | "trace";
+declare enum ResponseType {
+  text = 0,
+  json = 1
+}
+//#endregion
+//#region src/index.d.ts
+declare const bfetch: Fetch;
+//#endregion
+export { Context, ExtendOptions, Fetch, FetchOptions, FetchResponse, Hooks, Input, RequestHttpVerbs, ResponseType, bfetch };

package/dist/index.js

@@ -0,0 +1,167 @@
+//#region src/http-error.ts
+var HTTPError = class extends Error {
+	status;
+	statusText;
+	constructor(response, request, options) {
+		super(`Request failed: [${request.method} ${request.url}]`);
+		this.response = response;
+		this.request = request;
+		this.options = options;
+		this.name = "fetch-error";
+		this.status = response.status;
+		this.statusText = response.statusText;
+	}
+};
+
+//#endregion
+//#region src/types.ts
+let ResponseType = /* @__PURE__ */ function(ResponseType) {
+	ResponseType[ResponseType["text"] = 0] = "text";
+	ResponseType[ResponseType["json"] = 1] = "json";
+	return ResponseType;
+}({});
+
+//#endregion
+//#region src/http.ts
+function constructRequest(ctx) {
+	const query = ctx.query.toString();
+	return new Request(ctx.url + (query ? `?${query}` : ""), {
+		method: ctx.method,
+		headers: ctx.headers,
+		body: ctx.data
+	});
+}
+function detectResponseType(responseTypeHeader) {
+	const JSON_RESPONSE = /^application\/(?:[\w!#$%&*.^`~-]*\+)?json(?:;.+)?$/i;
+	responseTypeHeader = responseTypeHeader.split(";").shift() || "";
+	if (JSON_RESPONSE.test(responseTypeHeader)) return ResponseType.json;
+	return ResponseType.text;
+}
+
+//#endregion
+//#region src/merge.ts
+function mergeURL(path, baseUrl) {
+	if (path instanceof URL) return path.toString();
+	if (!baseUrl) return path;
+	if (path.startsWith(baseUrl)) return path;
+	if (!baseUrl.endsWith("/") && !path.startsWith("/")) return `${baseUrl}/${path}`;
+	if (baseUrl.endsWith("/") && path.startsWith("/")) return `${baseUrl.slice(0, -1)}${path}`;
+	return `${baseUrl}${path}`;
+}
+function mergeParams(...params) {
+	const result = new URLSearchParams();
+	function normalizeQueryValue(value) {
+		if (value == null) return "";
+		if (typeof value === "object") return JSON.stringify(value);
+		return String(value);
+	}
+	params.forEach((queries) => {
+		for (const [key, value] of Object.entries(queries)) if (value === void 0) result.delete(key);
+		else if (Array.isArray(value)) value.forEach((val) => result.append(key, val));
+		else result.set(key, normalizeQueryValue(value));
+	});
+	return result;
+}
+
+//#endregion
+//#region src/parse-error.ts
+var ParseError = class extends Error {
+	constructor(response, request, options, cause) {
+		super("Failed to parse response", { cause });
+		this.response = response;
+		this.request = request;
+		this.options = options;
+		this.name = "parse-error";
+	}
+};
+
+//#endregion
+//#region src/fetch.ts
+function createContext(input, options, extendOption) {
+	let method = "get";
+	let data;
+	let headers = { Accept: "application/json, text/plain, */*" };
+	if (options.method) method = options.method;
+	if (options.data instanceof URLSearchParams) {
+		headers["Content-Type"] = "application/x-www-form-urlencoded";
+		data = options.data.toString();
+	} else if (options.data instanceof FormData) data = options.data;
+	else if (typeof options.data === "string") {
+		headers["Content-Type"] = "text/plain;charset=UTF-8";
+		data = options.data;
+	} else if (typeof options.data === "object") {
+		headers["Content-Type"] = "application/json";
+		data = JSON.stringify(options.data);
+	} else data = options.data;
+	headers = {
+		...headers,
+		...options.headers ?? {}
+	};
+	return {
+		method: method.toUpperCase(),
+		url: mergeURL(input, extendOption.baseUrl),
+		query: mergeParams(extendOption.query ?? {}, options.query ?? {}),
+		headers,
+		data,
+		options,
+		hooks: {
+			onRequestError: [extendOption.hooks?.onRequestError, options.hooks?.onRequestError],
+			onResponseError: [extendOption.hooks?.onResponseError, options.hooks?.onResponseError],
+			beforeRequest: [extendOption.hooks?.beforeRequest, options.hooks?.beforeRequest],
+			afterResponse: [extendOption.hooks?.afterResponse, options.hooks?.afterResponse],
+			onResponseParseError: [extendOption.hooks?.onResponseParseError, options.hooks?.onResponseParseError]
+		}
+	};
+}
+async function createFetchResponse(response, request, ctx) {
+	const contentType = detectResponseType(response.headers.get("content-type") ?? "application/json");
+	let data;
+	try {
+		if (contentType === ResponseType.json) data = await response.json();
+		else data = await response.text();
+	} catch (error) {
+		throw new ParseError(response, request, ctx.options, error);
+	}
+	return {
+		data,
+		status: response.status,
+		headers: response.headers,
+		statusText: response.statusText
+	};
+}
+function createFetch(extendOptions) {
+	const $fetch = async function(input, options = {}) {
+		extendOptions.hooks?.beforeRequest?.(options);
+		options.hooks?.beforeRequest?.(options);
+		const context = createContext(input, options, extendOptions);
+		const request = constructRequest(context);
+		let inflight;
+		try {
+			inflight = await fetch(request);
+			if (!inflight.ok) throw new HTTPError(inflight, request, context.options);
+			context.hooks.afterResponse[0]?.(request, inflight, options);
+			context.hooks.afterResponse[1]?.(request, inflight, options);
+			return await createFetchResponse(inflight, request, context);
+		} catch (error) {
+			if (error instanceof ParseError) {
+				context.hooks.onResponseParseError[0]?.(error, inflight, request, options);
+				context.hooks.onResponseParseError[1]?.(error, inflight, request, options);
+			} else if (error instanceof HTTPError) {
+				context.hooks.onResponseError[0]?.(error, inflight, request, options);
+				context.hooks.onResponseError[1]?.(error, inflight, request, options);
+			} else {
+				context.hooks.onRequestError[0]?.(error, request, options);
+				context.hooks.onRequestError[1]?.(error, request, options);
+			}
+			throw error;
+		}
+	};
+	return Object.assign($fetch, { extend: createFetch });
+}
+
+//#endregion
+//#region src/index.ts
+const bfetch = createFetch({});
+
+//#endregion
+export { ResponseType, bfetch };

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "unfee",
+  "type": "module",
+  "version": "0.0.1",
+  "packageManager": "pnpm@10.20.0",
+  "description": "Fetch API with sensible defaults",
+  "license": "MIT",
+  "repository": "ayb-cha/unfee",
+  "sideEffects": false,
+  "exports": "./dist/index.js",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc --noEmit && rolldown -c",
+    "lint": "eslint",
+    "lint:fix": "eslint --fix",
+    "prepare": "pnpm simple-git-hooks",
+    "test": "vitest run --coverage",
+    "release": "release-it"
+  },
+  "devDependencies": {
+    "@antfu/eslint-config": "^7.2.0",
+    "@commitlint/cli": "^19.6.1",
+    "@commitlint/config-conventional": "^19.6.0",
+    "@types/node": "^24.9.2",
+    "@vitest/coverage-v8": "^4.0.5",
+    "changelogen": "^0.6.2",
+    "eslint": "^9.39.2",
+    "h3": "2.0.1-rc.11",
+    "lint-staged": "^16.2.7",
+    "release-it": "^19.2.4",
+    "release-it-pnpm": "^4.6.6",
+    "rolldown": "1.0.0-rc.3",
+    "rolldown-plugin-dts": "^0.22.1",
+    "simple-git-hooks": "^2.13.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.5"
+  }
+}