fatcher/dist/index.js

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

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;
    }
    await 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 = {
  headers: {
    "Content-Type": "application/x-www-form-urlencoded"
  },
  credentials: "same-origin",
  cache: "default",
  redirect: "follow",
  referrerPolicy: "no-referrer-when-downgrade",
  mode: "cors"
};

function normalizeURL(baseURL, url) {
  let _url = `${baseURL}/${url}`;
  let schema = "";
  const [a, b] = _url.matchAll(/([a-z][a-z\d+\-.]*:)\/\//gi);
  if (b) {
    return url;
  }
  if (a) {
    schema = a[0];
    _url = _url.replace(schema, "");
  }
  const paths = [];
  for (const path of _url.split("/")) {
    if (path === "..") {
      paths.pop();
    } else if (path && path !== ".") {
      paths.push(path);
    }
  }
  return `${schema || "/"}${paths.join("/")}`;
}
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-fetch",
    async use(context) {
      let { url = "", requestHeaders: headers, payload, method = "GET", body, params, ...rest } = context;
      const contentType = headers.get("content-type");
      if (["GET", "HEAD"].includes(method)) {
        params = Object.assign({}, params, body);
        body = null;
      } else if (payload && contentType) {
        if (contentType.includes("application/json")) {
          body = JSON.stringify(payload);
        }
        if (contentType.includes("application/x-www-form-urlencoded")) {
          body = new URLSearchParams(payload);
        }
      }
      if (Object.keys(params).length) {
        url = `${url}?${new URLSearchParams(params)}`;
      }
      const response = await fetch(url, {
        ...rest,
        headers,
        body,
        method
      });
      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 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, 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);
  };
}

exports.FatcherError = FatcherError;
exports.canActivate = canActivate;
exports.chunkStreamReader = chunkStreamReader;
exports.createScopedRequest = createScopedRequest;
exports.fatcher = fatcher;
exports.isAbortError = isAbortError;
exports.isFatcherError = isFatcherError;
exports.mergeOptions = mergeOptions;
exports.readStreamByChunk = readStreamByChunk;
exports.setDefaultOptions = setDefaultOptions;