@mintlify/http-client 0.0.5 → 0.0.8

package/LICENSE

@@ -0,0 +1,93 @@
+Copyright (c) 2022 Mintlify, Inc.
+
+Elastic License 2.0
+
+## Acceptance
+
+By using the software, you agree to all of the terms and conditions below.
+
+## Copyright License
+
+The licensor grants you a non-exclusive, royalty-free, worldwide,
+non-sublicensable, non-transferable license to use, copy, distribute, make
+available, and prepare derivative works of the software, in each case subject to
+the limitations and conditions below.
+
+## Limitations
+
+You may not provide the software to third parties as a hosted or managed
+service, where the service provides users with access to any substantial set of
+the features or functionality of the software.
+
+You may not move, change, disable, or circumvent the license key functionality
+in the software, and you may not remove or obscure any functionality in the
+software that is protected by the license key.
+
+You may not alter, remove, or obscure any licensing, copyright, or other notices
+of the licensor in the software. Any use of the licensor’s trademarks is subject
+to applicable law.
+
+## Patents
+
+The licensor grants you a license, under any patent claims the licensor can
+license, or becomes able to license, to make, have made, use, sell, offer for
+sale, import and have imported the software, in each case subject to the
+limitations and conditions in this license. This license does not cover any
+patent claims that you cause to be infringed by modifications or additions to
+the software. If you or your company make any written claim that the software
+infringes or contributes to infringement of any patent, your patent license for
+the software granted under these terms ends immediately. If your company makes
+such a claim, your patent license ends immediately for work on behalf of your
+company.
+
+## Notices
+
+You must ensure that anyone who gets a copy of any part of the software from you
+also gets a copy of these terms.
+
+If you modify the software, you must include in any modified copies of the
+software prominent notices stating that you have modified the software.
+
+## No Other Rights
+
+These terms do not imply any licenses other than those expressly granted in
+these terms.
+
+## Termination
+
+If you use the software in violation of these terms, such use is not licensed,
+and your licenses will automatically terminate. If the licensor provides you
+with a notice of your violation, and you cease all violation of this license no
+later than 30 days after you receive that notice, your licenses will be
+reinstated retroactively. However, if you violate these terms after such
+reinstatement, any additional violation of these terms will cause your licenses
+to terminate automatically and permanently.
+
+## No Liability
+
+_As far as the law allows, the software comes as is, without any warranty or
+condition, and the licensor will not be liable to you for any damages arising
+out of these terms or the use or nature of the software, under any kind of
+legal claim._
+
+## Definitions
+
+The **licensor** is the entity offering these terms, and the **software** is the
+software the licensor makes available under these terms, including any portion
+of it.
+
+**you** refers to the individual or entity agreeing to these terms.
+
+**your company** is any legal entity, sole proprietorship, or other kind of
+organization that you work for, plus all organizations that have control over,
+are under the control of, or are under common control with that
+organization. **control** means ownership of substantially all the assets of an
+entity, or the power to direct its management and policies by vote, contract, or
+otherwise. Control can be direct or indirect.
+
+**your licenses** are all the licenses granted to you for the software under
+these terms.
+
+**use** means anything you do with the software requiring one of your licenses.
+
+**trademark** means trademarks, service marks, and similar rights.

package/README.md

@@ -1,16 +1,16 @@
-# @mintlify/http-clients
-
-Reusable Mintlify http clients [npm package](https://www.npmjs.com/package/@mintlify/http-client). See [mintlify](../../README.md) for more documentation.
-
-## Installation
-
-```
-npm install @mintlify-http-client
-```
-
-## Usage
-
-```ts
-const client = getLeavesClient(subdomain);
-navPromise = client.getNavigation();
-```
+# @mintlify/http-clients
+
+Reusable Mintlify http clients [npm package](https://www.npmjs.com/package/@mintlify/http-client). See [mintlify](../../README.md) for more documentation.
+
+## Installation
+
+```
+npm install @mintlify-http-client
+```
+
+## Usage
+
+```ts
+const client = getLeavesClient(subdomain);
+navPromise = client.getNavigation();
+```

package/dist/client/baseClient.d.ts

@@ -1,64 +1,64 @@
-import { IBaseClient } from './interfaces';
-import { HttpMethods, QueryType, RequestInitType } from './types';
-/**
- * BaseClient serves as the base class for API clients.
- * Provides basic functionalities for making HTTP requests to a server.
- */
-export declare abstract class BaseClient implements IBaseClient {
-    readonly host: string;
-    protected readonly reqInit: RequestInit | undefined;
-    /**
-     * @param host - The server's address.
-     * @param reqInit - Optional default request initializer.
-     */
-    protected constructor(host: string, reqInit?: RequestInit | undefined);
-    fetch(path: string, query?: QueryType, init?: RequestInit): Promise<{
-        uri: string;
-        res: Response;
-        req: RequestInit;
-    }>;
-    get(path: string, query?: QueryType, init?: RequestInitType): Promise<Response>;
-    put(path: string, query?: QueryType, init?: RequestInitType): Promise<Response>;
-    delete(path: string, query?: QueryType, init?: RequestInitType): Promise<Response>;
-    post(path: string, query?: QueryType, init?: RequestInitType): Promise<Response>;
-    text(path: string, query?: QueryType, init?: RequestInit): Promise<string>;
-    json<T extends object>(path: string, query?: QueryType, init?: RequestInit): Promise<T>;
-    method(method: HttpMethods, path: string, query?: QueryType, init?: RequestInitType): Promise<Response>;
-    /**
-     * Constructs a URI path by joining URI components.
-     * @param paths - Paths to encode and join.
-     * @returns encoded URI path.
-     */
-    getPath(...paths: string[]): string;
-    /**
-     * Constructs a URI by appending a path to the host.
-     * @param path - The path to append to the host.
-     * @returns URI string.
-     */
-    getUri(path: string): string;
-    /**
-     * Handles text responses from the server.
-     * @param req - The request object.
-     * @param res - The response object.
-     * @param uri - The request URI.
-     * @returns Promise that resolves with the text data.
-     */
-    protected handleText({ req, res, uri, }: {
-        req: RequestInit;
-        res: Response;
-        uri: string;
-    }): Promise<string>;
-    /**
-     * Handles JSON responses from the server.
-     * @param req - The request object.
-     * @param res - The response object.
-     * @param uri - The request URI.
-     * @returns Promise that resolves with the JSON data.
-     */
-    protected handleJson<T>({ req, res, uri, }: {
-        req: RequestInit;
-        res: Response;
-        uri: string;
-    }): Promise<T>;
-}
+import { IBaseClient } from './interfaces';
+import { HttpMethods, QueryType, RequestInitType } from './types';
+/**
+ * BaseClient serves as the base class for API clients.
+ * Provides basic functionalities for making HTTP requests to a server.
+ */
+export declare abstract class BaseClient implements IBaseClient {
+    readonly host: string;
+    protected readonly reqInit: RequestInit | undefined;
+    /**
+     * @param host - The server's address.
+     * @param reqInit - Optional default request initializer.
+     */
+    protected constructor(host: string, reqInit?: RequestInit | undefined);
+    fetch(path: string, query?: QueryType, init?: RequestInit): Promise<{
+        uri: string;
+        res: Response;
+        req: RequestInit;
+    }>;
+    get(path: string, query?: QueryType, init?: RequestInitType): Promise<Response>;
+    put(path: string, query?: QueryType, init?: RequestInitType): Promise<Response>;
+    delete(path: string, query?: QueryType, init?: RequestInitType): Promise<Response>;
+    post(path: string, query?: QueryType, init?: RequestInitType): Promise<Response>;
+    text(path: string, query?: QueryType, init?: RequestInit): Promise<string>;
+    json<T extends object>(path: string, query?: QueryType, init?: RequestInit): Promise<T>;
+    method(method: HttpMethods, path: string, query?: QueryType, init?: RequestInitType): Promise<Response>;
+    /**
+     * Constructs a URI path by joining URI components.
+     * @param paths - Paths to encode and join.
+     * @returns encoded URI path.
+     */
+    getPath(...paths: string[]): string;
+    /**
+     * Constructs a URI by appending a path to the host.
+     * @param path - The path to append to the host.
+     * @returns URI string.
+     */
+    getUri(path: string): string;
+    /**
+     * Handles text responses from the server.
+     * @param req - The request object.
+     * @param res - The response object.
+     * @param uri - The request URI.
+     * @returns Promise that resolves with the text data.
+     */
+    protected handleText({ req, res, uri, }: {
+        req: RequestInit;
+        res: Response;
+        uri: string;
+    }): Promise<string>;
+    /**
+     * Handles JSON responses from the server.
+     * @param req - The request object.
+     * @param res - The response object.
+     * @param uri - The request URI.
+     * @returns Promise that resolves with the JSON data.
+     */
+    protected handleJson<T>({ req, res, uri, }: {
+        req: RequestInit;
+        res: Response;
+        uri: string;
+    }): Promise<T>;
+}
 //# sourceMappingURL=baseClient.d.ts.map

package/dist/client/baseClient.js

@@ -1,94 +1,94 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseClient = void 0;
-const clientError_1 = require("./clientError");
-/**
- * BaseClient serves as the base class for API clients.
- * Provides basic functionalities for making HTTP requests to a server.
- */
-class BaseClient {
-    /**
-     * @param host - The server's address.
-     * @param reqInit - Optional default request initializer.
-     */
-    constructor(host, reqInit = undefined) {
-        this.host = host;
-        this.reqInit = reqInit;
-    }
-    async fetch(path, query, init) {
-        const req = {
-            ...this.reqInit,
-            ...init,
-            headers: {
-                ...this.reqInit?.headers,
-                ...init?.headers,
-            },
-        };
-        let uri = this.getUri(path);
-        uri = query ? `${uri}?${new URLSearchParams(query)}` : uri;
-        return { uri, res: await fetch(uri, req), req };
-    }
-    get(path, query, init) {
-        return this.method('get', path, query, init);
-    }
-    put(path, query, init) {
-        return this.method('put', path, query, init);
-    }
-    delete(path, query, init) {
-        return this.method('delete', path, query, init);
-    }
-    post(path, query, init) {
-        return this.method('post', path, query, init);
-    }
-    async text(path, query, init) {
-        const result = await this.fetch(path, query, init);
-        return this.handleText(result);
-    }
-    async json(path, query, init) {
-        const result = await this.fetch(path, query, init);
-        return this.handleJson(result);
-    }
-    async method(method, path, query, init) {
-        const result = await this.fetch(path, query, { ...init, method });
-        return result.res;
-    }
-    /**
-     * Constructs a URI path by joining URI components.
-     * @param paths - Paths to encode and join.
-     * @returns encoded URI path.
-     */
-    getPath(...paths) {
-        return paths.map(encodeURIComponent).join('/');
-    }
-    /**
-     * Constructs a URI by appending a path to the host.
-     * @param path - The path to append to the host.
-     * @returns URI string.
-     */
-    getUri(path) {
-        return encodeURI(`${this.host}/${path}`);
-    }
-    /**
-     * Handles text responses from the server.
-     * @param req - The request object.
-     * @param res - The response object.
-     * @param uri - The request URI.
-     * @returns Promise that resolves with the text data.
-     */
-    handleText({ req, res, uri, }) {
-        return clientError_1.handleText.bind(this)(req, res, uri);
-    }
-    /**
-     * Handles JSON responses from the server.
-     * @param req - The request object.
-     * @param res - The response object.
-     * @param uri - The request URI.
-     * @returns Promise that resolves with the JSON data.
-     */
-    handleJson({ req, res, uri, }) {
-        const handle = (clientError_1.handleJson);
-        return handle.bind(this)(req, res, uri);
-    }
-}
-exports.BaseClient = BaseClient;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseClient = void 0;
+const clientError_1 = require("./clientError");
+/**
+ * BaseClient serves as the base class for API clients.
+ * Provides basic functionalities for making HTTP requests to a server.
+ */
+class BaseClient {
+    /**
+     * @param host - The server's address.
+     * @param reqInit - Optional default request initializer.
+     */
+    constructor(host, reqInit = undefined) {
+        this.host = host;
+        this.reqInit = reqInit;
+    }
+    async fetch(path, query, init) {
+        const req = {
+            ...this.reqInit,
+            ...init,
+            headers: {
+                ...this.reqInit?.headers,
+                ...init?.headers,
+            },
+        };
+        let uri = this.getUri(path);
+        uri = query ? `${uri}?${new URLSearchParams(query)}` : uri;
+        return { uri, res: await fetch(uri, req), req };
+    }
+    get(path, query, init) {
+        return this.method('get', path, query, init);
+    }
+    put(path, query, init) {
+        return this.method('put', path, query, init);
+    }
+    delete(path, query, init) {
+        return this.method('delete', path, query, init);
+    }
+    post(path, query, init) {
+        return this.method('post', path, query, init);
+    }
+    async text(path, query, init) {
+        const result = await this.fetch(path, query, init);
+        return this.handleText(result);
+    }
+    async json(path, query, init) {
+        const result = await this.fetch(path, query, init);
+        return this.handleJson(result);
+    }
+    async method(method, path, query, init) {
+        const result = await this.fetch(path, query, { ...init, method });
+        return result.res;
+    }
+    /**
+     * Constructs a URI path by joining URI components.
+     * @param paths - Paths to encode and join.
+     * @returns encoded URI path.
+     */
+    getPath(...paths) {
+        return paths.map(encodeURIComponent).join('/');
+    }
+    /**
+     * Constructs a URI by appending a path to the host.
+     * @param path - The path to append to the host.
+     * @returns URI string.
+     */
+    getUri(path) {
+        return encodeURI(`${this.host}/${path}`);
+    }
+    /**
+     * Handles text responses from the server.
+     * @param req - The request object.
+     * @param res - The response object.
+     * @param uri - The request URI.
+     * @returns Promise that resolves with the text data.
+     */
+    handleText({ req, res, uri, }) {
+        return clientError_1.handleText.bind(this)(req, res, uri);
+    }
+    /**
+     * Handles JSON responses from the server.
+     * @param req - The request object.
+     * @param res - The response object.
+     * @param uri - The request URI.
+     * @returns Promise that resolves with the JSON data.
+     */
+    handleJson({ req, res, uri, }) {
+        const handle = (clientError_1.handleJson);
+        return handle.bind(this)(req, res, uri);
+    }
+}
+exports.BaseClient = BaseClient;
 //# sourceMappingURL=baseClient.js.map

package/dist/client/clientError.d.ts

@@ -1,33 +1,33 @@
-import { BaseClient } from './baseClient';
-import { IClientError } from './interfaces';
-/**
- * Type guard for ClientError.
- * @param object - The object to check.
- * @returns True if the object is a ClientError; otherwise, false.
- */
-export declare function isClientError(object: any): object is IClientError;
-/**
- * Fetches a resource as text.
- * @param req - The request object.
- * @param res - The response object.
- * @param uri - The URI to fetch from.
- * @throws ClientError - If the response is not ok.
- * @returns The fetched text.
- */
-export declare function handleText(this: BaseClient, req: RequestInit, res: Response, uri: string): Promise<string>;
-/**
- * Fetches a resource as JSON.
- * @param req - The request object.
- * @param res - The response object.
- * @param uri - The URI to fetch from.
- * @throws ClientError - If the response is not ok.
- * @returns The fetched JSON data.
- */
-export declare function handleJson<T>(this: BaseClient, req: RequestInit, res: Response, uri: string): Promise<T>;
-/**
- * Checks if a client has access to a resource.
- * @param accessCondition - The condition to check to get access.
- * @throws ClientError - If the condition is true.
- */
-export declare function handleAccess<TClient extends BaseClient>(this: TClient, accessCondition: boolean): void;
+import { BaseClient } from './baseClient';
+import { IClientError } from './interfaces';
+/**
+ * Type guard for ClientError.
+ * @param object - The object to check.
+ * @returns True if the object is a ClientError; otherwise, false.
+ */
+export declare function isClientError(object: any): object is IClientError;
+/**
+ * Fetches a resource as text.
+ * @param req - The request object.
+ * @param res - The response object.
+ * @param uri - The URI to fetch from.
+ * @throws ClientError - If the response is not ok.
+ * @returns The fetched text.
+ */
+export declare function handleText(this: BaseClient, req: RequestInit, res: Response, uri: string): Promise<string>;
+/**
+ * Fetches a resource as JSON.
+ * @param req - The request object.
+ * @param res - The response object.
+ * @param uri - The URI to fetch from.
+ * @throws ClientError - If the response is not ok.
+ * @returns The fetched JSON data.
+ */
+export declare function handleJson<T>(this: BaseClient, req: RequestInit, res: Response, uri: string): Promise<T>;
+/**
+ * Checks if a client has access to a resource.
+ * @param accessCondition - The condition to check to get access.
+ * @throws ClientError - If the condition is true.
+ */
+export declare function handleAccess<TClient extends BaseClient>(this: TClient, accessCondition: boolean): void;
 //# sourceMappingURL=clientError.d.ts.map