@alphatique/hono-fetch 0.0.0-stage → 1.0.4

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2026 Alphatique
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/dist/index.d.mts

@@ -0,0 +1,33 @@
+import { Schema } from "hono";
+import { HonoBase } from "hono/hono-base";
+import { Endpoint, ExtractSchema } from "hono/types";
+import "hono/utils/headers";
+//#region src/config.d.ts
+interface HonoFetchConfig {
+  baseUrl: string;
+  onError?: (err: unknown) => any;
+}
+//#endregion
+//#region src/types.d.ts
+type Method = 'get' | 'post' | 'put' | 'delete' | 'patch';
+type ExtractPath<S extends Schema, M extends Method> = { [P in keyof S]: P extends string ? InferEndpoint<S, M, P> extends Endpoint ? P : never : never; }[keyof S];
+type InferEndpoint<S extends Schema, M extends Method, P extends keyof S> = S[P][`$${M}`];
+type InferInput<S extends Schema, M extends Method, P extends keyof S> = InferEndpoint<S, M, P>['input'];
+type InferOutput<S extends Schema, M extends Method, P extends keyof S> = InferEndpoint<S, M, P>['output'];
+type InferError<C extends HonoFetchConfig> = C['onError'] extends ((err: unknown) => infer E) ? Awaited<E> : never;
+//#endregion
+//#region src/index.d.ts
+export declare class HonoFetch<S extends Schema, C extends HonoFetchConfig> {
+  private config;
+  constructor(config: C);
+  private fetch;
+  get<P extends ExtractPath<S, 'get'>>(path: P, args: InferInput<S, 'get', P>): Promise<InferOutput<S, "get", P> | InferError<C>>;
+  post<P extends ExtractPath<S, 'post'>>(path: P, args: InferInput<S, 'post', P>): Promise<InferError<C> | InferOutput<S, "post", P>>;
+  put<P extends ExtractPath<S, 'put'>>(path: P, args: InferInput<S, 'put', P>): Promise<InferError<C> | InferOutput<S, "put", P>>;
+  delete<P extends ExtractPath<S, 'delete'>>(path: P, args: InferInput<S, 'delete', P>): Promise<InferError<C> | InferOutput<S, "delete", P>>;
+  patch<P extends ExtractPath<S, 'patch'>>(path: P, args: InferInput<S, 'patch', P>): Promise<InferError<C> | InferOutput<S, "patch", P>>;
+}
+type InferSchema<T extends HonoBase<any, any, any>> = T extends HonoBase<any, any, any> ? ExtractSchema<T> : never;
+export declare function honoFetch<T extends HonoBase<any, any, any>, C extends HonoFetchConfig = HonoFetchConfig>(config: C): HonoFetch<InferSchema<T>, C>;
+//#endregion
+export {};

package/dist/index.mjs

@@ -0,0 +1,71 @@
+//#region src/utils.ts
+function replaceUrlParam(urlString, params) {
+	for (const [k, v] of Object.entries(params)) {
+		const reg = new RegExp("/:" + k + "(?:{[^/]+})?\\??");
+		urlString = urlString.replace(reg, v ? `/${v}` : "");
+	}
+	return urlString;
+}
+//#endregion
+//#region src/index.ts
+var HonoFetch = class {
+	config;
+	constructor(config) {
+		this.config = config;
+	}
+	async fetch(method, path, args) {
+		const url = new URL(args.param ? replaceUrlParam(path, args.param) : path, this.config.baseUrl);
+		if (args.query) for (const [k, v] of Object.entries(args.query)) {
+			if (v === void 0) continue;
+			if (Array.isArray(v)) for (const v2 of v) url.searchParams.append(k, v2);
+			else url.searchParams.set(k, v);
+		}
+		let contentType = null;
+		let body = null;
+		if (args.json) {
+			contentType = "application/json";
+			body = JSON.stringify(args.json);
+		}
+		if (args.form) {
+			const form = new FormData();
+			for (const [k, v] of Object.entries(args.form)) {
+				if (v === void 0) continue;
+				if (Array.isArray(v)) for (const v2 of v) form.append(k, v2);
+				else form.set(k, v);
+			}
+			body = form;
+		}
+		const headers = new Headers(args.header);
+		if (contentType) headers.set("Content-Type", contentType);
+		try {
+			return (await fetch(url, {
+				method: method.toUpperCase(),
+				headers,
+				body
+			})).json();
+		} catch (err) {
+			if (this.config.onError) return this.config.onError(err);
+			throw err;
+		}
+	}
+	get(path, args) {
+		return this.fetch("get", path, args);
+	}
+	post(path, args) {
+		return this.fetch("post", path, args);
+	}
+	put(path, args) {
+		return this.fetch("put", path, args);
+	}
+	delete(path, args) {
+		return this.fetch("delete", path, args);
+	}
+	patch(path, args) {
+		return this.fetch("patch", path, args);
+	}
+};
+function honoFetch(config) {
+	return new HonoFetch(config);
+}
+//#endregion
+export { HonoFetch, honoFetch };

package/package.json

@@ -1,6 +1,36 @@
 {
-  "name": "@alphatique/hono-fetch",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+	"name": "@alphatique/hono-fetch",
+	"version": "1.0.4",
+	"license": "ISC",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/alphatique/hono-fetch.git"
+	},
+	"files": [
+		"dist"
+	],
+	"type": "module",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.mts",
+			"default": "./dist/index.mjs"
+		}
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"scripts": {
+		"prepare": "vp config --no-agent",
+		"build": "vp pack"
+	},
+	"devDependencies": {
+		"hono": "^4.12.10",
+		"typescript": "^5.9.3",
+		"vite": "catalog:",
+		"vite-plus": "catalog:"
+	},
+	"peerDependencies": {
+		"hono": "^4.12.10"
+	},
+	"packageManager": "pnpm@12.11.2"
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.