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 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 parseURL(baseURL, url) {
  let [_url, querystring] = `${baseURL || "/"}/${url || "/"}`.split("?");
  const [schema, isAbsoluteURL] = _url.match(/([a-z][a-z\d+\-.]*:)\/\//gi) || [];
  if (isAbsoluteURL) {
    return url;
  }
  if (schema) {
    if (!_url.startsWith(schema)) {
      return url;
    }
    _url = _url.replace(schema, "");
  }
  const paths = [];
  for (const path of _url.split("/")) {
    if (path === "..") {
      paths.pop();
    } else if (path && path !== ".") {
      paths.push(path);
    }
  }
  _url = `${schema || "/"}${paths.join("/")}`;
  if (querystring) {
    return `${_url}?${querystring}`;
  }
  return _url;
}

function createContext(options) {
  const { baseUrl = "", url = "", params = {}, headers = {} } = options;
  if (!url) {
    throw new Error("[Fatcher] URL is required.");
  }
  const [normalizedURL, querystring] = parseURL(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,
        validateCode,
        ...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 (validateCode ? validateCode(status) : ok) {
        return result;
      }
      return Promise.reject(new FatcherError(context, response));
    }
  };
}

async function registerMiddlewares(unregisteredMiddlewares) {
  var _a;
  let middlewares = [];
  for await (const middleware of unregisteredMiddlewares) {
    if (Array.isArray(middleware)) {
      middlewares = middlewares.concat(await registerMiddlewares(middleware));
    } else {
      let current = [isFunction(middleware) ? await middleware() : middleware];
      if ((_a = current[0].presets) == null ? void 0 : _a.length) {
        current = (await registerMiddlewares(current[0].presets)).concat(current);
      }
      middlewares = middlewares.concat(current);
    }
  }
  return middlewares;
}

async function fatcher(inlineOptions = {}) {
  const options = mergeOptions(defaultOptions, inlineOptions);
  const { middlewares: customMiddlewares = [], ...rest } = options;
  const registeredMiddlewares = await 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;