@stacksjs/api 0.59.11 → 0.61.0

package/dist/index.js

@@ -160,7 +160,8 @@ var withoutTrailingSlash = function(input = "", respectQueryAndFragment) {
     fragment = input.slice(fragmentIndex);
   }
   const [s0, ...s] = path.split("?");
-  return (s0.slice(0, -1) || "/") + (s.length > 0 ? `?${s.join("?")}` : "") + fragment;
+  const cleanPath = s0.endsWith("/") ? s0.slice(0, -1) : s0;
+  return (cleanPath || "/") + (s.length > 0 ? `?${s.join("?")}` : "") + fragment;
 };
 var withTrailingSlash = function(input = "", respectQueryAndFragment) {
   if (!respectQueryAndFragment) {
@@ -280,7 +281,7 @@ var TRAILING_SLASH_RE = /\/$|\/\?|\/#/;
 var JOIN_LEADING_SLASH_RE = /^\.?\//;
 var protocolRelative = Symbol.for("ufo:protocolRelative");
 
-// ../../../../node_modules/ofetch/dist/shared/ofetch.00501375.mjs
+// ../../../../node_modules/ofetch/dist/shared/ofetch.37386b05.mjs
 var createFetchError = function(ctx) {
   const errorMessage = ctx.error?.message || ctx.error?.toString() || "";
   const method = ctx.request?.method || ctx.options?.method || "GET";
@@ -394,8 +395,7 @@ var createFetch = function(globalOptions = {}) {
         }
         return $fetchRaw(context.request, {
           ...context.options,
-          retry: retries - 1,
-          timeout: context.options.timeout
+          retry: retries - 1
         });
       }
     }
@@ -443,9 +443,10 @@ var createFetch = function(globalOptions = {}) {
         }
       }
     }
+    let abortTimeout;
     if (!context.options.signal && context.options.timeout) {
       const controller = new AbortController;
-      setTimeout(() => controller.abort(), context.options.timeout);
+      abortTimeout = setTimeout(() => controller.abort(), context.options.timeout);
       context.options.signal = controller.signal;
     }
     try {
@@ -456,6 +457,10 @@ var createFetch = function(globalOptions = {}) {
         await context.options.onRequestError(context);
       }
       return await onError(context);
+    } finally {
+      if (abortTimeout) {
+        clearTimeout(abortTimeout);
+      }
     }
     const hasBody = context.response.body && !nullBodyResponses.has(context.response.status) && context.options.method !== "HEAD";
     if (hasBody) {
@@ -554,86 +559,91 @@ var AbortController = _globalThis.AbortController;
 var ofetch = createFetch({ fetch, Headers, AbortController });
 
 // src/index.ts
-async function useHttpFetch(endpoint = "") {
-  let baseURL = "/";
-  if (endpoint)
-    baseURL = endpoint;
-  async function post(url, params) {
-    const headers = { Accept: "application/json" };
-    if (token.value)
-      headers.Authorization = `Bearer ${token.value}`;
-    const parameters = {
-      ...params,
-      ...{
-        headers,
-        parseResponse: JSON.parse,
-        method: "POST",
-        baseURL
-      }
-    };
-    loading.value = true;
-    try {
-      const result = await ofetch(url, parameters);
-      loading.value = false;
-      return result;
-    } catch (err) {
-      loading.value = false;
-      throw err;
-    }
-  }
-  async function get(url, params) {
-    const headers = { Accept: "application/json" };
-    if (token.value)
-      headers.Authorization = `Bearer ${token.value}`;
-    const parameters = {
-      ...params,
-      ...{
-        headers,
-        parseResponse: JSON.parse,
-        method: "GET",
-        baseURL
-      }
-    };
-    return await ofetch(url, parameters);
-  }
-  async function patch(url, params) {
-    const headers = { Accept: "application/json" };
-    if (token.value)
-      headers.Authorization = `Bearer ${token.value}`;
-    const parameters = {
-      ...params,
-      ...{
-        headers,
-        parseResponse: JSON.parse,
-        method: "PATCH",
-        baseURL
-      }
-    };
-    loading.value = true;
-    return await ofetch(url, parameters);
-  }
-  async function destroy(url, params) {
-    const headers = { Accept: "application/json" };
-    if (token.value)
-      headers.Authorization = `Bearer ${token.value}`;
-    const parameters = {
-      ...params,
-      ...{
-        headers,
-        method: "DELETE",
-        baseURL
-      }
-    };
-    loading.value = true;
-    return await ofetch(url, parameters);
-  }
-  function setToken(authToken) {
-    token.value = authToken;
+async function post(url, params) {
+  const headers = { Accept: "application/json" };
+  if (token.value)
+    headers.Authorization = `Bearer ${token.value}`;
+  const parameters = {
+    ...params,
+    ...{
+      headers,
+      parseResponse: JSON.parse,
+      method: "POST",
+      baseURL
+    }
+  };
+  loading.value = true;
+  try {
+    const result = await ofetch(url, parameters);
+    loading.value = false;
+    return result;
+  } catch (err) {
+    loading.value = false;
+    throw err;
   }
-  return { post, get, patch, destroy, baseURL, loading, token, setToken };
 }
+async function get(url, params) {
+  const headers = { Accept: "application/json" };
+  if (token.value)
+    headers.Authorization = `Bearer ${token.value}`;
+  const parameters = {
+    ...params,
+    ...{
+      headers,
+      parseResponse: JSON.parse,
+      method: "GET",
+      baseURL
+    }
+  };
+  return await ofetch(url, parameters);
+}
+async function patch(url, params) {
+  const headers = { Accept: "application/json" };
+  if (token.value)
+    headers.Authorization = `Bearer ${token.value}`;
+  const parameters = {
+    ...params,
+    ...{
+      headers,
+      parseResponse: JSON.parse,
+      method: "PATCH",
+      baseURL
+    }
+  };
+  loading.value = true;
+  return await ofetch(url, parameters);
+}
+async function destroy(url, params) {
+  const headers = { Accept: "application/json" };
+  if (token.value)
+    headers.Authorization = `Bearer ${token.value}`;
+  const parameters = {
+    ...params,
+    ...{
+      headers,
+      method: "DELETE",
+      baseURL
+    }
+  };
+  loading.value = true;
+  return await ofetch(url, parameters);
+}
+var setToken = function(authToken) {
+  token.value = authToken;
+};
 var loading = ref(false);
 var token = ref("");
+var baseURL = "/";
+var Fetch = {
+  post,
+  get,
+  patch,
+  destroy,
+  baseURL,
+  loading,
+  token,
+  setToken
+};
 export {
-  useHttpFetch
+  Fetch
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/api",
   "type": "module",
-  "version": "0.59.11",
+  "version": "0.61.0",
   "description": "The Stacks array utilities.",
   "author": "Chris Breuer",
   "license": "MIT",
@@ -53,7 +53,7 @@
   },
   "dependencies": {
     "@stacksjs/utils": "latest",
-    "ofetch": "^1.3.3"
+    "ofetch": "^1.3.4"
   },
   "devDependencies": {
     "@stacksjs/development": "latest"

package/src/index.ts

@@ -1,115 +1,149 @@
 import { ofetch } from 'ofetch'
-import type { FetchOptions } from 'ofetch'
 
 interface Params {
   [key: string]: any // Replace 'any' with more specific types if possible
 }
 
+interface FetchRequestHeaders {
+  'Content-Type'?: string
+  Authorization?: string
+  Accept?: string
+  'User-Agent'?: string
+  Referer?: string
+  Origin?: string
+  'Cache-Control'?: string
+  Pragma?: string
+  Cookie?: string
+  'If-Modified-Since'?: string
+  'If-None-Match'?: string
+  'X-Requested-With'?: string
+  'Accept-Encoding'?: string
+  'Accept-Language'?: string
+  [key: string]: string | undefined // To allow additional headers
+}
+
+interface FetchRequestParams {
+  headers?: FetchRequestHeaders
+  method?: string
+  baseURL?: string
+  body?: any // Optional, for request bodies like in POST or PUT requests
+  mode?: RequestMode // Optional, e.g., 'cors', 'no-cors', 'same-origin'
+  credentials?: RequestCredentials // Optional, e.g., 'include', 'same-origin', 'omit'
+  cache?: RequestCache // Optional, e.g., 'default', 'no-store', 'reload'
+  redirect?: RequestRedirect // Optional, e.g., 'follow', 'manual', 'error'
+  referrerPolicy?: ReferrerPolicy // Optional, e.g., 'no-referrer', 'origin'
+  integrity?: string // Optional, for subresource integrity
+  keepalive?: boolean // Optional, for whether the request should outlive the page
+  signal?: AbortSignal // Optional, to abort the request
+  [key: string]: any // To allow additional parameters
+}
+
 type FetchResponse = string | Blob | ArrayBuffer | ReadableStream<Uint8Array>
 
 const loading = ref(false)
 const token = ref('')
+const baseURL = '/'
 
-export async function useHttpFetch(endpoint = '') {
-  let baseURL = '/'
-
-  if (endpoint)
-    baseURL = endpoint
+async function post(url: string, params?: Params): Promise<any> {
+  const headers: FetchRequestHeaders = { Accept: 'application/json' }
 
-  async function post(url: string, params?: Params): Promise<any> {
-    const headers: any = { Accept: 'application/json' }
+  if (token.value) headers.Authorization = `Bearer ${token.value}`
 
-    if (token.value)
-      headers.Authorization = `Bearer ${token.value}`
-
-    const parameters: FetchOptions = {
-      ...params,
-      ...{
-        headers,
-        parseResponse: JSON.parse,
-        method: 'POST',
-        baseURL,
-      },
-    }
+  const parameters: FetchRequestParams = {
+    ...params,
+    ...{
+      headers,
+      parseResponse: JSON.parse,
+      method: 'POST',
+      baseURL,
+    },
+  }
 
-    loading.value = true
+  loading.value = true
 
-    try {
-      const result: string | FetchResponse | Blob | ArrayBuffer | ReadableStream<Uint8Array> = await ofetch(url, parameters)
+  try {
+    const result: string | FetchResponse | Blob | ArrayBuffer | ReadableStream<Uint8Array> = await ofetch(
+      url,
+      parameters,
+    )
 
-      loading.value = false
-      return result
-    }
-    catch (err: any) {
-      loading.value = false
+    loading.value = false
+    return result
+  } catch (err: any) {
+    loading.value = false
 
-      throw err
-    }
+    throw err
   }
+}
 
-  async function get(url: string, params?: Params): Promise<any> {
-    const headers: any = { Accept: 'application/json' }
-
-    if (token.value)
-      headers.Authorization = `Bearer ${token.value}`
+async function get(url: string, params?: Params): Promise<any> {
+  const headers: FetchRequestHeaders = { Accept: 'application/json' }
 
-    const parameters: FetchOptions = {
-      ...params,
-      ...{
-        headers,
-        parseResponse: JSON.parse,
-        method: 'GET',
-        baseURL,
-      },
-    }
+  if (token.value) headers.Authorization = `Bearer ${token.value}`
 
-    return await ofetch(url, parameters) as FetchResponse
+  const parameters: FetchRequestParams = {
+    ...params,
+    ...{
+      headers,
+      parseResponse: JSON.parse,
+      method: 'GET',
+      baseURL,
+    },
   }
 
-  async function patch(url: string, params?: Params): Promise<any> {
-    const headers: any = { Accept: 'application/json' }
-
-    if (token.value)
-      headers.Authorization = `Bearer ${token.value}`
+  return (await ofetch(url, parameters)) as FetchResponse
+}
 
-    const parameters: FetchOptions = {
-      ...params,
-      ...{
-        headers,
-        parseResponse: JSON.parse,
-        method: 'PATCH',
-        baseURL,
-      },
-    }
+async function patch(url: string, params?: Params): Promise<any> {
+  const headers: FetchRequestHeaders = { Accept: 'application/json' }
 
-    loading.value = true
+  if (token.value) headers.Authorization = `Bearer ${token.value}`
 
-    return await ofetch(url, parameters) as FetchResponse
+  const parameters: FetchRequestParams = {
+    ...params,
+    ...{
+      headers,
+      parseResponse: JSON.parse,
+      method: 'PATCH',
+      baseURL,
+    },
   }
 
-  async function destroy(url: string, params?: Params): Promise<any> {
-    const headers: any = { Accept: 'application/json' }
+  loading.value = true
 
-    if (token.value)
-      headers.Authorization = `Bearer ${token.value}`
+  return (await ofetch(url, parameters)) as FetchResponse
+}
 
-    const parameters: FetchOptions = {
-      ...params,
-      ...{
-        headers,
-        method: 'DELETE',
-        baseURL,
-      },
-    }
+async function destroy(url: string, params?: Params): Promise<any> {
+  const headers: FetchRequestHeaders = { Accept: 'application/json' }
 
-    loading.value = true
+  if (token.value) headers.Authorization = `Bearer ${token.value}`
 
-    return await ofetch(url, parameters) as FetchResponse
+  const parameters: FetchRequestParams = {
+    ...params,
+    ...{
+      headers,
+      method: 'DELETE',
+      baseURL,
+    },
   }
 
-  function setToken(authToken: string) {
-    token.value = authToken
-  }
+  loading.value = true
+
+  return (await ofetch(url, parameters)) as FetchResponse
+}
+
+function setToken(authToken: string) {
+  token.value = authToken
+}
 
-  return { post, get, patch, destroy, baseURL, loading, token, setToken }
+export const Fetch = {
+  post,
+  get,
+  patch,
+  destroy,
+  baseURL,
+  loading,
+  token,
+  setToken,
 }

package/dist/index.d.ts

@@ -1,14 +0,0 @@
-interface Params {
-    [key: string]: any;
-}
-export declare function useHttpFetch(endpoint?: string): Promise<{
-    post: (url: string, params?: Params) => Promise<any>;
-    get: (url: string, params?: Params) => Promise<any>;
-    patch: (url: string, params?: Params) => Promise<any>;
-    destroy: (url: string, params?: Params) => Promise<any>;
-    baseURL: string;
-    loading: any;
-    token: any;
-    setToken: (authToken: string) => void;
-}>;
-export {};