@gcmdev/faxios 0.1.0 → 0.2.1

package/src/lib/defaults/index.ts

@@ -0,0 +1,221 @@
+"use strict";
+
+import FaxiosError from "../core/FaxiosError.js";
+import formDataToJSON from "../helpers/formDataToJSON.js";
+import toFormData from "../helpers/toFormData.js";
+import toURLEncodedForm from "../helpers/toURLEncodedForm.js";
+import platform from "../platform.js";
+import type {
+  FaxiosDefaults,
+  FaxiosRequestHeaders,
+  FaxiosResponse,
+  GenericFormData,
+  InternalFaxiosRequestConfig
+} from "../types.js";
+import utils from "../utils.js";
+import transitionalDefaults from "./transitional.js";
+
+/**
+ * It takes a string, tries to parse it, and if it fails, it returns the stringified version
+ * of the input
+ *
+ * @param {any} rawValue - The value to be stringified.
+ * @param {Function} parser - A function that parses a string into a JavaScript object.
+ * @param {Function} encoder - A function that takes a value and returns a string.
+ *
+ * @returns {string} A stringified version of the rawValue.
+ */
+function serializeObjectPayload(
+  data: unknown,
+  contentType: string,
+  formSerializer: Record<string, unknown> | undefined,
+  FormDataCtor: (new () => object) | null | undefined
+): unknown {
+  if (contentType.indexOf("application/x-www-form-urlencoded") > -1) {
+    return toURLEncodedForm(data, formSerializer).toString();
+  }
+  const isFileList = utils.isFileList(data);
+  if (isFileList || contentType.indexOf("multipart/form-data") > -1) {
+    const _FormData = FormDataCtor;
+    return toFormData(
+      isFileList ? { "files[]": data } : data,
+      (_FormData && new _FormData()) as GenericFormData | null | undefined,
+      formSerializer
+    );
+  }
+  return undefined;
+}
+
+function throwOnStrictJSONError(
+  e: unknown,
+  strictJSONParsing: boolean,
+  config: InternalFaxiosRequestConfig
+): void {
+  if (!strictJSONParsing) return;
+  if ((e as { name?: string; }).name === "SyntaxError") {
+    throw FaxiosError.from(
+      e as Error,
+      FaxiosError.ERR_BAD_RESPONSE,
+      config,
+      null,
+      (config as unknown as Record<string, unknown>)["response"] as
+        | FaxiosResponse
+        | undefined
+    );
+  }
+  throw e;
+}
+
+function stringifySafely(
+  rawValue: unknown,
+  parser?: ((s: string) => unknown) | null,
+  encoder?: ((v: unknown) => string) | null
+): unknown {
+  if (utils.isString(rawValue)) {
+    try {
+      (parser || JSON.parse)(rawValue as string);
+      return (rawValue as string).trim();
+    }
+    catch (e) {
+      if ((e as { name?: string; }).name !== "SyntaxError") {
+        throw e;
+      }
+    }
+  }
+
+  return (encoder || JSON.stringify)(rawValue);
+}
+
+const defaults: FaxiosDefaults = {
+  transitional: transitionalDefaults,
+
+  transformRequest: [
+    function transformRequest(
+      this: InternalFaxiosRequestConfig,
+      data: unknown,
+      headers: FaxiosRequestHeaders
+    ) {
+      const contentType =
+        (headers.getContentType() as string | null | undefined) || "";
+      const hasJSONContentType = contentType.indexOf("application/json") > -1;
+      const isObjectPayload = utils.isObject(data);
+
+      if (isObjectPayload && utils.isHTMLForm(data)) {
+        const GlobalFormData = (globalThis as Record<string, unknown>)[
+          "FormData"
+        ] as (new (el?: unknown) => unknown) | undefined;
+        if (GlobalFormData) {
+          data = new GlobalFormData(data);
+        }
+      }
+
+      const isFormData = utils.isFormData(data);
+
+      if (isFormData) {
+        return hasJSONContentType ? JSON.stringify(formDataToJSON(data)) : data;
+      }
+
+      // fetch takes any ArrayBufferView as a body and sends only the view's bytes.
+      // Never unwrap it to `.buffer`: a subarray or DataView would send the whole backing buffer.
+      if (
+        utils.isArrayBuffer(data) ||
+        utils.isArrayBufferView(data) ||
+        utils.isBuffer(data) ||
+        utils.isStream(data) ||
+        utils.isFile(data) ||
+        utils.isBlob(data) ||
+        utils.isReadableStream?.(data)
+      ) {
+        return data;
+      }
+      if (utils.isURLSearchParams(data)) {
+        headers.setContentType(
+          "application/x-www-form-urlencoded;charset=utf-8",
+          false
+        );
+        return (data as { toString: () => string; }).toString();
+      }
+
+      if (isObjectPayload) {
+        const formSerializer = this.formSerializer as Record<string, unknown> | undefined;
+        const serialized = serializeObjectPayload(data, contentType, formSerializer, this.env?.FormData);
+        if (serialized !== undefined) return serialized;
+      }
+
+      if (isObjectPayload || hasJSONContentType) {
+        headers.setContentType("application/json", false);
+        return stringifySafely(data);
+      }
+
+      return data;
+    },
+  ],
+
+  transformResponse: [
+    function transformResponse(
+      this: InternalFaxiosRequestConfig,
+      data: unknown
+    ) {
+      const transitional = this.transitional || defaults.transitional;
+      const forcedJSONParsing = transitional && transitional.forcedJSONParsing;
+      const responseType = this.responseType;
+      const JSONRequested = responseType === "json";
+      const shouldParseJSON = (forcedJSONParsing && !responseType) || JSONRequested;
+
+      if (utils.isResponse?.(data) || utils.isReadableStream?.(data)) {
+        return data;
+      }
+
+      if (data && utils.isString(data) && shouldParseJSON) {
+        const silentJSONParsing =
+          transitional && transitional.silentJSONParsing;
+        const strictJSONParsing = !silentJSONParsing && JSONRequested;
+
+        try {
+          return JSON.parse(data as string, utils.hasOwnProp(this, "parseReviver") ? this.parseReviver : undefined);
+        }
+        catch (e) {
+          throwOnStrictJSONError(e, strictJSONParsing, this);
+        }
+      }
+
+      return data;
+    },
+  ],
+
+  /**
+   * A timeout in milliseconds to abort a request. If set to 0 (default) a
+   * timeout is not created.
+   */
+  timeout: 0,
+
+  xsrfCookieName: "XSRF-TOKEN",
+  xsrfHeaderName: "X-XSRF-TOKEN",
+
+  maxContentLength: -1,
+  maxBodyLength: -1,
+
+  env: {
+    FormData: platform.classes.FormData,
+  },
+
+  validateStatus: function validateStatus(status: number) {
+    return status >= 200 && status < 300;
+  },
+
+  headers: {
+    common: {
+      Accept: "application/json, text/plain, */*",
+      "Content-Type": undefined,
+    },
+    delete: {},
+    get: {},
+    head: {},
+    post: {},
+    put: {},
+    patch: {},
+    query: {},
+  },
+};
+
+export default defaults;

package/src/lib/defaults/transitional.ts

@@ -0,0 +1,9 @@
+"use strict";
+
+export default {
+  silentJSONParsing: true,
+  forcedJSONParsing: true,
+  clarifyTimeoutError: false,
+  advertiseZstdAcceptEncoding: false,
+  validateStatusUndefinedResolves: true,
+};

package/src/lib/env/data.ts

@@ -0,0 +1 @@
+export const VERSION = "0.2.1";

package/src/lib/faxios.ts

@@ -0,0 +1,306 @@
+// @ts-self-types="./faxios.d.ts"
+"use strict";
+
+import CanceledError from "./cancel/CanceledError.js";
+import isCancel from "./cancel/isCancel.js";
+import type { DefineConfig, DefinedEndpoint } from "./core/define.js";
+import Faxios, { ejectMiddleware, useMiddleware } from "./core/Faxios.js";
+import FaxiosError from "./core/FaxiosError.js";
+import FaxiosHeaders from "./core/FaxiosHeaders.js";
+import mergeConfig from "./core/mergeConfig.js";
+import type { RouteBuilder, RouteConfig } from "./core/route.js";
+import defaults from "./defaults/index.js";
+import { VERSION } from "./env/data.js";
+import formDataToJSON from "./helpers/formDataToJSON.js";
+import HttpStatusCode from "./helpers/HttpStatusCode.js";
+import isFaxiosError from "./helpers/isFaxiosError.js";
+import toFormData from "./helpers/toFormData.js";
+import type { StandardSchemaV1 } from "./types/standard-schema.js";
+import type { Method, StringLiteralsOrString, CreateFaxiosDefaults, FaxiosDefaults, FaxiosHeaderValue, FaxiosMiddleware, FaxiosPluginArgument, FaxiosRequestConfig, HeadersDefaults, FaxiosResponse, SchemaConfig } from "./types.js";
+import utils from "./utils.js";
+
+/**
+ * Create an instance of Faxios
+ *
+ * @param {Object} defaultConfig The default config for the instance
+ *
+ * @returns {Faxios} A new instance of Faxios
+ */
+function createInstance(defaultConfig: FaxiosRequestConfig): FaxiosInstance {
+  const context = new Faxios(defaultConfig);
+  const instance = (Faxios.prototype.request as (...args: Array<unknown>) => unknown).bind(context) as unknown as FaxiosInstance;
+
+  // Copy faxios.prototype to instance. The instance is a callable populated
+  // dynamically here; extend mutates it via own-key copy.
+  const target = instance as unknown as Record<string, unknown>;
+  utils.extend(target, Faxios.prototype, context, { allOwnKeys: true });
+
+  // Copy context to instance
+  utils.extend(target, context, null, { allOwnKeys: true });
+
+  // use() and eject() aren't Faxios members, so the instance gets them here. use() returns the
+  // callable instance for chaining. At runtime it only registers the middleware; the plugin rules
+  // live in FaxiosInstance["use"], so the cast is the single place the phantom TOpts/TCaps
+  // refinement meets the untyped registry.
+  const use = (middleware: Parameters<typeof useMiddleware>[1]): FaxiosInstance => {
+    useMiddleware(context, middleware);
+    return instance;
+  };
+  instance.use = use as FaxiosInstance["use"];
+  instance.eject = (middleware: unknown) => {
+    ejectMiddleware(context, middleware);
+  };
+
+  // Factory for creating new instances
+  instance.create = function create(instanceConfig?: CreateFaxiosDefaults): FaxiosInstance {
+    return createInstance(mergeConfig(defaultConfig, instanceConfig));
+  };
+
+  return instance;
+}
+
+// Keys of TNeed that THave lacks, or provides with an incompatible type.
+type MissingCapabilities<THave, TNeed> = {
+  [K in keyof TNeed]: K extends keyof THave ? (THave[K] extends TNeed[K] ? never : K) : K;
+}[keyof TNeed];
+
+// `unknown` when THave satisfies TNeed; otherwise a required brand property whose name explains
+// the fix and whose value names the missing capabilities, so the compiler error points at them.
+type RequireCapabilities<THave, TNeed> = [MissingCapabilities<THave, TNeed>] extends [never]
+  ? unknown
+  : { "faxios: install a plugin that provides this capability first": MissingCapabilities<THave, TNeed>; };
+
+// Capabilities TProv would provide that THave already has. use() throws ERR_BAD_OPTION for these at
+// runtime, so they are a type error too.
+type DuplicateCapabilities<THave, TProv> = Extract<keyof TProv, keyof THave>;
+
+type RejectDuplicateCapabilities<THave, TProv> = [DuplicateCapabilities<THave, TProv>] extends [never]
+  ? unknown
+  : { "faxios: another installed plugin already provides this capability": DuplicateCapabilities<THave, TProv>; };
+
+// A plugin that adds capabilities must carry them, however TProv was supplied (inferred, annotated
+// or as an explicit type argument), so use() can't record a capability ctx.capabilities lacks.
+// NoInfer: TypeScript infers into conditional branches, and this branch must stay a check only.
+type RequireProvidesValue<TProv> = [keyof TProv] extends [never] ? unknown : { provides: NoInfer<TProv>; };
+
+// use() skips a nullish provides, so it adds no capabilities. Without this, `provides: undefined`
+// infers TProv as undefined and `TCaps & undefined` collapses to never, which satisfies every check.
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type -- no capabilities, as in FaxiosInstance
+type ProvidedCapabilities<TProv> = [TProv] extends [null | undefined] ? {} : TProv;
+
+// use() reads capability names with Object.keys() and skips the keys that could pollute a prototype,
+// so the registry only holds string names. A symbol, number or dangerous key would be typed on
+// ctx.capabilities without matching a registered name, and nothing could satisfy a requirement for one.
+type UnsupportedCapabilityKeys<TCaps> = Extract<keyof TCaps, symbol | number | "__proto__" | "constructor" | "prototype">;
+
+type RejectUnsupportedCapabilityKeys<TReq, TProv> = [UnsupportedCapabilityKeys<TReq> | UnsupportedCapabilityKeys<TProv>] extends [never]
+  ? unknown
+  : { "faxios: capability names must be strings other than __proto__, constructor and prototype": UnsupportedCapabilityKeys<TReq> | UnsupportedCapabilityKeys<TProv>; };
+
+// Nothing sets a plugin option for the caller, so a required one would be typed as present in the
+// plugin's middleware while every request that omits it leaves it undefined.
+type RequiredOptions<TOpt> = { [K in keyof TOpt]-?: object extends Pick<TOpt, K> ? never : K; }[keyof TOpt];
+
+type RequireOptionalOptions<TOpt> = [RequiredOptions<TOpt>] extends [never]
+  ? unknown
+  : { "faxios: plugin request options must be optional": RequiredOptions<TOpt>; };
+
+type UnionToIntersection<T> = (T extends unknown ? (value: T) => void : never) extends (value: infer I) => void ? I : never;
+type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : true;
+
+// keyof a union holds only the keys every member shares, so a union of capability maps would check
+// nothing. Which member applies can't be known, so a union is rejected.
+type RejectUnionCapabilities<TReq, TProv> = IsUnion<TReq> extends true
+  ? { "faxios: a plugin's required capabilities can't be a union": TReq; }
+  : IsUnion<TProv> extends true ? { "faxios: a plugin's provided capabilities can't be a union": TProv; } : unknown;
+
+type CheckPlugin<THave, TReq, TProv, TOpt> = RequireCapabilities<THave, TReq>
+  & RejectDuplicateCapabilities<THave, TProv>
+  & RequireProvidesValue<TProv>
+  & RejectUnsupportedCapabilityKeys<TReq, TProv>
+  & RequireOptionalOptions<TOpt>
+  & RejectUnionCapabilities<TReq, TProv>;
+
+/**
+ * A faxios instance. `TOpts` holds the request options that installed plugins add to every
+ * config-taking member; `TCaps` holds the capabilities installed plugins provide.
+ */
+// `{}` defaults: no plugin options or capabilities yet. Middleware written inline in use() is typed
+// from these, so it can use `Object.keys(ctx.capabilities)` or `"name" in ctx.capabilities`
+// without narrowing first.
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type -- see above
+export type FaxiosInstance<TOpts = {}, TCaps = {}> = {
+  /**
+   * Register middleware or a plugin and return this instance, typed with the plugin's request
+   * options and capabilities added. A plugin whose required capabilities aren't installed yet, or
+   * that provides a capability another installed plugin already provides, is a type error.
+   */
+  use: <TReq = unknown, TProv = unknown, TOpt = unknown>(
+    middleware: FaxiosMiddleware<TOpts, TCaps> | (FaxiosPluginArgument<TReq, TProv, TOpt> & CheckPlugin<TCaps, TReq, TProv, TOpt>)
+  ) => FaxiosInstance<TOpts & TOpt, TCaps & ProvidedCapabilities<TProv>>;
+  /**
+   * Remove middleware or a plugin registered with use(), by reference. In-flight requests are
+   * unaffected. The instance type is not narrowed: request options and capabilities the ejected
+   * plugin added stay in its type.
+   */
+  // A method, so its parameter is checked bivariantly: middleware typed for this instance's
+  // options and capabilities is accepted.
+  // eslint-disable-next-line @typescript-eslint/method-signature-style -- see above
+  eject<TReq = unknown, TProv = unknown, TOpt = unknown>(middleware: FaxiosMiddleware<TOpt> | FaxiosPluginArgument<TReq, TProv, TOpt>): void;
+  /**
+   * Define a typed endpoint for `method` and `url` (with optional `{key}` placeholders). `config`
+   * holds request defaults and the `pathParamsSchema`, `paramsSchema`, `requestSchema` and
+   * `responseSchema` to apply; schemas are locked at define time. Per-call `url`, `method` and
+   * schemas are ignored, and `pathParams`, `params` and `data` are required when their schema is set.
+   * The endpoint is a plain function that sends through this instance, so add middleware with
+   * `.use()` on the instance, not on the endpoint.
+   */
+  define: <
+    PP extends StandardSchemaV1<unknown, Record<string, unknown>> | undefined = undefined,
+    P extends StandardSchemaV1 | undefined = undefined,
+    D extends StandardSchemaV1 | undefined = undefined,
+    R extends StandardSchemaV1 | undefined = undefined
+  >(
+    method: StringLiteralsOrString<Method>,
+    url: string,
+    config?: DefineConfig<PP, P, D, R> & TOpts
+  ) => DefinedEndpoint<PP, P, D, R, TOpts>;
+  /**
+   * Group endpoints that share `url` and `config`. Returns one endpoint factory per method (`get`,
+   * `post`, `put`, `patch`, `delete`, `head`, `options`; no `query`), each taking `paramsSchema`,
+   * `requestSchema`, `responseSchema` and request defaults like `define()`. The route-level
+   * `pathParamsSchema` applies to every method and wins over a method's. Endpoints are plain
+   * functions that send through this instance, so add middleware with `.use()` on the instance.
+   */
+  route: <PP extends StandardSchemaV1<unknown, Record<string, unknown>> | undefined = undefined>(
+    url: string,
+    config?: RouteConfig<PP> & TOpts
+  ) => RouteBuilder<PP, TOpts>;
+  <O, D = unknown>(config: SchemaConfig<O, D> & TOpts): Promise<FaxiosResponse<O, D>>;
+  <O, D = unknown>(url: string, config: SchemaConfig<O, D> & TOpts): Promise<FaxiosResponse<O, D>>;
+  <T = unknown, R = FaxiosResponse<T>, D = unknown>(config: FaxiosRequestConfig<D> & TOpts): Promise<R>;
+  <T = unknown, R = FaxiosResponse<T>, D = unknown>(url: string, config?: FaxiosRequestConfig<D> & TOpts): Promise<R>;
+  request: {
+    <O, D = unknown>(config: SchemaConfig<O, D> & TOpts): Promise<FaxiosResponse<O, D>>;
+    <T = unknown, R = FaxiosResponse<T>, D = unknown>(config: FaxiosRequestConfig<D> & TOpts): Promise<R>;
+  };
+  get: {
+    <O, D = unknown>(url: string, config: SchemaConfig<O, D> & TOpts): Promise<FaxiosResponse<O, D>>;
+    <T = unknown, R = FaxiosResponse<T>, D = unknown>(url: string, config?: FaxiosRequestConfig<D> & TOpts): Promise<R>;
+  };
+  delete: {
+    <O, D = unknown>(url: string, config: SchemaConfig<O, D> & TOpts): Promise<FaxiosResponse<O, D>>;
+    <T = unknown, R = FaxiosResponse<T>, D = unknown>(url: string, config?: FaxiosRequestConfig<D> & TOpts): Promise<R>;
+  };
+  head: {
+    <O, D = unknown>(url: string, config: SchemaConfig<O, D> & TOpts): Promise<FaxiosResponse<O, D>>;
+    <T = unknown, R = FaxiosResponse<T>, D = unknown>(url: string, config?: FaxiosRequestConfig<D> & TOpts): Promise<R>;
+  };
+  options: {
+    <O, D = unknown>(url: string, config: SchemaConfig<O, D> & TOpts): Promise<FaxiosResponse<O, D>>;
+    <T = unknown, R = FaxiosResponse<T>, D = unknown>(url: string, config?: FaxiosRequestConfig<D> & TOpts): Promise<R>;
+  };
+  post: {
+    <O, D = unknown>(url: string, data: D | undefined, config: SchemaConfig<O, D> & TOpts): Promise<FaxiosResponse<O, D>>;
+    <T = unknown, R = FaxiosResponse<T>, D = unknown>(url: string, data?: D, config?: FaxiosRequestConfig<D> & TOpts): Promise<R>;
+  };
+  put: {
+    <O, D = unknown>(url: string, data: D | undefined, config: SchemaConfig<O, D> & TOpts): Promise<FaxiosResponse<O, D>>;
+    <T = unknown, R = FaxiosResponse<T>, D = unknown>(url: string, data?: D, config?: FaxiosRequestConfig<D> & TOpts): Promise<R>;
+  };
+  patch: {
+    <O, D = unknown>(url: string, data: D | undefined, config: SchemaConfig<O, D> & TOpts): Promise<FaxiosResponse<O, D>>;
+    <T = unknown, R = FaxiosResponse<T>, D = unknown>(url: string, data?: D, config?: FaxiosRequestConfig<D> & TOpts): Promise<R>;
+  };
+  query: {
+    <O, D = unknown>(url: string, data: D | undefined, config: SchemaConfig<O, D> & TOpts): Promise<FaxiosResponse<O, D>>;
+    <T = unknown, R = FaxiosResponse<T>, D = unknown>(url: string, data?: D, config?: FaxiosRequestConfig<D> & TOpts): Promise<R>;
+  };
+  postForm: {
+    <O, D = unknown>(url: string, data: D | undefined, config: SchemaConfig<O, D> & TOpts): Promise<FaxiosResponse<O, D>>;
+    <T = unknown, R = FaxiosResponse<T>, D = unknown>(url: string, data?: D, config?: FaxiosRequestConfig<D> & TOpts): Promise<R>;
+  };
+  putForm: {
+    <O, D = unknown>(url: string, data: D | undefined, config: SchemaConfig<O, D> & TOpts): Promise<FaxiosResponse<O, D>>;
+    <T = unknown, R = FaxiosResponse<T>, D = unknown>(url: string, data?: D, config?: FaxiosRequestConfig<D> & TOpts): Promise<R>;
+  };
+  patchForm: {
+    <O, D = unknown>(url: string, data: D | undefined, config: SchemaConfig<O, D> & TOpts): Promise<FaxiosResponse<O, D>>;
+    <T = unknown, R = FaxiosResponse<T>, D = unknown>(url: string, data?: D, config?: FaxiosRequestConfig<D> & TOpts): Promise<R>;
+  };
+  // `common` plus one header group per method; a key set directly on
+  // `headers` applies to every method.
+  defaults: Omit<FaxiosDefaults, "headers"> & {
+    headers: HeadersDefaults & { [key: string]: FaxiosHeaderValue | undefined; };
+  } & Partial<TOpts>;
+  /**
+   * Build the URL for `config` without sending a request. Applies `baseURL`, `params` and
+   * `paramsSerializer`, but does not substitute `pathParams` or run schemas, so `{key}`
+   * placeholders come back as written.
+   */
+  getUri: (config?: FaxiosRequestConfig & TOpts) => string;
+  create: (instanceConfig?: CreateFaxiosDefaults) => FaxiosInstance;
+};
+
+/** The default export: an instance plus the static helpers only it carries. */
+export type FaxiosStatic = FaxiosInstance & {
+  Faxios: typeof Faxios;
+  CanceledError: typeof CanceledError;
+  isCancel: typeof isCancel;
+  VERSION: typeof VERSION;
+  toFormData: typeof toFormData;
+  FaxiosError: typeof FaxiosError;
+  Cancel: typeof CanceledError;
+  all: (promises: Array<Promise<unknown>>) => Promise<Array<unknown>>;
+  spread: (fn: (...args: Array<unknown>) => unknown) => (arr: Array<unknown>) => unknown;
+  isFaxiosError: typeof isFaxiosError;
+  mergeConfig: typeof mergeConfig;
+  FaxiosHeaders: typeof FaxiosHeaders;
+  formToJSON: (thing: unknown) => unknown;
+  HttpStatusCode: typeof HttpStatusCode;
+  default: FaxiosStatic;
+};
+
+// Create the default instance to be exported; the statics are attached below.
+const faxios = createInstance(defaults) as FaxiosStatic;
+
+// Expose Faxios class to allow class inheritance
+faxios.Faxios = Faxios;
+
+faxios.CanceledError = CanceledError;
+faxios.isCancel = isCancel;
+faxios.VERSION = VERSION;
+faxios.toFormData = toFormData;
+
+// Expose FaxiosError class
+faxios.FaxiosError = FaxiosError;
+
+// alias for CanceledError for backward compatibility
+faxios.Cancel = faxios.CanceledError;
+
+// Expose all/spread
+faxios.all = async function all(promises: Array<Promise<unknown>>): Promise<Array<unknown>> {
+  return Promise.all(promises);
+};
+
+faxios.spread = (fn: (...args: Array<unknown>) => unknown) => (arr: Array<unknown>) => fn(...arr);
+
+// Expose isFaxiosError
+faxios.isFaxiosError = isFaxiosError;
+
+// Expose mergeConfig
+faxios.mergeConfig = mergeConfig;
+
+faxios.FaxiosHeaders = FaxiosHeaders;
+
+faxios.formToJSON = (thing: unknown): unknown => formDataToJSON(utils.isHTMLForm(thing) ? ((): unknown => {
+  const GlobalFormData = (globalThis as Record<string, unknown>)["FormData"] as (new (el?: unknown) => unknown) | undefined;
+  return GlobalFormData ? new GlobalFormData(thing) : thing;
+})() : thing);
+
+faxios.HttpStatusCode = HttpStatusCode;
+
+faxios.default = faxios;
+
+// this module should only have a default export
+export default faxios;

package/src/lib/helpers/FaxiosURLSearchParams.ts

@@ -0,0 +1,52 @@
+"use strict";
+
+import type { ParamEncoder } from "../types.js";
+import toFormData from "./toFormData.js";
+
+/**
+ * It encodes a string by replacing all characters that are not in the unreserved set with
+ * their percent-encoded equivalents
+ *
+ * @param {string} str - The string to encode.
+ *
+ * @returns {string} The encoded string.
+ */
+function encode(str: string): string {
+  const charMap: Record<string, string> = {
+    "!": "%21",
+    "'": "%27",
+    "(": "%28",
+    ")": "%29",
+    "~": "%7E",
+    "%20": "+",
+  };
+  return encodeURIComponent(str).replace(/[!'()~]|%20/g, function replacer(match: string) {
+    return charMap[match] ?? match;
+  });
+}
+
+class FaxiosURLSearchParams {
+  #pairs: Array<[string, unknown]> = [];
+
+  constructor(params?: unknown, options?: unknown) {
+    params && toFormData(params, this, options as Record<string, unknown>);
+  }
+
+  append(name: string, value: unknown): void {
+    this.#pairs.push([ name, value ]);
+  }
+
+  toString(encoder?: ParamEncoder): string {
+    const _encode = encoder
+      ? (value: string) => encoder.call(undefined, value, encode)
+      : encode;
+
+    return this.#pairs
+      .map(function each(pair: [string, unknown]) {
+        return _encode(String(pair[0])) + "=" + _encode(String(pair[1]!));
+      }, "")
+      .join("&");
+  }
+}
+
+export default FaxiosURLSearchParams;

package/src/lib/helpers/HttpStatusCode.ts

@@ -0,0 +1,77 @@
+const HttpStatusCode = {
+  Continue: 100,
+  SwitchingProtocols: 101,
+  Processing: 102,
+  EarlyHints: 103,
+  Ok: 200,
+  Created: 201,
+  Accepted: 202,
+  NonAuthoritativeInformation: 203,
+  NoContent: 204,
+  ResetContent: 205,
+  PartialContent: 206,
+  MultiStatus: 207,
+  AlreadyReported: 208,
+  ImUsed: 226,
+  MultipleChoices: 300,
+  MovedPermanently: 301,
+  Found: 302,
+  SeeOther: 303,
+  NotModified: 304,
+  UseProxy: 305,
+  Unused: 306,
+  TemporaryRedirect: 307,
+  PermanentRedirect: 308,
+  BadRequest: 400,
+  Unauthorized: 401,
+  PaymentRequired: 402,
+  Forbidden: 403,
+  NotFound: 404,
+  MethodNotAllowed: 405,
+  NotAcceptable: 406,
+  ProxyAuthenticationRequired: 407,
+  RequestTimeout: 408,
+  Conflict: 409,
+  Gone: 410,
+  LengthRequired: 411,
+  PreconditionFailed: 412,
+  PayloadTooLarge: 413,
+  UriTooLong: 414,
+  UnsupportedMediaType: 415,
+  RangeNotSatisfiable: 416,
+  ExpectationFailed: 417,
+  ImATeapot: 418,
+  MisdirectedRequest: 421,
+  UnprocessableEntity: 422,
+  Locked: 423,
+  FailedDependency: 424,
+  TooEarly: 425,
+  UpgradeRequired: 426,
+  PreconditionRequired: 428,
+  TooManyRequests: 429,
+  RequestHeaderFieldsTooLarge: 431,
+  UnavailableForLegalReasons: 451,
+  InternalServerError: 500,
+  NotImplemented: 501,
+  BadGateway: 502,
+  ServiceUnavailable: 503,
+  GatewayTimeout: 504,
+  HttpVersionNotSupported: 505,
+  VariantAlsoNegotiates: 506,
+  InsufficientStorage: 507,
+  LoopDetected: 508,
+  NotExtended: 510,
+  NetworkAuthenticationRequired: 511,
+  WebServerIsDown: 521,
+  ConnectionTimedOut: 522,
+  OriginIsUnreachable: 523,
+  TimeoutOccurred: 524,
+  SslHandshakeFailed: 525,
+  InvalidSslCertificate: 526,
+};
+
+Object.entries(HttpStatusCode).forEach(([ key, value ]) => {
+  (HttpStatusCode as Record<string | number, string | number>)[value] = key;
+});
+
+export default HttpStatusCode;