@gcmdev/faxios 0.2.1 → 0.2.3

package/src/lib/cancel/CanceledError.ts

@@ -13,7 +13,7 @@ class CanceledError extends FaxiosError {
    *
    * @returns {CanceledError} The created error.
    */
-  constructor(message?: string | null, config?: FaxiosRequestConfig, request?: unknown) {
+  constructor(message?: null | string, config?: FaxiosRequestConfig, request?: unknown) {
     super(message == null ? "canceled" : message, FaxiosError.ERR_CANCELED, config as InternalFaxiosRequestConfig, request);
     this.name = "CanceledError";
     (this as unknown as Record<string, unknown>)["__CANCEL__"] = true;

package/src/lib/core/Faxios.ts

@@ -2,10 +2,9 @@
 
 import CanceledError from "../cancel/CanceledError.js";
 import buildURL from "../helpers/buildURL.js";
-import cloneConfig, { DANGEROUS_KEYS } from "../helpers/cloneConfig.js";
+import cloneConfig from "../helpers/cloneConfig.js";
 import validator from "../helpers/validator.js";
 import type { ValidatorFn } from "../helpers/validator.js";
-import type { StandardSchemaV1 } from "../types/standard-schema.js";
 import type {
   FaxiosContext,
   FaxiosMiddleware,
@@ -21,6 +20,7 @@ import type {
   SchemaConfig,
   StringLiteralsOrString
 } from "../types.js";
+import type { StandardSchemaV1 } from "../types/standard-schema.js";
 import utils from "../utils.js";
 import buildFullPath from "./buildFullPath.js";
 import { createDefinedEndpoint } from "./define.js";
@@ -29,21 +29,21 @@ import dispatchRequest from "./dispatchRequest.js";
 import FaxiosError from "./FaxiosError.js";
 import FaxiosHeaders from "./FaxiosHeaders.js";
 import mergeConfig from "./mergeConfig.js";
-import type { RouteConfig, RouteBuilder } from "./route.js";
+import type { RouteBuilder, RouteConfig } from "./route.js";
 import { createRouteBuilder } from "./route.js";
 
 type TransitionalFn = (
-  validator: ValidatorFn | false | undefined,
+  validator: false | undefined | ValidatorFn,
   version?: string,
   message?: string
 ) => ValidatorFn;
 type SpellingFn = (correctSpelling: string) => ValidatorFn;
 const validators = validator.validators as Record<
   string,
-  ValidatorFn | undefined
+  undefined | ValidatorFn
 > & {
-  transitional?: TransitionalFn;
   spelling?: SpellingFn;
+  transitional?: TransitionalFn;
 };
 
 // Every method header group declared on HeadersDefaults. `satisfies` keeps this
@@ -133,7 +133,10 @@ function resolveAllowAbsoluteUrls(
   defaults: FaxiosRequestConfig
 ): void {
   if (config.allowAbsoluteUrls === undefined) {
-    config.allowAbsoluteUrls = defaults.allowAbsoluteUrls ?? !defaults.baseURL;
+    // Own reads only: instance defaults may be a plain object (the default instance's are).
+    const allowAbsoluteUrls = utils.hasOwnProp(defaults, "allowAbsoluteUrls") ? defaults.allowAbsoluteUrls : undefined;
+    const baseURL = utils.hasOwnProp(defaults, "baseURL") ? defaults.baseURL : undefined;
+    config.allowAbsoluteUrls = allowAbsoluteUrls ?? !baseURL;
   }
 }
 
@@ -143,10 +146,10 @@ type AnyContextMiddleware = FaxiosMiddleware<unknown, unknown>;
 type AnyContextNext = FaxiosNext<unknown, unknown>;
 
 type MiddlewareEntry = {
+  provided: Array<string>;
   // The value passed to use(), kept only for eject()'s identity check.
   ref: unknown;
   run: AnyContextMiddleware;
-  provided: Array<string>;
 };
 
 function composeMiddleware(entries: ReadonlyArray<MiddlewareEntry>, dispatch: AnyContextNext): AnyContextNext {
@@ -272,7 +275,7 @@ class Faxios {
 
   #addCapabilities(pluginName: string, provides: unknown): Array<string> {
     const source = provides as Record<string, unknown>;
-    const keys = Object.keys(source).filter(key => !DANGEROUS_KEYS.has(key));
+    const keys = Object.keys(source).filter(key => !utils.isDangerousKey(key));
     for (const key of keys) {
       if (utils.hasOwnProp(this.#capabilities, key)) {
         throw new FaxiosError(`Plugin "${pluginName}" provides capability "${key}", which another plugin already provides`, FaxiosError.ERR_BAD_OPTION);
@@ -295,9 +298,9 @@ class Faxios {
    */
 
   async request<O, D = unknown>(config: SchemaConfig<O, D>): Promise<FaxiosResponse<O, D>>;
-  async request<T = unknown, R = FaxiosResponse<T>, D = unknown>(configOrUrl: string | FaxiosRequestConfig<D>, config?: FaxiosRequestConfig<D>): Promise<R>;
+  async request<T = unknown, R = FaxiosResponse<T>, D = unknown>(configOrUrl: FaxiosRequestConfig<D> | string, config?: FaxiosRequestConfig<D>): Promise<R>;
   async request(
-    configOrUrl: string | FaxiosRequestConfig,
+    configOrUrl: FaxiosRequestConfig | string,
     config?: FaxiosRequestConfig
   ) {
     try {
@@ -313,7 +316,7 @@ class Faxios {
   }
 
   async #request(
-    configOrUrl: string | FaxiosRequestConfig,
+    configOrUrl: FaxiosRequestConfig | string,
     config?: FaxiosRequestConfig
   ): Promise<unknown> {
     /*eslint no-param-reassign:0*/
@@ -361,8 +364,9 @@ class Faxios {
     );
 
     // Set config.method
+    const defaultMethod = utils.hasOwnProp(this.defaults, "method") ? this.defaults.method : undefined;
     config.method = (
-      (config.method || this.defaults.method || "get") as string
+      (config.method || defaultMethod || "get") as string
     ).toLowerCase();
 
     // Flatten headers

package/src/lib/core/FaxiosError.ts

@@ -1,8 +1,8 @@
 // @ts-self-types="./FaxiosError.d.ts" — required for Deno: index.d.ts re-exports SchemaValidationError from here
 "use strict";
 
+import type { FaxiosResponse, InternalFaxiosRequestConfig } from "../types.js";
 import type { StandardSchemaV1 } from "../types/standard-schema.js";
-import type { InternalFaxiosRequestConfig, FaxiosResponse } from "../types.js";
 import utils from "../utils.js";
 import FaxiosHeaders from "./FaxiosHeaders.js";
 
@@ -247,9 +247,9 @@ export type SchemaValidationError =
   }
   | FaxiosError & {
     code:
-      | typeof FaxiosError.ERR_BAD_REQUEST_SCHEMA
       | typeof FaxiosError.ERR_BAD_PARAMS_SCHEMA
-      | typeof FaxiosError.ERR_BAD_PATH_PARAMS_SCHEMA;
+      | typeof FaxiosError.ERR_BAD_PATH_PARAMS_SCHEMA
+      | typeof FaxiosError.ERR_BAD_REQUEST_SCHEMA;
     issues: SchemaIssues;
   };
 

package/src/lib/core/FaxiosHeaders.ts

@@ -9,16 +9,16 @@ import utils from "../utils.js";
 const $internals = Symbol("internals");
 
 type HeaderMatcher =
-  | string
+  | ((this: FaxiosHeaders, value: string, name: string) => boolean)
   | RegExp
-  | ((this: FaxiosHeaders, value: string, name: string) => boolean);
+  | string;
 
 type HeaderInput =
-  | Record<string, unknown>
   | FaxiosHeaders
+  | null
+  | Record<string, unknown>
   | string
-  | undefined
-  | null;
+  | undefined;
 
 /** Matches a `FaxiosHeaders` instance by its type-only brand. */
 export type FaxiosHeadersInstance = Pick<FaxiosHeaders, typeof faxiosHeadersBrand>;
@@ -28,10 +28,29 @@ function normalizeHeader(header: string): string {
     .toLowerCase();
 }
 
+// Per instance: lowercased own key -> own key. Callers may also write and delete headers as plain
+// properties, so an entry is only trusted while its key is still own, and a miss rebuilds the index.
+const keyIndexes = new WeakMap<object, Map<string, string>>();
+
+function indexKeys(headers: object): Map<string, string> {
+  const index = new Map<string, string>();
+  // Later keys overwrite earlier ones, matching utils.findKey, which scans from the end.
+  for (const key of Object.keys(headers)) {
+    index.set(key.toLowerCase(), key);
+  }
+  keyIndexes.set(headers, index);
+  return index;
+}
+
+function findHeaderKey(headers: object, lHeader: string): string | undefined {
+  const key = keyIndexes.get(headers)?.get(lHeader);
+  return key !== undefined && utils.hasOwnProp(headers, key) ? key : indexKeys(headers).get(lHeader);
+}
+
 // eslint-disable-next-line sonarjs/function-return-type
 function normalizeValue(
   value: FaxiosHeaderValue | undefined
-): string | Array<string> | false | null | undefined {
+): Array<string> | false | null | string | undefined {
   if (value == null) {
     return value;
   }
@@ -64,9 +83,9 @@ function matchHeaderValue(
   value: unknown,
   header: string,
   filter:
-    | string
-    | RegExp
     | ((this: FaxiosHeaders, value: string, name: string) => boolean)
+    | RegExp
+    | string
     | undefined,
   isHeaderNameFilter?: boolean
 ): boolean | undefined {
@@ -176,7 +195,7 @@ class FaxiosHeaders {
   declare hasAuthorization: (matcher?: HeaderMatcher) => boolean;
 
   constructor(
-    headers?: Record<string, unknown> | FaxiosHeaders | string | null
+    headers?: FaxiosHeaders | null | Record<string, unknown> | string
   ) {
     headers && this.set(headers);
   }
@@ -187,6 +206,9 @@ class FaxiosHeaders {
     rewrite?: boolean
   ): this {
     const self = this;
+    // Set once a lookup misses, which rebuilds the index from the own keys. Only setHeader writes
+    // to self until this call returns, so from then on the index is complete and a miss is final.
+    let index: Map<string, string> | undefined;
 
     function setHeader(
       _value: unknown,
@@ -199,7 +221,11 @@ class FaxiosHeaders {
         return;
       }
 
-      const key = utils.findKey(self, lHeader) as string | undefined;
+      const key = index ? index.get(lHeader) : findHeaderKey(self, lHeader);
+      if (key === undefined) {
+        index ??= keyIndexes.get(self)!;
+        index.set(String(_header).toLowerCase(), _header);
+      }
 
       if (
         !key ||
@@ -244,23 +270,23 @@ class FaxiosHeaders {
 
   get(header: string): FaxiosHeaderValue | undefined;
   get(header: string, parser: true): Record<string, string> | undefined;
-  get(header: string, parser: RegExp): RegExpExecArray | null | undefined;
+  get(header: string, parser: RegExp): null | RegExpExecArray | undefined;
   get<R>(header: string, parser: (this: FaxiosHeaders, value: FaxiosHeaderValue, header: string) => R): R | undefined;
   get(
     header: string,
     parser?:
-      | RegExp
       | ((
         this: FaxiosHeaders,
         value: FaxiosHeaderValue,
         header: string
       ) => unknown)
+      | RegExp
       | true
   ): unknown {
     header = normalizeHeader(header);
 
     if (header) {
-      const key = utils.findKey(this, header) as string | undefined;
+      const key = findHeaderKey(this, header);
 
       if (key) {
         const value = (this as Record<string, unknown>)[
@@ -299,7 +325,7 @@ class FaxiosHeaders {
     header = normalizeHeader(header);
 
     if (header) {
-      const key = utils.findKey(this, header) as string | undefined;
+      const key = findHeaderKey(this, header);
 
       return !!(
         key &&
@@ -317,7 +343,7 @@ class FaxiosHeaders {
     return false;
   }
 
-  delete(header: string | Array<string>, matcher?: HeaderMatcher): boolean {
+  delete(header: Array<string> | string, matcher?: HeaderMatcher): boolean {
     const self = this;
     let deleted = false;
 
@@ -325,7 +351,7 @@ class FaxiosHeaders {
       _header = normalizeHeader(_header);
 
       if (_header) {
-        const key = utils.findKey(self, _header) as string | undefined;
+        const key = findHeaderKey(self, _header);
 
         if (
           key &&
@@ -381,11 +407,12 @@ class FaxiosHeaders {
 
   normalize(format: boolean = false): this {
     const self = this;
-    const headers: Record<string, unknown> = {};
+    // Lowercased normalized name -> normalized name, for names already kept.
+    const kept = new Map<string, string>();
 
     utils.forEach(this, (value: unknown, _header: unknown) => {
       const header = _header as string;
-      const key = utils.findKey(headers, header) as string | undefined;
+      const key = kept.get(header.toLowerCase());
 
       if (key) {
         (self as Record<string, unknown>)[key] = normalizeValue(
@@ -405,7 +432,7 @@ class FaxiosHeaders {
         value as FaxiosHeaderValue
       );
 
-      headers[normalized] = true;
+      kept.set(normalized.toLowerCase(), normalized);
     });
 
     return this;
@@ -450,15 +477,15 @@ class FaxiosHeaders {
   }
 
   static from(
-    thing?: Record<string, unknown> | FaxiosHeaders | string | null
+    thing?: FaxiosHeaders | null | Record<string, unknown> | string
   ): FaxiosHeaders {
     return thing instanceof this ? thing : new this(thing);
   }
 
   static concat(
-    first: Record<string, unknown> | FaxiosHeaders | string | undefined | null,
+    first: FaxiosHeaders | null | Record<string, unknown> | string | undefined,
     ...targets: Array<
-      Record<string, unknown> | FaxiosHeaders | string | undefined | null
+      FaxiosHeaders | null | Record<string, unknown> | string | undefined
     >
   ): FaxiosHeaders {
     const computed = new this(first);
@@ -468,7 +495,7 @@ class FaxiosHeaders {
     return computed;
   }
 
-  static accessor(header: string | Array<string>): typeof FaxiosHeaders {
+  static accessor(header: Array<string> | string): typeof FaxiosHeaders {
     const self = this as unknown as Record<
       symbol,
       { accessors: Record<string, boolean>; }

package/src/lib/core/define.ts

@@ -1,19 +1,19 @@
 // @ts-self-types="./define.d.ts" — required for Deno: maps built .js to adjacent .d.ts in dist/
 
+import type { FaxiosRequestConfig, FaxiosResponse, Method, StringLiteralsOrString } from "../types.js";
 import type { StandardSchemaV1 } from "../types/standard-schema.js";
-import type { FaxiosRequestConfig, FaxiosResponse, StringLiteralsOrString, Method } from "../types.js";
 import mergeConfig from "./mergeConfig.js";
 
 type StrippedFields =
-  | "url"
+  | "data"
   | "method"
-  | "pathParams"
   | "params"
-  | "data"
-  | "pathParamsSchema"
   | "paramsSchema"
+  | "pathParams"
+  | "pathParamsSchema"
   | "requestSchema"
-  | "responseSchema";
+  | "responseSchema"
+  | "url";
 
 /** Request config accepted by a defined endpoint call: everything except `url`, `method`, `pathParams`, `params`, `data` and the schemas. */
 export type BasePerCallConfig = Omit<FaxiosRequestConfig, StrippedFields>;
@@ -47,12 +47,12 @@ export type DefineConfig<
   D extends StandardSchemaV1 | undefined = undefined,
   R extends StandardSchemaV1 | undefined = undefined
 > = BasePerCallConfig & {
+  paramsSchema?: P;
   /**
    * Standard Schema that validates `pathParams` on every call; its output fills the `{key}`
    * placeholders. Makes `pathParams` required per call. A failure rejects with `ERR_BAD_PATH_PARAMS_SCHEMA`.
    */
   pathParamsSchema?: PP;
-  paramsSchema?: P;
   requestSchema?: D;
   responseSchema?: R;
 };

package/src/lib/core/dispatchRequest.ts

@@ -7,7 +7,7 @@ import FaxiosError from "../core/FaxiosError.js";
 import FaxiosHeaders from "../core/FaxiosHeaders.js";
 import { validateSchema } from "../core/validateSchema.js";
 import { substitutePathParams } from "../helpers/substitutePathParams.js";
-import type { InternalFaxiosRequestConfig, FaxiosResponse } from "../types.js";
+import type { FaxiosResponse, InternalFaxiosRequestConfig } from "../types.js";
 import utils from "../utils.js";
 import transformData from "./transformData.js";
 
@@ -104,7 +104,12 @@ export default async function dispatchRequest(this: unknown, config: InternalFax
 
   config.data = transformData.call(config, config.transformRequest);
 
-  if (config.data != null && !utils.isFormData(config.data) && [ "post", "put", "patch" ].indexOf(config.method as string) !== -1) {
+  const data: unknown = config.data;
+  // Binary and stream bodies keep their own type: fetch uses `Blob.type` or sends none.
+  const isBinaryOrStream = utils.isBlob(data) || utils.isFile(data) || utils.isArrayBuffer(data) || utils.isArrayBufferView(data) ||
+    utils.isReadableStream?.(data) || utils.isStream(data) ||
+    (typeof data === "object" && data !== null && Symbol.asyncIterator in data);
+  if (data != null && !utils.isFormData(data) && !isBinaryOrStream && [ "post", "put", "patch" ].indexOf(config.method as string) !== -1) {
     (config.headers as unknown as { setContentType: (v: string, r: boolean) => void; }).setContentType("application/x-www-form-urlencoded", false);
   }
 
@@ -151,7 +156,7 @@ export default async function dispatchRequest(this: unknown, config: InternalFax
         if (!isCancel(reason)) {
           throwIfCancellationRequested(config);
 
-          const r = reason as { response?: { data?: unknown; headers?: unknown; status?: number; [k: string]: unknown; }; } | null;
+          const r = reason as null | { response?: { [k: string]: unknown; data?: unknown; headers?: unknown; status?: number; }; };
           if (r?.response) {
             (config as unknown as Record<string, unknown>)["response"] = r.response;
             try {

package/src/lib/core/mergeConfig.ts

@@ -1,6 +1,6 @@
 "use strict";
 
-import type { FaxiosRequestConfig, FaxiosDefaults } from "../types.js";
+import type { FaxiosDefaults, FaxiosRequestConfig } from "../types.js";
 import utils from "../utils.js";
 import FaxiosHeaders from "./FaxiosHeaders.js";
 
@@ -15,7 +15,7 @@ const headersToObject = (thing: unknown) => (thing instanceof FaxiosHeaders ? {
  *
  * @returns {Object} New object resulting from merging config2 to config1
  */
-export default function mergeConfig(config1: FaxiosRequestConfig | FaxiosDefaults | Record<string, unknown>, config2?: FaxiosRequestConfig | FaxiosDefaults | Record<string, unknown>): FaxiosRequestConfig & Record<string, unknown> {
+export default function mergeConfig(config1: FaxiosDefaults | FaxiosRequestConfig | Record<string, unknown>, config2?: FaxiosDefaults | FaxiosRequestConfig | Record<string, unknown>): FaxiosRequestConfig & Record<string, unknown> {
    
   config2 = config2 || {};
 
@@ -79,6 +79,40 @@ export default function mergeConfig(config1: FaxiosRequestConfig | FaxiosDefault
     return undefined;
   }
 
+  // Shallow own-key copy into a null-prototype object, later sources winning. Every own key is
+  // kept, including `constructor`, `prototype` and `__proto__`: `params` are caller data that
+  // reach the query string, and defineProperty stores them as plain data slots.
+  function ownCopy(...sources: Array<unknown>): Record<string, unknown> {
+    const out: Record<string, unknown> = Object.create(null);
+    for (const source of sources) {
+      if (!utils.isPlainObject(source)) continue;
+      const record = source as Record<string, unknown>;
+      for (const key of Object.keys(record)) {
+        Object.defineProperty(out, key, Object.assign(Object.create(null) as PropertyDescriptor, {
+          value: record[key],
+          enumerable: true,
+          writable: true,
+          configurable: true,
+        }));
+      }
+    }
+    return out;
+  }
+
+  // `params`: a plain object is copied with every own key; anything else (URLSearchParams,
+  // a custom serializer's input) passes through as given.
+  function mergeParams(a: unknown, b: unknown): unknown {
+    const source = utils.isUndefined(b) ? a : b;
+    if (!utils.isPlainObject(source)) return source;
+    return utils.isUndefined(b) ? ownCopy(a) : ownCopy(a, b);
+  }
+
+  // `env`: shallow, null-prototype, so `fetch`, `Request` and `Response` can only be own values.
+  function mergeEnv(a: unknown, b: unknown): unknown {
+    if (utils.isUndefined(a) && utils.isUndefined(b)) return undefined;
+    return ownCopy(a, b);
+  }
+
   function getMergedTransitionalOption(prop: string): unknown {
     const c2 = config2 as Record<string, unknown>;
     const c1 = config1 as Record<string, unknown>;
@@ -117,7 +151,11 @@ export default function mergeConfig(config1: FaxiosRequestConfig | FaxiosDefault
   const mergeMap = {
     url: valueFromConfig2,
     method: valueFromConfig2,
-    data: valueFromConfig2,
+    // The body is passed by reference: faxios never mutates it, and copying would drop keys such
+    // as `constructor` and cost a deep clone per request.
+    data: (_a: unknown, b: unknown) => b,
+    params: mergeParams,
+    env: mergeEnv,
     baseURL: defaultToConfig2,
     transformRequest: defaultToConfig2,
     transformResponse: defaultToConfig2,
@@ -150,7 +188,7 @@ export default function mergeConfig(config1: FaxiosRequestConfig | FaxiosDefault
 
   utils.forEach(Object.keys({ ...config1, ...config2 }), function computeConfigValue(_value: unknown, _prop: unknown) {
     const key = _value as string;
-    if (key === "__proto__" || key === "constructor" || key === "prototype") return;
+    if (utils.isDangerousKey(key)) return;
     const mergeFn = (utils.hasOwnProp(mergeMap, key) ? (mergeMap as Record<string, typeof mergeDeepProperties>)[key] : mergeDeepProperties)!;
     const a = utils.hasOwnProp(config1, key) ? c1[key] : undefined;
     const b = utils.hasOwnProp(config2, key) ? c2[key] : undefined;

package/src/lib/core/prepareRequest.ts

@@ -96,7 +96,7 @@ function prepareRequest(config: FaxiosRequestConfig): FaxiosRequestConfig {
   const url = own("url");
 
   const headers: FaxiosHeaders = FaxiosHeaders.from(
-    own("headers") as Record<string, unknown> | null | undefined
+    own("headers") as null | Record<string, unknown> | undefined
   );
   newConfig.headers = headers;
 

package/src/lib/core/route.ts

@@ -1,5 +1,6 @@
 // @ts-self-types="./route.d.ts" — required for Deno: maps built .js to adjacent .d.ts in dist/
 
+import cloneConfig from "../helpers/cloneConfig.js";
 import type { StandardSchemaV1 } from "../types/standard-schema.js";
 import type { BasePerCallConfig, DefineConfig, DefinedEndpoint, FaxiosLike } from "./define.js";
 import { createDefinedEndpoint } from "./define.js";
@@ -28,7 +29,7 @@ export type RouteMethodConfig<
 
 /** The object `route()` returns: one endpoint factory per HTTP method (no `query`). */
 export type RouteBuilder<PP extends StandardSchemaV1<unknown, Record<string, unknown>> | undefined, TOpts = unknown> = {
-  [M in "get" | "post" | "put" | "patch" | "delete" | "head" | "options"]: <
+  [M in "delete" | "get" | "head" | "options" | "patch" | "post" | "put"]: <
     P extends StandardSchemaV1 | undefined = undefined,
     D extends StandardSchemaV1 | undefined = undefined,
     R extends StandardSchemaV1 | undefined = undefined
@@ -43,11 +44,7 @@ export function createRouteBuilder<PP extends StandardSchemaV1<unknown, Record<s
   url: string,
   routeConfig?: RouteConfig<PP>
 ): RouteBuilder<PP> {
-  const raw = Object.assign(Object.create(null), routeConfig ?? {});
-  delete raw.__proto__;
-  delete raw.constructor;
-  delete raw.prototype;
-  const { pathParamsSchema, ...routeDefaults } = raw;
+  const { pathParamsSchema, ...routeDefaults } = cloneConfig(routeConfig ?? {});
 
   const builder = {} as RouteBuilder<PP>;
   for (const method of methods) {

package/src/lib/core/transformData.ts

@@ -2,12 +2,12 @@
 
 import FaxiosHeaders from "../core/FaxiosHeaders.js";
 import defaults from "../defaults/index.js";
-import type { InternalFaxiosRequestConfig, FaxiosRequestHeaders, FaxiosRequestTransformer, FaxiosResponseTransformer } from "../types.js";
+import type { FaxiosRequestHeaders, FaxiosRequestTransformer, FaxiosResponseTransformer, InternalFaxiosRequestConfig } from "../types.js";
 import utils from "../utils.js";
 
 type TransformFn = FaxiosRequestTransformer | FaxiosResponseTransformer;
 
-export default function transformData(this: unknown, fns: TransformFn | Array<TransformFn> | undefined, response?: { data?: unknown; headers?: unknown; status?: number; } | null): unknown {
+export default function transformData(this: unknown, fns: Array<TransformFn> | TransformFn | undefined, response?: null | { data?: unknown; headers?: unknown; status?: number; }): unknown {
   const config = (this || defaults) as InternalFaxiosRequestConfig;
   const context = response || config;
   const headers = FaxiosHeaders.from(context.headers as Record<string, unknown> | undefined);

package/src/lib/core/validateSchema.ts

@@ -1,13 +1,13 @@
 import isCancel from "../cancel/isCancel.js";
+import type { FaxiosResponse, InternalFaxiosRequestConfig } from "../types.js";
 import type { StandardSchemaV1 } from "../types/standard-schema.js";
-import type { InternalFaxiosRequestConfig, FaxiosResponse } from "../types.js";
 import FaxiosError from "./FaxiosError.js";
 
 type SchemaErrorCode =
-  | typeof FaxiosError.ERR_BAD_RESPONSE_SCHEMA
-  | typeof FaxiosError.ERR_BAD_REQUEST_SCHEMA
   | typeof FaxiosError.ERR_BAD_PARAMS_SCHEMA
-  | typeof FaxiosError.ERR_BAD_PATH_PARAMS_SCHEMA;
+  | typeof FaxiosError.ERR_BAD_PATH_PARAMS_SCHEMA
+  | typeof FaxiosError.ERR_BAD_REQUEST_SCHEMA
+  | typeof FaxiosError.ERR_BAD_RESPONSE_SCHEMA;
 
 export async function validateSchema<S extends StandardSchemaV1>(
   schema: S,

package/src/lib/defaults/index.ts

@@ -96,7 +96,7 @@ const defaults: FaxiosDefaults = {
       headers: FaxiosRequestHeaders
     ) {
       const contentType =
-        (headers.getContentType() as string | null | undefined) || "";
+        (headers.getContentType() as null | string | undefined) || "";
       const hasJSONContentType = contentType.indexOf("application/json") > -1;
       const isObjectPayload = utils.isObject(data);
 

package/src/lib/env/data.ts

@@ -1 +1 @@
-export const VERSION = "0.2.1";
+export const VERSION = "0.2.3";