fatcher/dist/index.esm.js

function canActivate(data) {
  return data instanceof Response && !data.bodyUsed && !!data.body;
}

function isAbortError(error) {
  return error instanceof DOMException && error.name === "AbortError";
}

async function readStreamByChunk(readableStream, callback) {
  async function read(reader) {
    const { value, done } = await reader.read();
    if (done || !value) {
      return;
    }
    callback(value);
    await read(reader);
  }
  return read(readableStream.getReader());
}
const chunkStreamReader = readStreamByChunk;

class FatcherError extends Error {
  constructor(context, response) {
    super(`[Fatcher] Fetch failed with status code ${response.status}`);
    this.name = "FatcherError";
    this.__isFatcherError__ = true;
    this._response = response;
    this._context = context;
  }
  toJSON() {
    const headers = {};
    for (const [key, value] of this._response.headers) {
      headers[key] = value;
    }
    return {
      status: this._response.status,
      statusText: this._response.statusText,
      context: this._context,
      headers,
      data: this._response.body
    };
  }
}

function isFatcherError(error) {
  return error instanceof FatcherError && error.name === "FatcherError" && error.__isFatcherError__;
}

const defaultOptions = {
  baseUrl: "/",
  middlewares: [],
  headers: {
    "Content-Type": "application/x-www-form-urlencoded"
  },
  params: {},
  credentials: "same-origin",
  cache: "default",
  redirect: "follow",
  referrerPolicy: "no-referrer-when-downgrade",
  mode: "cors"
};

function isAbsoluteURL(url) {
  return /^http(s)?:\/\/.+/.test(url);
}
function normalize(url) {
  let protocol;
  return url.replace(/http(s?):\/\//, (str) => {
    protocol = str;
    return "";
  }).replace(/\/\/(\/)?/g, "/").replace(/.*\S/, (str) => (protocol != null ? protocol : "") + str);
}
function normalizeURL(baseURL, url) {
  if (!url) {
    return baseURL;
  }
  if (isAbsoluteURL(url)) {
    return normalize(url);
  }
  if (baseURL === "/") {
    return url;
  }
  return normalize(`${baseURL}/${url}`);
}
function isFunction(value) {
  return typeof value === "function";
}
function immutable(record) {
  return new Proxy(record, {
    set() {
      return true;
    }
  });
}
function merge(initial, patches, customMerge) {
  return patches.reduce((merged, patch) => Object.assign(merged, customMerge(merged, patch)), Object.assign(/* @__PURE__ */ Object.create(null), initial));
}

function mergeOptions(options, ...patchOptions) {
  return merge(options, patchOptions, (merged, current) => {
    const { headers } = current;
    if (headers) {
      current.headers = Object.assign({}, merged.headers || {}, headers);
    }
    return current;
  });
}

function setDefaultOptions(patchRequestOptions) {
  Object.assign(defaultOptions, mergeOptions(defaultOptions, patchRequestOptions));
}

function createContext(options) {
  const { baseUrl = "", url = "", params = {}, headers = {} } = options;
  if (!url) {
    throw new Error("[Fatcher] URL is required.");
  }
  const [normalizedURL, querystring] = normalizeURL(baseUrl, url).split("?");
  if (querystring) {
    for (const [key, value] of new URLSearchParams(querystring)) {
      params[key] = value;
    }
  }
  const requestHeaders = new Headers();
  for (const [key, value] of Object.entries(headers)) {
    if (value) {
      requestHeaders.set(key, value);
    }
  }
  return { ...options, url: normalizedURL, params, requestHeaders };
}

function mergeContext(context, ...patchContext) {
  return merge(context, patchContext, (merged, current) => {
    const { headers } = current;
    if (headers) {
      current.headers = Object.assign(merged.headers || {}, headers);
      for (const [key, value] of Object.entries(headers)) {
        if (value) {
          context.requestHeaders.set(key, value);
        }
      }
    }
    return current;
  });
}

function composeMiddlewares(middlewares) {
  return function use(initialContext) {
    let currentIndex = -1;
    let response;
    let context = initialContext;
    let immutableContext = immutable(context);
    async function dispatch(index, patchContext) {
      if (index <= currentIndex) {
        return Promise.reject(new Error(`Middleware <${middlewares[index - 1].name}> call next() more than once.`));
      }
      currentIndex = index;
      const middleware = middlewares[index];
      if (!middleware) {
        return response;
      }
      if (patchContext) {
        context = mergeContext(context, patchContext);
        immutableContext = immutable(context);
      }
      try {
        return response = await middleware.use(immutableContext, async (patch) => dispatch(index + 1, patch));
      } catch (error) {
        return Promise.reject(error);
      }
    }
    return dispatch(0);
  };
}

function fetcher() {
  return {
    name: "fatcher-middleware-http-fetcher",
    async use(context) {
      const { url = "", requestHeaders: headers, ...rest } = context;
      const response = await fetch(url, {
        ...rest,
        headers
      });
      const { status, statusText, ok, headers: responseHeaders } = response;
      const result = {
        status,
        statusText,
        headers: responseHeaders,
        url,
        data: response
      };
      if (ok) {
        return result;
      }
      return Promise.reject(new FatcherError(context, response));
    }
  };
}

function payloadConsumer() {
  return {
    name: "fatcher-middleware-payload-consumer",
    use(context, next) {
      const { payload, url, requestHeaders, method, body, params = {} } = context;
      const contentType = requestHeaders.get("content-type");
      let normalizeUrl = url;
      if (["GET", "HEAD"].includes(method)) {
        if (Object.keys(params).length) {
          normalizeUrl = `${url}?${new URLSearchParams(Object.assign({}, params, body)).toString()}`;
        }
        return next({
          url: normalizeUrl,
          body: null
        });
      }
      let normalizedBody = body;
      if (payload) {
        if (contentType == null ? void 0 : contentType.includes("application/json")) {
          normalizedBody = JSON.stringify(payload);
        }
        if (contentType == null ? void 0 : contentType.includes("application/x-www-form-urlencoded")) {
          normalizedBody = new URLSearchParams(payload);
        }
      }
      if (Object.keys(params).length) {
        normalizeUrl = `${url}?${new URLSearchParams(params).toString()}`;
      }
      return next({
        url: normalizeUrl,
        body: normalizedBody
      });
    }
  };
}

function registerMiddlewares(unregisteredMiddlewares) {
  return unregisteredMiddlewares.reduce((total, current) => {
    var _a;
    let middleware;
    if (Array.isArray(current)) {
      middleware = registerMiddlewares(current);
    } else {
      middleware = [isFunction(current) ? current() : current];
      if ((_a = middleware[0].presets) == null ? void 0 : _a.length) {
        middleware = registerMiddlewares(middleware[0].presets).concat(middleware);
      }
    }
    return total.concat(middleware);
  }, []);
}

async function fatcher(inlineOptions = {}) {
  const options = mergeOptions(defaultOptions, inlineOptions);
  const { middlewares: customMiddlewares = [], ...rest } = options;
  const registeredMiddlewares = registerMiddlewares([...customMiddlewares, payloadConsumer, fetcher]);
  const useMiddlewares = composeMiddlewares(registeredMiddlewares);
  const initialContext = createContext(rest);
  const result = await useMiddlewares(initialContext);
  const data = canActivate(result.data) ? result.data.body : result.data;
  return {
    ...result,
    options,
    data
  };
}

function createScopedRequest(scopedOptions = {}) {
  return function request(url, payload, inlineOptions = {}) {
    const options = mergeOptions(scopedOptions, { ...inlineOptions, url, payload });
    return fatcher(options);
  };
}

export { FatcherError, canActivate, chunkStreamReader, createScopedRequest, fatcher, isAbortError, isFatcherError, mergeOptions, readStreamByChunk, setDefaultOptions };