@gitkraken/core-gitlens 0.6.0 → 0.7.0

package/dist/plus/integrations/errors.d.ts

@@ -1,6 +1,5 @@
-export type { AuthTokenInfo } from '../../git/errors.js';
-export { AuthenticationError, AuthenticationErrorReason, RequestClientError, RequestNotFoundError, RequestRateLimitError, } from '../../git/errors.js';
-import { RequestRateLimitError } from '../../git/errors.js';
+import { AuthTokenInfo, AuthenticationError, AuthenticationErrorReason, RequestClientError, RequestNotFoundError, RequestRateLimitError } from "../../git/errors.js";
+//#region ../plus/integrations/src/errors.d.ts
 /**
  * Thrown by a provider read when it can't produce a result for a reason that is NOT "the account is empty":
  * a prerequisite is missing (e.g. Trello has no app key) or a required scope can't be resolved (e.g. the
@@ -9,28 +8,28 @@ import { RequestRateLimitError } from '../../git/errors.js';
  * `{ error }` the facade surfaces as a warning + `fetchFailed`.
  */
 export declare class IntegrationReadUnavailableError extends Error {
-    constructor(provider: string, reason: string);
+  constructor(provider: string, reason: string);
 }
 /**
  * Thrown by integration provider HTTP clients when an upstream request fails.
  */
 export declare class ProviderFetchError extends Error {
-    readonly response: Response;
-    get status(): number;
-    get statusText(): string;
-    /**
-     * Builds the error with the upstream body folded into the message, for clients that hold a `Response` whose
-     * body has not been read (i.e. every non-`ok` path). Use this rather than the constructor whenever the body is
-     * still available: the status line alone cannot distinguish a throttled request from a permission failure on
-     * the statuses hosts overload (see {@link isRateLimitResponse}), and only the body says which one it is.
-     *
-     * Never throws: the body is best-effort, so an unreadable, empty, or already-consumed one simply yields the
-     * status-line-only message the constructor would have produced.
-     */
-    static fromResponse(provider: string, response: Response): Promise<ProviderFetchError>;
-    constructor(provider: string, response: Response, errors?: {
-        message: string;
-    }[]);
+  readonly response: Response;
+  get status(): number;
+  get statusText(): string;
+  /**
+   * Builds the error with the upstream body folded into the message, for clients that hold a `Response` whose
+   * body has not been read (i.e. every non-`ok` path). Use this rather than the constructor whenever the body is
+   * still available: the status line alone cannot distinguish a throttled request from a permission failure on
+   * the statuses hosts overload (see {@link isRateLimitResponse}), and only the body says which one it is.
+   *
+   * Never throws: the body is best-effort, so an unreadable, empty, or already-consumed one simply yields the
+   * status-line-only message the constructor would have produced.
+   */
+  static fromResponse(provider: string, response: Response): Promise<ProviderFetchError>;
+  constructor(provider: string, response: Response, errors?: {
+    message: string;
+  }[]);
 }
 /**
  * Whether a provider's error response denotes a rate limit rather than a permission failure. Kept here, in one
@@ -50,8 +49,8 @@ export declare class ProviderFetchError extends Error {
  * "(403) Forbidden." and can never match, which is what made this check dead code on the direct-fetch clients.
  */
 export declare function isRateLimitResponse(ex: {
-    status: number;
-    message?: string;
+  status: number;
+  message?: string;
 }): boolean;
 /**
  * A response's headers as either a `fetch` `Headers` instance or the plain object an SDK error carries. Read via
@@ -65,9 +64,9 @@ type ResponseHeaders = Pick<Headers, 'get'> | Record<string, unknown>;
  * instance the direct clients get, and the plain object the SDK attaches to its errors.
  */
 export declare function toRateLimitError(ex: Error & {
-    response?: {
-        headers?: ResponseHeaders;
-    };
+  response?: {
+    headers?: ResponseHeaders;
+  };
 }, token: string | undefined): RequestRateLimitError;
 /**
  * Normalizes a caught `unknown` into an `Error`. Result cores type their failure channel as `error: Error`,
@@ -76,4 +75,6 @@ export declare function toRateLimitError(ex: Error & {
  * classification. Passes an existing `Error` through unchanged and wraps anything else with `String(ex)`.
  */
 export declare function toError(ex: unknown): Error;
+//#endregion
+export { type AuthTokenInfo, AuthenticationError, AuthenticationErrorReason, RequestClientError, RequestNotFoundError, RequestRateLimitError };
 //# sourceMappingURL=errors.d.ts.map

package/dist/plus/integrations/errors.js

@@ -1,154 +1,130 @@
-export { AuthenticationError, AuthenticationErrorReason, RequestClientError, RequestNotFoundError, RequestRateLimitError, } from '../../git/errors.js';
-import { RequestRateLimitError } from '../../git/errors.js';
+import { AuthenticationError, AuthenticationErrorReason, RequestClientError, RequestNotFoundError, RequestRateLimitError } from "../../git/errors.js";
+//#region ../plus/integrations/src/errors.ts
 /**
- * Thrown by a provider read when it can't produce a result for a reason that is NOT "the account is empty":
- * a prerequisite is missing (e.g. Trello has no app key) or a required scope can't be resolved (e.g. the
- * Linear viewer id, needed to scope "my issues"). Returning an empty/undefined result in these cases would be
- * indistinguishable from a genuinely empty account; throwing this lets the result cores recover it into an
- * `{ error }` the facade surfaces as a warning + `fetchFailed`.
- */
-export class IntegrationReadUnavailableError extends Error {
-    constructor(provider, reason) {
-        super(`${provider} read unavailable: ${reason}`);
-        Error.captureStackTrace?.(this, new.target);
-    }
-}
+* Thrown by a provider read when it can't produce a result for a reason that is NOT "the account is empty":
+* a prerequisite is missing (e.g. Trello has no app key) or a required scope can't be resolved (e.g. the
+* Linear viewer id, needed to scope "my issues"). Returning an empty/undefined result in these cases would be
+* indistinguishable from a genuinely empty account; throwing this lets the result cores recover it into an
+* `{ error }` the facade surfaces as a warning + `fetchFailed`.
+*/
+var IntegrationReadUnavailableError = class extends Error {
+	constructor(provider, reason) {
+		super(`${provider} read unavailable: ${reason}`);
+		Error.captureStackTrace?.(this, new.target);
+	}
+};
 /**
- * Thrown by integration provider HTTP clients when an upstream request fails.
- */
-export class ProviderFetchError extends Error {
-    response;
-    get status() {
-        return this.response.status;
-    }
-    get statusText() {
-        return this.response.statusText;
-    }
-    /**
-     * Builds the error with the upstream body folded into the message, for clients that hold a `Response` whose
-     * body has not been read (i.e. every non-`ok` path). Use this rather than the constructor whenever the body is
-     * still available: the status line alone cannot distinguish a throttled request from a permission failure on
-     * the statuses hosts overload (see {@link isRateLimitResponse}), and only the body says which one it is.
-     *
-     * Never throws: the body is best-effort, so an unreadable, empty, or already-consumed one simply yields the
-     * status-line-only message the constructor would have produced.
-     */
-    static async fromResponse(provider, response) {
-        return new ProviderFetchError(provider, response, await readErrorBodyMessage(response));
-    }
-    constructor(provider, response, errors) {
-        super(`${provider} request failed: ${!response.ok ? `(${response.status}) ${response.statusText}. ` : ''}${errors?.length ? errors[0].message : ''}`);
-        this.response = response;
-        Error.captureStackTrace?.(this, new.target);
-    }
-}
+* Thrown by integration provider HTTP clients when an upstream request fails.
+*/
+var ProviderFetchError = class ProviderFetchError extends Error {
+	response;
+	get status() {
+		return this.response.status;
+	}
+	get statusText() {
+		return this.response.statusText;
+	}
+	/**
+	* Builds the error with the upstream body folded into the message, for clients that hold a `Response` whose
+	* body has not been read (i.e. every non-`ok` path). Use this rather than the constructor whenever the body is
+	* still available: the status line alone cannot distinguish a throttled request from a permission failure on
+	* the statuses hosts overload (see {@link isRateLimitResponse}), and only the body says which one it is.
+	*
+	* Never throws: the body is best-effort, so an unreadable, empty, or already-consumed one simply yields the
+	* status-line-only message the constructor would have produced.
+	*/
+	static async fromResponse(provider, response) {
+		return new ProviderFetchError(provider, response, await readErrorBodyMessage(response));
+	}
+	constructor(provider, response, errors) {
+		super(`${provider} request failed: ${!response.ok ? `(${response.status}) ${response.statusText}. ` : ""}${errors?.length ? errors[0].message : ""}`);
+		this.response = response;
+		Error.captureStackTrace?.(this, new.target);
+	}
+};
 /** Cap on the body text folded into an error message, so an HTML error page can't become the message. */
 const maxErrorBodyLength = 500;
 /**
- * Best-effort human-readable message from an error response body, in the `errors` shape the
- * {@link ProviderFetchError} constructor takes. Tolerant by design — every host in use words its errors
- * differently and some do not send JSON at all:
- *   - Azure DevOps — `{ message: "TF400733: ..." }`
- *   - Bitbucket    — `{ error: { message: "..." } }`, and bare text for a throttled request
- *   - GitLab       — `{ message: "..." }` or `{ error: "..." }`
- * Anything unrecognized falls back to the raw text, which is what the substring check wants anyway.
- */
+* Best-effort human-readable message from an error response body, in the `errors` shape the
+* {@link ProviderFetchError} constructor takes. Tolerant by design — every host in use words its errors
+* differently and some do not send JSON at all:
+*   - Azure DevOps — `{ message: "TF400733: ..." }`
+*   - Bitbucket    — `{ error: { message: "..." } }`, and bare text for a throttled request
+*   - GitLab       — `{ message: "..." }` or `{ error: "..." }`
+* Anything unrecognized falls back to the raw text, which is what the substring check wants anyway.
+*/
 async function readErrorBodyMessage(response) {
-    let text;
-    try {
-        // `bodyUsed` is not a guarantee (a stream can fail mid-read), hence the catch — but it avoids the throw
-        // entirely on the common path where something upstream already consumed the body.
-        if (response.bodyUsed)
-            return undefined;
-        text = (await response.text())?.trim();
-    }
-    catch {
-        return undefined;
-    }
-    if (!text)
-        return undefined;
-    let message;
-    try {
-        const body = JSON.parse(text);
-        if (body != null && typeof body === 'object') {
-            const { message: m, error } = body;
-            if (typeof m === 'string') {
-                message = m;
-            }
-            else if (typeof error === 'string') {
-                message = error;
-            }
-            else if (error != null && typeof error === 'object') {
-                // Some hosts nest it as `{ error: { message } }`; narrow the same way as the outer object.
-                const nested = error.message;
-                if (typeof nested === 'string') {
-                    message = nested;
-                }
-            }
-        }
-    }
-    catch {
-        // Not JSON — Bitbucket sends bare text for a throttled request, and any host can send an HTML error page.
-    }
-    message = (message ?? text).trim();
-    return message ? [{ message: message.slice(0, maxErrorBodyLength) }] : undefined;
+	let text;
+	try {
+		if (response.bodyUsed) return void 0;
+		text = (await response.text())?.trim();
+	} catch {
+		return;
+	}
+	if (!text) return void 0;
+	let message;
+	try {
+		const body = JSON.parse(text);
+		if (body != null && typeof body === "object") {
+			const { message: m, error } = body;
+			if (typeof m === "string") message = m;
+			else if (typeof error === "string") message = error;
+			else if (error != null && typeof error === "object") {
+				const nested = error.message;
+				if (typeof nested === "string") message = nested;
+			}
+		}
+	} catch {}
+	message = (message ?? text).trim();
+	return message ? [{ message: message.slice(0, maxErrorBodyLength) }] : void 0;
 }
 /**
- * Whether a provider's error response denotes a rate limit rather than a permission failure. Kept here, in one
- * place, because the distinction is consequential: a rate limit is retryable, while a permission failure is
- * surfaced as `auth` and drives a reconnect prompt — misclassifying one as the other asks the user to
- * re-authenticate a perfectly healthy connection.
- *
- * Which status a throttled request arrives on varies by host, which is why this takes both:
- *   - Azure DevOps and Bitbucket Cloud document 429 (learn.microsoft.com .../integrate/concepts/rate-limits).
- *   - GitHub documents "a `403` or `429` response" for both its primary and secondary limits
- *     (docs.github.com/en/rest/using-the-rest-api/rate-limits-for-the-rest-api).
- *   - GitLab uses 403 for some throttles.
- * So 429 alone is decisive, and on 403 the message decides.
- *
- * NOTE the message must actually carry the host's body for the 403 path to work — see
- * {@link ProviderFetchError.fromResponse}. A `ProviderFetchError` built from the status line alone reads
- * "(403) Forbidden." and can never match, which is what made this check dead code on the direct-fetch clients.
- */
-export function isRateLimitResponse(ex) {
-    // Matches the phrasing hosts actually use: GitHub/Bitbucket "API rate limit exceeded", GitLab "rate limit
-    // exceeded", Azure "Request was blocked due to exceeding usage of resource 'RateLimit'" / "TF400733: The
-    // request has been canceled: Request was blocked due to exceeding usage".
-    if (ex.status === 429)
-        return true;
-    const message = ex.message?.toLowerCase();
-    return message != null && (message.includes('rate limit') || message.includes('ratelimit'));
+* Whether a provider's error response denotes a rate limit rather than a permission failure. Kept here, in one
+* place, because the distinction is consequential: a rate limit is retryable, while a permission failure is
+* surfaced as `auth` and drives a reconnect prompt — misclassifying one as the other asks the user to
+* re-authenticate a perfectly healthy connection.
+*
+* Which status a throttled request arrives on varies by host, which is why this takes both:
+*   - Azure DevOps and Bitbucket Cloud document 429 (learn.microsoft.com .../integrate/concepts/rate-limits).
+*   - GitHub documents "a `403` or `429` response" for both its primary and secondary limits
+*     (docs.github.com/en/rest/using-the-rest-api/rate-limits-for-the-rest-api).
+*   - GitLab uses 403 for some throttles.
+* So 429 alone is decisive, and on 403 the message decides.
+*
+* NOTE the message must actually carry the host's body for the 403 path to work — see
+* {@link ProviderFetchError.fromResponse}. A `ProviderFetchError` built from the status line alone reads
+* "(403) Forbidden." and can never match, which is what made this check dead code on the direct-fetch clients.
+*/
+function isRateLimitResponse(ex) {
+	if (ex.status === 429) return true;
+	const message = ex.message?.toLowerCase();
+	return message != null && (message.includes("rate limit") || message.includes("ratelimit"));
 }
 /**
- * Builds a {@link RequestRateLimitError} from a provider error response, reading the reset epoch from the
- * standard `x-ratelimit-reset` header when present. Accepts both header shapes in use: the `fetch` `Headers`
- * instance the direct clients get, and the plain object the SDK attaches to its errors.
- */
-export function toRateLimitError(ex, token) {
-    const headers = ex.response?.headers;
-    const raw = headers == null
-        ? undefined
-        : typeof headers.get === 'function'
-            ? headers.get('x-ratelimit-reset')
-            : headers['x-ratelimit-reset'];
-    // Only a header that actually came back as a string/number can be a reset epoch; anything else (a nested SDK
-    // object, an array of values) would stringify to garbage and parse to NaN anyway.
-    let resetAt;
-    if (typeof raw === 'string' || typeof raw === 'number') {
-        resetAt = parseInt(String(raw), 10);
-        if (Number.isNaN(resetAt)) {
-            resetAt = undefined;
-        }
-    }
-    return new RequestRateLimitError(ex, token, resetAt);
+* Builds a {@link RequestRateLimitError} from a provider error response, reading the reset epoch from the
+* standard `x-ratelimit-reset` header when present. Accepts both header shapes in use: the `fetch` `Headers`
+* instance the direct clients get, and the plain object the SDK attaches to its errors.
+*/
+function toRateLimitError(ex, token) {
+	const headers = ex.response?.headers;
+	const raw = headers == null ? void 0 : typeof headers.get === "function" ? headers.get("x-ratelimit-reset") : headers["x-ratelimit-reset"];
+	let resetAt;
+	if (typeof raw === "string" || typeof raw === "number") {
+		resetAt = parseInt(String(raw), 10);
+		if (Number.isNaN(resetAt)) resetAt = void 0;
+	}
+	return new RequestRateLimitError(ex, token, resetAt);
 }
 /**
- * Normalizes a caught `unknown` into an `Error`. Result cores type their failure channel as `error: Error`,
- * but a `catch` binding is `unknown` and a provider (or a third-party SDK) can throw a non-Error value;
- * returning it raw would leak a non-Error through the public result surface and break downstream `instanceof`
- * classification. Passes an existing `Error` through unchanged and wraps anything else with `String(ex)`.
- */
-export function toError(ex) {
-    return ex instanceof Error ? ex : new Error(String(ex));
+* Normalizes a caught `unknown` into an `Error`. Result cores type their failure channel as `error: Error`,
+* but a `catch` binding is `unknown` and a provider (or a third-party SDK) can throw a non-Error value;
+* returning it raw would leak a non-Error through the public result surface and break downstream `instanceof`
+* classification. Passes an existing `Error` through unchanged and wraps anything else with `String(ex)`.
+*/
+function toError(ex) {
+	return ex instanceof Error ? ex : new Error(String(ex));
 }
+//#endregion
+export { AuthenticationError, AuthenticationErrorReason, IntegrationReadUnavailableError, ProviderFetchError, RequestClientError, RequestNotFoundError, RequestRateLimitError, isRateLimitResponse, toError, toRateLimitError };
+
 //# sourceMappingURL=errors.js.map

package/dist/plus/integrations/errors.js.map

@@ -1 +1 @@
-{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../../src/plus/integrations/errors.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"errors.js","names":[],"sources":["../../../../plus/integrations/src/errors.ts"],"sourcesContent":["export type { AuthTokenInfo } from '@gitlens/git/errors.js';\nexport {\n\tAuthenticationError,\n\tAuthenticationErrorReason,\n\tRequestClientError,\n\tRequestNotFoundError,\n\tRequestRateLimitError,\n} from '@gitlens/git/errors.js';\n\nimport { RequestRateLimitError } from '@gitlens/git/errors.js';\n\n/**\n * Thrown by a provider read when it can't produce a result for a reason that is NOT \"the account is empty\":\n * a prerequisite is missing (e.g. Trello has no app key) or a required scope can't be resolved (e.g. the\n * Linear viewer id, needed to scope \"my issues\"). Returning an empty/undefined result in these cases would be\n * indistinguishable from a genuinely empty account; throwing this lets the result cores recover it into an\n * `{ error }` the facade surfaces as a warning + `fetchFailed`.\n */\nexport class IntegrationReadUnavailableError extends Error {\n\tconstructor(provider: string, reason: string) {\n\t\tsuper(`${provider} read unavailable: ${reason}`);\n\t\tError.captureStackTrace?.(this, new.target);\n\t}\n}\n\n/**\n * Thrown by integration provider HTTP clients when an upstream request fails.\n */\nexport class ProviderFetchError extends Error {\n\tget status(): number {\n\t\treturn this.response.status;\n\t}\n\n\tget statusText(): string {\n\t\treturn this.response.statusText;\n\t}\n\n\t/**\n\t * Builds the error with the upstream body folded into the message, for clients that hold a `Response` whose\n\t * body has not been read (i.e. every non-`ok` path). Use this rather than the constructor whenever the body is\n\t * still available: the status line alone cannot distinguish a throttled request from a permission failure on\n\t * the statuses hosts overload (see {@link isRateLimitResponse}), and only the body says which one it is.\n\t *\n\t * Never throws: the body is best-effort, so an unreadable, empty, or already-consumed one simply yields the\n\t * status-line-only message the constructor would have produced.\n\t */\n\tstatic async fromResponse(provider: string, response: Response): Promise<ProviderFetchError> {\n\t\treturn new ProviderFetchError(provider, response, await readErrorBodyMessage(response));\n\t}\n\n\tconstructor(\n\t\tprovider: string,\n\t\tpublic readonly response: Response,\n\t\terrors?: { message: string }[],\n\t) {\n\t\tsuper(\n\t\t\t`${provider} request failed: ${!response.ok ? `(${response.status}) ${response.statusText}. ` : ''}${\n\t\t\t\terrors?.length ? errors[0].message : ''\n\t\t\t}`,\n\t\t);\n\n\t\tError.captureStackTrace?.(this, new.target);\n\t}\n}\n\n/** Cap on the body text folded into an error message, so an HTML error page can't become the message. */\nconst maxErrorBodyLength = 500;\n\n/**\n * Best-effort human-readable message from an error response body, in the `errors` shape the\n * {@link ProviderFetchError} constructor takes. Tolerant by design — every host in use words its errors\n * differently and some do not send JSON at all:\n *   - Azure DevOps — `{ message: \"TF400733: ...\" }`\n *   - Bitbucket    — `{ error: { message: \"...\" } }`, and bare text for a throttled request\n *   - GitLab       — `{ message: \"...\" }` or `{ error: \"...\" }`\n * Anything unrecognized falls back to the raw text, which is what the substring check wants anyway.\n */\nasync function readErrorBodyMessage(response: Response): Promise<{ message: string }[] | undefined> {\n\tlet text;\n\ttry {\n\t\t// `bodyUsed` is not a guarantee (a stream can fail mid-read), hence the catch — but it avoids the throw\n\t\t// entirely on the common path where something upstream already consumed the body.\n\t\tif (response.bodyUsed) return undefined;\n\n\t\ttext = (await response.text())?.trim();\n\t} catch {\n\t\treturn undefined;\n\t}\n\tif (!text) return undefined;\n\n\tlet message: string | undefined;\n\ttry {\n\t\tconst body: unknown = JSON.parse(text);\n\t\tif (body != null && typeof body === 'object') {\n\t\t\tconst { message: m, error } = body as { message?: unknown; error?: unknown };\n\t\t\tif (typeof m === 'string') {\n\t\t\t\tmessage = m;\n\t\t\t} else if (typeof error === 'string') {\n\t\t\t\tmessage = error;\n\t\t\t} else if (error != null && typeof error === 'object') {\n\t\t\t\t// Some hosts nest it as `{ error: { message } }`; narrow the same way as the outer object.\n\t\t\t\tconst nested = (error as { message?: unknown }).message;\n\t\t\t\tif (typeof nested === 'string') {\n\t\t\t\t\tmessage = nested;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t} catch {\n\t\t// Not JSON — Bitbucket sends bare text for a throttled request, and any host can send an HTML error page.\n\t}\n\n\tmessage = (message ?? text).trim();\n\treturn message ? [{ message: message.slice(0, maxErrorBodyLength) }] : undefined;\n}\n\n/**\n * Whether a provider's error response denotes a rate limit rather than a permission failure. Kept here, in one\n * place, because the distinction is consequential: a rate limit is retryable, while a permission failure is\n * surfaced as `auth` and drives a reconnect prompt — misclassifying one as the other asks the user to\n * re-authenticate a perfectly healthy connection.\n *\n * Which status a throttled request arrives on varies by host, which is why this takes both:\n *   - Azure DevOps and Bitbucket Cloud document 429 (learn.microsoft.com .../integrate/concepts/rate-limits).\n *   - GitHub documents \"a `403` or `429` response\" for both its primary and secondary limits\n *     (docs.github.com/en/rest/using-the-rest-api/rate-limits-for-the-rest-api).\n *   - GitLab uses 403 for some throttles.\n * So 429 alone is decisive, and on 403 the message decides.\n *\n * NOTE the message must actually carry the host's body for the 403 path to work — see\n * {@link ProviderFetchError.fromResponse}. A `ProviderFetchError` built from the status line alone reads\n * \"(403) Forbidden.\" and can never match, which is what made this check dead code on the direct-fetch clients.\n */\nexport function isRateLimitResponse(ex: { status: number; message?: string }): boolean {\n\t// Matches the phrasing hosts actually use: GitHub/Bitbucket \"API rate limit exceeded\", GitLab \"rate limit\n\t// exceeded\", Azure \"Request was blocked due to exceeding usage of resource 'RateLimit'\" / \"TF400733: The\n\t// request has been canceled: Request was blocked due to exceeding usage\".\n\tif (ex.status === 429) return true;\n\n\tconst message = ex.message?.toLowerCase();\n\treturn message != null && (message.includes('rate limit') || message.includes('ratelimit'));\n}\n\n/**\n * A response's headers as either a `fetch` `Headers` instance or the plain object an SDK error carries. Read via\n * duck-typing on `get` rather than `instanceof Headers`, so this works in both the Node and webworker builds\n * without depending on the global being present.\n */\ntype ResponseHeaders = Pick<Headers, 'get'> | Record<string, unknown>;\n\n/**\n * Builds a {@link RequestRateLimitError} from a provider error response, reading the reset epoch from the\n * standard `x-ratelimit-reset` header when present. Accepts both header shapes in use: the `fetch` `Headers`\n * instance the direct clients get, and the plain object the SDK attaches to its errors.\n */\nexport function toRateLimitError(\n\tex: Error & { response?: { headers?: ResponseHeaders } },\n\ttoken: string | undefined,\n): RequestRateLimitError {\n\tconst headers = ex.response?.headers as { get?: unknown } & Record<string, unknown>;\n\tconst raw =\n\t\theaders == null\n\t\t\t? undefined\n\t\t\t: typeof headers.get === 'function'\n\t\t\t\t? (headers.get as (name: string) => string | null)('x-ratelimit-reset')\n\t\t\t\t: headers['x-ratelimit-reset'];\n\n\t// Only a header that actually came back as a string/number can be a reset epoch; anything else (a nested SDK\n\t// object, an array of values) would stringify to garbage and parse to NaN anyway.\n\tlet resetAt: number | undefined;\n\tif (typeof raw === 'string' || typeof raw === 'number') {\n\t\tresetAt = parseInt(String(raw), 10);\n\t\tif (Number.isNaN(resetAt)) {\n\t\t\tresetAt = undefined;\n\t\t}\n\t}\n\n\treturn new RequestRateLimitError(ex, token, resetAt);\n}\n\n/**\n * Normalizes a caught `unknown` into an `Error`. Result cores type their failure channel as `error: Error`,\n * but a `catch` binding is `unknown` and a provider (or a third-party SDK) can throw a non-Error value;\n * returning it raw would leak a non-Error through the public result surface and break downstream `instanceof`\n * classification. Passes an existing `Error` through unchanged and wraps anything else with `String(ex)`.\n */\nexport function toError(ex: unknown): Error {\n\treturn ex instanceof Error ? ex : new Error(String(ex));\n}\n"],"mappings":";;;;;;;;;AAkBA,IAAa,kCAAb,cAAqD,MAAM;CAC1D,YAAY,UAAkB,QAAgB;EAC7C,MAAM,GAAG,SAAS,qBAAqB,QAAQ;EAC/C,MAAM,oBAAoB,MAAM,UAAU;CAC3C;AACD;;;;AAKA,IAAa,qBAAb,MAAa,2BAA2B,MAAM;CAwB5B;CAvBjB,IAAI,SAAiB;EACpB,OAAO,KAAK,SAAS;CACtB;CAEA,IAAI,aAAqB;EACxB,OAAO,KAAK,SAAS;CACtB;;;;;;;;;;CAWA,aAAa,aAAa,UAAkB,UAAiD;EAC5F,OAAO,IAAI,mBAAmB,UAAU,UAAU,MAAM,qBAAqB,QAAQ,CAAC;CACvF;CAEA,YACC,UACA,UACA,QACC;EACD,MACC,GAAG,SAAS,mBAAmB,CAAC,SAAS,KAAK,IAAI,SAAS,OAAO,IAAI,SAAS,WAAW,MAAM,KAC/F,QAAQ,SAAS,OAAO,EAAE,CAAC,UAAU,IAEvC;EAPgB,KAAA,WAAA;EAShB,MAAM,oBAAoB,MAAM,UAAU;CAC3C;AACD;;AAGA,MAAM,qBAAqB;;;;;;;;;;AAW3B,eAAe,qBAAqB,UAAgE;CACnG,IAAI;CACJ,IAAI;EAGH,IAAI,SAAS,UAAU,OAAO,KAAA;EAE9B,QAAQ,MAAM,SAAS,KAAK,EAAA,EAAI,KAAK;CACtC,QAAQ;EACP;CACD;CACA,IAAI,CAAC,MAAM,OAAO,KAAA;CAElB,IAAI;CACJ,IAAI;EACH,MAAM,OAAgB,KAAK,MAAM,IAAI;EACrC,IAAI,QAAQ,QAAQ,OAAO,SAAS,UAAU;GAC7C,MAAM,EAAE,SAAS,GAAG,UAAU;GAC9B,IAAI,OAAO,MAAM,UAChB,UAAU;QACJ,IAAI,OAAO,UAAU,UAC3B,UAAU;QACJ,IAAI,SAAS,QAAQ,OAAO,UAAU,UAAU;IAEtD,MAAM,SAAU,MAAgC;IAChD,IAAI,OAAO,WAAW,UACrB,UAAU;GAEZ;EACD;CACD,QAAQ,CAER;CAEA,WAAW,WAAW,KAAA,CAAM,KAAK;CACjC,OAAO,UAAU,CAAC,EAAE,SAAS,QAAQ,MAAM,GAAG,kBAAkB,EAAE,CAAC,IAAI,KAAA;AACxE;;;;;;;;;;;;;;;;;;AAmBA,SAAgB,oBAAoB,IAAmD;CAItF,IAAI,GAAG,WAAW,KAAK,OAAO;CAE9B,MAAM,UAAU,GAAG,SAAS,YAAY;CACxC,OAAO,WAAW,SAAS,QAAQ,SAAS,YAAY,KAAK,QAAQ,SAAS,WAAW;AAC1F;;;;;;AAcA,SAAgB,iBACf,IACA,OACwB;CACxB,MAAM,UAAU,GAAG,UAAU;CAC7B,MAAM,MACL,WAAW,OACR,KAAA,IACA,OAAO,QAAQ,QAAQ,aACrB,QAAQ,IAAwC,mBAAmB,IACpE,QAAQ;CAIb,IAAI;CACJ,IAAI,OAAO,QAAQ,YAAY,OAAO,QAAQ,UAAU;EACvD,UAAU,SAAS,OAAO,GAAG,GAAG,EAAE;EAClC,IAAI,OAAO,MAAM,OAAO,GACvB,UAAU,KAAA;CAEZ;CAEA,OAAO,IAAI,sBAAsB,IAAI,OAAO,OAAO;AACpD;;;;;;;AAQA,SAAgB,QAAQ,IAAoB;CAC3C,OAAO,cAAc,QAAQ,KAAK,IAAI,MAAM,OAAO,EAAE,CAAC;AACvD"}

package/dist/plus/integrations/index.d.ts

@@ -1,26 +1,39 @@
-import type { Account } from '../../git/models/author.js';
-import { CacheController } from '../../utils/promiseCache.js';
-import type { IntegrationIds } from './constants.js';
-import type { AccountProvider, ConfigProvider, HttpProvider, IntegrationServiceHooks, IntegrationStorageProvider, RepositoriesProvider } from './context.js';
-import type { IntegrationManager } from './manager.js';
+import { CacheController } from "../../utils/promiseCache.js";
+import { IssueSearchCapabilities, IssueSearchCriteria, IssueSearchRelationship, IssueStateFilter } from "../../git/models/issue.js";
+import { PullRequestFilter, PullRequestSearchCapabilities, PullRequestSearchCriteria, PullRequestStateFilter } from "../../git/models/pullRequest.js";
+import { Account } from "../../git/models/author.js";
+import { AuthenticationSessionLike, CloudIntegrationAuthType, CloudIntegrationConnection, CloudIntegrationType, ConfiguredIntegrationDescriptor, ProviderAuthenticationSession, toCloudIntegrationType, toIntegrationId } from "./authentication/models.js";
+import { GitCloudHostIntegrationId, GitSelfManagedHostIntegrationId, IntegrationIds, IssuesCloudHostIntegrationId, IssuesSelfManagedHostIntegrationId, SupportedCloudIntegrationIds, isIntegrationId, isSupportedCloudIntegrationId } from "./constants.js";
+import { Source, Sources } from "./telemetry.js";
+import { ConfiguredIntegrationsChangeEvent } from "./authentication/configuredIntegrationService.js";
+import { IssueFilter } from "./providerFilters.js";
+import { ConnectionStateChangeEvent, ProviderBroadenResult, ProviderOrganization, ProviderPageInfo, ProviderPagedResult, ProviderRepositoryShape, ProviderResult, ProviderSweepResult, ProviderWarning, ProviderWarningKind, ProviderWarningOmission, ProviderWarningOmissionKind, ProviderWarningOmissionRecovery, ProviderWarningOmissionScope, RepositoryIdentity, RepositoryResolution, RepositoryResolutionStatus, ResolveRepositoryResult } from "./results.js";
+import { IssueCountResult, IssueCountScope } from "./reads/counts.js";
+import { TrackerIssueResult } from "./reads/trackerIssue.js";
+import { ClosedPullRequestSweepOptions, IntegrationManager, ListOrgsOptions, ListProjectsOptions, ProviderBroadenOrg, ProviderRepositoriesInput, ProviderRepositoryInput, ProviderSweepTarget, ProviderSweepTargetEvent, PullRequestSweepOptions } from "./manager.js";
+import { IntegrationAuthenticationProvider, IntegrationAuthenticationProviderDescriptor, IntegrationAuthenticationSessionDescriptor } from "./authentication/integrationAuthenticationProvider.js";
+import { AccountProvider, AuthenticationSessionsChangeEvent, ConfigChangeEvent, ConfigProvider, HttpProvider, IntegrationServiceHooks, IntegrationStorageProvider, IntegrationsRemoteConfig, RepositoriesProvider } from "./context.js";
+import { ManualTokenAuthProviderOptions, createManualTokenAuthProvider } from "./authentication/manualTokenProvider.js";
+import { areDomainsOnSameHost, hostFromDomain } from "./utils/domain.utils.js";
+//#region ../plus/integrations/src/index.d.ts
 /** A cached provider value, which may still be resolving. */
 export type IntegrationManagerCacheResult<T> = Promise<T | undefined> | T | undefined;
 /** Produces an account value on a cache miss. */
 export type IntegrationManagerCacheLoader<T> = (cacheable: CacheController) => {
-    value: IntegrationManagerCacheResult<T>;
-    expiresAt?: number;
+  value: IntegrationManagerCacheResult<T>;
+  expiresAt?: number;
 };
 /** Stable integration identity supplied to the consumer-owned account cache. */
 export interface IntegrationAccountCacheDescriptor {
-    readonly id: IntegrationIds;
-    readonly domain?: string;
+  readonly id: IntegrationIds;
+  readonly domain?: string;
 }
 /** Cache controls attached to a provider account lookup. */
 export interface IntegrationManagerCacheOptions {
-    readonly connectionId?: string;
-    readonly etag?: string;
-    readonly expiryOverride?: boolean | number;
-    readonly expireOnError?: boolean;
+  readonly connectionId?: string;
+  readonly etag?: string;
+  readonly expiryOverride?: boolean | number;
+  readonly expireOnError?: boolean;
 }
 /**
  * Optional consumer-owned cache for values reused by the public manager facade.
@@ -29,7 +42,7 @@ export interface IntegrationManagerCacheOptions {
  * extension host are implementation details and deliberately stay out of this contract.
  */
 export interface IntegrationManagerCacheProvider {
-    getCurrentAccount(integration: IntegrationAccountCacheDescriptor, cacheable: IntegrationManagerCacheLoader<Account>, options?: IntegrationManagerCacheOptions): IntegrationManagerCacheResult<Account>;
+  getCurrentAccount(integration: IntegrationAccountCacheDescriptor, cacheable: IntegrationManagerCacheLoader<Account>, options?: IntegrationManagerCacheOptions): IntegrationManagerCacheResult<Account>;
 }
 /**
  * Consumer-facing runtime for {@link createIntegrationManager}.
@@ -38,15 +51,14 @@ export interface IntegrationManagerCacheProvider {
  * The extension host's broader integration context remains private to the implementation.
  */
 export interface IntegrationManagerContext {
-    readonly storage: IntegrationStorageProvider;
-    readonly account: AccountProvider;
-    readonly config: ConfigProvider;
-    readonly http: HttpProvider;
-    readonly cache?: IntegrationManagerCacheProvider;
-    readonly repositories: RepositoriesProvider;
-    readonly hooks?: IntegrationServiceHooks;
+  readonly storage: IntegrationStorageProvider;
+  readonly account: AccountProvider;
+  readonly config: ConfigProvider;
+  readonly http: HttpProvider;
+  readonly cache?: IntegrationManagerCacheProvider;
+  readonly repositories: RepositoriesProvider;
+  readonly hooks?: IntegrationServiceHooks;
 }
-export type { ClosedPullRequestSweepOptions, IntegrationManager, ListOrgsOptions, ListProjectsOptions, ProviderBroadenOrg, ProviderRepositoriesInput, ProviderRepositoryInput, ProviderSweepTarget, ProviderSweepTargetEvent, PullRequestSweepOptions, } from './manager.js';
 /**
  * Construct an `@gitkraken/core-gitlens/plus/integrations` manager bound to the supplied runtime.
  *
@@ -60,22 +72,6 @@ export type { ClosedPullRequestSweepOptions, IntegrationManager, ListOrgsOptions
  * own VS Code subscriptions.
  */
 export declare function createIntegrationManager(ctx: IntegrationManagerContext): IntegrationManager;
-export type { AccountProvider, AuthenticationSessionsChangeEvent, ConfigChangeEvent, ConfigProvider, RepositoriesProvider, HttpProvider, IntegrationsRemoteConfig, IntegrationServiceHooks, IntegrationStorageProvider, } from './context.js';
-export type { Source, Sources } from './telemetry.js';
-export type { IntegrationIds, SupportedCloudIntegrationIds } from './constants.js';
-export type { ConfiguredIntegrationsChangeEvent } from './authentication/configuredIntegrationService.js';
-export type { IntegrationAuthenticationProvider, IntegrationAuthenticationProviderDescriptor, IntegrationAuthenticationSessionDescriptor, } from './authentication/integrationAuthenticationProvider.js';
-export type { AuthenticationSessionLike, CloudIntegrationAuthType, CloudIntegrationConnection, CloudIntegrationType, ConfiguredIntegrationDescriptor, ProviderAuthenticationSession, } from './authentication/models.js';
-export { toCloudIntegrationType, toIntegrationId } from './authentication/models.js';
-export { areDomainsOnSameHost, hostFromDomain } from './utils/domain.utils.js';
-export { createManualTokenAuthProvider, type ManualTokenAuthProviderOptions, } from './authentication/manualTokenProvider.js';
-export { GitCloudHostIntegrationId, GitSelfManagedHostIntegrationId, IssuesCloudHostIntegrationId, isIntegrationId, isSupportedCloudIntegrationId, } from './constants.js';
-export type { ConnectionStateChangeEvent, ProviderBroadenResult, ProviderPagedResult, ProviderPageInfo, ProviderResult, ProviderSweepResult, ProviderWarning, ProviderWarningKind, ProviderWarningOmission, ProviderWarningOmissionKind, ProviderWarningOmissionRecovery, ProviderWarningOmissionScope, ProviderOrganization, ProviderRepositoryShape, RepositoryIdentity, RepositoryResolution, RepositoryResolutionStatus, ResolveRepositoryResult, } from './results.js';
-export { IssueFilter, PullRequestFilter } from './providerFilters.js';
-export type { IssueSearchCapabilities, IssueSearchCriteria, IssueSearchRelationship } from './providerFilters.js';
-export type { PullRequestSearchCapabilities, PullRequestSearchCriteria } from './providerFilters.js';
-export type { IssueCountResult, IssueCountScope } from './reads/counts.js';
-export type { TrackerIssueResult } from './reads/trackerIssue.js';
-export type { PullRequestStateFilter } from '../../git/models/pullRequest.js';
-export type { IssueStateFilter } from '../../git/models/issue.js';
+//#endregion
+export { type AccountProvider, type AuthenticationSessionLike, type AuthenticationSessionsChangeEvent, type ClosedPullRequestSweepOptions, type CloudIntegrationAuthType, type CloudIntegrationConnection, type CloudIntegrationType, type ConfigChangeEvent, type ConfigProvider, type ConfiguredIntegrationDescriptor, type ConfiguredIntegrationsChangeEvent, type ConnectionStateChangeEvent, GitCloudHostIntegrationId, GitSelfManagedHostIntegrationId, type HttpProvider, type IntegrationAuthenticationProvider, type IntegrationAuthenticationProviderDescriptor, type IntegrationAuthenticationSessionDescriptor, type IntegrationIds, type IntegrationManager, type IntegrationServiceHooks, type IntegrationStorageProvider, type IntegrationsRemoteConfig, type IssueCountResult, type IssueCountScope, IssueFilter, type IssueSearchCapabilities, type IssueSearchCriteria, type IssueSearchRelationship, type IssueStateFilter, IssuesCloudHostIntegrationId, IssuesSelfManagedHostIntegrationId, type ListOrgsOptions, type ListProjectsOptions, type ManualTokenAuthProviderOptions, type ProviderAuthenticationSession, type ProviderBroadenOrg, type ProviderBroadenResult, type ProviderOrganization, type ProviderPageInfo, type ProviderPagedResult, type ProviderRepositoriesInput, type ProviderRepositoryInput, type ProviderRepositoryShape, type ProviderResult, type ProviderSweepResult, type ProviderSweepTarget, type ProviderSweepTargetEvent, type ProviderWarning, type ProviderWarningKind, type ProviderWarningOmission, type ProviderWarningOmissionKind, type ProviderWarningOmissionRecovery, type ProviderWarningOmissionScope, PullRequestFilter, type PullRequestSearchCapabilities, type PullRequestSearchCriteria, type PullRequestStateFilter, type PullRequestSweepOptions, type RepositoriesProvider, type RepositoryIdentity, type RepositoryResolution, type RepositoryResolutionStatus, type ResolveRepositoryResult, type Source, type Sources, type SupportedCloudIntegrationIds, type TrackerIssueResult, areDomainsOnSameHost, createManualTokenAuthProvider, hostFromDomain, isIntegrationId, isSupportedCloudIntegrationId, toCloudIntegrationType, toIntegrationId };
 //# sourceMappingURL=index.d.ts.map