api-def 0.12.0 → 0.13.0

package/cjs/util/retry/lib/retry.js

@@ -1,49 +1,47 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.operation = void 0;
-var retryOperation_1 = require("./retryOperation");
-var operation = function (options) {
-    var timeouts = _timeouts(options);
+const retryOperation_1 = __importDefault(require("./retryOperation"));
+const operation = (options) => {
+    const timeouts = _timeouts(options);
     return new retryOperation_1.default(timeouts, {
         forever: options && (options.forever || options.retries === Number.POSITIVE_INFINITY),
-        unref: options === null || options === void 0 ? void 0 : options.unref,
-        maxRetryTime: options === null || options === void 0 ? void 0 : options.maxRetryTime,
+        unref: options?.unref,
+        maxRetryTime: options?.maxRetryTime,
     });
 };
 exports.operation = operation;
-var _timeouts = function (options) {
-    var _a;
-    var createTimeout = function (attempt, opts) {
-        var random = opts.randomize ? Math.random() + 1 : 1;
-        var timeout = Math.round(random * Math.max(opts.minTimeout, 1) * Math.pow(opts.factor, attempt));
+const _timeouts = (options) => {
+    const createTimeout = (attempt, opts) => {
+        const random = opts.randomize ? Math.random() + 1 : 1;
+        let timeout = Math.round(random * Math.max(opts.minTimeout, 1) * opts.factor ** attempt);
         timeout = Math.min(timeout, opts.maxTimeout);
         return timeout;
     };
-    var defaultRetries = 10;
-    var opts = __assign({ retries: defaultRetries, factor: 2, minTimeout: 1 * 1000, maxTimeout: Number.POSITIVE_INFINITY, randomize: false }, options);
+    const defaultRetries = 10;
+    const opts = {
+        retries: defaultRetries,
+        factor: 2,
+        minTimeout: 1 * 1000,
+        maxTimeout: Number.POSITIVE_INFINITY,
+        randomize: false,
+        ...options,
+    };
     if (opts.minTimeout > opts.maxTimeout) {
         throw new Error("minTimeout is greater than maxTimeout");
     }
-    var timeouts = [];
-    var numRetries = (_a = opts.retries) !== null && _a !== void 0 ? _a : defaultRetries;
-    for (var i = 0; i < numRetries; i++) {
+    const timeouts = [];
+    const numRetries = opts.retries ?? defaultRetries;
+    for (let i = 0; i < numRetries; i++) {
         timeouts.push(createTimeout(i, opts));
     }
-    if ((options === null || options === void 0 ? void 0 : options.forever) && !timeouts.length) {
+    if (options?.forever && !timeouts.length) {
         timeouts.push(createTimeout(numRetries, opts));
     }
     // sort the array numerically ascending
-    timeouts.sort(function (a, b) { return a - b; });
+    timeouts.sort((a, b) => a - b);
     return timeouts;
 };

package/cjs/util/retry/lib/retryOperation.d.ts

@@ -1,27 +1,2 @@
-export default RetryOperation;
 declare function RetryOperation(timeouts: any, options: any): void;
-declare class RetryOperation {
-    constructor(timeouts: any, options: any);
-    _originalTimeouts: any;
-    _timeouts: any;
-    _options: any;
-    _maxRetryTime: any;
-    _fn: any;
-    _errors: any[];
-    _attempts: number;
-    _operationTimeout: any;
-    _operationTimeoutCb: any;
-    _timeout: NodeJS.Timeout | null;
-    _operationStart: number | null;
-    _timer: NodeJS.Timeout | null;
-    _cachedTimeouts: any;
-    reset(): void;
-    stop(): void;
-    retry(err: any): boolean;
-    attempt(fn: any, timeoutOps: any): void;
-    try(fn: any): void;
-    start: (fn: any) => void;
-    errors(): any[];
-    attempts(): number;
-    mainError(): any;
-}
+export default RetryOperation;

package/cjs/util/retry/lib/retryOperation.js

@@ -4,7 +4,7 @@ function RetryOperation(timeouts, options) {
     this._originalTimeouts = JSON.parse(JSON.stringify(timeouts));
     this._timeouts = timeouts;
     this._options = options || {};
-    this._maxRetryTime = (options === null || options === void 0 ? void 0 : options.maxRetryTime) || Number.POSITIVE_INFINITY;
+    this._maxRetryTime = options?.maxRetryTime || Number.POSITIVE_INFINITY;
     this._fn = null;
     this._errors = [];
     this._attempts = 1;
@@ -32,21 +32,20 @@ RetryOperation.prototype.stop = function () {
     this._cachedTimeouts = null;
 };
 RetryOperation.prototype.retry = function (err) {
-    var _this = this;
     if (this._timeout) {
         clearTimeout(this._timeout);
     }
     if (!err) {
         return false;
     }
-    var currentTime = new Date().getTime();
+    const currentTime = new Date().getTime();
     if (err && currentTime - this._operationStart >= this._maxRetryTime) {
         this._errors.push(err);
         this._errors.unshift(new Error("RetryOperation timeout occurred"));
         return false;
     }
     this._errors.push(err);
-    var timeout = this._timeouts.shift();
+    let timeout = this._timeouts.shift();
     if (timeout === undefined) {
         if (this._cachedTimeouts) {
             // retry forever, only keep last error
@@ -57,17 +56,17 @@ RetryOperation.prototype.retry = function (err) {
             return false;
         }
     }
-    this._timer = setTimeout(function () {
-        _this._attempts++;
-        if (_this._operationTimeoutCb) {
-            _this._timeout = setTimeout(function () {
-                _this._operationTimeoutCb(_this._attempts);
-            }, _this._operationTimeout);
-            if (_this._options.unref) {
-                _this._timeout.unref();
+    this._timer = setTimeout(() => {
+        this._attempts++;
+        if (this._operationTimeoutCb) {
+            this._timeout = setTimeout(() => {
+                this._operationTimeoutCb(this._attempts);
+            }, this._operationTimeout);
+            if (this._options.unref) {
+                this._timeout.unref();
             }
         }
-        _this._fn(_this._attempts);
+        this._fn(this._attempts);
     }, timeout);
     if (this._options.unref) {
         this._timer.unref();
@@ -75,7 +74,6 @@ RetryOperation.prototype.retry = function (err) {
     return true;
 };
 RetryOperation.prototype.attempt = function (fn, timeoutOps) {
-    var _this = this;
     this._fn = fn;
     if (timeoutOps) {
         if (timeoutOps.timeout) {
@@ -86,8 +84,8 @@ RetryOperation.prototype.attempt = function (fn, timeoutOps) {
         }
     }
     if (this._operationTimeoutCb) {
-        this._timeout = setTimeout(function () {
-            _this._operationTimeoutCb();
+        this._timeout = setTimeout(() => {
+            this._operationTimeoutCb();
         }, this._operationTimeout);
     }
     this._operationStart = new Date().getTime();
@@ -112,13 +110,13 @@ RetryOperation.prototype.mainError = function () {
     if (this._errors.length === 0) {
         return null;
     }
-    var counts = {};
-    var mainError = null;
-    var mainErrorCount = 0;
-    for (var i = 0; i < this._errors.length; i++) {
-        var error = this._errors[i];
-        var message = error.message;
-        var count = (counts[message] || 0) + 1;
+    const counts = {};
+    let mainError = null;
+    let mainErrorCount = 0;
+    for (let i = 0; i < this._errors.length; i++) {
+        const error = this._errors[i];
+        const message = error.message;
+        const count = (counts[message] || 0) + 1;
         counts[message] = count;
         if (count >= mainErrorCount) {
             mainError = error;

package/esm/Api.d.ts

@@ -1,9 +1,9 @@
-import type { ApiResponse, BaseRequestConfig, RequestConfig, RequestMiddleware } from "./ApiTypes";
-import { type ResolveUrlOptions } from "./ApiUtils";
-import type Endpoint from "./Endpoint";
-import EndpointBuilder from "./EndpointBuilder";
-import type { ApiMockingConfig } from "./MockingTypes";
-import type RequestBackend from "./backend/RequestBackend";
+import type { ApiResponse, BaseRequestConfig, RequestConfig, RequestMiddleware } from "./ApiTypes.js";
+import { type ResolveUrlOptions } from "./ApiUtils.js";
+import type RequestBackend from "./backend/RequestBackend.js";
+import type Endpoint from "./Endpoint.js";
+import EndpointBuilder from "./EndpointBuilder.js";
+import type { ApiMockingConfig } from "./MockingTypes.js";
 export declare const getRequestBackend: () => RequestBackend | null;
 export declare const isRequestBackendDefault: () => boolean;
 export declare const setRequestBackend: (backend: RequestBackend) => void;
@@ -48,10 +48,10 @@ export declare class Api implements ApiInfo {
     getConfig(): BaseRequestConfig;
     computeRequestConfig(): BaseRequestConfig;
     private hotRequest;
-    get: <R = unknown>(path: string, config: RequestConfig) => Promise<ApiResponse<R>>;
-    post: <R = unknown>(path: string, config: RequestConfig) => Promise<ApiResponse<R>>;
-    put: <R = unknown>(path: string, config: RequestConfig) => Promise<ApiResponse<R>>;
-    delete: <R = unknown>(path: string, config: RequestConfig) => Promise<ApiResponse<R>>;
-    patch: <R = unknown>(path: string, config: RequestConfig) => Promise<ApiResponse<R>>;
+    get: <R = unknown>(path: string | URL, config: RequestConfig) => Promise<ApiResponse<R>>;
+    post: <R = unknown>(path: string | URL, config: RequestConfig) => Promise<ApiResponse<R>>;
+    put: <R = unknown>(path: string | URL, config: RequestConfig) => Promise<ApiResponse<R>>;
+    delete: <R = unknown>(path: string | URL, config: RequestConfig) => Promise<ApiResponse<R>>;
+    patch: <R = unknown>(path: string | URL, config: RequestConfig) => Promise<ApiResponse<R>>;
     resolveUrl(options: ApiResolveUrlOptions): URL;
 }

package/esm/Api.js

@@ -1,19 +1,10 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { RequestMethod } from "./ApiConstants";
-import { resolveUrl } from "./ApiUtils";
-import EndpointBuilder from "./EndpointBuilder";
-import { processRequestConfigs } from "./RequestConfig";
-import * as Requester from "./Requester";
-import * as Utils from "./Utils";
-import FetchRequestBackend from "./backend/FetchRequestBackend";
+import { RequestMethod } from "./ApiConstants.js";
+import { resolveUrl } from "./ApiUtils.js";
+import FetchRequestBackend from "./backend/FetchRequestBackend.js";
+import EndpointBuilder from "./EndpointBuilder.js";
+import { processRequestConfigs } from "./RequestConfig.js";
+import * as Requester from "./Requester.js";
+import * as Utils from "./Utils.js";
 // use fetch as default if it is present
 let requestBackend = Utils.getGlobalFetch() ? new FetchRequestBackend() : null;
 let requestBackendIsDefault = true;
@@ -50,7 +41,6 @@ export class Api {
     //private mutable = false;
     //private wasMutable = false;
     constructor(options) {
-        var _a, _b, _c, _d;
         this.endpoints = {};
         /*configure(info: Partial<ApiInfo>): void {
           if (!this.mutable) {
@@ -62,13 +52,13 @@ export class Api {
           Object.assign(this.info, info);
           this.mutable = false;
         }*/
-        this.hotRequest = (requestMethod) => (path, config) => __awaiter(this, void 0, void 0, function* () { return yield Requester.submit(new HotRequestHost(this, path, requestMethod), config, null); });
+        this.hotRequest = (requestMethod) => async (path, config) => await Requester.submit(new HotRequestHost(this, path instanceof URL ? path.href : path, requestMethod), config, null);
         this.get = this.hotRequest(RequestMethod.GET);
         this.post = this.hotRequest(RequestMethod.POST);
         this.put = this.hotRequest(RequestMethod.PUT);
         this.delete = this.hotRequest(RequestMethod.DELETE);
         this.patch = this.hotRequest(RequestMethod.PATCH);
-        const requestBackend = (_a = options.requestBackend) !== null && _a !== void 0 ? _a : getRequestBackend();
+        const requestBackend = options.requestBackend ?? getRequestBackend();
         if (!requestBackend) {
             throw new Error("[api-def] No request backend provided in either Api options or globally, use `setRequestBackend()` to set one or pass one via `requestBackend`");
         }
@@ -76,8 +66,8 @@ export class Api {
             name: options.name,
             baseUrl: options.baseUrl,
             middleware: options.middleware || [],
-            defaultRequestConfig: (_c = (_b = options.defaultRequestConfig) !== null && _b !== void 0 ? _b : options.config) !== null && _c !== void 0 ? _c : undefined,
-            mocking: (_d = options.mocking) !== null && _d !== void 0 ? _d : undefined,
+            defaultRequestConfig: options.defaultRequestConfig ?? options.config ?? undefined,
+            mocking: options.mocking ?? undefined,
             requestBackend: requestBackend,
         };
         //this.mutable = options.mutable ?? false;
@@ -127,9 +117,8 @@ export class Api {
         return ((typeof this.defaultRequestConfig === "function" ? this.defaultRequestConfig() : this.defaultRequestConfig) || {});
     }
     resolveUrl(options) {
-        var _a;
         return resolveUrl({
-            baseUrl: (_a = options.baseUrl) !== null && _a !== void 0 ? _a : this.baseUrl,
+            baseUrl: options.baseUrl ?? this.baseUrl,
             path: options.path,
         });
     }

package/esm/ApiConstants.d.ts

@@ -1,4 +1,4 @@
-import type { EnumOf } from "./Utils";
+import type { EnumOf } from "./Utils.js";
 export declare const RequestMethod: {
     readonly POST: "post";
     readonly GET: "get";

package/esm/ApiTypes.d.ts

@@ -1,8 +1,8 @@
-import type { Api } from "./Api";
-import type { CacheSource, EventResultType, RequestEvent, RequestMethod, ResponseType } from "./ApiConstants";
-import type RequestContext from "./RequestContext";
-import type { Validation } from "./Validation";
-import type RequestBackend from "./backend/RequestBackend";
+import type { Api } from "./Api.js";
+import type { CacheSource, EventResultType, RequestEvent, RequestMethod, ResponseType } from "./ApiConstants.js";
+import type RequestBackend from "./backend/RequestBackend.js";
+import type RequestContext from "./RequestContext.js";
+import type { Validation } from "./Validation.js";
 export type AcceptableStatus = number | [min: number, max: number];
 export type RawHeaders = Record<string, string | number | boolean | null | undefined>;
 export type Params = string;

package/esm/ApiUtils.d.ts

@@ -1,11 +1,12 @@
-import type { ResponseType } from "./ApiConstants";
-import type { AcceptableStatus, CancelledRequestError } from "./ApiTypes";
+import type { ResponseType } from "./ApiConstants.js";
+import type { AcceptableStatus, CancelledRequestError } from "./ApiTypes.js";
 export interface ResolveUrlOptions {
-    path: string;
+    path: string | URL;
     baseUrl: string;
 }
 export declare const isCancelledError: (error: Error) => error is CancelledRequestError;
 export declare const isNetworkError: (error: Error) => boolean;
+export declare const isAbsoluteUrl: (url: string) => boolean;
 export declare const isAcceptableStatus: (status: number, acceptableStatus?: AcceptableStatus[]) => boolean;
 export declare const inferResponseType: (contentType: string | null | undefined) => ResponseType;
 export declare const resolvePathParams: (path: string, params: Record<string, string> | undefined, allowMissing?: boolean) => string;

package/esm/ApiUtils.js

@@ -2,14 +2,16 @@ export const isCancelledError = (error) => {
     return "isCancelledRequest" in error;
 };
 export const isNetworkError = (error) => {
-    var _a;
     return (error.name === "NetworkError" ||
         error.message === "Network Error" ||
-        ((_a = error.constructor) === null || _a === void 0 ? void 0 : _a.name) === "NetworkError");
+        error.constructor?.name === "NetworkError");
+};
+export const isAbsoluteUrl = (url) => {
+    return /^[a-zA-Z][a-zA-Z\d+\-.]*:\/\//.test(url);
 };
 const DEFAULT_ACCEPTABLE_STATUS = [[200, 299], 304];
 export const isAcceptableStatus = (status, acceptableStatus) => {
-    const acceptable = acceptableStatus !== null && acceptableStatus !== void 0 ? acceptableStatus : DEFAULT_ACCEPTABLE_STATUS;
+    const acceptable = acceptableStatus ?? DEFAULT_ACCEPTABLE_STATUS;
     for (const cmpStatus of acceptable) {
         if (Array.isArray(cmpStatus)) {
             const [min, max] = cmpStatus;
@@ -30,7 +32,7 @@ const JSON_CONTENT_TYPES = ["text/json", "application/json"];
 const ARRAY_BUFFER_CONTENT_TYPES = ["application/octet-stream"];
 const STREAM_CONTENT_TYPES = ["text/event-stream", "application/x-ndjson"];
 export const inferResponseType = (contentType) => {
-    const contentTypePart = contentType === null || contentType === void 0 ? void 0 : contentType.split(";")[0].trim();
+    const contentTypePart = contentType?.split(";")[0].trim();
     if (contentTypePart) {
         if (TEXT_CONTENT_TYPES.includes(contentTypePart)) {
             return "text";
@@ -48,7 +50,7 @@ export const inferResponseType = (contentType) => {
     return "text";
 };
 export const resolvePathParams = (path, params, allowMissing) => {
-    const computedPath = path.startsWith("/") ? path : `/${path}`;
+    const computedPath = path.startsWith("/") || isAbsoluteUrl(path) ? path : `/${path}`;
     if (params) {
         const computedPathParts = computedPath.split("/");
         const unusedKeys = new Set(Object.keys(params));
@@ -82,14 +84,20 @@ export const resolvePathParams = (path, params, allowMissing) => {
 };
 export const resolveUrl = (options) => {
     const { baseUrl, path } = options;
+    if (path instanceof URL) {
+        return new URL(path.href);
+    }
+    if (isAbsoluteUrl(path)) {
+        return new URL(path);
+    }
     let result = !baseUrl.endsWith("/") ? `${baseUrl}/` : baseUrl;
     result += path.startsWith("/") ? path.substring(1) : path;
-    let origin = undefined;
+    let origin;
     if (typeof window !== "undefined") {
         origin = window.origin;
     }
     if (!origin) {
-        if (result.indexOf("://") === -1) {
+        if (!isAbsoluteUrl(result)) {
             result = `https://${result}`;
         }
     }

package/esm/Endpoint.d.ts

@@ -1,9 +1,9 @@
-import type { Api } from "./Api";
-import type { RequestMethod, ResponseType } from "./ApiConstants";
-import type { ApiResponse, BaseRequestConfig, Body, ComputedRequestConfig, Params, Query, RawHeaders, RequestConfig, RequestHost, RequestMiddleware, State } from "./ApiTypes";
-import type * as Mocking from "./MockingTypes";
-import type { Validation } from "./Validation";
-import type RequestBackend from "./backend/RequestBackend";
+import type { Api } from "./Api.js";
+import type { RequestMethod, ResponseType } from "./ApiConstants.js";
+import type { ApiResponse, BaseRequestConfig, Body, ComputedRequestConfig, Params, Query, RawHeaders, RequestConfig, RequestHost, RequestMiddleware, State } from "./ApiTypes.js";
+import type RequestBackend from "./backend/RequestBackend.js";
+import type * as Mocking from "./MockingTypes.js";
+import type { Validation } from "./Validation.js";
 export interface EndpointResolveUrlOptions<TParams extends Params | undefined, TQuery extends Query | undefined> {
     baseUrl?: string;
     params?: (TParams extends string | symbol | number ? Record<TParams, string> : never) | undefined;

package/esm/Endpoint.js

@@ -1,20 +1,17 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import * as Requester from "./Requester";
-import { resolvePathParams } from "./ApiUtils";
-import { processRequestConfigs } from "./RequestConfig";
+import { resolvePathParams } from "./ApiUtils.js";
+import { processRequestConfigs } from "./RequestConfig.js";
+import * as Requester from "./Requester.js";
 export default class Endpoint {
     constructor(api, options) {
-        var _a, _b;
         this.api = api;
-        this.info = Object.assign(Object.assign({}, options), { config: undefined, name: options.name || options.id, validation: options.validation || {}, middleware: options.middleware || [], defaultRequestConfig: (_b = (_a = options.defaultRequestConfig) !== null && _a !== void 0 ? _a : options.config) !== null && _b !== void 0 ? _b : {} });
+        this.info = {
+            ...options,
+            config: undefined,
+            name: options.name || options.id,
+            validation: options.validation || {},
+            middleware: options.middleware || [],
+            defaultRequestConfig: options.defaultRequestConfig ?? options.config ?? {},
+        };
     }
     get id() {
         return this.info.id;
@@ -50,22 +47,19 @@ export default class Endpoint {
     get middleware() {
         return this.info.middleware || [];
     }
-    submit(config) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            let mock = false;
-            const apiMocking = this.api.mocking;
-            if (apiMocking) {
-                const mockingEnabled = (_a = (typeof apiMocking.enabled === "function" ? apiMocking.enabled() : apiMocking.enabled)) !== null && _a !== void 0 ? _a : false;
-                if (mockingEnabled) {
-                    if (!((_b = this.mocking) === null || _b === void 0 ? void 0 : _b.handler)) {
-                        throw new Error(`[api-def] Endpoint for '${this.path}' has no mocking`);
-                    }
-                    mock = true;
+    async submit(config) {
+        let mock = false;
+        const apiMocking = this.api.mocking;
+        if (apiMocking) {
+            const mockingEnabled = (typeof apiMocking.enabled === "function" ? apiMocking.enabled() : apiMocking.enabled) ?? false;
+            if (mockingEnabled) {
+                if (!this.mocking?.handler) {
+                    throw new Error(`[api-def] Endpoint for '${this.path}' has no mocking`);
                 }
+                mock = true;
             }
-            return Requester.submit(this, config, mock ? this.mocking : null);
-        });
+        }
+        return Requester.submit(this, config, mock ? this.mocking : null);
     }
     resolveUrl(options) {
         const { query } = options;

package/esm/EndpointBuilder.d.ts

@@ -1,8 +1,8 @@
 import type * as zod from "zod";
-import type { Api } from "./Api";
-import type { ResponseType } from "./ApiConstants";
-import type { Body, Params, Query, RawHeaders, State } from "./ApiTypes";
-import Endpoint, { type EndpointOptions } from "./Endpoint";
+import type { Api } from "./Api.js";
+import type { ResponseType } from "./ApiConstants.js";
+import type { Body, Params, Query, RawHeaders, State } from "./ApiTypes.js";
+import Endpoint, { type EndpointOptions } from "./Endpoint.js";
 type DefaultResponseOf<T extends ResponseType | undefined> = T extends "text" ? string : T extends "arraybuffer" ? ArrayBuffer : "stream" extends T ? AsyncIterable<Uint8Array> : unknown;
 export type EndpointBuildOptions<TResponse = unknown, TParams extends Params | undefined = undefined, TQuery extends Query | undefined = undefined, TBody extends Body | undefined = undefined, TState extends State = State, TRequestHeaders extends RawHeaders | undefined = RawHeaders | undefined, TResponseHeaders extends RawHeaders | undefined = RawHeaders | undefined, TPath extends string = string, TResponseType extends ResponseType | undefined = undefined> = Omit<EndpointOptions<TResponse, TParams, TQuery, TBody, TState, TPath, TRequestHeaders, TResponseHeaders>, "validation"> & {
     responseType?: TResponseType;

package/esm/EndpointBuilder.js

@@ -1,4 +1,4 @@
-import Endpoint from "./Endpoint";
+import Endpoint from "./Endpoint.js";
 export default class EndpointBuilder {
     constructor(api) {
         this.validation = {};
@@ -30,7 +30,7 @@ export default class EndpointBuilder {
         return this;
     }
     build(options) {
-        const endpoint = new Endpoint(this.api, Object.assign(Object.assign({}, options), { validation: this.validation }));
+        const endpoint = new Endpoint(this.api, { ...options, validation: this.validation });
         this.api.endpoints[endpoint.id] = endpoint;
         return endpoint;
     }

package/esm/MockingTypes.d.ts

@@ -1,4 +1,4 @@
-import type { ApiResponse, Body, Params, Query, RawHeaders, State } from "./ApiTypes";
+import type { ApiResponse, Body, Params, Query, RawHeaders, State } from "./ApiTypes.js";
 export interface ApiMockingConfig {
     enabled: boolean | (() => boolean);
 }

package/esm/QueryHandling.d.ts

@@ -1,3 +1,3 @@
-import type { QueryStringify } from "./ApiTypes";
+import type { QueryStringify } from "./ApiTypes.js";
 export declare const DEFAULT_QUERY_STRINGIFY: QueryStringify;
 export declare const DEFAULT_QUERY_PARSE: (queryString: string) => Record<string, any>;

package/esm/QueryHandling.js

@@ -1,10 +1,9 @@
 export const DEFAULT_QUERY_STRINGIFY = (query) => {
-    var _a, _b;
     const queryStrings = [];
     const queryKeys = Object.keys(query);
     for (let i = 0; i < queryKeys.length; i++) {
         const key = queryKeys[i];
-        queryStrings.push(`${key}=${(_b = (_a = query[key]) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : ""}`);
+        queryStrings.push(`${key}=${query[key]?.toString() ?? ""}`);
     }
     return queryStrings.join("&");
 };
@@ -13,7 +12,7 @@ export const DEFAULT_QUERY_PARSE = (queryString) => {
     const queryStrings = queryString.split("&");
     for (let i = 0; i < queryStrings.length; i++) {
         const [key, value] = queryStrings[i].split("=");
-        query[key] = !(value === null || value === void 0 ? void 0 : value.length) ? true : value;
+        query[key] = !value?.length ? true : value;
     }
     return query;
 };

package/esm/RequestConfig.d.ts

@@ -1,2 +1,2 @@
-import { type BaseRequestConfig, type Body, type ComputedRequestConfig, type Params, type Query, type RawHeaders, type RequestConfig, type State } from "./ApiTypes";
+import { type BaseRequestConfig, type Body, type ComputedRequestConfig, type Params, type Query, type RawHeaders, type RequestConfig, type State } from "./ApiTypes.js";
 export declare const processRequestConfigs: <TParams extends Params | undefined, TQuery extends Query | undefined, TBody extends Body | undefined, TState extends State, TRequestHeaders extends RawHeaders | undefined>(configs: (RequestConfig<TParams, TQuery, TBody, TState, TRequestHeaders> | BaseRequestConfig | undefined)[]) => ComputedRequestConfig<TParams, TQuery, TBody, TState, TRequestHeaders>;

package/esm/RequestConfig.js

@@ -1,24 +1,23 @@
-import { COMPUTED_CONFIG_SYMBOL, } from "./ApiTypes";
-import { DEFAULT_QUERY_PARSE, DEFAULT_QUERY_STRINGIFY } from "./QueryHandling";
-import * as Utils from "./Utils";
+import { COMPUTED_CONFIG_SYMBOL, } from "./ApiTypes.js";
+import { DEFAULT_QUERY_PARSE, DEFAULT_QUERY_STRINGIFY } from "./QueryHandling.js";
+import * as Utils from "./Utils.js";
 const MERGED_CONFIG_KEYS = ["headers"];
 export const processRequestConfigs = (configs) => {
-    var _a, _b;
     const computedConfig = Utils.assign({
         [COMPUTED_CONFIG_SYMBOL]: true,
     }, ...configs);
     // merge other values
     for (const key of MERGED_CONFIG_KEYS) {
         computedConfig[key] = Utils.assign({}, ...configs.reduce((acc, config) => {
-            if (config === null || config === void 0 ? void 0 : config[key]) {
+            if (config?.[key]) {
                 acc.push(config[key]);
             }
             return acc;
         }, []));
     }
     computedConfig.queryHandling = {
-        parse: ((_a = computedConfig.queryHandling) === null || _a === void 0 ? void 0 : _a.parse) || DEFAULT_QUERY_PARSE,
-        stringify: ((_b = computedConfig.queryHandling) === null || _b === void 0 ? void 0 : _b.stringify) || computedConfig.queryParser || DEFAULT_QUERY_STRINGIFY,
+        parse: computedConfig.queryHandling?.parse || DEFAULT_QUERY_PARSE,
+        stringify: computedConfig.queryHandling?.stringify || computedConfig.queryParser || DEFAULT_QUERY_STRINGIFY,
     };
     computedConfig.queryParser = undefined;
     const query = computedConfig.query;

package/esm/RequestContext.d.ts

@@ -1,10 +1,10 @@
-import type { Api } from "./Api";
-import type { RequestEvent, RequestMethod, ResponseType } from "./ApiConstants";
-import type { ApiResponse, Body, ComputedRequestConfig, EventResult, Params, Query, RawHeaders, RequestCacheInfo, RequestEventHandlers, RequestHost, RequestStats, State } from "./ApiTypes";
-import type { EndpointMockingConfig } from "./MockingTypes";
-import type { RequestError } from "./RequestError";
-import type { Validation } from "./Validation";
-import type RequestBackend from "./backend/RequestBackend";
+import type { Api } from "./Api.js";
+import type { RequestEvent, RequestMethod, ResponseType } from "./ApiConstants.js";
+import type { ApiResponse, Body, ComputedRequestConfig, EventResult, Params, Query, RawHeaders, RequestCacheInfo, RequestEventHandlers, RequestHost, RequestStats, State } from "./ApiTypes.js";
+import type RequestBackend from "./backend/RequestBackend.js";
+import type { EndpointMockingConfig } from "./MockingTypes.js";
+import type { RequestError } from "./RequestError.js";
+import type { Validation } from "./Validation.js";
 export default class RequestContext<TResponse = any, TParams extends Params | undefined = Params | undefined, TQuery extends Query | undefined = Query | undefined, TBody extends Body | undefined = Body | undefined, TState extends State = State> {
     readonly id: number;
     readonly key: string;