desfetch 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 NotZero
+
+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/README.md

@@ -0,0 +1,193 @@
+# desfetch
+
+A tiny type-safe `fetch` wrapper for destructured { data, error } results, with automatic JSON parsing, custom parsers, and no `try/catch`.
+
+## Features
+
+- Automatically parses JSON responses
+- Supports custom response parsers
+- TypeScript-friendly
+- Returns `{ data, error }` instead of throwing
+- Uses the native `fetch` API
+- Allows passing a custom `fetch` implementation
+- Zero dependencies
+
+## Installation
+
+```bash
+pnpm add desfetch
+```
+
+Or with npm:
+
+```bash
+npm install desfetch
+```
+
+## Usage
+
+### Basic usage
+
+By default, `desfetch` parses the response as JSON:
+
+```ts
+import desfetch from "desfetch";
+
+const { data, error } = await desfetch<User>("/api/user");
+
+if (error) {
+  console.error(error);
+  return;
+}
+
+console.log(data.name);
+```
+
+### POST request
+
+`desfetch` accepts all standard `RequestInit` options:
+
+```ts
+const { data, error } = await desfetch<User>("/api/user", {
+  method: "POST",
+  headers: {
+    "Content-Type": "application/json",
+  },
+  body: JSON.stringify({
+    name: "John",
+  }),
+});
+```
+
+### Custom parsing
+
+You can provide your own parser when the response isn't JSON.
+
+For example, parsing plain text:
+
+```ts
+const { data, error } = await desfetch<string>("/api/message", {
+  parse: (response) => response.text(),
+});
+
+console.log(data);
+```
+
+Or parsing a `Blob`:
+
+```ts
+const { data, error } = await desfetch<Blob>("/api/file", {
+  parse: (response) => response.blob(),
+});
+```
+
+### Custom `fetch`
+
+The third argument allows you to provide a custom `fetch` implementation:
+
+```ts
+const { data, error } = await desfetch<User>(
+  "/api/user",
+  {},
+  customFetch,
+);
+```
+
+This can be useful with frameworks that provide their own `fetch` implementation:
+
+```ts
+const { data, error } = await desfetch<User>("/api/user", {}, fetch);
+```
+
+## Error handling
+
+`desfetch` never throws instead, it returns one of these shapes:
+
+```ts
+{
+  data: T;
+  error: null;
+}
+```
+
+or:
+
+```ts
+{
+  data: null;
+  error: Error;
+}
+```
+
+For example:
+
+```ts
+const { data, error } = await desfetch<User>("/api/user");
+
+if (error) {
+  console.error("Request failed:", error);
+  return;
+}
+
+console.log(data.name);
+```
+
+HTTP responses outside the `2xx` range are treated as errors:
+
+```text
+HTTP 404: Not Found
+HTTP 500: Internal Server Error
+```
+
+## API
+
+```ts
+type DesFetchOptions<T> = RequestInit & {
+  parse?: (response: Response) => Promise<T>;
+};
+
+const desfetch = async <T = unknown>(
+  url: string | URL,
+  options?: DesFetchOptions<T>,
+  fetchInstance?: typeof globalThis.fetch,
+): Promise<
+  | { data: T; error: null }
+  | { data: null; error: Error }
+>;
+```
+
+### `url`
+
+The URL to request.
+
+Accepts either a `string` or `URL`.
+
+### `options`
+
+All standard `RequestInit` options are supported, plus:
+
+#### `parse`
+
+A function responsible for converting the `Response` into the desired type.
+
+The default parser is:
+
+```ts
+(response) => response.json();
+```
+
+### `fetchInstance`
+
+Optional custom `fetch` implementation.
+
+Defaults to:
+
+```ts
+globalThis.fetch
+```
+
+Simple fetch, typed data, explicit errors.
+
+## Source Code
+
+Since this lib is MIT licensed, you can also contribute to it at it's repo on [GitHub](https://github.com/yspoof/desfetch)

package/dist/index.cjs

@@ -0,0 +1 @@
+"use strict";var o=Object.defineProperty;var a=Object.getOwnPropertyDescriptor;var c=Object.getOwnPropertyNames;var i=Object.prototype.hasOwnProperty;var T=(t,r)=>{for(var s in r)o(t,s,{get:r[s],enumerable:!0})},l=(t,r,s,n)=>{if(r&&typeof r=="object"||typeof r=="function")for(let e of c(r))!i.call(t,e)&&e!==s&&o(t,e,{get:()=>r[e],enumerable:!(n=a(r,e))||n.enumerable});return t};var p=t=>l(o({},"__esModule",{value:!0}),t);var w={};T(w,{default:()=>f});module.exports=p(w);var u=async t=>await t.json(),h=async(t,{parse:r=u,...s}={},n=globalThis.fetch)=>{try{let e=await n(t,s);if(!e.ok)throw new Error(`HTTP ${e.status}: ${e.statusText}`);return{data:await r(e),error:null}}catch(e){return{data:null,error:e instanceof Error?e:new Error(String(e))}}},f=h;

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+type DesFetchOptions<T> = RequestInit & {
+    parse?: (response: Response) => Promise<T>;
+};
+declare const desfetch: <T = unknown>(url: string | URL, { parse, ...options }?: DesFetchOptions<T>, fetchInstance?: typeof globalThis.fetch) => Promise<{
+    data: Awaited<T>;
+    error: null;
+} | {
+    data: null;
+    error: Error;
+}>;
+export default desfetch;

package/dist/index.js

@@ -0,0 +1 @@
+var o=async t=>await t.json(),a=async(t,{parse:r=o,...s}={},n=globalThis.fetch)=>{try{let e=await n(t,s);if(!e.ok)throw new Error(`HTTP ${e.status}: ${e.statusText}`);return{data:await r(e),error:null}}catch(e){return{data:null,error:e instanceof Error?e:new Error(String(e))}}},c=a;export{c as default};

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "desfetch",
+  "version": "1.0.0",
+  "description": "A tiny type-safe fetch wrapper for destructured { data, error } results, with automatic JSON parsing, custom parsers, and no try/catch.",
+  "keywords": [
+    "api",
+    "client",
+    "fetch",
+    "http",
+    "request"
+  ],
+  "license": "MIT",
+  "author": "n0tz3r0",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "devDependencies": {
+    "tsup": "^8.5.1",
+    "typescript": "^7.0.2"
+  },
+  "devEngines": {
+    "packageManager": {
+      "name": "pnpm",
+      "version": "11.24.0",
+      "onFail": "download"
+    }
+  },
+  "scripts": {
+    "build": "tsup && tsc",
+    "dev": "tsup --watch"
+  }
+}