api-def 0.12.0 → 0.13.0

package/cjs/Api.d.ts

@@ -1,9 +1,9 @@
 import type { ApiResponse, BaseRequestConfig, RequestConfig, RequestMiddleware } from "./ApiTypes";
 import { type ResolveUrlOptions } from "./ApiUtils";
+import type RequestBackend from "./backend/RequestBackend";
 import type Endpoint from "./Endpoint";
 import EndpointBuilder from "./EndpointBuilder";
 import type { ApiMockingConfig } from "./MockingTypes";
-import type RequestBackend from "./backend/RequestBackend";
 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/cjs/Api.js

@@ -1,95 +1,88 @@
 "use strict";
-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());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
     }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Api = exports.setRequestBackend = exports.isRequestBackendDefault = exports.getRequestBackend = void 0;
-var ApiConstants_1 = require("./ApiConstants");
-var ApiUtils_1 = require("./ApiUtils");
-var EndpointBuilder_1 = require("./EndpointBuilder");
-var RequestConfig_1 = require("./RequestConfig");
-var Requester = require("./Requester");
-var Utils = require("./Utils");
-var FetchRequestBackend_1 = require("./backend/FetchRequestBackend");
+const ApiConstants_1 = require("./ApiConstants");
+const ApiUtils_1 = require("./ApiUtils");
+const FetchRequestBackend_1 = __importDefault(require("./backend/FetchRequestBackend"));
+const EndpointBuilder_1 = __importDefault(require("./EndpointBuilder"));
+const RequestConfig_1 = require("./RequestConfig");
+const Requester = __importStar(require("./Requester"));
+const Utils = __importStar(require("./Utils"));
 // use fetch as default if it is present
-var requestBackend = Utils.getGlobalFetch() ? new FetchRequestBackend_1.default() : null;
-var requestBackendIsDefault = true;
-var getRequestBackend = function () {
+let requestBackend = Utils.getGlobalFetch() ? new FetchRequestBackend_1.default() : null;
+let requestBackendIsDefault = true;
+const getRequestBackend = () => {
     return requestBackend;
 };
 exports.getRequestBackend = getRequestBackend;
-var isRequestBackendDefault = function () {
+const isRequestBackendDefault = () => {
     return requestBackendIsDefault;
 };
 exports.isRequestBackendDefault = isRequestBackendDefault;
-var setRequestBackend = function (backend) {
+const setRequestBackend = (backend) => {
     requestBackendIsDefault = false;
     requestBackend = backend;
 };
 exports.setRequestBackend = setRequestBackend;
-var HotRequestHost = /** @class */ (function () {
-    function HotRequestHost(api, path, method) {
+class HotRequestHost {
+    constructor(api, path, method) {
         this.responseType = undefined;
         this.validation = {};
         this.api = api;
         this.method = method;
         this.path = path;
     }
-    Object.defineProperty(HotRequestHost.prototype, "baseUrl", {
-        get: function () {
-            return this.api.baseUrl;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    HotRequestHost.prototype.computeConfig = function (config) {
-        var apiDefaults = this.api.computeRequestConfig();
+    get baseUrl() {
+        return this.api.baseUrl;
+    }
+    computeConfig(config) {
+        const apiDefaults = this.api.computeRequestConfig();
         return (0, RequestConfig_1.processRequestConfigs)([apiDefaults, config]);
-    };
-    HotRequestHost.prototype.getRequestBackend = function () {
+    }
+    getRequestBackend() {
         return this.api.requestBackend;
-    };
-    return HotRequestHost;
-}());
-var Api = /** @class */ (function () {
+    }
+}
+class Api {
     //private mutable = false;
     //private wasMutable = false;
-    function Api(options) {
-        var _this = this;
-        var _a, _b, _c, _d;
+    constructor(options) {
         this.endpoints = {};
         /*configure(info: Partial<ApiInfo>): void {
           if (!this.mutable) {
@@ -101,20 +94,13 @@ var Api = /** @class */ (function () {
           Object.assign(this.info, info);
           this.mutable = false;
         }*/
-        this.hotRequest = function (requestMethod) {
-            return function (path, config) { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, Requester.submit(new HotRequestHost(this, path, requestMethod), config, null)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            }); }); };
-        };
+        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(ApiConstants_1.RequestMethod.GET);
         this.post = this.hotRequest(ApiConstants_1.RequestMethod.POST);
         this.put = this.hotRequest(ApiConstants_1.RequestMethod.PUT);
         this.delete = this.hotRequest(ApiConstants_1.RequestMethod.DELETE);
         this.patch = this.hotRequest(ApiConstants_1.RequestMethod.PATCH);
-        var requestBackend = (_a = options.requestBackend) !== null && _a !== void 0 ? _a : (0, exports.getRequestBackend)();
+        const requestBackend = options.requestBackend ?? (0, exports.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`");
         }
@@ -122,91 +108,61 @@ var Api = /** @class */ (function () {
             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;
         //this.wasMutable = this.mutable;
         this.endpoints = {};
     }
-    Object.defineProperty(Api.prototype, "requestBackend", {
-        get: function () {
-            return this.info.requestBackend;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Api.prototype, "baseUrl", {
-        get: function () {
-            return this.info.baseUrl;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Api.prototype, "config", {
-        /**
-         * @deprecated use `defaultRequestConfig` instead
-         */
-        get: function () {
-            return this.info.defaultRequestConfig;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Api.prototype, "defaultRequestConfig", {
-        get: function () {
-            return this.info.defaultRequestConfig;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Api.prototype, "middleware", {
-        get: function () {
-            return this.info.middleware;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Api.prototype, "mocking", {
-        get: function () {
-            return this.info.mocking;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Api.prototype, "name", {
-        get: function () {
-            return this.info.name;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Api.prototype.endpoint = function () {
+    get requestBackend() {
+        return this.info.requestBackend;
+    }
+    get baseUrl() {
+        return this.info.baseUrl;
+    }
+    /**
+     * @deprecated use `defaultRequestConfig` instead
+     */
+    get config() {
+        return this.info.defaultRequestConfig;
+    }
+    get defaultRequestConfig() {
+        return this.info.defaultRequestConfig;
+    }
+    get middleware() {
+        return this.info.middleware;
+    }
+    get mocking() {
+        return this.info.mocking;
+    }
+    get name() {
+        return this.info.name;
+    }
+    endpoint() {
         return new EndpointBuilder_1.default(this);
-    };
+    }
     /**
      * @deprecated use `requestBackend` instead
      */
-    Api.prototype.getRequestBackend = function () {
+    getRequestBackend() {
         return this.requestBackend;
-    };
+    }
     /**
      * @deprecated use `computeRequestConfig()` instead
      */
-    Api.prototype.getConfig = function () {
+    getConfig() {
         return this.computeRequestConfig();
-    };
-    Api.prototype.computeRequestConfig = function () {
+    }
+    computeRequestConfig() {
         return ((typeof this.defaultRequestConfig === "function" ? this.defaultRequestConfig() : this.defaultRequestConfig) || {});
-    };
-    Api.prototype.resolveUrl = function (options) {
-        var _a;
+    }
+    resolveUrl(options) {
         return (0, ApiUtils_1.resolveUrl)({
-            baseUrl: (_a = options.baseUrl) !== null && _a !== void 0 ? _a : this.baseUrl,
+            baseUrl: options.baseUrl ?? this.baseUrl,
             path: options.path,
         });
-    };
-    return Api;
-}());
+    }
+}
 exports.Api = Api;

package/cjs/ApiTypes.d.ts

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

package/cjs/ApiUtils.d.ts

@@ -1,11 +1,12 @@
 import type { ResponseType } from "./ApiConstants";
 import type { AcceptableStatus, CancelledRequestError } from "./ApiTypes";
 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/cjs/ApiUtils.js

@@ -1,24 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveUrl = exports.resolvePathParams = exports.inferResponseType = exports.isAcceptableStatus = exports.isNetworkError = exports.isCancelledError = void 0;
-var isCancelledError = function (error) {
+exports.resolveUrl = exports.resolvePathParams = exports.inferResponseType = exports.isAcceptableStatus = exports.isAbsoluteUrl = exports.isNetworkError = exports.isCancelledError = void 0;
+const isCancelledError = (error) => {
     return "isCancelledRequest" in error;
 };
 exports.isCancelledError = isCancelledError;
-var isNetworkError = function (error) {
-    var _a;
+const isNetworkError = (error) => {
     return (error.name === "NetworkError" ||
         error.message === "Network Error" ||
-        ((_a = error.constructor) === null || _a === void 0 ? void 0 : _a.name) === "NetworkError");
+        error.constructor?.name === "NetworkError");
 };
 exports.isNetworkError = isNetworkError;
-var DEFAULT_ACCEPTABLE_STATUS = [[200, 299], 304];
-var isAcceptableStatus = function (status, acceptableStatus) {
-    var acceptable = acceptableStatus !== null && acceptableStatus !== void 0 ? acceptableStatus : DEFAULT_ACCEPTABLE_STATUS;
-    for (var _i = 0, acceptable_1 = acceptable; _i < acceptable_1.length; _i++) {
-        var cmpStatus = acceptable_1[_i];
+const isAbsoluteUrl = (url) => {
+    return /^[a-zA-Z][a-zA-Z\d+\-.]*:\/\//.test(url);
+};
+exports.isAbsoluteUrl = isAbsoluteUrl;
+const DEFAULT_ACCEPTABLE_STATUS = [[200, 299], 304];
+const isAcceptableStatus = (status, acceptableStatus) => {
+    const acceptable = acceptableStatus ?? DEFAULT_ACCEPTABLE_STATUS;
+    for (const cmpStatus of acceptable) {
         if (Array.isArray(cmpStatus)) {
-            var min = cmpStatus[0], max = cmpStatus[1];
+            const [min, max] = cmpStatus;
             if (status >= min && status <= max) {
                 return true;
             }
@@ -32,12 +34,12 @@ var isAcceptableStatus = function (status, acceptableStatus) {
     return false;
 };
 exports.isAcceptableStatus = isAcceptableStatus;
-var TEXT_CONTENT_TYPES = ["text/plain", "text/html", "text/xml", "application/xml"];
-var JSON_CONTENT_TYPES = ["text/json", "application/json"];
-var ARRAY_BUFFER_CONTENT_TYPES = ["application/octet-stream"];
-var STREAM_CONTENT_TYPES = ["text/event-stream", "application/x-ndjson"];
-var inferResponseType = function (contentType) {
-    var contentTypePart = contentType === null || contentType === void 0 ? void 0 : contentType.split(";")[0].trim();
+const TEXT_CONTENT_TYPES = ["text/plain", "text/html", "text/xml", "application/xml"];
+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"];
+const inferResponseType = (contentType) => {
+    const contentTypePart = contentType?.split(";")[0].trim();
     if (contentTypePart) {
         if (TEXT_CONTENT_TYPES.includes(contentTypePart)) {
             return "text";
@@ -55,14 +57,14 @@ var inferResponseType = function (contentType) {
     return "text";
 };
 exports.inferResponseType = inferResponseType;
-var resolvePathParams = function (path, params, allowMissing) {
-    var computedPath = path.startsWith("/") ? path : "/".concat(path);
+const resolvePathParams = (path, params, allowMissing) => {
+    const computedPath = path.startsWith("/") || (0, exports.isAbsoluteUrl)(path) ? path : `/${path}`;
     if (params) {
-        var computedPathParts = computedPath.split("/");
-        var unusedKeys = new Set(Object.keys(params));
-        for (var i = 0; i < computedPathParts.length; i++) {
-            var part = computedPathParts[i];
-            var paramKey = void 0;
+        const computedPathParts = computedPath.split("/");
+        const unusedKeys = new Set(Object.keys(params));
+        for (let i = 0; i < computedPathParts.length; i++) {
+            const part = computedPathParts[i];
+            let paramKey;
             if (part.startsWith(":")) {
                 paramKey = part.substring(1);
             }
@@ -70,36 +72,42 @@ var resolvePathParams = function (path, params, allowMissing) {
                 paramKey = part.substring(1, part.length - 1);
             }
             if (paramKey) {
-                var paramValue = params[paramKey];
+                const paramValue = params[paramKey];
                 if (!paramValue) {
                     if (allowMissing) {
                         continue;
                     }
-                    throw new Error("[api-def] Missing param '".concat(paramKey, "'"));
+                    throw new Error(`[api-def] Missing param '${paramKey}'`);
                 }
                 computedPathParts[i] = paramValue;
                 unusedKeys.delete(paramKey);
             }
         }
         if (unusedKeys.size > 0 && !allowMissing) {
-            throw new Error("[api-def] Missing param '".concat(Array.from(unusedKeys)[0], "'"));
+            throw new Error(`[api-def] Missing param '${Array.from(unusedKeys)[0]}'`);
         }
         return computedPathParts.join("/");
     }
     return computedPath;
 };
 exports.resolvePathParams = resolvePathParams;
-var resolveUrl = function (options) {
-    var baseUrl = options.baseUrl, path = options.path;
-    var result = !baseUrl.endsWith("/") ? "".concat(baseUrl, "/") : baseUrl;
+const resolveUrl = (options) => {
+    const { baseUrl, path } = options;
+    if (path instanceof URL) {
+        return new URL(path.href);
+    }
+    if ((0, exports.isAbsoluteUrl)(path)) {
+        return new URL(path);
+    }
+    let result = !baseUrl.endsWith("/") ? `${baseUrl}/` : baseUrl;
     result += path.startsWith("/") ? path.substring(1) : path;
-    var origin = undefined;
+    let origin;
     if (typeof window !== "undefined") {
         origin = window.origin;
     }
     if (!origin) {
-        if (result.indexOf("://") === -1) {
-            result = "https://".concat(result);
+        if (!(0, exports.isAbsoluteUrl)(result)) {
+            result = `https://${result}`;
         }
     }
     return new URL(result, origin);

package/cjs/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 RequestBackend from "./backend/RequestBackend";
 import type * as Mocking from "./MockingTypes";
 import type { Validation } from "./Validation";
-import type RequestBackend from "./backend/RequestBackend";
 export interface EndpointResolveUrlOptions<TParams extends Params | undefined, TQuery extends Query | undefined> {
     baseUrl?: string;
     params?: (TParams extends string | symbol | number ? Record<TParams, string> : never) | undefined;