@gitkraken/core-gitlens 0.6.0 → 0.7.1

package/dist/plus/integrations/providers/linear.js

@@ -1,363 +1,320 @@
-import { isIssueResourceDescriptor } from '../../../git/utils/resourceDescriptor.utils.js';
-import { Logger } from '../../../utils/logger.js';
-import { toTokenWithInfo } from '../authentication/models.js';
-import { toCollectionScopeFailure } from '../collectionMetadata.js';
-import { IssuesCloudHostIntegrationId } from '../constants.js';
-import { IntegrationReadUnavailableError } from '../errors.js';
-import { IssuesIntegration } from '../models/issuesIntegration.js';
-import { fromProviderIssue, providersMetadata, toIssueShape } from './models.js';
-import { mergeCollectionMetadata } from './utils/providerPaging.js';
-const metadata = providersMetadata[IssuesCloudHostIntegrationId.Linear];
-const authProvider = Object.freeze({ id: metadata.id, scopes: metadata.scopes });
+import { Logger as _logger } from "../../../utils/logger.js";
+import { isIssueResourceDescriptor } from "../../../git/utils/resourceDescriptor.utils.js";
+import { IntegrationReadUnavailableError } from "../errors.js";
+import { toCollectionScopeFailure } from "../collectionMetadata.js";
+import "../constants.js";
+import { toTokenWithInfo } from "../authentication/models.js";
+import { mergeCollectionMetadata } from "./utils/providerPaging.js";
+import { fromProviderIssue, providersMetadata, toIssueShape } from "./models.js";
+import { IssuesIntegration } from "../models/issuesIntegration.js";
+import * as l10n from "@vscode/l10n";
+//#region ../plus/integrations/src/providers/linear.ts
+const metadata = providersMetadata["linear"];
+const authProvider = Object.freeze({
+	id: metadata.id,
+	scopes: metadata.scopes
+});
 const maxPagesPerRequest = 10;
 /**
- * The account-wide drain's own backstop, separate from {@link maxPagesPerRequest}.
- *
- * Raised to 50 (5,000 issues at the SDK's 100-per-page) because 10 no longer means what it used to. That read
- * once fanned out over four overlapping relationship queries and merged them, so most of what a page cost was
- * rows already returned — a low budget capped the waste. It is now a single server-ordered query over an `or`
- * filter, so every page is 100 issues the caller has not seen, and the same budget just truncates real results
- * at 1,000.
- *
- * Reaching it is reported rather than silent: {@link LinearIntegration.searchProviderMyIssuesWithTruncation}
- * returns `truncated`, so the facade can say the read was incomplete instead of publishing a capped list as a
- * whole account. The bound stays — a runaway cursor must not spend requests forever — but it is now set where a
- * real Linear account is unlikely to reach it rather than where the duplication used to hurt.
- */
+* The account-wide drain's own backstop, separate from {@link maxPagesPerRequest}.
+*
+* Raised to 50 (5,000 issues at the SDK's 100-per-page) because 10 no longer means what it used to. That read
+* once fanned out over four overlapping relationship queries and merged them, so most of what a page cost was
+* rows already returned — a low budget capped the waste. It is now a single server-ordered query over an `or`
+* filter, so every page is 100 issues the caller has not seen, and the same budget just truncates real results
+* at 1,000.
+*
+* Reaching it is reported rather than silent: {@link LinearIntegration.searchProviderMyIssuesWithTruncation}
+* returns `truncated`, so the facade can say the read was incomplete instead of publishing a capped list as a
+* whole account. The bound stays — a runaway cursor must not spend requests forever — but it is now set where a
+* real Linear account is unlikely to reach it rather than where the duplication used to hurt.
+*/
 const maxAccountWidePagesPerRequest = 50;
 const linearImplicitTeamsPageSize = 50;
-export class LinearIntegration extends IssuesIntegration {
-    _autolinks;
-    async autolinks() {
-        const connected = this.maybeConnected ?? (await this.isConnected());
-        if (!connected || this._session == null) {
-            return [];
-        }
-        const cachedAutolinks = this._autolinks?.get(this._session.accessToken);
-        if (cachedAutolinks != null)
-            return cachedAutolinks;
-        const organization = await this.getOrganization(this._session);
-        if (organization == null)
-            return [];
-        const autolinks = [];
-        const teams = await this.getTeams(this._session);
-        for (const team of teams ?? []) {
-            const dashedPrefix = `${team.key}-`;
-            const underscoredPrefix = `${team.key}_`;
-            autolinks.push({
-                prefix: dashedPrefix,
-                url: `${organization.url}/issue/${dashedPrefix}<num>`,
-                alphanumeric: false,
-                ignoreCase: false,
-                title: `Open Issue ${dashedPrefix}<num> on ${organization.name}`,
-                type: 'issue',
-                description: `${organization.name} Issue ${dashedPrefix}<num>`,
-                descriptor: { ...organization },
-            });
-            autolinks.push({
-                prefix: underscoredPrefix,
-                url: `${organization.url}/issue/${dashedPrefix}<num>`,
-                alphanumeric: false,
-                ignoreCase: false,
-                referenceType: 'branch',
-                title: `Open Issue ${dashedPrefix}<num> on ${organization.name}`,
-                type: 'issue',
-                description: `${organization.name} Issue ${dashedPrefix}<num>`,
-                descriptor: { ...organization },
-            });
-        }
-        this._autolinks ??= new Map();
-        this._autolinks.set(this._session.accessToken, autolinks);
-        return autolinks;
-    }
-    _organizations;
-    async getOrganization(session, force = false) {
-        const { accessToken } = session;
-        this._organizations ??= new Map();
-        const cachedResources = this._organizations.get(accessToken);
-        if (cachedResources == null || force) {
-            const api = await this.getProvidersApi();
-            const organization = await api.getLinearOrganization(toTokenWithInfo(this.id, session));
-            const descriptor = organization && {
-                id: organization.id,
-                key: organization.key,
-                name: organization.name,
-                url: organization.url,
-            };
-            if (descriptor) {
-                this._organizations.set(accessToken, descriptor);
-            }
-        }
-        return this._organizations.get(accessToken);
-    }
-    _teams;
-    async getTeams(session, force = false) {
-        return (await this.getTeamsWithMetadata(session, force))?.values;
-    }
-    async getTeamsWithMetadata(session, force = false) {
-        const { accessToken } = session;
-        this._teams ??= new Map();
-        const cachedResources = this._teams.get(accessToken);
-        if (cachedResources != null && !force)
-            return { values: cachedResources };
-        const api = await this.getProvidersApi();
-        const teams = await api.getLinearTeamsForCurrentUser(toTokenWithInfo(this.id, session));
-        const descriptors = teams?.map(t => ({
-            id: t.id,
-            key: t.key,
-            name: t.name,
-            avatarUrl: t.iconUrl,
-        }));
-        if (descriptors == null)
-            return undefined;
-        // provider-apis currently requests Linear's teams connection without pageInfo or a cursor. Linear's
-        // implicit page size is 50, so exactly a full page cannot prove there is no team 51. Preserve the useful
-        // prefix, but mark it unknown and leave it uncached so the next read retries instead of treating it as
-        // authoritative. Once provider-apis exposes a paged primitive, replace this fail-closed guard with a drain.
-        if (descriptors.length >= linearImplicitTeamsPageSize) {
-            return { values: descriptors, metadata: { completeness: 'unknown' } };
-        }
-        this._teams.set(accessToken, descriptors);
-        return { values: descriptors };
-    }
-    async getProviderResourcesForUser(session) {
-        const organization = await this.getOrganization(session);
-        return organization != null ? [organization] : undefined;
-    }
-    getProviderProjectsForResources(session, _resources) {
-        return this.getTeams(session);
-    }
-    async getProviderProjectsForResourcesWithMetadata(session, _resources) {
-        return (await this.getTeamsWithMetadata(session)) ?? { values: [] };
-    }
-    authProvider = authProvider;
-    async getProviderAccountForResource(session, _resource) {
-        const api = await this.getProvidersApi();
-        // Linear's viewer isn't a ProviderAccount (no username/avatar), so build the Account manually
-        // (Trello-style) from the fields the viewer query returns.
-        const user = await api.getLinearCurrentUser(toTokenWithInfo(this.id, session));
-        if (user == null)
-            return undefined;
-        return {
-            provider: this,
-            id: user.id,
-            name: user.name ?? user.displayName ?? undefined,
-            username: user.displayName ?? undefined,
-            email: user.email ?? undefined,
-            avatarUrl: undefined,
-        };
-    }
-    async getProviderIssuesForProject(session, project, options) {
-        return (await this.getProviderIssuesForProjectWithTruncation(session, project, options))?.values;
-    }
-    async getProviderIssuesForProjectWithTruncation(session, project, options) {
-        if (!isIssueResourceDescriptor(project))
-            return undefined;
-        const api = await this.getProvidersApi();
-        // `getProviderProjectsForResources` returns Linear teams, so `project.id` is a team id here. Drain the
-        // team's issues (Linear pages by cursor); bounded by maxPagesPerRequest as a backstop. `truncated` is
-        // set when that backstop stopped the drain with more pages still available.
-        let cursor;
-        let hasMore;
-        let requestCount = 0;
-        let truncated = false;
-        let collectionMetadata;
-        const issues = [];
-        do {
-            let result;
-            try {
-                result = await api.getLinearIssues(toTokenWithInfo(this.id, session), { teams: [project.id] }, { cursor: cursor, sort: options?.sort });
-            }
-            catch (ex) {
-                // A page failure after the first page leaves the already-drained prefix intact; record the
-                // failure at the project scope instead of re-throwing and discarding the prefix. If nothing was
-                // fetched yet, preserve the original throw behavior so the caller sees a hard error.
-                if (issues.length === 0)
-                    throw ex;
-                truncated = true;
-                collectionMetadata = mergeCollectionMetadata(collectionMetadata, {
-                    completeness: 'partial',
-                    failures: [toCollectionScopeFailure({ providerId: this.id, projectId: project.id }, ex)],
-                });
-                break;
-            }
-            requestCount += 1;
-            hasMore = result.paging?.more ?? false;
-            const nextCursor = result.paging?.cursor;
-            truncated ||= result.paging?.truncated === true;
-            collectionMetadata = mergeCollectionMetadata(collectionMetadata, result.metadata);
-            for (const issue of result.values) {
-                const shape = toIssueShape(issue, this);
-                if (shape != null) {
-                    issues.push(shape);
-                }
-            }
-            // The provider claims more but returns no advancing cursor: we can't continue without re-reading the
-            // same page, so the drain is incomplete — flag it rather than silently stopping.
-            if (hasMore && (nextCursor == null || nextCursor === cursor)) {
-                truncated = true;
-                break;
-            }
-            cursor = nextCursor;
-            if (hasMore && requestCount >= maxPagesPerRequest) {
-                truncated = true;
-            }
-        } while (requestCount < maxPagesPerRequest && hasMore);
-        // Linear's issue list has no server-side author/assignee filter, so scope to the current user
-        // client-side when a user was requested (the assignee filter is what "my issues" means here).
-        // Match on the viewer's stable id, not the passed display name: Linear's `name` (full name) and
-        // `displayName` (nickname) are distinct fields, and assignees are normalized with `.name` = the full
-        // name while the caller's `user` is the displayName — so a name string can miss. The assignee `.id`
-        // is the Linear user id, which is unambiguous.
-        if (options?.user != null) {
-            const viewerId = (await api.getLinearCurrentUser(toTokenWithInfo(this.id, session)))?.id;
-            // If the viewer can't be resolved we can't scope to "my issues" — returning the unfiltered team
-            // issues would leak everyone else's, and returning [] is indistinguishable from "no issues assigned
-            // to me". Throw so the facade (getIssuesForProjectResult → runCaptured) surfaces a warning +
-            // fetchFailed the caller can act on, instead of a silent empty.
-            if (viewerId == null) {
-                throw new IntegrationReadUnavailableError(metadata.name, 'could not resolve the current user to scope issues to');
-            }
-            const values = issues.filter(issue => issue.assignees?.some(a => a.id === viewerId));
-            return truncated
-                ? { values: values, truncated: true, recovery: 'none', metadata: collectionMetadata }
-                : { values: values, truncated: false, metadata: collectionMetadata };
-        }
-        return truncated
-            ? { values: issues, truncated: true, recovery: 'none', metadata: collectionMetadata }
-            : { values: issues, truncated: false, metadata: collectionMetadata };
-    }
-    get id() {
-        return IssuesCloudHostIntegrationId.Linear;
-    }
-    get key() {
-        return 'linear';
-    }
-    get name() {
-        return metadata.name;
-    }
-    get domain() {
-        return metadata.domain;
-    }
-    async searchProviderMyIssues(session, resources, cancellation) {
-        return (await this.searchProviderMyIssuesWithTruncation(session, resources, cancellation))?.values;
-    }
-    /**
-     * Account-wide "my issues" for Linear, drained to exhaustion and reporting whether it got there.
-     *
-     * The SDK read is one server-ordered query over an `or` filter across the four relationships (assigned,
-     * created, named in an issue's content, named in a comment), so each page is 100 issues the caller has not
-     * seen and the pages are ordered as one sequence. Draining it is therefore just following the cursor.
-     *
-     * Overridden rather than left to the base default because that default hardcodes `truncated: false`, and a
-     * bounded drain that stops early is exactly the case a caller must be able to see. Three things end the
-     * drain, and only one of them is completion:
-     *
-     * - the provider says there is no next page — complete;
-     * - the backstop is reached — `truncated`, because issues beyond it exist and were not read;
-     * - the provider claims a next page but hands back a cursor that does not advance — also `truncated`, since
-     *   the read cannot continue and the remainder is unreachable rather than absent.
-     *
-     * Cancellation is deliberately NOT truncation: the caller asked for the read to stop, so the partial list is
-     * what it asked for, and flagging it would surface an incompleteness warning for a user action.
-     */
-    async searchProviderMyIssuesWithTruncation(session, resources, cancellation, options) {
-        if (resources != null) {
-            return undefined;
-        }
-        const api = await this.getProvidersApi();
-        let cursor = undefined;
-        // Starts false so an immediate cancellation, which leaves the loop before the first response, reads as
-        // "no more pages known" rather than as an unfinished drain.
-        let hasMore = false;
-        let requestCount = 0;
-        let truncated = false;
-        const issues = [];
-        try {
-            do {
-                if (cancellation?.aborted) {
-                    break;
-                }
-                const result = await api.getIssuesForCurrentUser(toTokenWithInfo(this.id, session), {
-                    cursor: cursor,
-                    sort: options?.sort,
-                });
-                requestCount += 1;
-                hasMore = result.paging?.more ?? false;
-                const nextCursor = result.paging?.cursor;
-                // Keep this page before deciding whether to continue: the request is already paid for, so
-                // dropping its rows would lose real results to save nothing.
-                const formattedIssues = result.values
-                    .map(issue => toIssueShape(issue, this))
-                    .filter((result) => result != null);
-                if (formattedIssues.length > 0) {
-                    issues.push(...formattedIssues);
-                }
-                // The provider claims more but hands back no advancing cursor: continuing would re-read the page
-                // just returned. `ProvidersApi.getPagedResult` already normalizes this into `more: false`, so
-                // this is a backstop for if that ever stops holding rather than a case seen today -- but the rest
-                // of the account is unreachable either way, which is what `truncated` says.
-                if (hasMore && (nextCursor == null || nextCursor === cursor)) {
-                    truncated = true;
-                    break;
-                }
-                cursor = nextCursor;
-            } while (requestCount < maxAccountWidePagesPerRequest && hasMore);
-            // Ran out of budget with pages still to come.
-            if (hasMore && requestCount >= maxAccountWidePagesPerRequest) {
-                truncated = true;
-            }
-        }
-        catch (ex) {
-            if (issues.length === 0) {
-                throw ex;
-            }
-            // Kept what was already fetched, so the list is real but short of the account.
-            truncated = true;
-            Logger.error(ex, 'searchProviderMyIssues');
-        }
-        return { values: issues, truncated: truncated };
-    }
-    async getProviderLinkedIssueOrPullRequest(session, resource, { key }, _type) {
-        const issue = await this.getRawProviderIssue(session, resource, key);
-        const autolinkableIssue = issue && {
-            ...issue,
-            url: this.getIssueAutolinkLikeUrl(issue),
-        };
-        return autolinkableIssue && toIssueShape(autolinkableIssue, this);
-    }
-    async getProviderIssue(session, resource, id) {
-        const result = await this.getRawProviderIssue(session, resource, id);
-        return result && fromProviderIssue(result, this);
-    }
-    async getProviderIssueByResourceId(session, resourceId, id, _resourceUrl) {
-        const api = await this.getProvidersApi();
-        const result = await api.getIssue(toTokenWithInfo(this.id, session), {
-            resourceId: resourceId,
-            number: id,
-        });
-        return result && fromProviderIssue(result, this);
-    }
-    async getRawProviderIssue(session, resource, id) {
-        const api = await this.getProvidersApi();
-        if (!isIssueResourceDescriptor(resource)) {
-            Logger.error(undefined, 'getProviderIssue: resource is not an IssueResourceDescriptor');
-            return undefined;
-        }
-        return api.getIssue(toTokenWithInfo(this.id, session), {
-            resourceId: resource.id,
-            number: id,
-        });
-    }
-    getIssueAutolinkLikeUrl(issue) {
-        const url = issue.url;
-        if (url == null)
-            return null;
-        const lastSegment = url.split('/').pop();
-        if (!lastSegment || issue.number === lastSegment) {
-            return url;
-        }
-        return url.substring(0, url.length - lastSegment.length - 1);
-    }
-}
+var LinearIntegration = class extends IssuesIntegration {
+	_autolinks;
+	async autolinks() {
+		if (!(this.maybeConnected ?? await this.isConnected()) || this._session == null) return [];
+		const cachedAutolinks = this._autolinks?.get(this._session.accessToken);
+		if (cachedAutolinks != null) return cachedAutolinks;
+		const organization = await this.getOrganization(this._session);
+		if (organization == null) return [];
+		const autolinks = [];
+		const teams = await this.getTeams(this._session);
+		for (const team of teams ?? []) {
+			const dashedPrefix = `${team.key}-`;
+			const underscoredPrefix = `${team.key}_`;
+			autolinks.push({
+				prefix: dashedPrefix,
+				url: `${organization.url}/issue/${dashedPrefix}<num>`,
+				alphanumeric: false,
+				ignoreCase: false,
+				title: l10n.t("Open Issue {0} on {1}", `${dashedPrefix}<num>`, organization.name),
+				type: "issue",
+				description: l10n.t("{0} Issue {1}", organization.name, `${dashedPrefix}<num>`),
+				descriptor: { ...organization }
+			});
+			autolinks.push({
+				prefix: underscoredPrefix,
+				url: `${organization.url}/issue/${dashedPrefix}<num>`,
+				alphanumeric: false,
+				ignoreCase: false,
+				referenceType: "branch",
+				title: l10n.t("Open Issue {0} on {1}", `${dashedPrefix}<num>`, organization.name),
+				type: "issue",
+				description: l10n.t("{0} Issue {1}", organization.name, `${dashedPrefix}<num>`),
+				descriptor: { ...organization }
+			});
+		}
+		this._autolinks ??= /* @__PURE__ */ new Map();
+		this._autolinks.set(this._session.accessToken, autolinks);
+		return autolinks;
+	}
+	_organizations;
+	async getOrganization(session, force = false) {
+		const { accessToken } = session;
+		this._organizations ??= /* @__PURE__ */ new Map();
+		if (this._organizations.get(accessToken) == null || force) {
+			const organization = await (await this.getProvidersApi()).getLinearOrganization(toTokenWithInfo(this.id, session));
+			const descriptor = organization && {
+				id: organization.id,
+				key: organization.key,
+				name: organization.name,
+				url: organization.url
+			};
+			if (descriptor) this._organizations.set(accessToken, descriptor);
+		}
+		return this._organizations.get(accessToken);
+	}
+	_teams;
+	async getTeams(session, force = false) {
+		return (await this.getTeamsWithMetadata(session, force))?.values;
+	}
+	async getTeamsWithMetadata(session, force = false) {
+		const { accessToken } = session;
+		this._teams ??= /* @__PURE__ */ new Map();
+		const cachedResources = this._teams.get(accessToken);
+		if (cachedResources != null && !force) return { values: cachedResources };
+		const descriptors = (await (await this.getProvidersApi()).getLinearTeamsForCurrentUser(toTokenWithInfo(this.id, session)))?.map((t) => ({
+			id: t.id,
+			key: t.key,
+			name: t.name,
+			avatarUrl: t.iconUrl
+		}));
+		if (descriptors == null) return void 0;
+		if (descriptors.length >= linearImplicitTeamsPageSize) return {
+			values: descriptors,
+			metadata: { completeness: "unknown" }
+		};
+		this._teams.set(accessToken, descriptors);
+		return { values: descriptors };
+	}
+	async getProviderResourcesForUser(session) {
+		const organization = await this.getOrganization(session);
+		return organization != null ? [organization] : void 0;
+	}
+	getProviderProjectsForResources(session, _resources) {
+		return this.getTeams(session);
+	}
+	async getProviderProjectsForResourcesWithMetadata(session, _resources) {
+		return await this.getTeamsWithMetadata(session) ?? { values: [] };
+	}
+	authProvider = authProvider;
+	async getProviderAccountForResource(session, _resource) {
+		const user = await (await this.getProvidersApi()).getLinearCurrentUser(toTokenWithInfo(this.id, session));
+		if (user == null) return void 0;
+		return {
+			provider: this,
+			id: user.id,
+			name: user.name ?? user.displayName ?? void 0,
+			username: user.displayName ?? void 0,
+			email: user.email ?? void 0,
+			avatarUrl: void 0
+		};
+	}
+	async getProviderIssuesForProject(session, project, options) {
+		return (await this.getProviderIssuesForProjectWithTruncation(session, project, options))?.values;
+	}
+	async getProviderIssuesForProjectWithTruncation(session, project, options) {
+		if (!isIssueResourceDescriptor(project)) return void 0;
+		const api = await this.getProvidersApi();
+		let cursor;
+		let hasMore;
+		let requestCount = 0;
+		let truncated = false;
+		let collectionMetadata;
+		const issues = [];
+		do {
+			let result;
+			try {
+				result = await api.getLinearIssues(toTokenWithInfo(this.id, session), { teams: [project.id] }, {
+					cursor,
+					sort: options?.sort
+				});
+			} catch (ex) {
+				if (issues.length === 0) throw ex;
+				truncated = true;
+				collectionMetadata = mergeCollectionMetadata(collectionMetadata, {
+					completeness: "partial",
+					failures: [toCollectionScopeFailure({
+						providerId: this.id,
+						projectId: project.id
+					}, ex)]
+				});
+				break;
+			}
+			requestCount += 1;
+			hasMore = result.paging?.more ?? false;
+			const nextCursor = result.paging?.cursor;
+			truncated ||= result.paging?.truncated === true;
+			collectionMetadata = mergeCollectionMetadata(collectionMetadata, result.metadata);
+			for (const issue of result.values) {
+				const shape = toIssueShape(issue, this);
+				if (shape != null) issues.push(shape);
+			}
+			if (hasMore && (nextCursor == null || nextCursor === cursor)) {
+				truncated = true;
+				break;
+			}
+			cursor = nextCursor;
+			if (hasMore && requestCount >= maxPagesPerRequest) truncated = true;
+		} while (requestCount < maxPagesPerRequest && hasMore);
+		if (options?.user != null) {
+			const viewerId = (await api.getLinearCurrentUser(toTokenWithInfo(this.id, session)))?.id;
+			if (viewerId == null) throw new IntegrationReadUnavailableError(metadata.name, "could not resolve the current user to scope issues to");
+			const values = issues.filter((issue) => issue.assignees?.some((a) => a.id === viewerId));
+			return truncated ? {
+				values,
+				truncated: true,
+				recovery: "none",
+				metadata: collectionMetadata
+			} : {
+				values,
+				truncated: false,
+				metadata: collectionMetadata
+			};
+		}
+		return truncated ? {
+			values: issues,
+			truncated: true,
+			recovery: "none",
+			metadata: collectionMetadata
+		} : {
+			values: issues,
+			truncated: false,
+			metadata: collectionMetadata
+		};
+	}
+	get id() {
+		return "linear";
+	}
+	get key() {
+		return "linear";
+	}
+	get name() {
+		return metadata.name;
+	}
+	get domain() {
+		return metadata.domain;
+	}
+	async searchProviderMyIssues(session, resources, cancellation) {
+		return (await this.searchProviderMyIssuesWithTruncation(session, resources, cancellation))?.values;
+	}
+	/**
+	* Account-wide "my issues" for Linear, drained to exhaustion and reporting whether it got there.
+	*
+	* The SDK read is one server-ordered query over an `or` filter across the four relationships (assigned,
+	* created, named in an issue's content, named in a comment), so each page is 100 issues the caller has not
+	* seen and the pages are ordered as one sequence. Draining it is therefore just following the cursor.
+	*
+	* Overridden rather than left to the base default because that default hardcodes `truncated: false`, and a
+	* bounded drain that stops early is exactly the case a caller must be able to see. Three things end the
+	* drain, and only one of them is completion:
+	*
+	* - the provider says there is no next page — complete;
+	* - the backstop is reached — `truncated`, because issues beyond it exist and were not read;
+	* - the provider claims a next page but hands back a cursor that does not advance — also `truncated`, since
+	*   the read cannot continue and the remainder is unreachable rather than absent.
+	*
+	* Cancellation is deliberately NOT truncation: the caller asked for the read to stop, so the partial list is
+	* what it asked for, and flagging it would surface an incompleteness warning for a user action.
+	*/
+	async searchProviderMyIssuesWithTruncation(session, resources, cancellation, options) {
+		if (resources != null) return;
+		const api = await this.getProvidersApi();
+		let cursor = void 0;
+		let hasMore = false;
+		let requestCount = 0;
+		let truncated = false;
+		const issues = [];
+		try {
+			do {
+				if (cancellation?.aborted) break;
+				const result = await api.getIssuesForCurrentUser(toTokenWithInfo(this.id, session), {
+					cursor,
+					sort: options?.sort
+				});
+				requestCount += 1;
+				hasMore = result.paging?.more ?? false;
+				const nextCursor = result.paging?.cursor;
+				const formattedIssues = result.values.map((issue) => toIssueShape(issue, this)).filter((result) => result != null);
+				if (formattedIssues.length > 0) issues.push(...formattedIssues);
+				if (hasMore && (nextCursor == null || nextCursor === cursor)) {
+					truncated = true;
+					break;
+				}
+				cursor = nextCursor;
+			} while (requestCount < maxAccountWidePagesPerRequest && hasMore);
+			if (hasMore && requestCount >= maxAccountWidePagesPerRequest) truncated = true;
+		} catch (ex) {
+			if (issues.length === 0) throw ex;
+			truncated = true;
+			_logger.error(ex, "searchProviderMyIssues");
+		}
+		return {
+			values: issues,
+			truncated
+		};
+	}
+	async getProviderLinkedIssueOrPullRequest(session, resource, { key }, _type) {
+		const issue = await this.getRawProviderIssue(session, resource, key);
+		const autolinkableIssue = issue && {
+			...issue,
+			url: this.getIssueAutolinkLikeUrl(issue)
+		};
+		return autolinkableIssue && toIssueShape(autolinkableIssue, this);
+	}
+	async getProviderIssue(session, resource, id) {
+		const result = await this.getRawProviderIssue(session, resource, id);
+		return result && fromProviderIssue(result, this);
+	}
+	async getProviderIssueByResourceId(session, resourceId, id, _resourceUrl) {
+		const result = await (await this.getProvidersApi()).getIssue(toTokenWithInfo(this.id, session), {
+			resourceId,
+			number: id
+		});
+		return result && fromProviderIssue(result, this);
+	}
+	async getRawProviderIssue(session, resource, id) {
+		const api = await this.getProvidersApi();
+		if (!isIssueResourceDescriptor(resource)) {
+			_logger.error(void 0, "getProviderIssue: resource is not an IssueResourceDescriptor");
+			return;
+		}
+		return api.getIssue(toTokenWithInfo(this.id, session), {
+			resourceId: resource.id,
+			number: id
+		});
+	}
+	getIssueAutolinkLikeUrl(issue) {
+		const url = issue.url;
+		if (url == null) return null;
+		const lastSegment = url.split("/").pop();
+		if (!lastSegment || issue.number === lastSegment) return url;
+		return url.substring(0, url.length - lastSegment.length - 1);
+	}
+};
+//#endregion
+export { LinearIntegration };
+
 //# sourceMappingURL=linear.js.map