sushi-fetch 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sushi-Fetch Project
+
+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,210 @@
+# 🍣 sushi-fetch
+
+> **Simple, fast, and powerful data fetching with built-in caching,
+> deduplication, and retry --- for modern JavaScript.**
+
+![npm](https://img.shields.io/npm/v/sushi-fetch)
+![downloads](https://img.shields.io/npm/dm/sushi-fetch)
+![license](https://img.shields.io/npm/l/sushi-fetch)
+![typescript](https://img.shields.io/badge/types-TypeScript-blue)
+![bundle](https://img.shields.io/bundlephobia/min/sushi-fetch)
+![node](https://img.shields.io/node/v/sushi-fetch)
+![stars](https://img.shields.io/github/stars/sushilibdev/sushi-fetch?style=social)
+
+------------------------------------------------------------------------
+
+## ✨ Features
+
+-   ⚡ Fast & Lightweight
+-   📦 Built-in Cache (TTL support)
+-   🔁 Request Deduplication
+-   🔄 Retry System (fixed & exponential)
+-   ⏱️ Timeout Control
+-   ♻️ Stale-While-Revalidate support
+-   🎯 Fully Typed with TypeScript
+-   🧠 Smart & Minimal API
+-   🔌 Works in Node.js & modern environments
+
+------------------------------------------------------------------------
+
+## 📦 Installation
+
+``` bash
+npm install sushi-fetch
+```
+
+or
+
+``` bash
+yarn add sushi-fetch
+```
+
+------------------------------------------------------------------------
+
+## 🚀 Quick Start
+
+``` ts
+import { sushiFetch } from "sushi-fetch"
+
+const users = await sushiFetch("https://jsonplaceholder.typicode.com/users", {
+  cache: true,
+  ttl: 10000,
+  retries: 2
+})
+
+console.log(users)
+```
+
+------------------------------------------------------------------------
+
+## ⚙️ API
+
+### sushiFetch(url, options?)
+
+Fetch data with powerful built-in features.
+
+#### Parameters
+
+  --------------------------------------------------------------------------
+  Name            Type         Default           Description
+  --------------- ------------ ----------------- ---------------------------
+  url             string       ---               API endpoint
+
+  cache           boolean      true              Enable caching
+
+  ttl             number       5000              Cache lifetime (ms)
+
+  revalidate      boolean      false             Return cached data &
+                                                 revalidate in background
+
+  timeout         number       ---               Request timeout in ms
+
+  retries         number       0                 Retry attempts
+
+  retryDelay      number       500               Delay between retries
+
+  retryStrategy   "fixed"      "exponential"     Retry strategy
+
+  parseJson       boolean      true              Parse response as JSON
+
+  onSuccess       (data) =\>   ---               Success callback
+                  void                           
+
+  onError         (error) =\>  ---               Error callback
+                  void                           
+
+  cacheKey        string       auto              Custom cache key
+  --------------------------------------------------------------------------
+
+------------------------------------------------------------------------
+
+## 🧠 Caching Example
+
+``` ts
+await sushiFetch("/api/data", {
+  cache: true,
+  ttl: 10000
+})
+```
+
+------------------------------------------------------------------------
+
+## ♻️ Stale-While-Revalidate
+
+``` ts
+await sushiFetch("/api/data", {
+  cache: true,
+  revalidate: true
+})
+```
+
+------------------------------------------------------------------------
+
+## 🔁 Retry Example
+
+``` ts
+await sushiFetch("/api/data", {
+  retries: 3,
+  retryStrategy: "exponential",
+  retryDelay: 500
+})
+```
+
+------------------------------------------------------------------------
+
+## ⏱️ Timeout Example
+
+``` ts
+await sushiFetch("/api/data", {
+  timeout: 3000
+})
+```
+
+------------------------------------------------------------------------
+
+## 📦 Cache Utilities
+
+``` ts
+import { sushiCache } from "sushi-fetch"
+
+sushiCache.has(key)
+sushiCache.delete(key)
+sushiCache.clear()
+```
+
+------------------------------------------------------------------------
+
+## 🧩 Advanced Example
+
+``` ts
+const data = await sushiFetch("https://api.example.com/posts", {
+  cache: true,
+  ttl: 60000,
+  retries: 2,
+  timeout: 5000,
+  revalidate: true,
+  onSuccess: (data) => console.log("Success:", data),
+  onError: (err) => console.error("Error:", err)
+})
+```
+
+------------------------------------------------------------------------
+
+## 🛠️ Roadmap
+
+-   AbortController support
+-   Middleware / interceptor system
+-   Polling / auto re-fetch
+-   React hooks (useSushiFetch)
+-   Devtools debugging mode
+-   SSR utilities
+
+------------------------------------------------------------------------
+
+## 🤝 Contributing
+
+Contributions, issues, and feature requests are welcome!
+
+Feel free to open a PR or issue 💛
+
+------------------------------------------------------------------------
+
+## 📄 License
+
+MIT © 2026 --- Sushi-Fetch Project
+
+------------------------------------------------------------------------
+
+## 🌟 Support
+
+If you like this project:
+
+-   ⭐ Star this repo
+-   🍣 Share it with others
+-   🐛 Report bugs & ideas
+
+------------------------------------------------------------------------
+
+# 🔥 Tagline
+
+> sushi-fetch --- fetching data should be simple, fast, and delicious 🍣

package/dist/index.js

@@ -0,0 +1,315 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  SushiCache: () => SushiCache,
+  fetcher: () => fetcher,
+  sushiCache: () => sushiCache,
+  sushiFetch: () => sushiFetch
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/fetcher.ts
+var import_node_fetch = __toESM(require("node-fetch"));
+
+// src/core/cache.ts
+var SushiCache = class {
+  constructor(options = {}) {
+    this.store = /* @__PURE__ */ new Map();
+    this.hits = 0;
+    this.misses = 0;
+    this.maxSize = options.maxSize ?? Infinity;
+    this.defaultTTL = options.defaultTTL ?? 5e3;
+    this.onEvict = options.onEvict;
+  }
+  // ========================
+  // CORE
+  // ========================
+  set(key, data, ttl = this.defaultTTL) {
+    const now = Date.now();
+    const expiry = now + ttl;
+    if (this.store.has(key)) {
+      this.store.delete(key);
+    }
+    this.store.set(key, {
+      data,
+      expiry,
+      lastAccess: now
+    });
+    this.evictIfNeeded();
+  }
+  get(key) {
+    const entry = this.store.get(key);
+    if (!entry) {
+      this.misses++;
+      return null;
+    }
+    if (Date.now() > entry.expiry) {
+      this.store.delete(key);
+      this.misses++;
+      return null;
+    }
+    entry.lastAccess = Date.now();
+    this.store.delete(key);
+    this.store.set(key, entry);
+    this.hits++;
+    return entry.data;
+  }
+  peek(key) {
+    const entry = this.store.get(key);
+    if (!entry) return null;
+    if (Date.now() > entry.expiry) {
+      this.store.delete(key);
+      return null;
+    }
+    return entry.data;
+  }
+  has(key) {
+    return this.get(key) !== null;
+  }
+  delete(key) {
+    const entry = this.store.get(key);
+    if (entry && this.onEvict) {
+      this.onEvict(key, entry.data);
+    }
+    this.store.delete(key);
+  }
+  deleteMany(keys) {
+    for (const key of keys) {
+      this.delete(key);
+    }
+  }
+  clear() {
+    if (this.onEvict) {
+      for (const [key, entry] of this.store.entries()) {
+        this.onEvict(key, entry.data);
+      }
+    }
+    this.store.clear();
+  }
+  // ========================
+  // LRU EVICTION
+  // ========================
+  evictIfNeeded() {
+    if (this.store.size <= this.maxSize) return;
+    const oldestKey = this.store.keys().next().value;
+    if (!oldestKey) return;
+    const entry = this.store.get(oldestKey);
+    if (entry && this.onEvict) {
+      this.onEvict(oldestKey, entry.data);
+    }
+    this.store.delete(oldestKey);
+  }
+  // ========================
+  // UTILITIES
+  // ========================
+  async getOrSet(key, fetcher2, ttl = this.defaultTTL) {
+    const cached = this.get(key);
+    if (cached !== null) return cached;
+    const data = await fetcher2();
+    this.set(key, data, ttl);
+    return data;
+  }
+  pruneExpired() {
+    const now = Date.now();
+    for (const [key, entry] of this.store.entries()) {
+      if (now > entry.expiry) {
+        this.delete(key);
+      }
+    }
+  }
+  size() {
+    return this.store.size;
+  }
+  keys() {
+    return this.store.keys();
+  }
+  values() {
+    return Array.from(this.store.values()).map((v) => v.data);
+  }
+  entries() {
+    return Array.from(this.store.entries()).map(([k, v]) => [k, v.data]);
+  }
+  stats() {
+    return {
+      hits: this.hits,
+      misses: this.misses,
+      size: this.store.size
+    };
+  }
+};
+
+// src/core/fetcher.ts
+var cache = new SushiCache();
+var pendingRequests = /* @__PURE__ */ new Map();
+var revalidateLocks = /* @__PURE__ */ new Set();
+var DEFAULT_TTL = 5e3;
+var globalMiddleware = [];
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function buildAbortController(timeout) {
+  if (!timeout) return null;
+  const controller = new AbortController();
+  const id = setTimeout(() => controller.abort(), timeout);
+  controller.signal.addEventListener("abort", () => clearTimeout(id));
+  return controller;
+}
+function computeBackoff(attempt, base, strategy) {
+  if (strategy === "fixed") return base;
+  return base * Math.pow(2, attempt) + Math.random() * 100;
+}
+async function retryFetch(fn, retries, delay, strategy, retryOn) {
+  let attempt = 0;
+  while (true) {
+    try {
+      return await fn();
+    } catch (err) {
+      const shouldRetry = retryOn ? retryOn(null, err) : true;
+      if (attempt >= retries || !shouldRetry) throw err;
+      await sleep(computeBackoff(attempt, delay, strategy));
+      attempt++;
+    }
+  }
+}
+async function runMiddleware(type, ctx, resOrErr) {
+  const stack = [...globalMiddleware, ...ctx.options.middleware || []];
+  for (const mw of stack) {
+    const fn = mw[type];
+    if (!fn) continue;
+    if (type === "onRequest") await fn(ctx);
+    else await fn(resOrErr, ctx);
+  }
+}
+function buildCacheKey(url, options) {
+  return url + JSON.stringify(options || {});
+}
+async function fetcher(url, options = {}) {
+  const {
+    cache: useCache = true,
+    ttl = DEFAULT_TTL,
+    timeout,
+    revalidate = false,
+    force = false,
+    retries = 0,
+    retryDelay = 500,
+    retryStrategy = "fixed",
+    retryOn,
+    cacheKey,
+    cacheTags = [],
+    parseJson = true,
+    parser,
+    transform,
+    validateStatus = (s) => s >= 200 && s < 300,
+    onSuccess,
+    onError,
+    ...fetchOptions
+  } = options;
+  const key = cacheKey || buildCacheKey(url, fetchOptions);
+  const ctx = { url, options };
+  if (!force && useCache) {
+    const cached = cache.get(key);
+    if (cached !== null) {
+      if (revalidate && !revalidateLocks.has(key)) {
+        revalidateLocks.add(key);
+        fetcher(url, { ...options, revalidate: false }).finally(
+          () => revalidateLocks.delete(key)
+        );
+      }
+      return cached;
+    }
+  }
+  if (pendingRequests.has(key)) {
+    return pendingRequests.get(key);
+  }
+  const requestPromise = retryFetch(
+    async () => {
+      await runMiddleware("onRequest", ctx);
+      const controller = buildAbortController(timeout);
+      const res = await (0, import_node_fetch.default)(url, {
+        ...fetchOptions,
+        signal: controller?.signal
+      });
+      await runMiddleware("onResponse", ctx, res);
+      if (!validateStatus(res.status)) {
+        throw new Error(`HTTP ${res.status}`);
+      }
+      let data;
+      if (parser) data = await parser(res);
+      else if (parseJson) data = await res.json();
+      else data = await res.text();
+      if (transform) {
+        data = transform(data);
+      }
+      if (useCache) {
+        cache.set(key, data, ttl);
+        for (const tag of cacheTags) {
+          cache.set(`__tag__:${tag}:${key}`, true, ttl);
+        }
+      }
+      onSuccess?.(data);
+      return data;
+    },
+    retries,
+    retryDelay,
+    retryStrategy,
+    retryOn
+  ).catch(async (err) => {
+    await runMiddleware("onError", ctx, err);
+    onError?.(err);
+    throw err;
+  }).finally(() => {
+    pendingRequests.delete(key);
+  });
+  pendingRequests.set(key, requestPromise);
+  return requestPromise;
+}
+var sushiCache = {
+  clear: () => cache.clear(),
+  delete: (key) => cache.delete(key),
+  has: (key) => cache.has(key),
+  invalidateTag: (tag) => {
+    const prefix = `__tag__:${tag}:`;
+    for (const k of cache.keys()) {
+      if (k.startsWith(prefix)) {
+        const realKey = k.slice(prefix.length);
+        cache.delete(realKey);
+        cache.delete(k);
+      }
+    }
+  }
+};
+var sushiFetch = fetcher;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SushiCache,
+  fetcher,
+  sushiCache,
+  sushiFetch
+});

package/dist/index.mjs

@@ -0,0 +1,275 @@
+// src/core/fetcher.ts
+import fetch from "node-fetch";
+
+// src/core/cache.ts
+var SushiCache = class {
+  constructor(options = {}) {
+    this.store = /* @__PURE__ */ new Map();
+    this.hits = 0;
+    this.misses = 0;
+    this.maxSize = options.maxSize ?? Infinity;
+    this.defaultTTL = options.defaultTTL ?? 5e3;
+    this.onEvict = options.onEvict;
+  }
+  // ========================
+  // CORE
+  // ========================
+  set(key, data, ttl = this.defaultTTL) {
+    const now = Date.now();
+    const expiry = now + ttl;
+    if (this.store.has(key)) {
+      this.store.delete(key);
+    }
+    this.store.set(key, {
+      data,
+      expiry,
+      lastAccess: now
+    });
+    this.evictIfNeeded();
+  }
+  get(key) {
+    const entry = this.store.get(key);
+    if (!entry) {
+      this.misses++;
+      return null;
+    }
+    if (Date.now() > entry.expiry) {
+      this.store.delete(key);
+      this.misses++;
+      return null;
+    }
+    entry.lastAccess = Date.now();
+    this.store.delete(key);
+    this.store.set(key, entry);
+    this.hits++;
+    return entry.data;
+  }
+  peek(key) {
+    const entry = this.store.get(key);
+    if (!entry) return null;
+    if (Date.now() > entry.expiry) {
+      this.store.delete(key);
+      return null;
+    }
+    return entry.data;
+  }
+  has(key) {
+    return this.get(key) !== null;
+  }
+  delete(key) {
+    const entry = this.store.get(key);
+    if (entry && this.onEvict) {
+      this.onEvict(key, entry.data);
+    }
+    this.store.delete(key);
+  }
+  deleteMany(keys) {
+    for (const key of keys) {
+      this.delete(key);
+    }
+  }
+  clear() {
+    if (this.onEvict) {
+      for (const [key, entry] of this.store.entries()) {
+        this.onEvict(key, entry.data);
+      }
+    }
+    this.store.clear();
+  }
+  // ========================
+  // LRU EVICTION
+  // ========================
+  evictIfNeeded() {
+    if (this.store.size <= this.maxSize) return;
+    const oldestKey = this.store.keys().next().value;
+    if (!oldestKey) return;
+    const entry = this.store.get(oldestKey);
+    if (entry && this.onEvict) {
+      this.onEvict(oldestKey, entry.data);
+    }
+    this.store.delete(oldestKey);
+  }
+  // ========================
+  // UTILITIES
+  // ========================
+  async getOrSet(key, fetcher2, ttl = this.defaultTTL) {
+    const cached = this.get(key);
+    if (cached !== null) return cached;
+    const data = await fetcher2();
+    this.set(key, data, ttl);
+    return data;
+  }
+  pruneExpired() {
+    const now = Date.now();
+    for (const [key, entry] of this.store.entries()) {
+      if (now > entry.expiry) {
+        this.delete(key);
+      }
+    }
+  }
+  size() {
+    return this.store.size;
+  }
+  keys() {
+    return this.store.keys();
+  }
+  values() {
+    return Array.from(this.store.values()).map((v) => v.data);
+  }
+  entries() {
+    return Array.from(this.store.entries()).map(([k, v]) => [k, v.data]);
+  }
+  stats() {
+    return {
+      hits: this.hits,
+      misses: this.misses,
+      size: this.store.size
+    };
+  }
+};
+
+// src/core/fetcher.ts
+var cache = new SushiCache();
+var pendingRequests = /* @__PURE__ */ new Map();
+var revalidateLocks = /* @__PURE__ */ new Set();
+var DEFAULT_TTL = 5e3;
+var globalMiddleware = [];
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function buildAbortController(timeout) {
+  if (!timeout) return null;
+  const controller = new AbortController();
+  const id = setTimeout(() => controller.abort(), timeout);
+  controller.signal.addEventListener("abort", () => clearTimeout(id));
+  return controller;
+}
+function computeBackoff(attempt, base, strategy) {
+  if (strategy === "fixed") return base;
+  return base * Math.pow(2, attempt) + Math.random() * 100;
+}
+async function retryFetch(fn, retries, delay, strategy, retryOn) {
+  let attempt = 0;
+  while (true) {
+    try {
+      return await fn();
+    } catch (err) {
+      const shouldRetry = retryOn ? retryOn(null, err) : true;
+      if (attempt >= retries || !shouldRetry) throw err;
+      await sleep(computeBackoff(attempt, delay, strategy));
+      attempt++;
+    }
+  }
+}
+async function runMiddleware(type, ctx, resOrErr) {
+  const stack = [...globalMiddleware, ...ctx.options.middleware || []];
+  for (const mw of stack) {
+    const fn = mw[type];
+    if (!fn) continue;
+    if (type === "onRequest") await fn(ctx);
+    else await fn(resOrErr, ctx);
+  }
+}
+function buildCacheKey(url, options) {
+  return url + JSON.stringify(options || {});
+}
+async function fetcher(url, options = {}) {
+  const {
+    cache: useCache = true,
+    ttl = DEFAULT_TTL,
+    timeout,
+    revalidate = false,
+    force = false,
+    retries = 0,
+    retryDelay = 500,
+    retryStrategy = "fixed",
+    retryOn,
+    cacheKey,
+    cacheTags = [],
+    parseJson = true,
+    parser,
+    transform,
+    validateStatus = (s) => s >= 200 && s < 300,
+    onSuccess,
+    onError,
+    ...fetchOptions
+  } = options;
+  const key = cacheKey || buildCacheKey(url, fetchOptions);
+  const ctx = { url, options };
+  if (!force && useCache) {
+    const cached = cache.get(key);
+    if (cached !== null) {
+      if (revalidate && !revalidateLocks.has(key)) {
+        revalidateLocks.add(key);
+        fetcher(url, { ...options, revalidate: false }).finally(
+          () => revalidateLocks.delete(key)
+        );
+      }
+      return cached;
+    }
+  }
+  if (pendingRequests.has(key)) {
+    return pendingRequests.get(key);
+  }
+  const requestPromise = retryFetch(
+    async () => {
+      await runMiddleware("onRequest", ctx);
+      const controller = buildAbortController(timeout);
+      const res = await fetch(url, {
+        ...fetchOptions,
+        signal: controller?.signal
+      });
+      await runMiddleware("onResponse", ctx, res);
+      if (!validateStatus(res.status)) {
+        throw new Error(`HTTP ${res.status}`);
+      }
+      let data;
+      if (parser) data = await parser(res);
+      else if (parseJson) data = await res.json();
+      else data = await res.text();
+      if (transform) {
+        data = transform(data);
+      }
+      if (useCache) {
+        cache.set(key, data, ttl);
+        for (const tag of cacheTags) {
+          cache.set(`__tag__:${tag}:${key}`, true, ttl);
+        }
+      }
+      onSuccess?.(data);
+      return data;
+    },
+    retries,
+    retryDelay,
+    retryStrategy,
+    retryOn
+  ).catch(async (err) => {
+    await runMiddleware("onError", ctx, err);
+    onError?.(err);
+    throw err;
+  }).finally(() => {
+    pendingRequests.delete(key);
+  });
+  pendingRequests.set(key, requestPromise);
+  return requestPromise;
+}
+var sushiCache = {
+  clear: () => cache.clear(),
+  delete: (key) => cache.delete(key),
+  has: (key) => cache.has(key),
+  invalidateTag: (tag) => {
+    const prefix = `__tag__:${tag}:`;
+    for (const k of cache.keys()) {
+      if (k.startsWith(prefix)) {
+        const realKey = k.slice(prefix.length);
+        cache.delete(realKey);
+        cache.delete(k);
+      }
+    }
+  }
+};
+var sushiFetch = fetcher;
+export {
+  SushiCache,
+  fetcher,
+  sushiCache,
+  sushiFetch
+};

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "sushi-fetch",
+  "version": "0.1.0",
+  "description": "🍣 A tiny but powerful data-fetching & caching library for modern JavaScript & TypeScript apps",
+  "keywords": [
+    "fetch",
+    "http",
+    "cache",
+    "data-fetching",
+    "typescript",
+    "javascript",
+    "api",
+    "client",
+    "request",
+    "swr",
+    "axios-alternative"
+  ],
+  "homepage": "https://github.com/sushilibdev/sushi-fetch",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sushilibdev/sushi-fetch.git"
+  },
+  "bugs": {
+    "url": "https://github.com/sushilibdev/sushi-fetch/issues"
+  },
+  "author": "sushilibdev",
+  "license": "MIT",
+
+  "type": "commonjs",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+
+  "exports": {
+  ".": {
+    "types": "./dist/index.d.ts",
+    "import": "./dist/index.mjs",
+    "require": "./dist/index.cjs"
+    }
+  },
+
+  "files": [
+    "dist"
+  ],
+
+  "scripts": {
+    "dev": "ts-node examples/vanilla-js/app.ts",
+    "build": "tsup src/index.ts --format esm,cjs",
+    "watch": "tsup src/index.ts --format esm,cjs --dts --watch",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist",
+    "prepare": "npm run build"
+  },
+
+  "dependencies": {
+    "node-fetch": "^2.7.0"
+  },
+
+  "devDependencies": {
+    "@types/node-fetch": "^2.6.13",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3",
+    "tsup": "^8.0.1"
+  }
+}