@cacheable/net 2.0.1 → 2.0.2

package/dist/index.cjs

@@ -1 +1,719 @@
-"use strict";var v=Object.create;var w=Object.defineProperty;var L=Object.getOwnPropertyDescriptor;var q=Object.getOwnPropertyNames;var J=Object.getPrototypeOf,$=Object.prototype.hasOwnProperty;var A=(c,e)=>{for(var t in e)w(c,t,{get:e[t],enumerable:!0})},I=(c,e,t,s)=>{if(e&&typeof e=="object"||typeof e=="function")for(let n of q(e))!$.call(c,n)&&n!==t&&w(c,n,{get:()=>e[n],enumerable:!(s=L(e,n))||s.enumerable});return c};var G=(c,e,t)=>(t=c!=null?v(J(c)):{},I(e||!c||!c.__esModule?w(t,"default",{value:c,enumerable:!0}):t,c)),K=c=>I(w({},"__esModule",{value:!0}),c);var z={};A(z,{CacheableNet:()=>b,Net:()=>W,del:()=>E,fetch:()=>y,get:()=>k,head:()=>B,patch:()=>S,post:()=>H});module.exports=K(z);var R=require("cacheable"),U=require("hookified");var F=G(require("http-cache-semantics"),1),m=require("undici");async function y(c,e){let t={...e,cache:"no-cache"};if(!e.cache){let p=await(0,m.fetch)(c,t);if(!p.ok)throw new Error(`Fetch failed with status ${p.status}`);return p}if(e.method==="POST"||e.method==="PATCH"||e.method==="DELETE"||e.method==="HEAD"){let p=await(0,m.fetch)(c,t);if(!p.ok)throw new Error(`Fetch failed with status ${p.status}`);return p}let s=e.httpCachePolicy!==!1,n=e.method||"GET",a=`${n}:${c}`;if(!s){let p=await e.cache.getOrSet(a,async()=>{let T=await(0,m.fetch)(c,t);if(!T.ok)throw new Error(`Fetch failed with status ${T.status}`);return{body:await T.text(),status:T.status,statusText:T.statusText,headers:Object.fromEntries(T.headers.entries())}});if(!p)throw new Error("Failed to get or set cache data");return new Response(p.body,{status:p.status,statusText:p.statusText,headers:p.headers})}let o=`${a}:policy`,[i,r]=await Promise.all([e.cache.get(a),e.cache.get(o)]),h,u,f,l,P;r&&i&&(h=F.default.fromObject(r),u=i.body,f=i.status,l=i.statusText,P=i.headers);let N=t.headers||{},g={url:c,method:n,headers:N};if(h?.satisfiesWithoutRevalidation(g)){let p=h.responseHeaders();return new Response(u,{status:f,statusText:l,headers:p})}let C={};h?.revalidationHeaders(g)&&(C=h.revalidationHeaders(g));let d=await(0,m.fetch)(c,{...t,headers:{...t.headers,...C}});if(d.status===304&&h){let{policy:p,modified:T}=h.revalidatedPolicy(g,{status:d.status,headers:Object.fromEntries(d.headers.entries())});if(!T){let x=p.timeToLive();await e.cache.set(o,p.toObject(),x),await e.cache.set(a,{body:u,status:f,statusText:l,headers:P},x);let j=p.responseHeaders();return new Response(u,{status:f,statusText:l,headers:j})}}if(!d.ok&&d.status!==304)throw new Error(`Fetch failed with status ${d.status}`);let _=await d.text(),D={status:d.status,statusText:d.statusText,headers:Object.fromEntries(d.headers.entries())},O=new F.default(g,D);if(O.storable()){let p=O.timeToLive();await Promise.all([e.cache.set(a,{body:_,status:d.status,statusText:d.statusText,headers:D.headers},p),e.cache.set(o,O.toObject(),p)])}return new Response(_,{status:d.status,statusText:d.statusText,headers:d.headers})}async function k(c,e){let t=await y(c,{...e,method:"GET"}),s=await t.text(),n;try{n=JSON.parse(s)}catch{n=s}let a=new Response(s,{status:t.status,statusText:t.statusText,headers:t.headers});return{data:n,response:a}}async function H(c,e,t){let s,n={...t.headers};typeof e=="string"||e instanceof FormData||e instanceof URLSearchParams||e instanceof Blob?s=e:(s=JSON.stringify(e),!n["Content-Type"]&&!n["content-type"]&&(n["Content-Type"]="application/json"));let a=await y(c,{...t,headers:n,body:s,method:"POST"}),o=await a.text(),i;try{i=JSON.parse(o)}catch{i=o}let r=new Response(o,{status:a.status,statusText:a.statusText,headers:a.headers});return{data:i,response:r}}async function S(c,e,t){let s,n={...t.headers};typeof e=="string"||e instanceof FormData||e instanceof URLSearchParams||e instanceof Blob?s=e:(s=JSON.stringify(e),!n["Content-Type"]&&!n["content-type"]&&(n["Content-Type"]="application/json"));let a=await y(c,{...t,headers:n,body:s,method:"PATCH"}),o=await a.text(),i;try{i=JSON.parse(o)}catch{i=o}let r=new Response(o,{status:a.status,statusText:a.statusText,headers:a.headers});return{data:i,response:r}}async function E(c,e,t){let s,n;if(e!==void 0&&typeof e=="object"&&e!==null&&"cache"in e)s=void 0,n=e;else if(t)s=e,n=t;else throw new Error("Fetch options must include a cache instance or options.");let a,o={...n.headers};s!==void 0&&(typeof s=="string"||s instanceof FormData||s instanceof URLSearchParams||s instanceof Blob?a=s:(a=JSON.stringify(s),!o["Content-Type"]&&!o["content-type"]&&(o["Content-Type"]="application/json")));let i=await y(c,{...n,headers:o,body:a,method:"DELETE"}),r=await i.text(),h;try{h=JSON.parse(r)}catch{h=r}let u=new Response(r,{status:i.status,statusText:i.statusText,headers:i.headers});return{data:h,response:u}}async function B(c,e){return await y(c,{...e,method:"HEAD"})}var b=class extends U.Hookified{_cache=new R.Cacheable;_httpCachePolicy=!0;_stringify=JSON.stringify;_parse=JSON.parse;constructor(e){super(e),e?.cache&&(this._cache=e.cache instanceof R.Cacheable?e.cache:new R.Cacheable(e.cache)),e?.httpCachePolicy!==void 0&&(this._httpCachePolicy=e.httpCachePolicy),e?.stringify&&(this._stringify=e?.stringify),e?.parse&&(this._parse=e?.parse)}get stringify(){return this._stringify}set stringify(e){this._stringify=e}get parse(){return this._parse}set parse(e){this._parse=e}get cache(){return this._cache}set cache(e){this._cache=e}get httpCachePolicy(){return this._httpCachePolicy}set httpCachePolicy(e){this._httpCachePolicy=e}async fetch(e,t){let s={...t,cache:this._cache,httpCachePolicy:this._httpCachePolicy};return y(e,s)}async get(e,t){let s={...t,cache:this._cache,httpCachePolicy:this._httpCachePolicy,method:"GET"};t?.caching!==void 0&&delete s.cache;let n=await y(e,s),a=await n.text(),o,i=t?.parse||this._parse;try{o=i(a)}catch{o=a}let r=new Response(a,{status:n.status,statusText:n.statusText,headers:n.headers});return{data:o,response:r}}async post(e,t,s){let n,a={...s?.headers};typeof t=="string"||t instanceof FormData||t instanceof URLSearchParams||t instanceof Blob?n=t:(n=(s?.stringify||this._stringify)(t),!a["Content-Type"]&&!a["content-type"]&&(a["Content-Type"]="application/json"));let o={...s,headers:a,body:n,httpCachePolicy:this._httpCachePolicy,method:"POST"};s?.caching===!0&&(o.cache=this._cache);let i=await y(e,o),r=await i.text(),h,u=s?.parse||this._parse;try{h=u(r)}catch{h=r}let f=new Response(r,{status:i.status,statusText:i.statusText,headers:i.headers});return{data:h,response:f}}async head(e,t){let s={...t,cache:this._cache,httpCachePolicy:this._httpCachePolicy,method:"HEAD"};return t?.caching!==void 0&&!t.caching&&delete s.cache,await y(e,s)}async put(e,t,s){let n,a={...s?.headers};typeof t=="string"||t instanceof FormData||t instanceof URLSearchParams||t instanceof Blob?n=t:(n=(s?.stringify||this._stringify)(t),!a["Content-Type"]&&!a["content-type"]&&(a["Content-Type"]="application/json"));let o={...s,headers:a,body:n,httpCachePolicy:this._httpCachePolicy,method:"PUT"};s?.caching===!0&&(o.cache=this._cache);let i=await y(e,o),r=await i.text(),h,u=s?.parse||this._parse;try{h=u(r)}catch{h=r}let f=new Response(r,{status:i.status,statusText:i.statusText,headers:i.headers});return{data:h,response:f}}async patch(e,t,s){let n,a={...s?.headers};typeof t=="string"||t instanceof FormData||t instanceof URLSearchParams||t instanceof Blob?n=t:(n=(s?.stringify||this._stringify)(t),!a["Content-Type"]&&!a["content-type"]&&(a["Content-Type"]="application/json"));let o={...s,headers:a,body:n,httpCachePolicy:this._httpCachePolicy,method:"PATCH"};s?.caching===!0&&(o.cache=this._cache);let i=await y(e,o),r=await i.text(),h,u=s?.parse||this._parse;try{h=u(r)}catch{h=r}let f=new Response(r,{status:i.status,statusText:i.statusText,headers:i.headers});return{data:h,response:f}}async delete(e,t,s){let n,a={...s?.headers};t!==void 0&&(typeof t=="string"||t instanceof FormData||t instanceof URLSearchParams||t instanceof Blob?n=t:(n=(s?.stringify||this._stringify)(t),!a["Content-Type"]&&!a["content-type"]&&(a["Content-Type"]="application/json")));let o={...s,headers:a,body:n,httpCachePolicy:this._httpCachePolicy,method:"DELETE"};s?.caching===!0&&(o.cache=this._cache);let i=await y(e,o),r=await i.text(),h,u=s?.parse||this._parse;try{h=u(r)}catch{h=r}let f=new Response(r,{status:i.status,statusText:i.statusText,headers:i.headers});return{data:h,response:f}}},W=b;0&&(module.exports={CacheableNet,Net,del,fetch,get,head,patch,post});
+"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, {
+  CacheableNet: () => CacheableNet,
+  Net: () => Net,
+  del: () => del,
+  fetch: () => fetch,
+  get: () => get,
+  head: () => head,
+  patch: () => patch,
+  post: () => post
+});
+module.exports = __toCommonJS(index_exports);
+var import_cacheable = require("cacheable");
+var import_hookified = require("hookified");
+
+// src/fetch.ts
+var import_http_cache_semantics = __toESM(require("http-cache-semantics"), 1);
+var import_undici = require("undici");
+async function fetch(url, options) {
+  const fetchOptions = {
+    ...options,
+    cache: "no-cache"
+  };
+  if (!options.cache) {
+    const response2 = await (0, import_undici.fetch)(url, fetchOptions);
+    if (!response2.ok) {
+      throw new Error(`Fetch failed with status ${response2.status}`);
+    }
+    return response2;
+  }
+  if (options.method === "POST" || options.method === "PATCH" || options.method === "DELETE" || options.method === "HEAD") {
+    const response2 = await (0, import_undici.fetch)(url, fetchOptions);
+    if (!response2.ok) {
+      throw new Error(`Fetch failed with status ${response2.status}`);
+    }
+    return response2;
+  }
+  const httpCachePolicy = options.httpCachePolicy !== false;
+  const method = options.method || "GET";
+  const cacheKey = `${method}:${url}`;
+  if (!httpCachePolicy) {
+    const cachedData = await options.cache.getOrSet(cacheKey, async () => {
+      const response2 = await (0, import_undici.fetch)(url, fetchOptions);
+      if (!response2.ok) {
+        throw new Error(`Fetch failed with status ${response2.status}`);
+      }
+      const body2 = await response2.text();
+      return {
+        body: body2,
+        status: response2.status,
+        statusText: response2.statusText,
+        headers: Object.fromEntries(response2.headers.entries())
+      };
+    });
+    if (!cachedData) {
+      throw new Error("Failed to get or set cache data");
+    }
+    return new Response(cachedData.body, {
+      status: cachedData.status,
+      statusText: cachedData.statusText,
+      headers: cachedData.headers
+    });
+  }
+  const policyKey = `${cacheKey}:policy`;
+  const [cachedResponse, cachedPolicyData] = await Promise.all([
+    options.cache.get(cacheKey),
+    options.cache.get(policyKey)
+  ]);
+  let policy;
+  let cachedBody;
+  let cachedStatus;
+  let cachedStatusText;
+  let cachedHeaders;
+  if (cachedPolicyData && cachedResponse) {
+    policy = import_http_cache_semantics.default.fromObject(
+      cachedPolicyData
+    );
+    cachedBody = cachedResponse.body;
+    cachedStatus = cachedResponse.status;
+    cachedStatusText = cachedResponse.statusText;
+    cachedHeaders = cachedResponse.headers;
+  }
+  const requestHeaders = fetchOptions.headers || {};
+  const request = {
+    url,
+    method,
+    headers: requestHeaders
+  };
+  if (policy?.satisfiesWithoutRevalidation(request)) {
+    const headers = policy.responseHeaders();
+    return new Response(cachedBody, {
+      status: cachedStatus,
+      statusText: cachedStatusText,
+      headers
+    });
+  }
+  let revalidationHeaders = {};
+  if (policy?.revalidationHeaders(request)) {
+    revalidationHeaders = policy.revalidationHeaders(request);
+  }
+  const response = await (0, import_undici.fetch)(url, {
+    ...fetchOptions,
+    headers: {
+      ...fetchOptions.headers,
+      ...revalidationHeaders
+    }
+  });
+  if (response.status === 304 && policy) {
+    const { policy: updatedPolicy, modified } = policy.revalidatedPolicy(
+      request,
+      {
+        status: response.status,
+        headers: Object.fromEntries(response.headers.entries())
+      }
+    );
+    if (!modified) {
+      const ttl = updatedPolicy.timeToLive();
+      await options.cache.set(policyKey, updatedPolicy.toObject(), ttl);
+      await options.cache.set(
+        cacheKey,
+        {
+          body: cachedBody,
+          status: cachedStatus,
+          statusText: cachedStatusText,
+          headers: cachedHeaders
+        },
+        ttl
+      );
+      const headers = updatedPolicy.responseHeaders();
+      return new Response(cachedBody, {
+        status: cachedStatus,
+        statusText: cachedStatusText,
+        headers
+      });
+    }
+  }
+  if (!response.ok && response.status !== 304) {
+    throw new Error(`Fetch failed with status ${response.status}`);
+  }
+  const body = await response.text();
+  const responseForPolicy = {
+    status: response.status,
+    statusText: response.statusText,
+    headers: Object.fromEntries(response.headers.entries())
+  };
+  const newPolicy = new import_http_cache_semantics.default(request, responseForPolicy);
+  if (newPolicy.storable()) {
+    const ttl = newPolicy.timeToLive();
+    await Promise.all([
+      options.cache.set(
+        cacheKey,
+        {
+          body,
+          status: response.status,
+          statusText: response.statusText,
+          headers: responseForPolicy.headers
+        },
+        ttl
+      ),
+      options.cache.set(policyKey, newPolicy.toObject(), ttl)
+    ]);
+  }
+  return new Response(body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+}
+async function get(url, options) {
+  const response = await fetch(url, { ...options, method: "GET" });
+  const text = await response.text();
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch {
+    data = text;
+  }
+  const newResponse = new Response(text, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+  return {
+    data,
+    response: newResponse
+  };
+}
+async function post(url, data, options) {
+  let body;
+  const headers = { ...options.headers };
+  if (typeof data === "string") {
+    body = data;
+  } else if (data instanceof FormData || data instanceof URLSearchParams || data instanceof Blob) {
+    body = data;
+  } else {
+    body = JSON.stringify(data);
+    if (!headers["Content-Type"] && !headers["content-type"]) {
+      headers["Content-Type"] = "application/json";
+    }
+  }
+  const response = await fetch(url, {
+    ...options,
+    headers,
+    body,
+    method: "POST"
+  });
+  const text = await response.text();
+  let responseData;
+  try {
+    responseData = JSON.parse(text);
+  } catch {
+    responseData = text;
+  }
+  const newResponse = new Response(text, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+  return {
+    data: responseData,
+    response: newResponse
+  };
+}
+async function patch(url, data, options) {
+  let body;
+  const headers = { ...options.headers };
+  if (typeof data === "string") {
+    body = data;
+  } else if (data instanceof FormData || data instanceof URLSearchParams || data instanceof Blob) {
+    body = data;
+  } else {
+    body = JSON.stringify(data);
+    if (!headers["Content-Type"] && !headers["content-type"]) {
+      headers["Content-Type"] = "application/json";
+    }
+  }
+  const response = await fetch(url, {
+    ...options,
+    headers,
+    body,
+    method: "PATCH"
+  });
+  const text = await response.text();
+  let responseData;
+  try {
+    responseData = JSON.parse(text);
+  } catch {
+    responseData = text;
+  }
+  const newResponse = new Response(text, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+  return {
+    data: responseData,
+    response: newResponse
+  };
+}
+async function del(url, data, options) {
+  let actualData;
+  let actualOptions;
+  if (data !== void 0 && typeof data === "object" && data !== null && "cache" in data) {
+    actualData = void 0;
+    actualOptions = data;
+  } else if (options) {
+    actualData = data;
+    actualOptions = options;
+  } else {
+    throw new Error("Fetch options must include a cache instance or options.");
+  }
+  let body;
+  const headers = { ...actualOptions.headers };
+  if (actualData !== void 0) {
+    if (typeof actualData === "string") {
+      body = actualData;
+    } else if (actualData instanceof FormData || actualData instanceof URLSearchParams || actualData instanceof Blob) {
+      body = actualData;
+    } else {
+      body = JSON.stringify(actualData);
+      if (!headers["Content-Type"] && !headers["content-type"]) {
+        headers["Content-Type"] = "application/json";
+      }
+    }
+  }
+  const response = await fetch(url, {
+    ...actualOptions,
+    headers,
+    body,
+    method: "DELETE"
+  });
+  const text = await response.text();
+  let responseData;
+  try {
+    responseData = JSON.parse(text);
+  } catch {
+    responseData = text;
+  }
+  const newResponse = new Response(text, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+  return {
+    data: responseData,
+    response: newResponse
+  };
+}
+async function head(url, options) {
+  const response = await fetch(url, { ...options, method: "HEAD" });
+  return response;
+}
+
+// src/index.ts
+var CacheableNet = class extends import_hookified.Hookified {
+  _cache = new import_cacheable.Cacheable();
+  _httpCachePolicy = true;
+  _stringify = JSON.stringify;
+  _parse = JSON.parse;
+  constructor(options) {
+    super(options);
+    if (options?.cache) {
+      this._cache = options.cache instanceof import_cacheable.Cacheable ? options.cache : new import_cacheable.Cacheable(options.cache);
+    }
+    if (options?.httpCachePolicy !== void 0) {
+      this._httpCachePolicy = options.httpCachePolicy;
+    }
+    if (options?.stringify) {
+      this._stringify = options?.stringify;
+    }
+    if (options?.parse) {
+      this._parse = options?.parse;
+    }
+  }
+  /**
+   * Get the stringify function used for converting objects to strings.
+   * @returns {StringifyType} The current stringify function
+   */
+  get stringify() {
+    return this._stringify;
+  }
+  /**
+   * Set the stringify function for converting objects to strings.
+   * @param {StringifyType} value - The stringify function to use
+   */
+  set stringify(value) {
+    this._stringify = value;
+  }
+  /**
+   * Get the parse function used for converting strings to objects.
+   * @returns {ParseType} The current parse function
+   */
+  get parse() {
+    return this._parse;
+  }
+  /**
+   * Set the parse function for converting strings to objects.
+   * @param {ParseType} value - The parse function to use
+   */
+  set parse(value) {
+    this._parse = value;
+  }
+  /**
+   * Get the Cacheable instance used for caching fetch operations.
+   * @returns {Cacheable} The current Cacheable instance
+   */
+  get cache() {
+    return this._cache;
+  }
+  /**
+   * Set the Cacheable instance for caching fetch operations.
+   * @param {Cacheable} value - The Cacheable instance to use for caching
+   */
+  set cache(value) {
+    this._cache = value;
+  }
+  /**
+   * Get the current HTTP cache policy setting.
+   * @returns {boolean} Whether HTTP cache semantics are enabled
+   */
+  get httpCachePolicy() {
+    return this._httpCachePolicy;
+  }
+  /**
+   * Set whether to use HTTP cache semantics.
+   * @param {boolean} value - Enable or disable HTTP cache semantics
+   */
+  set httpCachePolicy(value) {
+    this._httpCachePolicy = value;
+  }
+  /**
+   * Fetch data from a URL with optional request options. Will use the cache that is already set in the instance.
+   *
+   * When `httpCachePolicy` is enabled (default), cache entries will have their TTL
+   * set based on HTTP cache headers (e.g., Cache-Control: max-age). When disabled,
+   * the default TTL from the Cacheable instance is used.
+   *
+   * @param {string} url The URL to fetch.
+   * @param {Omit<FetchOptions, "cache">} options Optional request options.
+   * @returns {Promise<FetchResponse>} The response from the fetch.
+   */
+  async fetch(url, options) {
+    const fetchOptions = {
+      ...options,
+      cache: this._cache,
+      httpCachePolicy: this._httpCachePolicy
+    };
+    return fetch(url, fetchOptions);
+  }
+  /**
+   * Perform a GET request to a URL with optional request options. By default caching is enabled on all requests. To
+   * disable set `options.caching` to false.
+   * @param {string} url The URL to fetch.
+   * @param {NetFetchOptions} options Optional request options (method will be set to GET).
+   * @returns {Promise<DataResponse<T>>} The typed data and response from the fetch.
+   */
+  async get(url, options) {
+    const fetchOptions = {
+      ...options,
+      cache: this._cache,
+      httpCachePolicy: this._httpCachePolicy,
+      method: "GET"
+    };
+    if (options?.caching !== void 0) {
+      delete fetchOptions.cache;
+    }
+    const response = await fetch(url, fetchOptions);
+    const text = await response.text();
+    let data;
+    const parseFn = options?.parse || this._parse;
+    try {
+      data = parseFn(text);
+    } catch {
+      data = text;
+    }
+    const newResponse = new Response(text, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+    return {
+      data,
+      response: newResponse
+    };
+  }
+  /**
+   * Perform a POST request to a URL with data and optional request options. By default caching is not enabled. To enable it
+   * set `options.caching` to true. Note, setting caching to tru means it will not post if the data is the same.
+   * @param {string} url The URL to fetch.
+   * @param {unknown} data The data to send in the request body.
+   * @param {Omit<NetFetchOptions, "method" | "body" >} options Optional request options (method and body will be set).
+   * @returns {Promise<DataResponse<T>>} The typed data and response from the fetch.
+   */
+  async post(url, data, options) {
+    let body;
+    const headers = { ...options?.headers };
+    if (typeof data === "string") {
+      body = data;
+    } else if (data instanceof FormData || data instanceof URLSearchParams || data instanceof Blob) {
+      body = data;
+    } else {
+      const stringifyFn = options?.stringify || this._stringify;
+      body = stringifyFn(data);
+      this.setContentType(headers);
+    }
+    const fetchOptions = {
+      ...options,
+      headers,
+      body,
+      httpCachePolicy: this._httpCachePolicy,
+      method: "POST"
+    };
+    if (options?.caching === true) {
+      fetchOptions.cache = this._cache;
+    }
+    const response = await fetch(url, fetchOptions);
+    const text = await response.text();
+    let responseData;
+    const parseFn = options?.parse || this._parse;
+    try {
+      responseData = parseFn(text);
+    } catch {
+      responseData = text;
+    }
+    const newResponse = new Response(text, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+    return {
+      data: responseData,
+      response: newResponse
+    };
+  }
+  /**
+   * Perform a HEAD request to a URL with optional request options. By default caching is enabled on all requests. To
+   * disable set `options.caching` to false.
+   * @param {string} url The URL to fetch.
+   * @param {NetFetchOptions} options Optional request options (method will be set to HEAD).
+   * @returns {Promise<FetchResponse>} The response from the fetch (no body).
+   */
+  async head(url, options) {
+    const fetchOptions = {
+      ...options,
+      cache: this._cache,
+      httpCachePolicy: this._httpCachePolicy,
+      method: "HEAD"
+    };
+    if (options?.caching !== void 0 && !options.caching) {
+      delete fetchOptions.cache;
+    }
+    const response = await fetch(url, fetchOptions);
+    return response;
+  }
+  /**
+   * Perform a PUT request to a URL with data and optional request options. By default caching is not enabled. To enable it
+   * set `options.caching` to true. Note, setting caching to true means it will not put if the data is the same.
+   * @param {string} url The URL to fetch.
+   * @param {unknown} data The data to send in the request body.
+   * @param {Omit<NetFetchOptions, 'method' | 'body'>} options Optional request options (method and body will be set).
+   * @returns {Promise<DataResponse<T>>} The typed data and response from the fetch.
+   */
+  async put(url, data, options) {
+    let body;
+    const headers = { ...options?.headers };
+    if (typeof data === "string") {
+      body = data;
+    } else if (data instanceof FormData || data instanceof URLSearchParams || data instanceof Blob) {
+      body = data;
+    } else {
+      const stringifyFn = options?.stringify || this._stringify;
+      body = stringifyFn(data);
+      this.setContentType(headers);
+    }
+    const fetchOptions = {
+      ...options,
+      headers,
+      body,
+      httpCachePolicy: this._httpCachePolicy,
+      method: "PUT"
+    };
+    if (options?.caching === true) {
+      fetchOptions.cache = this._cache;
+    }
+    const response = await fetch(url, fetchOptions);
+    const text = await response.text();
+    let responseData;
+    const parseFn = options?.parse || this._parse;
+    try {
+      responseData = parseFn(text);
+    } catch {
+      responseData = text;
+    }
+    const newResponse = new Response(text, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+    return {
+      data: responseData,
+      response: newResponse
+    };
+  }
+  /**
+   * Perform a PATCH request to a URL with data and optional request options. By default caching is not enabled. To enable it
+   * set `options.caching` to true. Note, setting caching to true means it will not patch if the data is the same.
+   * @param {string} url The URL to fetch.
+   * @param {unknown} data The data to send in the request body.
+   * @param {Omit<NetFetchOptions, 'method' | 'body'>} options Optional request options (method and body will be set).
+   * @returns {Promise<DataResponse<T>>} The typed data and response from the fetch.
+   */
+  async patch(url, data, options) {
+    let body;
+    const headers = { ...options?.headers };
+    if (typeof data === "string") {
+      body = data;
+    } else if (data instanceof FormData || data instanceof URLSearchParams || data instanceof Blob) {
+      body = data;
+    } else {
+      const stringifyFn = options?.stringify || this._stringify;
+      body = stringifyFn(data);
+      this.setContentType(headers);
+    }
+    const fetchOptions = {
+      ...options,
+      headers,
+      body,
+      httpCachePolicy: this._httpCachePolicy,
+      method: "PATCH"
+    };
+    if (options?.caching === true) {
+      fetchOptions.cache = this._cache;
+    }
+    const response = await fetch(url, fetchOptions);
+    const text = await response.text();
+    let responseData;
+    const parseFn = options?.parse || this._parse;
+    try {
+      responseData = parseFn(text);
+    } catch {
+      responseData = text;
+    }
+    const newResponse = new Response(text, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+    return {
+      data: responseData,
+      response: newResponse
+    };
+  }
+  /**
+   * Perform a DELETE request to a URL with optional data and request options. By default caching is not enabled. To enable it
+   * set `options.caching` to true. Note, setting caching to true means it will not delete if the data is the same.
+   * @param {string} url The URL to fetch.
+   * @param {unknown} data Optional data to send in the request body.
+   * @param {Omit<NetFetchOptions, 'method' | 'body'>} options Optional request options (method and body will be set).
+   * @returns {Promise<DataResponse<T>>} The typed data and response from the fetch.
+   */
+  async delete(url, data, options) {
+    let body;
+    const headers = { ...options?.headers };
+    if (data !== void 0) {
+      if (typeof data === "string") {
+        body = data;
+      } else if (data instanceof FormData || data instanceof URLSearchParams || data instanceof Blob) {
+        body = data;
+      } else {
+        const stringifyFn = options?.stringify || this._stringify;
+        body = stringifyFn(data);
+        this.setContentType(headers);
+      }
+    }
+    const fetchOptions = {
+      ...options,
+      headers,
+      body,
+      httpCachePolicy: this._httpCachePolicy,
+      method: "DELETE"
+    };
+    if (options?.caching === true) {
+      fetchOptions.cache = this._cache;
+    }
+    const response = await fetch(url, fetchOptions);
+    const text = await response.text();
+    let responseData;
+    const parseFn = options?.parse || this._parse;
+    try {
+      responseData = parseFn(text);
+    } catch {
+      responseData = text;
+    }
+    const newResponse = new Response(text, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+    return {
+      data: responseData,
+      response: newResponse
+    };
+  }
+  /**
+   * Sets the Content-Type header if not already set.
+   * Checks both "Content-Type" and "content-type" to handle case variations.
+   * @param headers - The headers object to modify
+   * @param contentType - The content type to set (defaults to "application/json")
+   * @private
+   */
+  setContentType(headers, contentType = "application/json") {
+    if (!headers["Content-Type"] && !headers["content-type"]) {
+      headers["Content-Type"] = contentType;
+    }
+  }
+};
+var Net = CacheableNet;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CacheableNet,
+  Net,
+  del,
+  fetch,
+  get,
+  head,
+  patch,
+  post
+});
+/* v8 ignore next -- @preserve */