@stacksjs/browser 0.70.21 → 0.70.23

package/dist/fetch.d.ts

@@ -0,0 +1,103 @@
+declare interface Params {
+  [key: string]: any 
+}
+declare interface ApiFetch {
+  get: (url: string, params?: Params, header?: Headers) => Promise<FetchResponse>
+  post: (url: string, params?: Params, header?: Headers) => Promise<FetchResponse>
+  destroy: (url: string, params?: Params, header?: Headers) => Promise<FetchResponse>
+  patch: (url: string, params?: Params, header?: Headers) => Promise<FetchResponse>
+  put: (url: string, params?: Params, header?: Headers) => Promise<FetchResponse>
+  setToken: (authToken: string) => void
+  baseURL: '/' | string
+  loading: boolean
+  token: string
+}
+declare type FetchResponse = string | Blob | ArrayBuffer | ReadableStream<Uint8Array>
+
+let loading = false
+let token = ''
+const baseURL = '/'
+
+async function get(url: string, params?: Params, headers?: Headers): Promise<FetchResponse> {
+  if (headers) {
+    if (token)
+      headers.set('Authorization', `Bearer ${token}`)
+  }
+
+  return await ofetch(url, { method: 'GET', baseURL, params, headers })
+}
+
+async function post(url: string, params?: Params, headers?: Headers): Promise<any> {
+  if (headers) {
+    if (token)
+      headers.set('Authorization', `Bearer ${token}`)
+  }
+
+  loading = true
+
+  try {
+    const result: string | FetchResponse | Blob | ArrayBuffer | ReadableStream<Uint8Array> = await ofetch(url, {
+      method: 'POST',
+      baseURL,
+      params,
+      headers,
+    })
+
+    loading = false
+    return result
+  }
+  catch (err: any) {
+    loading = false
+
+    throw err
+  }
+}
+
+async function patch(url: string, params?: Params, headers?: Headers): Promise<FetchResponse> {
+  if (headers) {
+    if (token)
+      headers.set('Authorization', `Bearer ${token}`)
+  }
+
+  loading = true
+
+  return await ofetch(url, {
+    method: 'PATCH',
+    baseURL,
+    params,
+    headers,
+  })
+}
+
+async function put(url: string, params?: Params, headers?: Headers): Promise<FetchResponse> {
+  if (headers) {
+    if (token)
+      headers.set('Authorization', `Bearer ${token}`)
+  }
+
+  loading = true
+
+  return await ofetch(url, {
+    method: 'PUT',
+    baseURL,
+    params,
+    headers,
+  })
+}
+
+async function destroy(url: string, params?: Params, headers?: Headers): Promise<FetchResponse> {
+  if (headers) {
+    if (token)
+      headers.set('Authorization', `Bearer ${token}`)
+  }
+
+  loading = true
+
+  return await ofetch(url, {
+    method: 'DELETE',
+    baseURL,
+    params,
+    headers,
+  })
+}
+declare function setToken(authToken: string): void;

package/dist/index.js

@@ -1403,14 +1403,681 @@ function debounce(fn, wait = 25, options = {}) {
 async function _applyPromised(fn, _this, args) {
   return await fn.apply(_this, args);
 }
-// src/utils/function.ts
-function batchInvoke(functions) {
-  functions.forEach((fn) => fn?.());
-}
-function tap(value, callback) {
-  callback(value);
+// ../../../../node_modules/destr/dist/index.mjs
+var suspectProtoRx = /"(?:_|\\u0{2}5[Ff]){2}(?:p|\\u0{2}70)(?:r|\\u0{2}72)(?:o|\\u0{2}6[Ff])(?:t|\\u0{2}74)(?:o|\\u0{2}6[Ff])(?:_|\\u0{2}5[Ff]){2}"\s*:/;
+var suspectConstructorRx = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
+var JsonSigRx = /^\s*["[{]|^\s*-?\d{1,16}(\.\d{1,17})?([Ee][+-]?\d+)?\s*$/;
+function jsonParseTransform(key, value) {
+  if (key === "__proto__" || key === "constructor" && value && typeof value === "object" && "prototype" in value) {
+    warnKeyDropped(key);
+    return;
+  }
   return value;
 }
+function warnKeyDropped(key) {
+  console.warn(`[destr] Dropping "${key}" key to prevent prototype pollution.`);
+}
+function destr(value, options = {}) {
+  if (typeof value !== "string") {
+    return value;
+  }
+  const _value = value.trim();
+  if (value[0] === '"' && value.endsWith('"') && !value.includes("\\")) {
+    return _value.slice(1, -1);
+  }
+  if (_value.length <= 9) {
+    const _lval = _value.toLowerCase();
+    if (_lval === "true") {
+      return true;
+    }
+    if (_lval === "false") {
+      return false;
+    }
+    if (_lval === "undefined") {
+      return;
+    }
+    if (_lval === "null") {
+      return null;
+    }
+    if (_lval === "nan") {
+      return Number.NaN;
+    }
+    if (_lval === "infinity") {
+      return Number.POSITIVE_INFINITY;
+    }
+    if (_lval === "-infinity") {
+      return Number.NEGATIVE_INFINITY;
+    }
+  }
+  if (!JsonSigRx.test(value)) {
+    if (options.strict) {
+      throw new SyntaxError("[destr] Invalid JSON");
+    }
+    return value;
+  }
+  try {
+    if (suspectProtoRx.test(value) || suspectConstructorRx.test(value)) {
+      if (options.strict) {
+        throw new Error("[destr] Possible prototype pollution");
+      }
+      return JSON.parse(value, jsonParseTransform);
+    }
+    return JSON.parse(value);
+  } catch (error) {
+    if (options.strict) {
+      throw error;
+    }
+    return value;
+  }
+}
+
+// ../../../../node_modules/ufo/dist/index.mjs
+var r = String.fromCharCode;
+var HASH_RE = /#/g;
+var AMPERSAND_RE = /&/g;
+var SLASH_RE = /\//g;
+var EQUAL_RE = /=/g;
+var PLUS_RE = /\+/g;
+var ENC_CARET_RE = /%5e/gi;
+var ENC_BACKTICK_RE = /%60/gi;
+var ENC_PIPE_RE = /%7c/gi;
+var ENC_SPACE_RE = /%20/gi;
+function encode(text) {
+  return encodeURI("" + text).replace(ENC_PIPE_RE, "|");
+}
+function encodeQueryValue(input) {
+  return encode(typeof input === "string" ? input : JSON.stringify(input)).replace(PLUS_RE, "%2B").replace(ENC_SPACE_RE, "+").replace(HASH_RE, "%23").replace(AMPERSAND_RE, "%26").replace(ENC_BACKTICK_RE, "`").replace(ENC_CARET_RE, "^").replace(SLASH_RE, "%2F");
+}
+function encodeQueryKey(text) {
+  return encodeQueryValue(text).replace(EQUAL_RE, "%3D");
+}
+function decode(text = "") {
+  try {
+    return decodeURIComponent("" + text);
+  } catch {
+    return "" + text;
+  }
+}
+function decodeQueryKey(text) {
+  return decode(text.replace(PLUS_RE, " "));
+}
+function decodeQueryValue(text) {
+  return decode(text.replace(PLUS_RE, " "));
+}
+function parseQuery(parametersString = "") {
+  const object = {};
+  if (parametersString[0] === "?") {
+    parametersString = parametersString.slice(1);
+  }
+  for (const parameter of parametersString.split("&")) {
+    const s = parameter.match(/([^=]+)=?(.*)/) || [];
+    if (s.length < 2) {
+      continue;
+    }
+    const key = decodeQueryKey(s[1]);
+    if (key === "__proto__" || key === "constructor") {
+      continue;
+    }
+    const value = decodeQueryValue(s[2] || "");
+    if (object[key] === undefined) {
+      object[key] = value;
+    } else if (Array.isArray(object[key])) {
+      object[key].push(value);
+    } else {
+      object[key] = [object[key], value];
+    }
+  }
+  return object;
+}
+function encodeQueryItem(key, value) {
+  if (typeof value === "number" || typeof value === "boolean") {
+    value = String(value);
+  }
+  if (!value) {
+    return encodeQueryKey(key);
+  }
+  if (Array.isArray(value)) {
+    return value.map((_value) => `${encodeQueryKey(key)}=${encodeQueryValue(_value)}`).join("&");
+  }
+  return `${encodeQueryKey(key)}=${encodeQueryValue(value)}`;
+}
+function stringifyQuery(query) {
+  return Object.keys(query).filter((k) => query[k] !== undefined).map((k) => encodeQueryItem(k, query[k])).filter(Boolean).join("&");
+}
+var PROTOCOL_STRICT_REGEX = /^[\s\w\0+.-]{2,}:([/\\]{1,2})/;
+var PROTOCOL_REGEX = /^[\s\w\0+.-]{2,}:([/\\]{2})?/;
+var PROTOCOL_RELATIVE_REGEX = /^([/\\]\s*){2,}[^/\\]/;
+var TRAILING_SLASH_RE = /\/$|\/\?|\/#/;
+var JOIN_LEADING_SLASH_RE = /^\.?\//;
+function hasProtocol(inputString, opts = {}) {
+  if (typeof opts === "boolean") {
+    opts = { acceptRelative: opts };
+  }
+  if (opts.strict) {
+    return PROTOCOL_STRICT_REGEX.test(inputString);
+  }
+  return PROTOCOL_REGEX.test(inputString) || (opts.acceptRelative ? PROTOCOL_RELATIVE_REGEX.test(inputString) : false);
+}
+function hasTrailingSlash(input = "", respectQueryAndFragment) {
+  if (!respectQueryAndFragment) {
+    return input.endsWith("/");
+  }
+  return TRAILING_SLASH_RE.test(input);
+}
+function withoutTrailingSlash(input = "", respectQueryAndFragment) {
+  if (!respectQueryAndFragment) {
+    return (hasTrailingSlash(input) ? input.slice(0, -1) : input) || "/";
+  }
+  if (!hasTrailingSlash(input, true)) {
+    return input || "/";
+  }
+  let path = input;
+  let fragment = "";
+  const fragmentIndex = input.indexOf("#");
+  if (fragmentIndex >= 0) {
+    path = input.slice(0, fragmentIndex);
+    fragment = input.slice(fragmentIndex);
+  }
+  const [s0, ...s] = path.split("?");
+  const cleanPath = s0.endsWith("/") ? s0.slice(0, -1) : s0;
+  return (cleanPath || "/") + (s.length > 0 ? `?${s.join("?")}` : "") + fragment;
+}
+function withTrailingSlash(input = "", respectQueryAndFragment) {
+  if (!respectQueryAndFragment) {
+    return input.endsWith("/") ? input : input + "/";
+  }
+  if (hasTrailingSlash(input, true)) {
+    return input || "/";
+  }
+  let path = input;
+  let fragment = "";
+  const fragmentIndex = input.indexOf("#");
+  if (fragmentIndex >= 0) {
+    path = input.slice(0, fragmentIndex);
+    fragment = input.slice(fragmentIndex);
+    if (!path) {
+      return fragment;
+    }
+  }
+  const [s0, ...s] = path.split("?");
+  return s0 + "/" + (s.length > 0 ? `?${s.join("?")}` : "") + fragment;
+}
+function withBase(input, base) {
+  if (isEmptyURL(base) || hasProtocol(input)) {
+    return input;
+  }
+  const _base = withoutTrailingSlash(base);
+  if (input.startsWith(_base)) {
+    return input;
+  }
+  return joinURL(_base, input);
+}
+function withQuery(input, query) {
+  const parsed = parseURL(input);
+  const mergedQuery = { ...parseQuery(parsed.search), ...query };
+  parsed.search = stringifyQuery(mergedQuery);
+  return stringifyParsedURL(parsed);
+}
+function isEmptyURL(url) {
+  return !url || url === "/";
+}
+function isNonEmptyURL(url) {
+  return url && url !== "/";
+}
+function joinURL(base, ...input) {
+  let url = base || "";
+  for (const segment of input.filter((url2) => isNonEmptyURL(url2))) {
+    if (url) {
+      const _segment = segment.replace(JOIN_LEADING_SLASH_RE, "");
+      url = withTrailingSlash(url) + _segment;
+    } else {
+      url = segment;
+    }
+  }
+  return url;
+}
+var protocolRelative = Symbol.for("ufo:protocolRelative");
+function parseURL(input = "", defaultProto) {
+  const _specialProtoMatch = input.match(/^[\s\0]*(blob:|data:|javascript:|vbscript:)(.*)/i);
+  if (_specialProtoMatch) {
+    const [, _proto, _pathname = ""] = _specialProtoMatch;
+    return {
+      protocol: _proto.toLowerCase(),
+      pathname: _pathname,
+      href: _proto + _pathname,
+      auth: "",
+      host: "",
+      search: "",
+      hash: ""
+    };
+  }
+  if (!hasProtocol(input, { acceptRelative: true })) {
+    return defaultProto ? parseURL(defaultProto + input) : parsePath(input);
+  }
+  const [, protocol = "", auth, hostAndPath = ""] = input.replace(/\\/g, "/").match(/^[\s\0]*([\w+.-]{2,}:)?\/\/([^/@]+@)?(.*)/) || [];
+  let [, host = "", path = ""] = hostAndPath.match(/([^#/?]*)(.*)?/) || [];
+  if (protocol === "file:") {
+    path = path.replace(/\/(?=[A-Za-z]:)/, "");
+  }
+  const { pathname, search, hash } = parsePath(path);
+  return {
+    protocol: protocol.toLowerCase(),
+    auth: auth ? auth.slice(0, Math.max(0, auth.length - 1)) : "",
+    host,
+    pathname,
+    search,
+    hash,
+    [protocolRelative]: !protocol
+  };
+}
+function parsePath(input = "") {
+  const [pathname = "", search = "", hash = ""] = (input.match(/([^#?]*)(\?[^#]*)?(#.*)?/) || []).splice(1);
+  return {
+    pathname,
+    search,
+    hash
+  };
+}
+function stringifyParsedURL(parsed) {
+  const pathname = parsed.pathname || "";
+  const search = parsed.search ? (parsed.search.startsWith("?") ? "" : "?") + parsed.search : "";
+  const hash = parsed.hash || "";
+  const auth = parsed.auth ? parsed.auth + "@" : "";
+  const host = parsed.host || "";
+  const proto = parsed.protocol || parsed[protocolRelative] ? (parsed.protocol || "") + "//" : "";
+  return proto + auth + host + pathname + search + hash;
+}
+
+// ../../../../node_modules/ofetch/dist/shared/ofetch.03887fc3.mjs
+class FetchError extends Error {
+  constructor(message, opts) {
+    super(message, opts);
+    this.name = "FetchError";
+    if (opts?.cause && !this.cause) {
+      this.cause = opts.cause;
+    }
+  }
+}
+function createFetchError(ctx) {
+  const errorMessage = ctx.error?.message || ctx.error?.toString() || "";
+  const method = ctx.request?.method || ctx.options?.method || "GET";
+  const url = ctx.request?.url || String(ctx.request) || "/";
+  const requestStr = `[${method}] ${JSON.stringify(url)}`;
+  const statusStr = ctx.response ? `${ctx.response.status} ${ctx.response.statusText}` : "<no response>";
+  const message = `${requestStr}: ${statusStr}${errorMessage ? ` ${errorMessage}` : ""}`;
+  const fetchError = new FetchError(message, ctx.error ? { cause: ctx.error } : undefined);
+  for (const key of ["request", "options", "response"]) {
+    Object.defineProperty(fetchError, key, {
+      get() {
+        return ctx[key];
+      }
+    });
+  }
+  for (const [key, refKey] of [
+    ["data", "_data"],
+    ["status", "status"],
+    ["statusCode", "status"],
+    ["statusText", "statusText"],
+    ["statusMessage", "statusText"]
+  ]) {
+    Object.defineProperty(fetchError, key, {
+      get() {
+        return ctx.response && ctx.response[refKey];
+      }
+    });
+  }
+  return fetchError;
+}
+var payloadMethods = new Set(Object.freeze(["PATCH", "POST", "PUT", "DELETE"]));
+function isPayloadMethod(method = "GET") {
+  return payloadMethods.has(method.toUpperCase());
+}
+function isJSONSerializable(value) {
+  if (value === undefined) {
+    return false;
+  }
+  const t = typeof value;
+  if (t === "string" || t === "number" || t === "boolean" || t === null) {
+    return true;
+  }
+  if (t !== "object") {
+    return false;
+  }
+  if (Array.isArray(value)) {
+    return true;
+  }
+  if (value.buffer) {
+    return false;
+  }
+  return value.constructor && value.constructor.name === "Object" || typeof value.toJSON === "function";
+}
+var textTypes = /* @__PURE__ */ new Set([
+  "image/svg",
+  "application/xml",
+  "application/xhtml",
+  "application/html"
+]);
+var JSON_RE = /^application\/(?:[\w!#$%&*.^`~-]*\+)?json(;.+)?$/i;
+function detectResponseType(_contentType = "") {
+  if (!_contentType) {
+    return "json";
+  }
+  const contentType = _contentType.split(";").shift() || "";
+  if (JSON_RE.test(contentType)) {
+    return "json";
+  }
+  if (textTypes.has(contentType) || contentType.startsWith("text/")) {
+    return "text";
+  }
+  return "blob";
+}
+function resolveFetchOptions(request, input, defaults, Headers2) {
+  const headers = mergeHeaders(input?.headers ?? request?.headers, defaults?.headers, Headers2);
+  let query;
+  if (defaults?.query || defaults?.params || input?.params || input?.query) {
+    query = {
+      ...defaults?.params,
+      ...defaults?.query,
+      ...input?.params,
+      ...input?.query
+    };
+  }
+  return {
+    ...defaults,
+    ...input,
+    query,
+    params: query,
+    headers
+  };
+}
+function mergeHeaders(input, defaults, Headers2) {
+  if (!defaults) {
+    return new Headers2(input);
+  }
+  const headers = new Headers2(defaults);
+  if (input) {
+    for (const [key, value] of Symbol.iterator in input || Array.isArray(input) ? input : new Headers2(input)) {
+      headers.set(key, value);
+    }
+  }
+  return headers;
+}
+async function callHooks(context, hooks) {
+  if (hooks) {
+    if (Array.isArray(hooks)) {
+      for (const hook of hooks) {
+        await hook(context);
+      }
+    } else {
+      await hooks(context);
+    }
+  }
+}
+var retryStatusCodes = /* @__PURE__ */ new Set([
+  408,
+  409,
+  425,
+  429,
+  500,
+  502,
+  503,
+  504
+]);
+var nullBodyResponses = /* @__PURE__ */ new Set([101, 204, 205, 304]);
+function createFetch(globalOptions = {}) {
+  const {
+    fetch = globalThis.fetch,
+    Headers: Headers2 = globalThis.Headers,
+    AbortController: AbortController2 = globalThis.AbortController
+  } = globalOptions;
+  async function onError3(context) {
+    const isAbort = context.error && context.error.name === "AbortError" && !context.options.timeout || false;
+    if (context.options.retry !== false && !isAbort) {
+      let retries;
+      if (typeof context.options.retry === "number") {
+        retries = context.options.retry;
+      } else {
+        retries = isPayloadMethod(context.options.method) ? 0 : 1;
+      }
+      const responseCode = context.response && context.response.status || 500;
+      if (retries > 0 && (Array.isArray(context.options.retryStatusCodes) ? context.options.retryStatusCodes.includes(responseCode) : retryStatusCodes.has(responseCode))) {
+        const retryDelay = typeof context.options.retryDelay === "function" ? context.options.retryDelay(context) : context.options.retryDelay || 0;
+        if (retryDelay > 0) {
+          await new Promise((resolve) => setTimeout(resolve, retryDelay));
+        }
+        return $fetchRaw(context.request, {
+          ...context.options,
+          retry: retries - 1
+        });
+      }
+    }
+    const error = createFetchError(context);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(error, $fetchRaw);
+    }
+    throw error;
+  }
+  const $fetchRaw = async function $fetchRaw2(_request, _options = {}) {
+    const context = {
+      request: _request,
+      options: resolveFetchOptions(_request, _options, globalOptions.defaults, Headers2),
+      response: undefined,
+      error: undefined
+    };
+    if (context.options.method) {
+      context.options.method = context.options.method.toUpperCase();
+    }
+    if (context.options.onRequest) {
+      await callHooks(context, context.options.onRequest);
+    }
+    if (typeof context.request === "string") {
+      if (context.options.baseURL) {
+        context.request = withBase(context.request, context.options.baseURL);
+      }
+      if (context.options.query) {
+        context.request = withQuery(context.request, context.options.query);
+        delete context.options.query;
+      }
+      if ("query" in context.options) {
+        delete context.options.query;
+      }
+      if ("params" in context.options) {
+        delete context.options.params;
+      }
+    }
+    if (context.options.body && isPayloadMethod(context.options.method)) {
+      if (isJSONSerializable(context.options.body)) {
+        context.options.body = typeof context.options.body === "string" ? context.options.body : JSON.stringify(context.options.body);
+        context.options.headers = new Headers2(context.options.headers || {});
+        if (!context.options.headers.has("content-type")) {
+          context.options.headers.set("content-type", "application/json");
+        }
+        if (!context.options.headers.has("accept")) {
+          context.options.headers.set("accept", "application/json");
+        }
+      } else if ("pipeTo" in context.options.body && typeof context.options.body.pipeTo === "function" || typeof context.options.body.pipe === "function") {
+        if (!("duplex" in context.options)) {
+          context.options.duplex = "half";
+        }
+      }
+    }
+    let abortTimeout;
+    if (!context.options.signal && context.options.timeout) {
+      const controller = new AbortController2;
+      abortTimeout = setTimeout(() => {
+        const error = new Error("[TimeoutError]: The operation was aborted due to timeout");
+        error.name = "TimeoutError";
+        error.code = 23;
+        controller.abort(error);
+      }, context.options.timeout);
+      context.options.signal = controller.signal;
+    }
+    try {
+      context.response = await fetch(context.request, context.options);
+    } catch (error) {
+      context.error = error;
+      if (context.options.onRequestError) {
+        await callHooks(context, context.options.onRequestError);
+      }
+      return await onError3(context);
+    } finally {
+      if (abortTimeout) {
+        clearTimeout(abortTimeout);
+      }
+    }
+    const hasBody = (context.response.body || context.response._bodyInit) && !nullBodyResponses.has(context.response.status) && context.options.method !== "HEAD";
+    if (hasBody) {
+      const responseType = (context.options.parseResponse ? "json" : context.options.responseType) || detectResponseType(context.response.headers.get("content-type") || "");
+      switch (responseType) {
+        case "json": {
+          const data = await context.response.text();
+          const parseFunction = context.options.parseResponse || destr;
+          context.response._data = parseFunction(data);
+          break;
+        }
+        case "stream": {
+          context.response._data = context.response.body || context.response._bodyInit;
+          break;
+        }
+        default: {
+          context.response._data = await context.response[responseType]();
+        }
+      }
+    }
+    if (context.options.onResponse) {
+      await callHooks(context, context.options.onResponse);
+    }
+    if (!context.options.ignoreResponseError && context.response.status >= 400 && context.response.status < 600) {
+      if (context.options.onResponseError) {
+        await callHooks(context, context.options.onResponseError);
+      }
+      return await onError3(context);
+    }
+    return context.response;
+  };
+  const $fetch = async function $fetch2(request, options) {
+    const r2 = await $fetchRaw(request, options);
+    return r2._data;
+  };
+  $fetch.raw = $fetchRaw;
+  $fetch.native = (...args) => fetch(...args);
+  $fetch.create = (defaultOptions = {}, customGlobalOptions = {}) => createFetch({
+    ...globalOptions,
+    ...customGlobalOptions,
+    defaults: {
+      ...globalOptions.defaults,
+      ...customGlobalOptions.defaults,
+      ...defaultOptions
+    }
+  });
+  return $fetch;
+}
+
+// ../../../../node_modules/ofetch/dist/index.mjs
+var _globalThis = function() {
+  if (typeof globalThis !== "undefined") {
+    return globalThis;
+  }
+  if (typeof self !== "undefined") {
+    return self;
+  }
+  if (typeof window !== "undefined") {
+    return window;
+  }
+  if (typeof global !== "undefined") {
+    return global;
+  }
+  throw new Error("unable to locate global object");
+}();
+var fetch = _globalThis.fetch ? (...args) => _globalThis.fetch(...args) : () => Promise.reject(new Error("[ofetch] global.fetch is not supported!"));
+var Headers2 = _globalThis.Headers;
+var AbortController2 = _globalThis.AbortController;
+var ofetch = createFetch({ fetch, Headers: Headers2, AbortController: AbortController2 });
+
+// src/utils/fetch.ts
+var loading = false;
+var token = "";
+var baseURL = "/";
+async function get(url, params, headers) {
+  if (headers) {
+    if (token)
+      headers.set("Authorization", `Bearer ${token}`);
+  }
+  return await ofetch(url, { method: "GET", baseURL, params, headers });
+}
+async function post(url, params, headers) {
+  if (headers) {
+    if (token)
+      headers.set("Authorization", `Bearer ${token}`);
+  }
+  loading = true;
+  try {
+    const result = await ofetch(url, {
+      method: "POST",
+      baseURL,
+      params,
+      headers
+    });
+    loading = false;
+    return result;
+  } catch (err) {
+    loading = false;
+    throw err;
+  }
+}
+async function patch(url, params, headers) {
+  if (headers) {
+    if (token)
+      headers.set("Authorization", `Bearer ${token}`);
+  }
+  loading = true;
+  return await ofetch(url, {
+    method: "PATCH",
+    baseURL,
+    params,
+    headers
+  });
+}
+async function put(url, params, headers) {
+  if (headers) {
+    if (token)
+      headers.set("Authorization", `Bearer ${token}`);
+  }
+  loading = true;
+  return await ofetch(url, {
+    method: "PUT",
+    baseURL,
+    params,
+    headers
+  });
+}
+async function destroy(url, params, headers) {
+  if (headers) {
+    if (token)
+      headers.set("Authorization", `Bearer ${token}`);
+  }
+  loading = true;
+  return await ofetch(url, {
+    method: "DELETE",
+    baseURL,
+    params,
+    headers
+  });
+}
+function setToken(authToken) {
+  token = authToken;
+}
+var Fetch = {
+  get,
+  post,
+  patch,
+  put,
+  destroy,
+  baseURL,
+  token,
+  setToken,
+  loading
+};
 // src/utils/guards.ts
 function notNullish(v) {
   return v != null;
@@ -1506,9 +2173,9 @@ var toNumber = (val) => {
   const n = isString(val) ? Number(val) : NaN;
   return isNaN(n) ? val : n;
 };
-var _globalThis;
+var _globalThis2;
 var getGlobalThis = () => {
-  return _globalThis || (_globalThis = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {});
+  return _globalThis2 || (_globalThis2 = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {});
 };
 function normalizeStyle(value) {
   if (isArray(value)) {
@@ -2576,7 +3243,7 @@ function createInstrumentations(readonly, shallow) {
         value = toRaw(value);
       }
       const target = toRaw(this);
-      const { has, get } = getProto(target);
+      const { has, get: get2 } = getProto(target);
       let hadKey = has.call(target, key);
       if (!hadKey) {
         key = toRaw(key);
@@ -2584,7 +3251,7 @@ function createInstrumentations(readonly, shallow) {
       } else if (true) {
         checkIdentityKeys(target, has, key);
       }
-      const oldValue = get.call(target, key);
+      const oldValue = get2.call(target, key);
       target.set(key, value);
       if (!hadKey) {
         trigger(target, "add", key, value);
@@ -2595,7 +3262,7 @@ function createInstrumentations(readonly, shallow) {
     },
     delete(key) {
       const target = toRaw(this);
-      const { has, get } = getProto(target);
+      const { has, get: get2 } = getProto(target);
       let hadKey = has.call(target, key);
       if (!hadKey) {
         key = toRaw(key);
@@ -2603,7 +3270,7 @@ function createInstrumentations(readonly, shallow) {
       } else if (true) {
         checkIdentityKeys(target, has, key);
       }
-      const oldValue = get ? get.call(target, key) : undefined;
+      const oldValue = get2 ? get2.call(target, key) : undefined;
       const result = target.delete(key);
       if (hadKey) {
         trigger(target, "delete", key, undefined, oldValue);
@@ -2749,8 +3416,8 @@ function markRaw(value) {
 }
 var toReactive = (value) => isObject(value) ? reactive(value) : value;
 var toReadonly = (value) => isObject(value) ? readonly(value) : value;
-function isRef(r) {
-  return r ? r["__v_isRef"] === true : false;
+function isRef(r2) {
+  return r2 ? r2["__v_isRef"] === true : false;
 }
 function ref(value) {
   return createRef(value, false);
@@ -2830,8 +3497,8 @@ class CustomRefImpl {
     this["__v_isRef"] = true;
     this._value = undefined;
     const dep = this.dep = new Dep;
-    const { get, set } = factory(dep.track.bind(dep), dep.trigger.bind(dep));
-    this._get = get;
+    const { get: get2, set } = factory(dep.track.bind(dep), dep.trigger.bind(dep));
+    this._get = get2;
     this._set = set;
   }
   get value() {
@@ -5384,7 +6051,7 @@ function computedWithControl(source, fn) {
     trigger2();
   };
   watch2(source, update, { flush: "sync" });
-  const get = typeof fn === "function" ? fn : fn.get;
+  const get2 = typeof fn === "function" ? fn : fn.get;
   const set = typeof fn === "function" ? undefined : fn.set;
   const result = customRef((_track, _trigger) => {
     track2 = _track;
@@ -5392,7 +6059,7 @@ function computedWithControl(source, fn) {
     return {
       get() {
         if (dirty.value) {
-          v = get(v);
+          v = get2(v);
           dirty.value = false;
         }
         track2();
@@ -5641,8 +6308,8 @@ function getIsIOS() {
 function toRef2(...args) {
   if (args.length !== 1)
     return toRef(...args);
-  const r = args[0];
-  return typeof r === "function" ? readonly(customRef(() => ({ get: r, set: noop }))) : ref(r);
+  const r2 = args[0];
+  return typeof r2 === "function" ? readonly(customRef(() => ({ get: r2, set: noop }))) : ref(r2);
 }
 var resolveRef = toRef2;
 function reactivePick(obj, ...keys) {
@@ -5923,14 +6590,14 @@ function refWithControl(initial, options = {}) {
     trigger2 = _trigger;
     return {
       get() {
-        return get();
+        return get2();
       },
       set(v) {
         set(v);
       }
     };
   });
-  function get(tracking = true) {
+  function get2(tracking = true) {
     if (tracking)
       track2();
     return source;
@@ -5947,12 +6614,12 @@ function refWithControl(initial, options = {}) {
     if (triggering)
       trigger2();
   }
-  const untrackedGet = () => get(false);
+  const untrackedGet = () => get2(false);
   const silentSet = (v) => set(v, false);
-  const peek = () => get(false);
+  const peek = () => get2(false);
   const lay = (v) => set(v, false);
   return extendRef(ref2, {
-    get,
+    get: get2,
     set,
     untrackedGet,
     silentSet,
@@ -6079,11 +6746,11 @@ function tryOnUnmounted(fn, target) {
   if (instance)
     onUnmounted(fn, target);
 }
-function createUntil(r, isNot = false) {
+function createUntil(r2, isNot = false) {
   function toMatch(condition, { flush = "sync", deep = false, timeout, throwOnTimeout } = {}) {
     let stop2 = null;
     const watcher = new Promise((resolve) => {
-      stop2 = watch2(r, (v) => {
+      stop2 = watch2(r2, (v) => {
         if (condition(v) !== isNot) {
           if (stop2)
             stop2();
@@ -6099,7 +6766,7 @@ function createUntil(r, isNot = false) {
     });
     const promises = [watcher];
     if (timeout != null) {
-      promises.push(promiseTimeout(timeout, throwOnTimeout).then(() => toValue(r)).finally(() => stop2 == null ? undefined : stop2()));
+      promises.push(promiseTimeout(timeout, throwOnTimeout).then(() => toValue(r2)).finally(() => stop2 == null ? undefined : stop2()));
     }
     return Promise.race(promises);
   }
@@ -6109,7 +6776,7 @@ function createUntil(r, isNot = false) {
     const { flush = "sync", deep = false, timeout, throwOnTimeout } = options != null ? options : {};
     let stop2 = null;
     const watcher = new Promise((resolve) => {
-      stop2 = watch2([r, value], ([v1, v2]) => {
+      stop2 = watch2([r2, value], ([v1, v2]) => {
         if (isNot !== (v1 === v2)) {
           if (stop2)
             stop2();
@@ -6125,9 +6792,9 @@ function createUntil(r, isNot = false) {
     });
     const promises = [watcher];
     if (timeout != null) {
-      promises.push(promiseTimeout(timeout, throwOnTimeout).then(() => toValue(r)).finally(() => {
+      promises.push(promiseTimeout(timeout, throwOnTimeout).then(() => toValue(r2)).finally(() => {
         stop2 == null || stop2();
-        return toValue(r);
+        return toValue(r2);
       }));
     }
     return Promise.race(promises);
@@ -6160,14 +6827,14 @@ function createUntil(r, isNot = false) {
       return count >= n;
     }, options);
   }
-  if (Array.isArray(toValue(r))) {
+  if (Array.isArray(toValue(r2))) {
     const instance = {
       toMatch,
       toContains,
       changed,
       changedTimes,
       get not() {
-        return createUntil(r, !isNot);
+        return createUntil(r2, !isNot);
       }
     };
     return instance;
@@ -6182,14 +6849,14 @@ function createUntil(r, isNot = false) {
       changed,
       changedTimes,
       get not() {
-        return createUntil(r, !isNot);
+        return createUntil(r2, !isNot);
       }
     };
     return instance;
   }
 }
-function until(r) {
-  return createUntil(r);
+function until(r2) {
+  return createUntil(r2);
 }
 function defaultComparator(value, othVal) {
   return value === othVal;
@@ -6284,13 +6951,13 @@ function useCounter(initialValue = 0, options = {}) {
   } = options;
   const inc = (delta = 1) => count.value = Math.max(Math.min(max, count.value + delta), min);
   const dec = (delta = 1) => count.value = Math.min(Math.max(min, count.value - delta), max);
-  const get = () => count.value;
+  const get2 = () => count.value;
   const set = (val) => count.value = Math.max(min, Math.min(max, val));
   const reset = (val = _initialValue) => {
     _initialValue = val;
     return set(val);
   };
-  return { count, inc, dec, get, set, reset };
+  return { count, inc, dec, get: get2, set, reset };
 }
 var REGEX_PARSE = /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[T\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/i;
 var REGEX_FORMAT = /[YMDHhms]o|\[([^\]]+)\]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a{1,2}|A{1,2}|m{1,2}|s{1,2}|Z{1,2}|z{1,4}|SSS/g;
@@ -8707,7 +9374,7 @@ function useBroadcastChannel(options) {
   const channel = ref();
   const data = ref();
   const error = shallowRef(null);
-  const post = (data2) => {
+  const post2 = (data2) => {
     if (channel.value)
       channel.value.postMessage(data2);
   };
@@ -8741,7 +9408,7 @@ function useBroadcastChannel(options) {
     isSupported,
     channel,
     data,
-    post,
+    post: post2,
     close,
     error,
     isClosed
@@ -10476,7 +11143,7 @@ function combineCallbacks(combination, ...callbacks) {
     };
   }
 }
-function createFetch(config = {}) {
+function createFetch2(config = {}) {
   const _combination = config.combination || "chain";
   const _options = config.options || {};
   const _fetchOptions = config.fetchOptions || {};
@@ -10547,7 +11214,7 @@ function useFetch(url, ...args) {
       options = { ...options, ...args[1] };
   }
   const {
-    fetch = (_a = defaultWindow) == null ? undefined : _a.fetch,
+    fetch: fetch2 = (_a = defaultWindow) == null ? undefined : _a.fetch,
     initialData,
     timeout
   } = options;
@@ -10575,7 +11242,7 @@ function useFetch(url, ...args) {
       };
     }
   };
-  const loading = (isLoading) => {
+  const loading2 = (isLoading) => {
     isFetching.value = isLoading;
     isFinished.value = !isLoading;
   };
@@ -10585,7 +11252,7 @@ function useFetch(url, ...args) {
   const execute = async (throwOnFailed = false) => {
     var _a2, _b;
     abort();
-    loading(true);
+    loading2(true);
     error.value = null;
     statusCode.value = null;
     aborted.value = false;
@@ -10618,14 +11285,14 @@ function useFetch(url, ...args) {
     };
     if (options.beforeFetch)
       Object.assign(context, await options.beforeFetch(context));
-    if (isCanceled || !fetch) {
-      loading(false);
+    if (isCanceled || !fetch2) {
+      loading2(false);
       return Promise.resolve(null);
     }
     let responseData = null;
     if (timer)
       timer.start();
-    return fetch(context.url, {
+    return fetch2(context.url, {
       ...defaultFetchOptions,
       ...context.options,
       headers: {
@@ -10671,7 +11338,7 @@ function useFetch(url, ...args) {
       return null;
     }).finally(() => {
       if (currentExecuteCounter === executeCounter)
-        loading(false);
+        loading2(false);
       if (timer)
         timer.stop();
       finallyEvent.trigger(null);
@@ -11322,7 +11989,7 @@ function useIdle(timeout = oneMinute, options = {}) {
 async function loadImage(options) {
   return new Promise((resolve, reject) => {
     const img = new Image;
-    const { src, srcset, sizes, class: clazz, loading, crossorigin, referrerPolicy, width, height, decoding, fetchPriority, ismap, usemap } = options;
+    const { src, srcset, sizes, class: clazz, loading: loading2, crossorigin, referrerPolicy, width, height, decoding, fetchPriority, ismap, usemap } = options;
     img.src = src;
     if (srcset != null)
       img.srcset = srcset;
@@ -11330,8 +11997,8 @@ async function loadImage(options) {
       img.sizes = sizes;
     if (clazz != null)
       img.className = clazz;
-    if (loading != null)
-      img.loading = loading;
+    if (loading2 != null)
+      img.loading = loading2;
     if (crossorigin != null)
       img.crossOrigin = crossorigin;
     if (referrerPolicy != null)
@@ -11681,8 +12348,8 @@ function useMagicKeys(options = {}) {
           refs[prop] = shallowRef(false);
         }
       }
-      const r = Reflect.get(target2, prop, rec);
-      return useReactive ? toValue(r) : r;
+      const r2 = Reflect.get(target2, prop, rec);
+      return useReactive ? toValue(r2) : r2;
     }
   });
   return proxy;
@@ -13142,7 +13809,7 @@ function useStepper(steps, initialStep) {
       return stepsRef.value[index2];
     return stepsRef.value[stepNames.value[index2]];
   }
-  function get(step) {
+  function get2(step) {
     if (!stepNames.value.includes(step))
       return;
     return at(stepNames.value.indexOf(step));
@@ -13190,7 +13857,7 @@ function useStepper(steps, initialStep) {
     isFirst,
     isLast,
     at,
-    get,
+    get: get2,
     goTo,
     goToNext,
     goToPrevious,
@@ -14530,7 +15197,7 @@ function useWebWorker(arg0, workerOptions, options) {
   } = options != null ? options : {};
   const data = ref(null);
   const worker = shallowRef();
-  const post = (...args) => {
+  const post2 = (...args) => {
     if (!worker.value)
       return;
     worker.value.postMessage(...args);
@@ -14557,7 +15224,7 @@ function useWebWorker(arg0, workerOptions, options) {
   }
   return {
     data,
-    post,
+    post: post2,
     terminate,
     worker
   };
@@ -15050,15 +15717,15 @@ function tagDedupeKey(tag) {
   return false;
 }
 var sepSub = "%separator";
-function sub(p2, token, isJson = false) {
+function sub(p2, token2, isJson = false) {
   let val;
-  if (token === "s" || token === "pageTitle") {
+  if (token2 === "s" || token2 === "pageTitle") {
     val = p2.pageTitle;
-  } else if (token.includes(".")) {
-    const dotIndex = token.indexOf(".");
-    val = p2[token.substring(0, dotIndex)]?.[token.substring(dotIndex + 1)];
+  } else if (token2.includes(".")) {
+    const dotIndex = token2.indexOf(".");
+    val = p2[token2.substring(0, dotIndex)]?.[token2.substring(dotIndex + 1)];
   } else {
-    val = p2[token];
+    val = p2[token2];
   }
   if (val !== undefined) {
     return isJson ? (val || "").replace(/"/g, "\\\"") : val || "";
@@ -15078,12 +15745,12 @@ function processTemplateParams(s, p2, sep, isJson = false) {
     return s;
   }
   const hasSepSub = s.includes(sepSub);
-  s = s.replace(/%\w+(?:\.\w+)?/g, (token) => {
-    if (token === sepSub || !tokens2.includes(token)) {
-      return token;
+  s = s.replace(/%\w+(?:\.\w+)?/g, (token2) => {
+    if (token2 === sepSub || !tokens2.includes(token2)) {
+      return token2;
     }
-    const re = sub(p2, token.slice(1), isJson);
-    return re !== undefined ? re : token;
+    const re = sub(p2, token2.slice(1), isJson);
+    return re !== undefined ? re : token2;
   }).trim();
   if (hasSepSub) {
     if (s.endsWith(sepSub))
@@ -15893,8 +16560,8 @@ scriptProxy[ScriptProxyTarget] = true;
 
 // ../../../../node_modules/@vueuse/head/node_modules/@unhead/vue/dist/shared/vue.ziyDaVMR.mjs
 var Vue3 = version[0] === "3";
-function resolveUnref2(r) {
-  return typeof r === "function" ? r() : unref(r);
+function resolveUnref2(r2) {
+  return typeof r2 === "function" ? r2() : unref(r2);
 }
 function resolveUnrefHeadInput(ref2) {
   if (ref2 instanceof Promise || ref2 instanceof Date || ref2 instanceof RegExp)
@@ -15903,7 +16570,7 @@ function resolveUnrefHeadInput(ref2) {
   if (!ref2 || !root)
     return root;
   if (Array.isArray(root))
-    return root.map((r) => resolveUnrefHeadInput(r));
+    return root.map((r2) => resolveUnrefHeadInput(r2));
   if (typeof root === "object") {
     const resolved = {};
     for (const k2 in root) {
@@ -16502,7 +17169,6 @@ export {
   refThrottled as throttledRef,
   throttle,
   templateRef,
-  tap,
   tab,
   syncRefs,
   syncRef,
@@ -16598,7 +17264,7 @@ export {
   createHead3 as createHead,
   createGlobalState,
   createGenericProjection,
-  createFetch,
+  createFetch2 as createFetch,
   createEventHook,
   createControlledPromise,
   controlledRef,
@@ -16625,11 +17291,11 @@ export {
   breakpointsMasterCss,
   breakpointsBootstrapV5,
   breakpointsAntDesign,
-  batchInvoke,
   refAutoReset as autoResetRef,
   computedAsync as asyncComputed,
   anyOf,
   logicAnd as and,
   HeadVuePlugin,
-  Head
+  Head,
+  Fetch
 };

package/dist/useFetch.d.ts

@@ -0,0 +1,19 @@
+import type { Ref } from 'vue';
+
+declare interface Params {
+  [key: string]: any
+}
+declare type FetchResponse = string | Blob | ArrayBuffer | ReadableStream<Uint8Array>
+
+interface UseFetchReturn {
+  get: (url: string, params?: Params, headers?: Headers) => Promise<FetchResponse>
+  post: (url: string, params?: Params, headers?: Headers) => Promise<FetchResponse>
+  patch: (url: string, params?: Params, headers?: Headers) => Promise<FetchResponse>
+  put: (url: string, params?: Params, headers?: Headers) => Promise<FetchResponse>
+  destroy: (url: string, params?: Params, headers?: Headers) => Promise<FetchResponse>
+  setToken: (authToken: string) => void
+  loading: Ref<boolean>
+  token: Ref<string>
+  baseURL: Ref<string>
+}
+export declare function useFetch(): UseFetchReturn;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/browser",
   "type": "module",
-  "version": "0.70.21",
+  "version": "0.70.23",
   "description": "Stacks core frontend/browser functionalities.",
   "author": "Chris Breuer",
   "contributors": ["Chris Breuer <chris@stacksjs.org>"],
@@ -34,7 +34,7 @@
     "prepublishOnly": "bun run build"
   },
   "devDependencies": {
-    "@stacksjs/development": "0.70.18",
-    "@stacksjs/utils": "0.70.18"
+    "@stacksjs/development": "0.70.22",
+    "@stacksjs/utils": "0.70.22"
   }
 }