1000fetches 0.2.0 → 0.2.2

package/dist/index.es.js

@@ -1,787 +0,0 @@
-class HttpError extends Error {
-  name = "HttpError";
-  status;
-  statusText;
-  data;
-  response;
-  url;
-  method;
-  cause;
-  constructor(message, status, statusText, data, response, url, method, cause) {
-    const statusCategory = status >= 500 ? "Server Error" : status >= 400 ? "Client Error" : status >= 300 ? "Redirect" : "Success";
-    const dataString = data ? JSON.stringify(data) : "No response data";
-    const truncatedData = dataString.length > 500 ? dataString.substring(0, 500) + "..." : dataString;
-    const enhancedMessage = `HTTP ${statusCategory} (${status}): ${message}
-Request: ${method} ${url}
-Data: ${truncatedData}`;
-    super(enhancedMessage, { cause });
-    this.status = status;
-    this.statusText = statusText;
-    this.data = data;
-    this.response = response;
-    this.url = url;
-    this.method = method;
-  }
-}
-class NetworkError extends Error {
-  name = "NetworkError";
-  cause;
-  constructor(message, cause) {
-    super(message, { cause });
-  }
-}
-class SchemaValidationError extends Error {
-  name = "SchemaValidationError";
-  schema;
-  data;
-  cause;
-  constructor(message, schema, data, cause) {
-    super(message, { cause });
-    this.schema = schema;
-    this.data = data;
-  }
-}
-class TimeoutError extends Error {
-  name = "TimeoutError";
-  cause;
-  constructor(message, cause) {
-    super(message, { cause });
-  }
-}
-class PathParameterError extends Error {
-  name = "PathParameterError";
-  url;
-  requiredParams;
-  providedParams;
-  cause;
-  constructor(message, url, requiredParams, providedParams, cause) {
-    const enhancedMessage = `${message}
-URL Template: ${url}
-Expected: [${requiredParams.map((p) => `"${p}"`).join(", ")}], Actual: [${providedParams.map((p) => `"${p}"`).join(", ")}]`;
-    super(enhancedMessage, { cause });
-    this.url = url;
-    this.requiredParams = requiredParams;
-    this.providedParams = providedParams;
-  }
-}
-class MiddlewareError extends Error {
-  name = "MiddlewareError";
-  type;
-  url;
-  method;
-  cause;
-  constructor(message, type, url, method, cause) {
-    const requestInfo = url ? `Request: ${method || "UNKNOWN"} ${url}` : "";
-    const enhancedMessage = requestInfo ? `${message}
-${requestInfo}` : message;
-    super(enhancedMessage, { cause });
-    this.type = type;
-    this.url = url;
-    this.method = method;
-  }
-}
-class SerializationError extends Error {
-  name = "SerializationError";
-  cause;
-  constructor(message, cause) {
-    super(message, { cause });
-  }
-}
-class InvalidSchemaError extends Error {
-  name = "InvalidSchemaError";
-  schema;
-  cause;
-  constructor(message, schema, cause) {
-    super(message, { cause });
-    this.schema = schema;
-  }
-}
-class AsyncSchemaValidationError extends Error {
-  name = "AsyncSchemaValidationError";
-  schema;
-  cause;
-  constructor(message, schema, cause) {
-    super(message, { cause });
-    this.schema = schema;
-  }
-}
-class InvalidBaseUrlError extends Error {
-  name = "InvalidBaseUrlError";
-  baseUrl;
-  cause;
-  constructor(message, baseUrl, cause) {
-    const enhancedMessage = `${message}
-Base URL: ${baseUrl}`;
-    super(enhancedMessage, { cause });
-    this.baseUrl = baseUrl;
-  }
-}
-function generatePath(path, params = {}) {
-  return path.replace(/:([^/\s?#]+)\??/g, (_match, paramName) => {
-    if (!/^[a-zA-Z0-9_]+$/.test(paramName)) {
-      throw new PathParameterError(
-        `Invalid path parameter name: "${paramName}"`,
-        path,
-        [paramName],
-        Object.keys(params)
-      );
-    }
-    const paramValue = params[paramName];
-    if (paramValue === void 0) {
-      throw new PathParameterError(
-        `Missing required path parameter: "${paramName}"`,
-        path,
-        [paramName],
-        Object.keys(params)
-      );
-    }
-    const stringValue = String(paramValue);
-    if (stringValue.includes("/") || stringValue.includes("?")) {
-      throw new PathParameterError(
-        `Invalid path parameter value for "${paramName}": contains invalid characters`,
-        path,
-        [paramName],
-        Object.keys(params)
-      );
-    }
-    return stringValue;
-  });
-}
-function createStreamingStream(reader, onChunk, totalBytes, signal) {
-  let transferredBytes = 0;
-  let readerReleased = false;
-  let isAborted = false;
-  const releaseReader = () => {
-    if (!readerReleased) {
-      readerReleased = true;
-      try {
-        reader.releaseLock();
-      } catch {
-      }
-    }
-  };
-  const abortHandler = () => {
-    isAborted = true;
-    releaseReader();
-  };
-  signal?.addEventListener("abort", abortHandler);
-  return new ReadableStream({
-    async start(controller) {
-      try {
-        while (!isAborted) {
-          const { done, value } = await reader.read();
-          if (done) break;
-          transferredBytes += value.length;
-          onChunk(value, totalBytes, transferredBytes);
-          controller.enqueue(value);
-        }
-        if (!isAborted) {
-          controller.close();
-        }
-      } catch (error) {
-        if (!isAborted) {
-          controller.error(error);
-        }
-        throw error;
-      } finally {
-        signal?.removeEventListener("abort", abortHandler);
-        releaseReader();
-      }
-    },
-    cancel() {
-      isAborted = true;
-      signal?.removeEventListener("abort", abortHandler);
-      releaseReader();
-    }
-  });
-}
-async function toStreamableRequest(request, onUploadStreaming) {
-  if (!onUploadStreaming || !request.body) {
-    return request;
-  }
-  if (!request.body.getReader) {
-    return request;
-  }
-  const reader = request.body.getReader();
-  const totalBytes = request.headers.get("content-length") ? parseInt(request.headers.get("content-length") || "0", 10) : void 0;
-  const stream = createStreamingStream(
-    reader,
-    (chunk, totalBytes2, transferredBytes) => {
-      onUploadStreaming({
-        chunk,
-        totalBytes: totalBytes2,
-        transferredBytes
-      });
-    },
-    totalBytes,
-    request.signal
-  );
-  return new Request(request.url, {
-    method: request.method,
-    headers: request.headers,
-    body: stream,
-    signal: request.signal,
-    credentials: request.credentials,
-    cache: request.cache,
-    mode: request.mode,
-    redirect: request.redirect,
-    referrer: request.referrer,
-    referrerPolicy: request.referrerPolicy,
-    integrity: request.integrity,
-    keepalive: request.keepalive,
-    duplex: "half"
-  });
-}
-async function toStreamableResponse(response, onDownloadStreaming) {
-  if (!onDownloadStreaming || !response.body) {
-    return response;
-  }
-  if (!response.body.getReader) {
-    return response;
-  }
-  const reader = response.body.getReader();
-  const totalBytes = response.headers.get("content-length") ? parseInt(response.headers.get("content-length") || "0", 10) : void 0;
-  const stream = createStreamingStream(
-    reader,
-    (chunk, totalBytes2, transferredBytes) => {
-      onDownloadStreaming({
-        chunk,
-        totalBytes: totalBytes2,
-        transferredBytes
-      });
-    },
-    totalBytes
-  );
-  return new Response(stream, {
-    status: response.status,
-    statusText: response.statusText,
-    headers: response.headers
-  });
-}
-const DEFAULT_RETRY_OPTIONS = {
-  maxRetries: 3,
-  retryDelay: 300,
-  backoffFactor: 2,
-  retryStatusCodes: [429, 500, 502, 503, 504],
-  retryNetworkErrors: true,
-  maxRetryDelay: 3e4,
-  shouldRetry: () => true
-};
-function createHttpRequest(config = {}) {
-  const {
-    baseUrl = "",
-    headers: defaultHeaders = {},
-    timeout: defaultTimeout = 3e4,
-    fetch: customFetch = fetch,
-    serializeBody: customSerializeBody,
-    serializeParams: customSerializeParams,
-    onRequestMiddleware,
-    onResponseMiddleware
-  } = config;
-  return async function fetcher(url, options = {}) {
-    const {
-      method = "GET",
-      headers = {},
-      params,
-      pathParams,
-      body,
-      timeout = defaultTimeout,
-      signal,
-      credentials,
-      cache,
-      mode,
-      redirect,
-      onUploadStreaming,
-      onDownloadStreaming,
-      responseType,
-      retryOptions: requestRetryOptions
-    } = options;
-    let urlObj;
-    let resolvedUrl = generatePath(url, pathParams);
-    if (baseUrl || params) {
-      if (baseUrl) {
-        resolvedUrl = constructUrl(baseUrl, resolvedUrl);
-        urlObj = new URL(resolvedUrl);
-      } else {
-        urlObj = new URL(resolvedUrl);
-      }
-    }
-    const baseRequestContext = {
-      url: resolvedUrl,
-      method,
-      params,
-      headers: new Headers({ ...defaultHeaders, ...headers }),
-      body,
-      signal,
-      fetchOptions: { credentials, cache, mode, redirect }
-    };
-    let requestContext = baseRequestContext;
-    if (onRequestMiddleware) {
-      try {
-        const contextCopy = {
-          ...baseRequestContext,
-          headers: new Headers(baseRequestContext.headers),
-          fetchOptions: { ...baseRequestContext.fetchOptions }
-        };
-        requestContext = await onRequestMiddleware(contextCopy);
-        if (requestContext.url !== resolvedUrl) {
-          urlObj = new URL(requestContext.url);
-        }
-      } catch (error) {
-        throw new MiddlewareError(
-          createErrorMessage("Request middleware failed", error),
-          "request",
-          requestContext.url,
-          requestContext.method,
-          createStandardizedError(error, "Request middleware")
-        );
-      }
-    }
-    if (requestContext.params) {
-      if (!urlObj) {
-        urlObj = new URL(requestContext.url);
-      }
-      const serializedParams = customSerializeParams ? customSerializeParams(requestContext.params) : serializeQueryParams(requestContext.params);
-      if (serializedParams) {
-        if (customSerializeParams) {
-          const queryString = serializedParams.startsWith("?") ? serializedParams.slice(1) : serializedParams;
-          const separator = urlObj.search ? "&" : "?";
-          urlObj.search += separator + queryString;
-        } else {
-          const newSearchParams = new URLSearchParams(serializedParams);
-          for (const [key, value] of newSearchParams) {
-            urlObj.searchParams.append(key, value);
-          }
-        }
-        requestContext.url = urlObj.toString();
-      }
-    }
-    const requestInit = {
-      method: requestContext.method,
-      headers: requestContext.headers,
-      ...requestContext.fetchOptions
-    };
-    if (requestContext.body !== void 0 && (requestContext.method === "POST" || requestContext.method === "PUT" || requestContext.method === "PATCH")) {
-      let body2;
-      let contentType;
-      if (customSerializeBody) {
-        const serializedBody = customSerializeBody(requestContext.body);
-        if (serializedBody == null) {
-          body2 = "";
-        } else {
-          body2 = serializedBody;
-          if (isObjectLike(requestContext.body) && typeof serializedBody === "string" && !requestContext.headers.has("content-type")) {
-            contentType = "application/json";
-          }
-        }
-      } else {
-        const serialized = serializeRequestBody(requestContext.body);
-        body2 = serialized.body;
-        contentType = serialized.contentType;
-      }
-      requestInit.body = body2;
-      if (contentType) {
-        requestContext.headers.set("content-type", contentType);
-      }
-      requestInit.duplex = "half";
-    }
-    const mergedRetryOptions = {
-      ...DEFAULT_RETRY_OPTIONS,
-      ...config.retryOptions,
-      ...requestRetryOptions
-    };
-    const maxRetries = mergedRetryOptions.maxRetries;
-    let lastError;
-    for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), timeout);
-      const finalSignal = createCombinedSignal(
-        requestContext.signal,
-        controller.signal,
-        () => clearTimeout(timeoutId)
-      );
-      try {
-        const request = new Request(requestContext.url, requestInit);
-        const trackedRequest = onUploadStreaming ? await toStreamableRequest(request, onUploadStreaming) : request;
-        const response = await customFetch(trackedRequest.url, {
-          method: trackedRequest.method,
-          headers: trackedRequest.headers,
-          body: trackedRequest.body,
-          signal: finalSignal,
-          ...requestContext.fetchOptions,
-          ...trackedRequest.body && { duplex: "half" }
-        });
-        const trackedResponse = onDownloadStreaming ? await toStreamableResponse(response, onDownloadStreaming) : response;
-        const responseData = await processResponse(trackedResponse, {
-          responseType,
-          method,
-          url: requestContext.url
-        });
-        if (onResponseMiddleware) {
-          try {
-            const middlewareResult = await onResponseMiddleware(responseData);
-            if (!middlewareResult || typeof middlewareResult !== "object" || !("data" in middlewareResult)) {
-              throw new MiddlewareError(
-                "Response middleware must return a valid ResponseType object",
-                "response",
-                requestContext.url,
-                method
-              );
-            }
-            return middlewareResult;
-          } catch (error) {
-            throw new MiddlewareError(
-              createErrorMessage("Response middleware failed", error),
-              "response",
-              requestContext.url,
-              method,
-              createStandardizedError(error, "Response middleware")
-            );
-          }
-        }
-        return responseData;
-      } catch (error) {
-        clearTimeout(timeoutId);
-        lastError = createStandardizedError(error, "Request execution");
-        if (lastError.name === "AbortError") {
-          lastError = new TimeoutError(
-            `Request timeout after ${timeout}ms`,
-            lastError
-          );
-        }
-        if (attempt >= maxRetries || !await shouldRetry(lastError, attempt, mergedRetryOptions)) {
-          throw lastError;
-        }
-        const delay = calculateRetryDelay(attempt, mergedRetryOptions);
-        await sleep(delay);
-      }
-    }
-    throw new Error("Retry loop terminated unexpectedly");
-  };
-}
-async function processResponse(response, options) {
-  const headers = Object.fromEntries(response.headers.entries());
-  let data;
-  try {
-    const requestedType = options.responseType;
-    const contentType = response.headers.get("content-type") ?? "";
-    const detectedType = contentType.includes("application/json") ? "json" : contentType.includes("text/") ? "text" : contentType.includes("application/octet-stream") || contentType.includes("application/pdf") || contentType.includes("image/") || contentType.includes("video/") || contentType.includes("audio/") ? "arrayBuffer" : contentType.includes("multipart/form-data") || contentType.includes("application/x-www-form-urlencoded") ? "formData" : void 0;
-    const finalType = requestedType ?? detectedType;
-    if (finalType === "json") {
-      data = await response.json();
-    } else if (finalType === "text") {
-      data = await response.text();
-    } else if (finalType === "blob") {
-      data = await response.blob();
-    } else if (finalType === "arrayBuffer") {
-      data = await response.arrayBuffer();
-    } else if (finalType === "formData") {
-      data = await response.formData();
-    } else {
-      const responseClone = response.clone();
-      try {
-        data = await response.json();
-      } catch {
-        data = await responseClone.text();
-      }
-    }
-  } catch (error) {
-    throw new SerializationError(
-      createErrorMessage("Failed to parse response body", error),
-      error instanceof Error ? error : void 0
-    );
-  }
-  if (!response.ok) {
-    throw new HttpError(
-      `HTTP ${response.status} ${response.statusText}`,
-      response.status,
-      response.statusText,
-      data,
-      response,
-      options.url,
-      options.method
-    );
-  }
-  return {
-    data,
-    status: response.status,
-    statusText: response.statusText,
-    headers,
-    method: options.method,
-    url: options.url,
-    raw: response
-  };
-}
-async function shouldRetry(error, retryCount, retryOptions) {
-  if (!retryOptions) return false;
-  if (retryOptions.shouldRetry) {
-    return await retryOptions.shouldRetry(error, retryCount);
-  }
-  if (error instanceof HttpError) {
-    return retryOptions.retryStatusCodes?.includes(error.status) ?? false;
-  }
-  if (error instanceof NetworkError || error.name === "TypeError") {
-    return retryOptions.retryNetworkErrors ?? false;
-  }
-  return false;
-}
-function calculateRetryDelay(attempt, retryOptions) {
-  if (!retryOptions) return 0;
-  const baseDelay = retryOptions.retryDelay ?? 300;
-  const backoffFactor = retryOptions.backoffFactor ?? 2;
-  const maxDelay = retryOptions.maxRetryDelay ?? 3e4;
-  const delay = baseDelay * Math.pow(backoffFactor, attempt);
-  return Math.min(delay, maxDelay);
-}
-function isObjectLike(value) {
-  return value !== null && typeof value === "object" && value.constructor?.name === "Object" || Array.isArray(value) || value !== null && typeof value === "object" && "toJSON" in value && typeof value.toJSON === "function";
-}
-function serializeQueryParams(params) {
-  const searchParams = new URLSearchParams();
-  for (const [key, value] of Object.entries(params)) {
-    if (Array.isArray(value)) {
-      for (const item of value) {
-        if (item !== void 0 && item !== null) {
-          searchParams.append(key, String(item));
-        }
-      }
-    } else if (value !== void 0 && value !== null) {
-      searchParams.append(key, String(value));
-    }
-  }
-  return searchParams.toString();
-}
-function serializeRequestBody(body) {
-  if (typeof body === "string" || body instanceof FormData || body instanceof URLSearchParams || body instanceof ArrayBuffer || body instanceof Blob || body instanceof ReadableStream) {
-    return { body };
-  }
-  if (isObjectLike(body)) {
-    return {
-      body: JSON.stringify(body),
-      contentType: "application/json"
-    };
-  }
-  if (body === null || body === void 0) {
-    return { body: "" };
-  }
-  return { body: String(body) };
-}
-function createErrorMessage(context, error) {
-  return `${context}: ${error instanceof Error ? error.message : String(error)}`;
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function createCombinedSignal(requestSignal, timeoutSignal, cleanup) {
-  if (!requestSignal && !timeoutSignal) {
-    return new AbortController().signal;
-  }
-  if (requestSignal?.aborted) {
-    return requestSignal;
-  }
-  const combinedController = new AbortController();
-  const handleAbort = () => {
-    cleanup?.();
-    combinedController.abort();
-  };
-  requestSignal?.addEventListener("abort", handleAbort);
-  timeoutSignal?.addEventListener("abort", handleAbort);
-  return combinedController.signal;
-}
-function createStandardizedError(error, context) {
-  if (error instanceof Error) {
-    return error;
-  }
-  return new Error(`${context}: ${String(error)}`);
-}
-function constructUrl(baseUrl, requestUrl) {
-  if (requestUrl.startsWith("http://") || requestUrl.startsWith("https://")) {
-    return requestUrl;
-  }
-  const baseUrlObj = new URL(baseUrl);
-  const basePath = baseUrlObj.pathname.replace(/\/$/, "");
-  const [path, query] = requestUrl.split("?");
-  if (requestUrl.startsWith("/")) {
-    baseUrlObj.pathname = basePath + path;
-  } else if (requestUrl) {
-    baseUrlObj.pathname = basePath + "/" + path;
-  }
-  if (query) {
-    baseUrlObj.search = baseUrlObj.search ? `${baseUrlObj.search}&${query}` : `?${query}`;
-  }
-  return baseUrlObj.toString();
-}
-function isStandardSchema(obj) {
-  return obj !== null && (typeof obj === "object" || typeof obj === "function") && "~standard" in obj && typeof obj["~standard"] === "object" && obj["~standard"] !== null && "validate" in obj["~standard"] && typeof obj["~standard"].validate === "function" && "version" in obj["~standard"] && typeof obj["~standard"].version === "number" && "vendor" in obj["~standard"] && typeof obj["~standard"].vendor === "string";
-}
-function createSchemaValidator() {
-  return {
-    validate(schema, data) {
-      if (!isStandardSchema(schema)) {
-        throw new InvalidSchemaError(
-          "Schema must implement the Standard Schema interface",
-          schema
-        );
-      }
-      const result = schema["~standard"].validate(data);
-      if (result instanceof Promise) {
-        throw new AsyncSchemaValidationError(
-          "Async Standard Schema validation is not supported in this context",
-          schema
-        );
-      }
-      if (result.issues) {
-        throw new SchemaValidationError(
-          JSON.stringify(result.issues),
-          schema,
-          data
-        );
-      }
-      return result.value;
-    },
-    isSchema(obj) {
-      return isStandardSchema(obj);
-    }
-  };
-}
-function validateAndNormalizeBaseUrl(baseUrl) {
-  const hasLocation = typeof window !== "undefined" && typeof window.location !== "undefined" && window.location.origin !== "null";
-  if (!baseUrl) {
-    return hasLocation ? window.location.origin : "";
-  }
-  if (baseUrl.startsWith("/")) {
-    return hasLocation ? new URL(baseUrl, window.location.origin).href.replace(/\/$/, "") : baseUrl.replace(/\/$/, "");
-  }
-  try {
-    new URL(baseUrl);
-  } catch {
-    throw new InvalidBaseUrlError(
-      `Invalid baseUrl: "${baseUrl}". Must be a valid absolute URL or relative path starting with "/".`,
-      baseUrl
-    );
-  }
-  return baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
-}
-function createExtractableResponse(promise) {
-  const extractable = promise;
-  extractable.data = async () => (await promise).data;
-  return extractable;
-}
-function createSchemaableResponse(url, options, requestHandler, schemaValidator) {
-  const basePromise = requestHandler(
-    url,
-    options
-  );
-  return Object.assign(basePromise, {
-    schema(schema) {
-      const validatedPromise = basePromise.then((response) => {
-        try {
-          const validatedData = schemaValidator.validate(
-            schema,
-            response.data
-          );
-          return {
-            ...response,
-            data: validatedData
-          };
-        } catch (error) {
-          throw new SchemaValidationError(
-            `Schema validation failed: ${error instanceof Error ? error.message : String(error)}`,
-            schema,
-            response.data,
-            error instanceof Error ? error : void 0
-          );
-        }
-      });
-      return createExtractableResponse(validatedPromise);
-    },
-    async data() {
-      return (await basePromise).data;
-    }
-  });
-}
-function createHttpClient(config = {}) {
-  const validatedConfig = {
-    ...config,
-    baseUrl: validateAndNormalizeBaseUrl(config.baseUrl)
-  };
-  const requestHandler = createHttpRequest(validatedConfig);
-  const schemaValidator = config.schemaValidator ?? createSchemaValidator();
-  function get(url, ...args) {
-    return createSchemaableResponse(
-      url,
-      {
-        ...args[0] ?? {},
-        method: "GET"
-      },
-      requestHandler,
-      schemaValidator
-    );
-  }
-  return {
-    get,
-    post: (url, body, ...args) => createSchemaableResponse(
-      url,
-      {
-        ...args[0] ?? {},
-        method: "POST",
-        body
-      },
-      requestHandler,
-      schemaValidator
-    ),
-    put: (url, body, ...args) => createSchemaableResponse(
-      url,
-      {
-        ...args[0] ?? {},
-        method: "PUT",
-        body
-      },
-      requestHandler,
-      schemaValidator
-    ),
-    patch: (url, body, ...args) => createSchemaableResponse(
-      url,
-      {
-        ...args[0] ?? {},
-        method: "PATCH",
-        body
-      },
-      requestHandler,
-      schemaValidator
-    ),
-    delete: (url, ...args) => createSchemaableResponse(
-      url,
-      {
-        ...args[0] ?? {},
-        method: "DELETE"
-      },
-      requestHandler,
-      schemaValidator
-    ),
-    /**
-     * Generic request method for custom HTTP methods and full control
-     */
-    request: (url, options) => createSchemaableResponse(
-      url,
-      options ?? {},
-      requestHandler,
-      schemaValidator
-    )
-  };
-}
-const http = createHttpClient();
-export {
-  AsyncSchemaValidationError,
-  HttpError,
-  MiddlewareError,
-  NetworkError,
-  PathParameterError,
-  SchemaValidationError,
-  SerializationError,
-  TimeoutError,
-  createHttpClient,
-  http as default,
-  http
-};
-//# sourceMappingURL=index.es.js.map