@gitkraken/core-gitlens 0.3.1 → 0.4.100

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

@@ -0,0 +1,850 @@
+import entityIdentifiersModule from '@gitkraken/provider-apis/entity-identifiers';
+import providerUtilsModule from '@gitkraken/provider-apis/provider-utils';
+import { Issue, RepositoryAccessLevel } from '../../../git/models/issue.js';
+import { PullRequest, PullRequestMergeableState, PullRequestReviewDecision, PullRequestReviewState, PullRequestStatusCheckRollupState, } from '../../../git/models/pullRequest.js';
+import { gitSuffixRegex } from '../../../git/utils/remote.utils.js';
+import { equalsIgnoreCase } from '../../../utils/string.js';
+import { GitCloudHostIntegrationId, GitSelfManagedHostIntegrationId, IssuesCloudHostIntegrationId, } from '../constants.js';
+import { IssueFilter, PullRequestFilter } from '../providerFilters.js';
+export { IssueFilter, PullRequestFilter } from '../providerFilters.js';
+import { getEntityIdentifierInput } from './utils.js';
+const { EntityIdentifierUtils } = entityIdentifiersModule;
+const { GitProviderUtils } = providerUtilsModule;
+// Local runtime copies of the `@gitkraken/provider-apis` string enums. Duplicated (not imported as
+// values) because the SDK ships as CJS whose named enum exports can't be statically imported as ESM
+// values from the bundled `dist`. Exported so the enum-parity test can deep-equal them against the
+// real SDK enums and turn any upstream drift into a test failure instead of a silent mismatch.
+export const GitBuildStatusState = {
+    ActionRequired: 'ACTION_REQUIRED',
+    Cancelled: 'CANCELLED',
+    Error: 'ERROR',
+    Failed: 'FAILED',
+    Pending: 'PENDING',
+    Running: 'RUNNING',
+    Skipped: 'SKIPPED',
+    Success: 'SUCCESS',
+    Warning: 'WARNING',
+    OptionalActionRequired: 'OPTIONAL_ACTION_REQUIRED',
+};
+export const GitIssueState = {
+    Open: 'OPEN',
+    Closed: 'CLOSED',
+};
+export const GitPullRequestState = {
+    Open: 'OPEN',
+    Closed: 'CLOSED',
+    Merged: 'MERGED',
+};
+export const GitPullRequestReviewState = {
+    Approved: 'APPROVED',
+    ChangesRequested: 'CHANGES_REQUESTED',
+    Commented: 'COMMENTED',
+    ReviewRequested: 'REVIEW_REQUESTED',
+};
+export const GitPullRequestMergeableState = {
+    Behind: 'BEHIND',
+    Blocked: 'BLOCKED',
+    Conflicts: 'CONFLICTS',
+    FailingChecks: 'FAILING_CHECKS',
+    Mergeable: 'MERGEABLE',
+    Unknown: 'UNKNOWN',
+    UnknownAndBlocked: 'UNKNOWN_AND_BLOCKED',
+    Unstable: 'UNSTABLE',
+};
+/**
+ * Returns an account-wide PR identity. Provider PR ids are commonly scoped to a repository or organization,
+ * so an id alone is never safe for deduplication across a multi-repository fan-out. Repository identity wins
+ * when available so the same row still deduplicates when a later facet adds or removes its URL.
+ */
+export function getProviderPullRequestIdentity(pr) {
+    const repository = pr.repository;
+    const urlIdentity = pr.url != null && pr.url.trim() !== '' ? `url:${pr.url}` : undefined;
+    if (repository == null)
+        return urlIdentity;
+    const owner = typeof repository.owner === 'string' ? repository.owner : repository.owner?.login;
+    const repositoryId = repository.id != null ? String(repository.id).trim() : '';
+    if (repositoryId !== '')
+        return `repository:${repositoryId}:pull-request:${pr.id}`;
+    const name = repository.name?.trim() ?? '';
+    const namespace = (repository.namespace ?? owner)?.trim() ?? '';
+    const project = repository.project?.trim() ?? '';
+    if (name !== '' && (namespace !== '' || project !== '')) {
+        return `repository:${namespace}/${project}/${name}:pull-request:${pr.id}`;
+    }
+    return urlIdentity;
+}
+export const ProviderPullRequestReviewState = GitPullRequestReviewState;
+export const ProviderBuildStatusState = GitBuildStatusState;
+export var PagingMode;
+(function (PagingMode) {
+    PagingMode["Project"] = "project";
+    PagingMode["Repo"] = "repo";
+    PagingMode["Repos"] = "repos";
+})(PagingMode || (PagingMode = {}));
+export const providersMetadata = {
+    [GitCloudHostIntegrationId.GitHub]: {
+        domain: 'github.com',
+        id: GitCloudHostIntegrationId.GitHub,
+        name: 'GitHub',
+        type: 'git',
+        iconKey: GitCloudHostIntegrationId.GitHub,
+        issuesPagingMode: PagingMode.Repos,
+        pullRequestsPagingMode: PagingMode.Repos,
+        // Use 'username' property on account for PR filters
+        supportedPullRequestFilters: [
+            PullRequestFilter.Author,
+            PullRequestFilter.Assignee,
+            PullRequestFilter.ReviewRequested,
+            PullRequestFilter.Mention,
+        ],
+        supportedAccountWidePullRequestFilters: [
+            PullRequestFilter.Author,
+            PullRequestFilter.Assignee,
+            PullRequestFilter.ReviewRequested,
+            PullRequestFilter.Mention,
+        ],
+        // Use 'username' property on account for issue filters
+        supportedIssueFilters: [IssueFilter.Author, IssueFilter.Assignee, IssueFilter.Mention],
+        // The account-wide read is three independent searches (`author:@me`, `assignee:@me`, `mentions:@me`) behind
+        // one composite cursor, so any subset of them is expressible.
+        supportedAccountWideIssueFilters: [IssueFilter.Author, IssueFilter.Assignee, IssueFilter.Mention],
+        scopes: ['repo', 'read:user', 'user:email'],
+    },
+    [GitSelfManagedHostIntegrationId.CloudGitHubEnterprise]: {
+        domain: '',
+        id: GitSelfManagedHostIntegrationId.CloudGitHubEnterprise,
+        name: 'GitHub Enterprise',
+        type: 'git',
+        iconKey: 'github-enterprise',
+        issuesPagingMode: PagingMode.Repos,
+        pullRequestsPagingMode: PagingMode.Repos,
+        // Use 'username' property on account for PR filters
+        supportedPullRequestFilters: [
+            PullRequestFilter.Author,
+            PullRequestFilter.Assignee,
+            PullRequestFilter.ReviewRequested,
+            PullRequestFilter.Mention,
+        ],
+        supportedAccountWidePullRequestFilters: [
+            PullRequestFilter.Author,
+            PullRequestFilter.Assignee,
+            PullRequestFilter.ReviewRequested,
+            PullRequestFilter.Mention,
+        ],
+        // Use 'username' property on account for issue filters
+        supportedIssueFilters: [IssueFilter.Author, IssueFilter.Assignee, IssueFilter.Mention],
+        // The account-wide read is three independent searches (`author:@me`, `assignee:@me`, `mentions:@me`) behind
+        // one composite cursor, so any subset of them is expressible.
+        supportedAccountWideIssueFilters: [IssueFilter.Author, IssueFilter.Assignee, IssueFilter.Mention],
+        scopes: ['repo', 'read:user', 'user:email'],
+    },
+    [GitCloudHostIntegrationId.GitLab]: {
+        domain: 'gitlab.com',
+        id: GitCloudHostIntegrationId.GitLab,
+        name: 'GitLab',
+        type: 'git',
+        iconKey: GitCloudHostIntegrationId.GitLab,
+        issuesPagingMode: PagingMode.Repo,
+        pullRequestsPagingMode: PagingMode.Repo,
+        // Use 'username' property on account for PR filters
+        supportedPullRequestFilters: [
+            PullRequestFilter.Author,
+            PullRequestFilter.Assignee,
+            PullRequestFilter.ReviewRequested,
+        ],
+        supportedAccountWidePullRequestFilters: [
+            PullRequestFilter.Author,
+            PullRequestFilter.Assignee,
+            PullRequestFilter.ReviewRequested,
+        ],
+        // Use 'username' property on account for issue filters
+        supportedIssueFilters: [IssueFilter.Author, IssueFilter.Assignee],
+        // The account-wide read drains one `scope=assigned_to_me` pass and one `scope=all` + `authorUsername` pass,
+        // unioned, so either axis is expressible on its own. Mention is absent because GitLab's REST issue read has
+        // no first-class mention filter to narrow with.
+        supportedAccountWideIssueFilters: [IssueFilter.Assignee, IssueFilter.Author],
+        scopes: ['api', 'read_user', 'read_repository'],
+    },
+    [GitSelfManagedHostIntegrationId.CloudGitLabSelfHosted]: {
+        domain: '',
+        id: GitSelfManagedHostIntegrationId.CloudGitLabSelfHosted,
+        name: 'GitLab Self-Hosted',
+        type: 'git',
+        iconKey: 'gitlab-self-hosted',
+        issuesPagingMode: PagingMode.Repo,
+        pullRequestsPagingMode: PagingMode.Repo,
+        // Use 'username' property on account for PR filters
+        supportedPullRequestFilters: [
+            PullRequestFilter.Author,
+            PullRequestFilter.Assignee,
+            PullRequestFilter.ReviewRequested,
+        ],
+        supportedAccountWidePullRequestFilters: [
+            PullRequestFilter.Author,
+            PullRequestFilter.Assignee,
+            PullRequestFilter.ReviewRequested,
+        ],
+        // Use 'username' property on account for issue filters
+        supportedIssueFilters: [IssueFilter.Author, IssueFilter.Assignee],
+        // The account-wide read drains one `scope=assigned_to_me` pass and one `scope=all` + `authorUsername` pass,
+        // unioned, so either axis is expressible on its own. Mention is absent because GitLab's REST issue read has
+        // no first-class mention filter to narrow with.
+        supportedAccountWideIssueFilters: [IssueFilter.Assignee, IssueFilter.Author],
+        scopes: ['api', 'read_user', 'read_repository'],
+    },
+    [GitCloudHostIntegrationId.Bitbucket]: {
+        domain: 'bitbucket.org',
+        id: GitCloudHostIntegrationId.Bitbucket,
+        name: 'Bitbucket',
+        type: 'git',
+        iconKey: GitCloudHostIntegrationId.Bitbucket,
+        pullRequestsPagingMode: PagingMode.Repo,
+        // Use 'id' property on account for PR filters (reviewer filter keyed by account id / reviewerId)
+        supportedPullRequestFilters: [PullRequestFilter.Author, PullRequestFilter.ReviewRequested],
+        supportedAccountWidePullRequestFilters: [PullRequestFilter.Author, PullRequestFilter.ReviewRequested],
+        scopes: ['account:read', 'repository:read', 'pullrequest:read', 'issue:read'],
+    },
+    [GitSelfManagedHostIntegrationId.BitbucketServer]: {
+        domain: '',
+        id: GitSelfManagedHostIntegrationId.BitbucketServer,
+        name: 'Bitbucket Data Center',
+        type: 'git',
+        iconKey: GitSelfManagedHostIntegrationId.BitbucketServer,
+        supportedPullRequestFilters: [PullRequestFilter.Author, PullRequestFilter.ReviewRequested],
+        supportedAccountWidePullRequestFilters: [PullRequestFilter.Author, PullRequestFilter.ReviewRequested],
+        scopes: ['Project (Read)', 'Repository (Write)'],
+    },
+    [GitCloudHostIntegrationId.AzureDevOps]: {
+        domain: 'dev.azure.com',
+        id: GitCloudHostIntegrationId.AzureDevOps,
+        name: 'Azure DevOps',
+        type: 'git',
+        iconKey: GitCloudHostIntegrationId.AzureDevOps,
+        issuesPagingMode: PagingMode.Project,
+        pullRequestsPagingMode: PagingMode.Repo,
+        // Use 'id' property on account for PR filters (reviewer filter keyed by account id / reviewerId)
+        supportedPullRequestFilters: [
+            PullRequestFilter.Author,
+            PullRequestFilter.Assignee,
+            PullRequestFilter.ReviewRequested,
+        ],
+        supportedAccountWidePullRequestFilters: [
+            PullRequestFilter.Author,
+            PullRequestFilter.Assignee,
+            PullRequestFilter.ReviewRequested,
+        ],
+        // Use 'name' property on account for issue filters
+        supportedIssueFilters: [IssueFilter.Author, IssueFilter.Assignee, IssueFilter.Mention],
+        // The account-wide read drains one (project × assignee) and one (project × author) query per project, so
+        // either axis is expressible on its own. There is no mention query to narrow to.
+        supportedAccountWideIssueFilters: [IssueFilter.Author, IssueFilter.Assignee],
+        scopes: ['vso.code', 'vso.identity', 'vso.project', 'vso.profile', 'vso.work'],
+    },
+    [GitSelfManagedHostIntegrationId.AzureDevOpsServer]: {
+        domain: '',
+        id: GitSelfManagedHostIntegrationId.AzureDevOpsServer,
+        name: 'Azure DevOps Server',
+        type: 'git',
+        iconKey: GitCloudHostIntegrationId.AzureDevOps,
+        issuesPagingMode: PagingMode.Project,
+        pullRequestsPagingMode: PagingMode.Repo,
+        // Use 'id' property on account for PR filters (reviewer filter keyed by account id / reviewerId)
+        supportedPullRequestFilters: [
+            PullRequestFilter.Author,
+            PullRequestFilter.Assignee,
+            PullRequestFilter.ReviewRequested,
+        ],
+        supportedAccountWidePullRequestFilters: [
+            PullRequestFilter.Author,
+            PullRequestFilter.Assignee,
+            PullRequestFilter.ReviewRequested,
+        ],
+        // Use 'name' property on account for issue filters
+        supportedIssueFilters: [IssueFilter.Author, IssueFilter.Assignee, IssueFilter.Mention],
+        // The account-wide read drains one (project × assignee) and one (project × author) query per project, so
+        // either axis is expressible on its own. There is no mention query to narrow to.
+        supportedAccountWideIssueFilters: [IssueFilter.Author, IssueFilter.Assignee],
+        scopes: ['vso.code', 'vso.identity', 'vso.project', 'vso.profile', 'vso.work'],
+    },
+    [IssuesCloudHostIntegrationId.Jira]: {
+        domain: 'atlassian.net',
+        id: IssuesCloudHostIntegrationId.Jira,
+        name: 'Jira',
+        type: 'issues',
+        iconKey: IssuesCloudHostIntegrationId.Jira,
+        scopes: [
+            'read:status:jira',
+            'read:application-role:jira',
+            'write:attachment:jira',
+            'read:comment:jira',
+            'read:project-category:jira',
+            'read:project:jira',
+            'read:issue.vote:jira',
+            'read:field-configuration:jira',
+            'write:issue:jira',
+            'read:issue-security-level:jira',
+            'write:issue.property:jira',
+            'read:issue.changelog:jira',
+            'read:avatar:jira',
+            'read:issue-meta:jira',
+            'read:permission:jira',
+            'offline_access',
+            'read:issue:jira',
+            'read:me',
+            'read:audit-log:jira',
+            'read:project.component:jira',
+            'read:group:jira',
+            'read:project-role:jira',
+            'write:comment:jira',
+            'read:label:jira',
+            'write:comment.property:jira',
+            'read:issue-details:jira',
+            'read:issue-type-hierarchy:jira',
+            'read:issue.transition:jira',
+            'read:user:jira',
+            'read:field:jira',
+            'read:issue-type:jira',
+            'read:project.property:jira',
+            'read:comment.property:jira',
+            'read:project-version:jira',
+        ],
+        supportedIssueFilters: [IssueFilter.Author, IssueFilter.Assignee, IssueFilter.Mention],
+    },
+    [IssuesCloudHostIntegrationId.Linear]: {
+        domain: 'linear.app',
+        id: IssuesCloudHostIntegrationId.Linear,
+        name: 'Linear',
+        type: 'issues',
+        iconKey: IssuesCloudHostIntegrationId.Linear,
+        scopes: [],
+        // Linear scopes "my issues" client-side by the viewer's assignee id; author/mention aren't supported.
+        supportedIssueFilters: [IssueFilter.Assignee],
+    },
+    [IssuesCloudHostIntegrationId.Trello]: {
+        domain: 'trello.com',
+        id: IssuesCloudHostIntegrationId.Trello,
+        name: 'Trello',
+        type: 'issues',
+        iconKey: IssuesCloudHostIntegrationId.Trello,
+        scopes: [],
+        // Trello cards are filtered by the assignee (member) only; author/mention have no Trello equivalent.
+        supportedIssueFilters: [IssueFilter.Assignee],
+    },
+};
+export function getReasonsForUserIssue(issue, userLogin) {
+    const reasons = [];
+    let isAuthor = false;
+    let isAssignee = false;
+    if (issue.author?.username === userLogin || issue.author?.name === userLogin) {
+        reasons.push('authored');
+        isAuthor = true;
+    }
+    if (issue.assignees?.some(assignee => assignee.username === userLogin || assignee.name === userLogin)) {
+        reasons.push('assigned');
+        isAssignee = true;
+    }
+    // TODO: Impossible to denote all issues we are mentioned on given their properties. for now just
+    // assume we are mentioned on any of our issues we are not the author or assignee on
+    if (!isAuthor && !isAssignee) {
+        reasons.push('mentioned');
+    }
+    return reasons;
+}
+function toIssueIdentifier(value) {
+    return String(value);
+}
+export function toIssueShape(issue, provider) {
+    // TODO: Add some protections/baselines rather than killing the transformation here
+    // `author` is intentionally not required: some providers have no per-item creator (e.g. Trello cards,
+    // which the SDK maps with `author: null`), and dropping every such item would discard the whole board.
+    // Fall back to an empty author instead so these issues still surface.
+    if (issue.updatedDate == null || issue.url == null)
+        return undefined;
+    return {
+        type: 'issue',
+        provider: provider,
+        // `id` is the provider's display number/key (GitHub number, Jira/Linear key, Trello idShort), NOT a
+        // globally-unique id: it's rendered to users as `#{id}`, used to build branch names, and passed back
+        // to the provider as the `getIssue`/cache lookup key, all of which expect the number. `nodeId` is the
+        // provider-native stable id, but its uniqueness scope is provider-specific (Azure work-item ids are
+        // organization-scoped), so cross-scope consumers must include provider/domain/container identity too.
+        // provider-apis declares this as a string, but some providers (notably
+        // Azure's broadened work-item path) return a number at runtime. Keep the
+        // public IssueShape contract truthful for consumers that use string APIs.
+        id: toIssueIdentifier(issue.number),
+        nodeId: issue.graphQLId ?? issue.id,
+        title: issue.title,
+        url: issue.url,
+        createdDate: issue.createdDate,
+        updatedDate: issue.updatedDate,
+        closedDate: issue.closedDate ?? undefined,
+        closed: issue.closedDate != null,
+        state: issue.closedDate != null ? 'closed' : 'opened',
+        author: {
+            id: issue.author?.id ?? '',
+            // An absent name stays absent, matching {@link fromProviderAccount}; see `IssueMember.name`.
+            name: issue.author?.name ?? undefined,
+            avatarUrl: issue.author?.avatarUrl ?? undefined,
+            url: issue.author?.url ?? undefined,
+        },
+        assignees: issue.assignees?.map(assignee => ({
+            id: assignee.id ?? '',
+            name: assignee.name ?? undefined,
+            avatarUrl: assignee.avatarUrl ?? undefined,
+            url: assignee.url ?? undefined,
+        })) ?? [],
+        project: issue.project?.id && issue.project.resourceId && issue.project.namespace
+            ? {
+                id: issue.project.id,
+                name: issue.project.name,
+                resourceId: issue.project.resourceId,
+                resourceName: issue.project.namespace,
+            }
+            : undefined,
+        repository: issue.repository?.owner?.login != null
+            ? {
+                owner: issue.repository.owner.login,
+                repo: issue.repository.name,
+                id: issue.repository.id,
+            }
+            : undefined,
+        labels: issue.labels.map(label => ({ color: label.color ?? undefined, name: label.name })),
+        commentsCount: issue.commentCount ?? undefined,
+        thumbsUpCount: issue.upvoteCount ?? undefined,
+        body: issue.description ?? undefined,
+        issueType: issue.type ?? undefined,
+    };
+}
+/**
+ * Maps a raw provider-apis {@link ProviderRepository} to the GitLens-owned {@link ProviderRepositoryShape}
+ * the ProviderBackend `listRepos` facade surfaces, so consumers don't depend on the SDK repo type. The SDK's
+ * nullable fields (`webUrl`/`httpsUrl`/`sshUrl`/`defaultBranch`) collapse to `undefined`, matching the
+ * `?? undefined` convention in {@link toIssueShape}/{@link toAccount}.
+ */
+export function toProviderRepositoryShape(repo) {
+    return {
+        id: repo.id,
+        namespace: repo.namespace,
+        name: repo.name,
+        project: repo.project ?? undefined,
+        url: repo.webUrl ?? undefined,
+        cloneUrlHttps: repo.httpsUrl ?? undefined,
+        cloneUrlSsh: repo.sshUrl ?? undefined,
+        defaultBranch: repo.defaultBranch?.name ?? undefined,
+    };
+}
+export function issueFilterToReason(filter) {
+    switch (filter) {
+        case IssueFilter.Author:
+            return 'authored';
+        case IssueFilter.Assignee:
+            return 'assigned';
+        case IssueFilter.Mention:
+            return 'mentioned';
+    }
+}
+export function toAccount(account, provider) {
+    return {
+        provider: provider,
+        id: account.id,
+        name: account.name ?? undefined,
+        email: account.email ?? undefined,
+        avatarUrl: account.avatarUrl ?? undefined,
+        username: account.username ?? undefined,
+    };
+}
+export const toProviderBuildStatusState = {
+    [PullRequestStatusCheckRollupState.Success]: GitBuildStatusState.Success,
+    [PullRequestStatusCheckRollupState.Failed]: GitBuildStatusState.Failed,
+    [PullRequestStatusCheckRollupState.Pending]: GitBuildStatusState.Pending,
+};
+export const fromProviderBuildStatusState = {
+    [GitBuildStatusState.Success]: PullRequestStatusCheckRollupState.Success,
+    [GitBuildStatusState.Failed]: PullRequestStatusCheckRollupState.Failed,
+    [GitBuildStatusState.Pending]: PullRequestStatusCheckRollupState.Pending,
+    [GitBuildStatusState.ActionRequired]: PullRequestStatusCheckRollupState.Failed,
+    // TODO: The rest of these are defaulted because we don't have a matching state for them
+    [GitBuildStatusState.Error]: undefined,
+    [GitBuildStatusState.Cancelled]: undefined,
+    [GitBuildStatusState.OptionalActionRequired]: undefined,
+    [GitBuildStatusState.Skipped]: undefined,
+    [GitBuildStatusState.Running]: undefined,
+    [GitBuildStatusState.Warning]: undefined,
+};
+export const toProviderPullRequestReviewState = {
+    [PullRequestReviewState.Approved]: GitPullRequestReviewState.Approved,
+    [PullRequestReviewState.ChangesRequested]: GitPullRequestReviewState.ChangesRequested,
+    [PullRequestReviewState.Commented]: GitPullRequestReviewState.Commented,
+    [PullRequestReviewState.ReviewRequested]: GitPullRequestReviewState.ReviewRequested,
+    [PullRequestReviewState.Dismissed]: null,
+    [PullRequestReviewState.Pending]: null,
+};
+export const fromProviderPullRequestReviewState = {
+    [GitPullRequestReviewState.Approved]: PullRequestReviewState.Approved,
+    [GitPullRequestReviewState.ChangesRequested]: PullRequestReviewState.ChangesRequested,
+    [GitPullRequestReviewState.Commented]: PullRequestReviewState.Commented,
+    [GitPullRequestReviewState.ReviewRequested]: PullRequestReviewState.ReviewRequested,
+};
+export const toProviderPullRequestMergeableState = {
+    [PullRequestMergeableState.Mergeable]: GitPullRequestMergeableState.Mergeable,
+    [PullRequestMergeableState.Conflicting]: GitPullRequestMergeableState.Conflicts,
+    [PullRequestMergeableState.Unknown]: GitPullRequestMergeableState.Unknown,
+    [PullRequestMergeableState.FailingChecks]: GitPullRequestMergeableState.FailingChecks,
+    [PullRequestMergeableState.BlockedByPolicy]: GitPullRequestMergeableState.Blocked,
+};
+export const fromProviderPullRequestMergeableState = {
+    [GitPullRequestMergeableState.Mergeable]: PullRequestMergeableState.Mergeable,
+    [GitPullRequestMergeableState.Conflicts]: PullRequestMergeableState.Conflicting,
+    [GitPullRequestMergeableState.Blocked]: PullRequestMergeableState.BlockedByPolicy,
+    [GitPullRequestMergeableState.FailingChecks]: PullRequestMergeableState.FailingChecks,
+    [GitPullRequestMergeableState.Unknown]: PullRequestMergeableState.Unknown,
+    [GitPullRequestMergeableState.Behind]: PullRequestMergeableState.Unknown,
+    [GitPullRequestMergeableState.UnknownAndBlocked]: PullRequestMergeableState.Unknown,
+    [GitPullRequestMergeableState.Unstable]: PullRequestMergeableState.Unknown,
+};
+export function toProviderReviews(reviewers) {
+    return reviewers
+        .filter(r => r.state !== PullRequestReviewState.Dismissed && r.state !== PullRequestReviewState.Pending)
+        .map(reviewer => ({
+        reviewer: toProviderAccount(reviewer.reviewer),
+        state: toProviderPullRequestReviewState[reviewer.state] ?? GitPullRequestReviewState.ReviewRequested,
+    }));
+}
+export function toReviewRequests(reviews) {
+    return reviews == null
+        ? undefined
+        : reviews
+            ?.filter(r => r.state === GitPullRequestReviewState.ReviewRequested)
+            .map(r => ({
+            isCodeOwner: false, // TODO: Find this value, and implement in the shared lib if needed
+            reviewer: fromProviderAccount(r.reviewer),
+            state: PullRequestReviewState.ReviewRequested,
+        }));
+}
+export function toCompletedReviews(reviews) {
+    return reviews == null
+        ? undefined
+        : reviews
+            ?.filter(r => r.state !== GitPullRequestReviewState.ReviewRequested)
+            .map(r => ({
+            isCodeOwner: false, // TODO: Find this value, and implement in the shared lib if needed
+            reviewer: fromProviderAccount(r.reviewer),
+            state: fromProviderPullRequestReviewState[r.state],
+        }));
+}
+export function toProviderReviewDecision(reviewDecision, reviewers) {
+    switch (reviewDecision) {
+        case PullRequestReviewDecision.Approved:
+            return GitPullRequestReviewState.Approved;
+        case PullRequestReviewDecision.ChangesRequested:
+            return GitPullRequestReviewState.ChangesRequested;
+        case PullRequestReviewDecision.ReviewRequired:
+            return GitPullRequestReviewState.ReviewRequested;
+        default: {
+            if (reviewers?.some(r => r.state === PullRequestReviewState.ReviewRequested)) {
+                return GitPullRequestReviewState.ReviewRequested;
+            }
+            else if (reviewers?.some(r => r.state === PullRequestReviewState.Commented)) {
+                return GitPullRequestReviewState.Commented;
+            }
+            return null;
+        }
+    }
+}
+export const fromPullRequestReviewDecision = {
+    [GitPullRequestReviewState.Approved]: PullRequestReviewDecision.Approved,
+    [GitPullRequestReviewState.ChangesRequested]: PullRequestReviewDecision.ChangesRequested,
+    [GitPullRequestReviewState.Commented]: undefined,
+    [GitPullRequestReviewState.ReviewRequested]: PullRequestReviewDecision.ReviewRequired,
+};
+export function toProviderPullRequestState(state) {
+    return state === 'opened'
+        ? GitPullRequestState.Open
+        : state === 'closed'
+            ? GitPullRequestState.Closed
+            : GitPullRequestState.Merged;
+}
+export function fromProviderPullRequestState(state) {
+    return state === GitPullRequestState.Open ? 'opened' : state === GitPullRequestState.Closed ? 'closed' : 'merged';
+}
+function toProviderPullRequestStatesCore(state) {
+    switch (state) {
+        case 'open':
+        case 'opened':
+            return [GitPullRequestState.Open];
+        case 'closed':
+            return [GitPullRequestState.Closed];
+        case 'merged':
+            return [GitPullRequestState.Merged];
+        case 'all':
+            return [GitPullRequestState.Open, GitPullRequestState.Closed, GitPullRequestState.Merged];
+    }
+}
+/** Maps PR include/state filters to the SDK's `states` input. `undefined`/omitted preserves the open-only default. */
+export function toProviderPullRequestStates(state) {
+    if (state == null)
+        return undefined;
+    const states = (Array.isArray(state) ? state : [state]).flatMap(s => toProviderPullRequestStatesCore(s));
+    return states.length > 0 ? [...new Set(states)] : undefined;
+}
+/** Maps an issue state filter to the SDK's `states` input. `undefined`/omitted preserves the open-only default. */
+export function toProviderIssueStates(state) {
+    switch (state) {
+        case 'open':
+            return [GitIssueState.Open];
+        case 'closed':
+            return [GitIssueState.Closed];
+        case 'all':
+            return [GitIssueState.Open, GitIssueState.Closed];
+        default:
+            return undefined;
+    }
+}
+/**
+ * Resolves a normalized {@link ProviderScope} to the provider-appropriate read inputs, dispatching on the
+ * provider's {@link PagingMode} (the authoritative per-provider scoping selector). Project-mode providers
+ * (Azure issues, Jira) produce `projectInputs` from `org` + `project`; repo/repos-mode providers produce a
+ * repo `GetRepoInput[]` from `scope.repos` (carrying `project` where relevant, e.g. Azure). This is the
+ * single public entry point consumers can use instead of hand-building the three underlying representations.
+ */
+export function resolveProviderScope(scope, pagingMode) {
+    if (pagingMode === PagingMode.Project) {
+        if (scope.org != null && scope.project != null) {
+            return { projectInputs: [{ namespace: scope.org, project: scope.project }] };
+        }
+        return {};
+    }
+    const reposInput = scope.repos?.map(r => ({ namespace: r.owner, name: r.name, project: scope.project }));
+    return { reposInput: reposInput };
+}
+export function providerPullRequestMatchesSearch(pr, search) {
+    const term = search.trim().toLowerCase();
+    if (term.length === 0)
+        return true;
+    return pr.title.toLowerCase().includes(term) || (pr.description?.toLowerCase().includes(term) ?? false);
+}
+function toProviderRemoteInfo(ref) {
+    // Match the SDK convention: only populate remoteInfo when both clone URLs are known.
+    return ref?.cloneHttps && ref?.cloneSsh ? { cloneUrlHTTPS: ref.cloneHttps, cloneUrlSSH: ref.cloneSsh } : null;
+}
+export function toProviderPullRequest(pr) {
+    const prReviews = [...(pr.reviewRequests ?? []), ...(pr.latestReviews ?? [])];
+    return {
+        id: pr.id,
+        graphQLId: pr.nodeId,
+        number: pr.number ?? Number.parseInt(pr.id, 10),
+        title: pr.title,
+        description: pr.body ?? null,
+        url: pr.url,
+        state: toProviderPullRequestState(pr.state),
+        isCrossRepository: pr.refs?.isCrossRepository ?? false,
+        isDraft: pr.isDraft ?? false,
+        createdDate: pr.createdDate,
+        updatedDate: pr.updatedDate,
+        closedDate: pr.closedDate ?? null,
+        mergedDate: pr.mergedDate ?? null,
+        commentCount: pr.commentsCount ?? null,
+        upvoteCount: pr.thumbsUpCount ?? null,
+        commitCount: null,
+        fileCount: null,
+        additions: pr.additions ?? null,
+        deletions: pr.deletions ?? null,
+        author: toProviderAccount(pr.author),
+        assignees: pr.assignees?.map(toProviderAccount) ?? null,
+        baseRef: pr.refs?.base == null
+            ? null
+            : {
+                name: pr.refs.base.branch,
+                oid: pr.refs.base.sha,
+            },
+        headRef: pr.refs?.head == null
+            ? null
+            : {
+                name: pr.refs.head.branch,
+                oid: pr.refs.head.sha,
+            },
+        reviews: toProviderReviews(prReviews),
+        reviewDecision: toProviderReviewDecision(pr.reviewDecision, prReviews),
+        repository: pr.repository != null
+            ? {
+                id: pr.repository.id ?? '',
+                name: pr.repository.repo,
+                owner: {
+                    login: pr.repository.owner,
+                },
+                remoteInfo: toProviderRemoteInfo(pr.refs?.base),
+            }
+            : {
+                id: '',
+                name: '',
+                owner: {
+                    login: '',
+                },
+                remoteInfo: null,
+            },
+        headRepository: pr.refs?.head != null
+            ? {
+                id: pr.refs.head.repo,
+                name: pr.refs.head.repo,
+                owner: {
+                    login: pr.refs.head.owner,
+                },
+                remoteInfo: toProviderRemoteInfo(pr.refs.head),
+                isFork: pr.refs.head.isFork,
+            }
+            : null,
+        headCommit: pr.statusCheckRollupState != null
+            ? {
+                buildStatuses: [
+                    {
+                        completedAt: null,
+                        description: '',
+                        name: '',
+                        state: toProviderBuildStatusState[pr.statusCheckRollupState],
+                        startedAt: null,
+                        stage: null,
+                        url: '',
+                    },
+                ],
+            }
+            : null,
+        permissions: pr.viewerCanUpdate == null
+            ? null
+            : {
+                canMerge: pr.viewerCanUpdate === true &&
+                    pr.repository.accessLevel != null &&
+                    pr.repository.accessLevel >= RepositoryAccessLevel.Write,
+                canMergeAndBypassProtections: pr.viewerCanUpdate === true &&
+                    pr.repository.accessLevel != null &&
+                    pr.repository.accessLevel >= RepositoryAccessLevel.Admin,
+            },
+        mergeableState: pr.mergeableState
+            ? toProviderPullRequestMergeableState[pr.mergeableState]
+            : GitPullRequestMergeableState.Unknown,
+    };
+}
+export function fromProviderPullRequest(pr, provider, options) {
+    const repository = pr.repository;
+    const repositoryName = repository?.name ?? '';
+    const repositoryOwner = repository?.owner?.login ?? '';
+    const repositoryRemoteInfo = repository?.remoteInfo;
+    const headRepository = pr.headRepository;
+    const headRepositoryRemoteInfo = headRepository?.remoteInfo;
+    return new PullRequest(provider, fromProviderAccount(pr.author), pr.id, pr.graphQLId || pr.id, pr.title, pr.url ?? '', {
+        owner: repositoryOwner,
+        repo: repositoryName,
+        // This has to be here until we can take this information from ProviderPullRequest:
+        accessLevel: RepositoryAccessLevel.Write,
+        id: repository?.id ?? '',
+    }, fromProviderPullRequestState(pr.state), pr.createdDate, pr.updatedDate, pr.closedDate ?? undefined, pr.mergedDate ?? undefined, pr.mergeableState ? fromProviderPullRequestMergeableState[pr.mergeableState] : undefined, pr.permissions?.canMerge || pr.permissions?.canMergeAndBypassProtections ? true : undefined, {
+        base: {
+            branch: pr.baseRef?.name ?? '',
+            sha: pr.baseRef?.oid ?? '',
+            repo: repositoryName,
+            owner: repositoryOwner,
+            exists: pr.baseRef != null,
+            url: repositoryRemoteInfo?.cloneUrlHTTPS
+                ? repositoryRemoteInfo.cloneUrlHTTPS.replace(gitSuffixRegex, '')
+                : '',
+            cloneHttps: repositoryRemoteInfo?.cloneUrlHTTPS || undefined,
+            cloneSsh: repositoryRemoteInfo?.cloneUrlSSH || undefined,
+        },
+        head: {
+            branch: pr.headRef?.name ?? '',
+            sha: pr.headRef?.oid ?? '',
+            repo: headRepository?.name ?? '',
+            owner: headRepository?.owner?.login ?? '',
+            exists: pr.headRef != null,
+            url: headRepositoryRemoteInfo?.cloneUrlHTTPS
+                ? headRepositoryRemoteInfo.cloneUrlHTTPS.replace(gitSuffixRegex, '')
+                : '',
+            cloneHttps: headRepositoryRemoteInfo?.cloneUrlHTTPS || undefined,
+            cloneSsh: headRepositoryRemoteInfo?.cloneUrlSSH || undefined,
+            isFork: headRepository?.isFork,
+        },
+        isCrossRepository: pr.isCrossRepository,
+    }, pr.isDraft, pr.additions ?? undefined, pr.deletions ?? undefined, pr.commentCount ?? undefined, pr.upvoteCount ?? undefined, pr.reviewDecision ? fromPullRequestReviewDecision[pr.reviewDecision] : undefined, toReviewRequests(pr.reviews), toCompletedReviews(pr.reviews), pr.assignees?.map(fromProviderAccount) ?? undefined, pr.headCommit?.buildStatuses?.[0]?.state
+        ? fromProviderBuildStatusState[pr.headCommit.buildStatuses[0].state]
+        : undefined, options?.project, pr.version, pr.description ?? undefined, pr.number, options?.currentAccountId != null ? pr.author?.id === options.currentAccountId : undefined);
+}
+export function fromProviderIssue(issue, integration, options) {
+    const identifier = toIssueIdentifier(issue.number);
+    return new Issue(integration, identifier, issue.graphQLId ?? issue.id, issue.title, issue.url ?? '', issue.createdDate, issue.updatedDate ?? issue.closedDate ?? issue.createdDate, issue.closedDate != null, issue.closedDate != null ? 'closed' : 'opened', fromProviderAccount(issue.author), issue.assignees?.map(fromProviderAccount) ?? undefined, issue.repository != null
+        ? {
+            owner: issue.repository.owner.login ?? '',
+            repo: issue.repository.name,
+            id: issue.repository.id,
+        }
+        : undefined, issue.closedDate ?? undefined, issue.labels?.map(label => ({ name: label.name, color: label.color ?? undefined })), issue.commentCount ?? undefined, issue.upvoteCount ?? undefined, issue.description ?? undefined, options?.project != null
+        ? {
+            id: options.project.id,
+            name: options.project.name,
+            resourceId: options.project.resourceId,
+            resourceName: options.project.resourceName,
+        }
+        : issue.project?.id && issue.project?.resourceId && issue.project?.namespace
+            ? {
+                id: issue.project.id,
+                name: issue.project.name,
+                resourceId: issue.project.resourceId,
+                resourceName: issue.project.namespace,
+            }
+            : undefined, identifier, issue.type ?? undefined);
+}
+export function toProviderPullRequestWithUniqueId(pr) {
+    return {
+        ...toProviderPullRequest(pr),
+        uuid: EntityIdentifierUtils.encode(getEntityIdentifierInput(pr)),
+    };
+}
+export function toProviderAccount(account) {
+    return {
+        id: account.id ?? null,
+        avatarUrl: account.avatarUrl ?? null,
+        name: account.name ?? null,
+        url: account.url ?? null,
+        // TODO: Implement these in our own model
+        email: '',
+        username: account.name ?? null,
+    };
+}
+export function fromProviderAccount(account) {
+    return {
+        id: account?.id ?? '',
+        // An absent name stays absent. `'unknown'` was a display fallback invented in the provider layer, and a
+        // consumer couldn't tell it apart from a member genuinely named that — so it couldn't be undone where a
+        // name-shaped placeholder is wrong (rendering an avatar-only chip, or building an AI prompt, where
+        // `Assignees: unknown` reads as a real assignee). It also disagreed with {@link toIssueShape}, which
+        // collapsed the same absent name to `''` — same facade method, two fallbacks. Both now emit `undefined`.
+        name: account?.name ?? undefined,
+        avatarUrl: account?.avatarUrl ?? undefined,
+        // `url` is optional, so an absent one must be `undefined`, not `''`. `''` passes a `!= null` presence
+        // check and renders as a link to nowhere, and it disagreed with {@link toIssueShape} — which already
+        // collapses to `undefined` — even though BOTH mappers feed `listIssuesPage` (the repo-scoped path goes
+        // through `toIssueShape`, Azure's account-wide path through {@link fromProviderIssue}). Same facade
+        // method, two shapes. Matches {@link toProviderRepositoryShape}, which collapses every absent optional.
+        url: account?.url ?? undefined,
+    };
+}
+export const getActionablePullRequests = GitProviderUtils.getActionablePullRequests;
+export function isGitHubDotCom(domain) {
+    return equalsIgnoreCase(domain, 'github.com');
+}
+export function isGitLabDotCom(domain) {
+    return equalsIgnoreCase(domain, 'gitlab.com');
+}
+// Anchor the `visualstudio.com` alternative on a label boundary (`^` or `.`) rather than `\b`: `\b` treats a
+// hyphen as a word boundary, so `\bvisualstudio\.com$` matched attacker-controlled hosts like
+// `evil-visualstudio.com` and classified them as Azure cloud, changing their auth/URL handling.
+const azureCloudDomainRegex = /^dev\.azure\.com$|(?:^|\.)visualstudio\.com$/i;
+export function isAzureCloudDomain(domain) {
+    return domain != null && azureCloudDomainRegex.test(domain);
+}
+const bitbucketCloudDomainRegex = /^bitbucket\.org$/i;
+export function isBitbucketCloudDomain(domain) {
+    return domain != null && bitbucketCloudDomainRegex.test(domain);
+}
+export function supportsCodeSuggest(provider) {
+    return isGitHubDotCom(provider.domain);
+}
+//# sourceMappingURL=models.js.map