@gitkraken/core-gitlens 0.5.116 → 0.7.0

package/src/git/models/repository.ts

@@ -1,510 +0,0 @@
-import { exhaustiveArray } from '../../utils/array.js';
-import { getScopedCounter } from '../../utils/counter.js';
-import { md5 } from '../../utils/crypto.js';
-import { trace } from '../../utils/decorators/log.js';
-import { memoize } from '../../utils/decorators/memoize.js';
-import type { UnifiedDisposable } from '../../utils/disposable.js';
-import { createDisposable } from '../../utils/disposable.js';
-import type { Event } from '../../utils/event.js';
-import { Emitter } from '../../utils/event.js';
-import { some } from '../../utils/iterable.js';
-import { basename, isDescendant, normalizePath } from '../../utils/path.js';
-import type { Uri } from '../../utils/uri.js';
-import type { GitProviderDescriptor } from '../providers/types.js';
-import { getCommonRepositoryUri } from '../utils/repository.utils.js';
-import type { WatcherRepoChangeEvent, WorkingTreeChangeEvent } from '../watching/changeEvent.js';
-import type { RepositoryWatchService, WatchHandle, WatchHooks } from '../watching/watchService.js';
-import type { RepositorySubscription } from '../watching/watchSession.js';
-import { RepositoryChangeEvent } from './repositoryChangeEvent.js';
-
-const instanceCounter = getScopedCounter();
-
-export interface GitDir {
-	readonly uri: Uri;
-	/** The common git directory for worktrees */
-	readonly commonUri?: Uri;
-	/** The parent (superproject) directory for submodules */
-	readonly parentUri?: Uri;
-}
-
-export type RepositoryChange =
-	| 'unknown'
-	| 'index'
-	| 'head'
-	| 'heads'
-	| 'tags'
-	| 'stash'
-	| 'remotes'
-	| 'worktrees'
-	| 'config'
-	| 'pausedOp'
-	| 'cherryPick'
-	| 'merge'
-	| 'rebase'
-	| 'revert'
-	| 'closed'
-	| 'ignores'
-	| 'remoteProviders'
-	| 'starred'
-	| 'opened'
-	| 'gkConfig'
-	| 'lastFetched';
-
-export const repositoryChanges = exhaustiveArray<RepositoryChange>()([
-	'unknown',
-	'index',
-	'head',
-	'heads',
-	'tags',
-	'stash',
-	'remotes',
-	'worktrees',
-	'config',
-	'pausedOp',
-	'cherryPick',
-	'merge',
-	'rebase',
-	'revert',
-	'closed',
-	'ignores',
-	'remoteProviders',
-	'starred',
-	'opened',
-	'gkConfig',
-	'lastFetched',
-]);
-
-/**
- * The only changes {@link Repository.fireChange} accepts with `force` — delivered straight to the repository's
- * emitter, bypassing the watch session, so they still arrive while it's suspended or when there's no watch handle
- * at all (a repo being opened, or closed, or a virtual repo that never had one).
- *
- * These have nothing intrinsic in common — being forced IS the shared property, which is why this is keyed off
- * `force` rather than some category of change.
- *
- * It's the partition consumers need: everything NOT listed here goes through the session, which does its
- * pre-notification work (e.g. advancing a cache's status clock) exactly once, before it notifies anyone. Nothing
- * runs upstream of a forced change, so a consumer bridging repository changes into a cache must handle these
- * itself. Forcing a change that isn't listed is a compile error — and consumers gate on this same array, so
- * listing one wires it up for free.
- */
-export const forcedRepositoryChanges = [
-	'opened',
-	'closed',
-	'lastFetched',
-] as const satisfies readonly RepositoryChange[];
-export type ForcedRepositoryChange = (typeof forcedRepositoryChanges)[number];
-
-export interface RepositoryInit {
-	readonly id: string;
-	readonly path: string;
-	readonly uri: Uri;
-	readonly name: string;
-	readonly provider: GitProviderDescriptor;
-	readonly gitDir: GitDir | undefined;
-	readonly index: number;
-	readonly root: boolean;
-	readonly watchService: RepositoryWatchService;
-}
-
-/**
- * An event describing working tree file changes.
- *
- * Deliberately exposes no path collection. Consumers react by refreshing, and a refresh re-reads current
- * state — so the paths only ever gate whether to bother, never what the answer is. A partial set would
- * read as usable while quietly licensing the one harmful outcome (concluding a file did NOT change), so
- * {@link changed} is the only way to ask.
- */
-export class RepositoryWorkingTreeChangeEvent {
-	constructor(
-		readonly repository: Repository,
-		/** Absolute paths changed in this batch; partial when {@link incomplete}. */
-		private readonly paths: ReadonlySet<string>,
-		/** Whether paths were dropped, so {@link paths} can't be used to rule anything out. */
-		private readonly incomplete: boolean,
-	) {}
-
-	/**
-	 * Whether `uri` — or anything beneath it, when it's a folder — changed in this batch.
-	 *
-	 * Conservative: `true` whenever the batch is incomplete, since a miss would then prove nothing. Matches
-	 * on paths rather than URIs so nothing has to be allocated to answer.
-	 */
-	changed(uri: Uri): boolean {
-		if (this.incomplete) return true;
-
-		const path = uri.fsPath;
-		return some(this.paths, p => p === path || isDescendant(p, path));
-	}
-
-	toString(): string {
-		if (this.incomplete) return `{ repository: ${this.repository.name ?? ''}, paths: incomplete }`;
-
-		const [first] = this.paths;
-		return `{ repository: ${this.repository.name ?? ''}, paths(${this.paths.size}): [${first ?? ''}${
-			this.paths.size > 1 ? ', ...' : ''
-		}] }`;
-	}
-}
-
-export class Repository {
-	private readonly _onDidChange = new Emitter<RepositoryChangeEvent>();
-	get onDidChange(): Event<RepositoryChangeEvent> {
-		return this._onDidChange.event;
-	}
-
-	private readonly _onDidChangeWorkingTree = new Emitter<RepositoryWorkingTreeChangeEvent>();
-	get onDidChangeWorkingTree(): Event<RepositoryWorkingTreeChangeEvent> {
-		return this._onDidChangeWorkingTree.event;
-	}
-
-	readonly commonPath: string | undefined;
-	readonly commonRepositoryName: string | undefined;
-	readonly commonUri: Uri | undefined;
-	readonly id: string;
-	readonly index: number;
-	readonly instance = instanceCounter.next();
-	readonly path: string;
-	readonly uri: Uri;
-	readonly provider: GitProviderDescriptor;
-	readonly root: boolean;
-
-	protected readonly _gitDir: GitDir | undefined;
-	protected _repoSubscription: RepositorySubscription | undefined;
-	protected _watchHandle: WatchHandle | undefined;
-	protected readonly _watchService: RepositoryWatchService;
-
-	private _pendingWorkingTreePaths?: Set<string>;
-	private _pendingWorkingTreeIncomplete = false;
-	private _pendingWorkingTreeFlush = false;
-	private _repoChangeListener: UnifiedDisposable | undefined;
-	/** Outstanding leases on the shared {@link _watchHandle} across `watch()` + `watchWorkingTree()`. */
-	private _watchHandleRefs = 0;
-	/** Outstanding `watch()` (repo-change) leases; drives the single shared bridge subscription. */
-	private _watchRefs = 0;
-	private _disposed = false;
-
-	constructor(init: RepositoryInit) {
-		({
-			id: this.id,
-			index: this.index,
-			gitDir: this._gitDir,
-			name: this._name = init.name ?? basename(init.uri.path),
-			path: this.path,
-			provider: this.provider,
-			root: this.root,
-			uri: this.uri,
-			watchService: this._watchService,
-		} = init);
-
-		// Pre-compute common* properties from gitDir
-		const commonGitDirUri = this._gitDir?.commonUri;
-		this.commonUri = commonGitDirUri != null ? getCommonRepositoryUri(commonGitDirUri) : undefined;
-		this.commonPath = this.commonUri != null ? normalizePath(this.commonUri.path) : undefined;
-		this.commonRepositoryName = this.commonPath != null ? basename(this.commonPath) : undefined;
-
-		// Apply commonRepositoryName prefix
-		if (this.commonRepositoryName) {
-			const prefix = `${this.commonRepositoryName}: `;
-			if (!this._name.startsWith(prefix)) {
-				this._name = `${prefix}${this._name}`;
-			}
-		}
-	}
-
-	dispose(): void {
-		this._disposed = true;
-		this._repoChangeListener?.dispose();
-		this._repoChangeListener = undefined;
-		this._repoSubscription?.dispose();
-		this._repoSubscription = undefined;
-		this._watchHandle?.dispose();
-		this._watchHandle = undefined;
-		this._watchHandleRefs = 0;
-		this._watchRefs = 0;
-		this._onDidChange.dispose();
-		this._onDidChangeWorkingTree.dispose();
-	}
-
-	/** Indicates whether this repository currently has an active `watch()` (repo-change) lease. */
-	get watching(): boolean {
-		return this._watchRefs > 0;
-	}
-
-	get etag(): number {
-		return this._updatedAt;
-	}
-
-	get etagWorkingTree(): number | undefined {
-		const etag = this._watchHandle?.session.etagWorkingTree;
-		return etag != null && etag > 0 ? etag : undefined;
-	}
-
-	get hasPendingChanges(): boolean {
-		return this._watchHandle?.session.hasPendingChanges ?? false;
-	}
-
-	@memoize()
-	get idHash(): string {
-		return md5(this.id);
-	}
-
-	/** Indicates whether this repository is a submodule */
-	get isSubmodule(): boolean {
-		return this._gitDir?.parentUri != null;
-	}
-
-	/** Indicates whether this repository is a worktree */
-	get isWorktree(): boolean {
-		return this._gitDir?.commonUri != null;
-	}
-
-	protected _lastFetched: number | undefined;
-	get lastFetchedCached(): number | undefined {
-		return this._lastFetched;
-	}
-
-	protected readonly _name: string;
-	get name(): string {
-		return this._name;
-	}
-
-	/** The parent repository URI (for submodules) */
-	get parentUri(): Uri | undefined {
-		return this._gitDir?.parentUri;
-	}
-
-	protected _updatedAt: number = 0;
-	get updatedAt(): number {
-		return this._updatedAt;
-	}
-
-	get virtual(): boolean {
-		return this.provider.virtual;
-	}
-
-	waitForRepoChange(timeoutMs: number): Promise<boolean> {
-		let timeoutId: ReturnType<typeof setTimeout> | undefined;
-		let listener: UnifiedDisposable | undefined;
-
-		const cleanup = () => {
-			if (timeoutId != null) {
-				clearTimeout(timeoutId);
-				timeoutId = undefined;
-			}
-			listener?.dispose();
-			listener = undefined;
-		};
-
-		return Promise.race([
-			new Promise<false>(r => {
-				timeoutId = setTimeout(() => {
-					cleanup();
-					r(false);
-				}, timeoutMs);
-			}),
-			new Promise<true>(r => {
-				listener = this.onDidChange(() => {
-					cleanup();
-					r(true);
-				});
-			}),
-		]);
-	}
-
-	/**
-	 * Starts watching this repository's `.git` directory for repo-change events (delivered via
-	 * {@link onDidChange}) and returns a lease. Ref-counted: the underlying watch handle is acquired
-	 * on the first lease (across `watch()` and {@link watchWorkingTree}) and released when the last
-	 * is disposed. The model is inert until watched. No-ops (returns a disposable that does nothing)
-	 * for repositories without a git directory (e.g. virtual repos).
-	 */
-	@trace({ onlyExit: true })
-	watch(): UnifiedDisposable {
-		const acquired = this.acquireWatchHandle();
-		if (acquired == null) return createDisposable(() => {});
-
-		if (this._watchRefs++ === 0) {
-			const sub = acquired.handle.session.subscribe();
-			this._repoSubscription = sub;
-			this._repoChangeListener = sub.onDidChange(e => this.onSessionRepoChange(e));
-		}
-
-		return createDisposable(
-			() => {
-				// Repo already torn down — its handle/subscriptions are gone; skip to avoid a negative refcount
-				if (this._disposed) return;
-
-				if (--this._watchRefs === 0) {
-					this._repoChangeListener?.dispose();
-					this._repoChangeListener = undefined;
-					this._repoSubscription?.dispose();
-					this._repoSubscription = undefined;
-				}
-				acquired.lease.dispose();
-			},
-			{ once: true },
-		);
-	}
-
-	@trace({ onlyExit: true })
-	watchWorkingTree(delay: number = 2500): UnifiedDisposable {
-		const acquired = this.acquireWatchHandle();
-		if (acquired == null) return createDisposable(() => {});
-
-		const sub = acquired.handle.session.subscribeToWorkingTree({ delayMs: delay });
-		const listener = sub.onDidChangeWorkingTree(e => this.onWorkingTreeChanged(e));
-
-		return createDisposable(
-			() => {
-				listener.dispose();
-				sub.dispose();
-				acquired.lease.dispose();
-			},
-			{ once: true },
-		);
-	}
-
-	/**
-	 * Creates a RepositoryChangeEvent for this repository.
-	 * Override in subclass to return a subclass-specific event type.
-	 */
-	protected createChangeEvent(changes: RepositoryChange[]): RepositoryChangeEvent {
-		return new RepositoryChangeEvent(this, changes);
-	}
-
-	protected fireChange(...changes: RepositoryChange[]): void;
-	/** Force-fire: delivered straight to the emitter, bypassing the watch session — see
-	 *  {@link forcedRepositoryChanges}, which is the only set this accepts. */
-	protected fireChange(change: ForcedRepositoryChange, force: true): void;
-	@trace()
-	protected fireChange(...args: RepositoryChange[] | [RepositoryChange, boolean]): void {
-		const lastArg = args.at(-1);
-		const force = typeof lastArg === 'boolean' ? lastArg : false;
-		const changes = (force ? args.slice(0, -1) : args) as RepositoryChange[];
-
-		this._updatedAt = Date.now();
-
-		if (force) {
-			const e = this.createChangeEvent(changes);
-			this._onDidChange.fire(e);
-			return;
-		}
-
-		this._watchHandle?.session.fireChange(...changes);
-	}
-
-	/** Called when the watch service notifies of FETCH_HEAD changes. */
-	protected onFetchHeadChanged(): void {
-		// Don't reset `_lastFetched` here: the FS watcher can fire even when the on-disk mtime
-		// hasn't advanced (atomic-rename / lock-file activity emits `change` events without an
-		// mtime bump), and wiping would clobber a fresher value set by `markFetched()`.
-		// `getLastFetched()` reconciles in-memory vs FS via `Math.max`. Force-fire so consumers
-		// invalidate their caches and re-read.
-		this.fireChange('lastFetched', true);
-	}
-
-	/**
-	 * Marks the repository as having just been fetched. Use after a GitLens-initiated fetch/pull
-	 * completes so the "last fetched" UI tracks the attempt even when git skipped rewriting
-	 * `.git/FETCH_HEAD` (modern git omits the rewrite when all refs are up-to-date). The
-	 * in-memory timestamp is reconciled with the on-disk mtime by {@link getLastFetched} via
-	 * `Math.max`, so this is monotonic.
-	 */
-	markFetched(timestamp: number = Date.now()): void {
-		const next = Math.max(this._lastFetched ?? 0, timestamp);
-		if (next === this._lastFetched) return;
-
-		this._lastFetched = next;
-		this.fireChange('lastFetched', true);
-	}
-
-	/** Called when .gitignore changes in the working tree. */
-	protected onGitIgnoreChanged(): void {
-		this.fireChange('ignores');
-	}
-
-	/** Called by the watch service when info/exclude changes. */
-	protected onIgnoresChanged(): void {}
-
-	/** Called by the session when a debounced repo change event fires */
-	private onSessionRepoChange(e: WatcherRepoChangeEvent): void {
-		this._updatedAt = Date.now();
-
-		const extEvent = this.createChangeEvent([...e.changes]);
-		this._onDidChange.fire(extEvent);
-	}
-
-	/**
-	 * Called by every {@link watchWorkingTree} subscription when its debounced batch arrives. Each
-	 * call to {@link watchWorkingTree} adds a separate bridge listener on the underlying watch
-	 * session, so a single fs change can invoke this method multiple times in the same microtask —
-	 * once per active subscription. We accumulate paths into a single pending event and defer the
-	 * actual fire to a microtask so back-to-back synchronous bridge calls collapse into ONE
-	 * `_onDidChangeWorkingTree` emission. Without this coalescing, every WIP-dependent listener
-	 * (graph, file history, compare branch, etc.) would fire N times for N active subscriptions.
-	 */
-	/** Takes the session event whole rather than spreading it across parameters — a subclass override that
-	 *  dropped a trailing positional argument silently defeated this pipeline once already. */
-	protected onWorkingTreeChanged(e: WorkingTreeChangeEvent): void {
-		this._updatedAt = Date.now();
-
-		this._pendingWorkingTreePaths ??= new Set<string>();
-		for (const p of e.paths) {
-			this._pendingWorkingTreePaths.add(p);
-		}
-		this._pendingWorkingTreeIncomplete ||= e.incomplete;
-
-		if (this._pendingWorkingTreeFlush) return;
-
-		this._pendingWorkingTreeFlush = true;
-		queueMicrotask(() => {
-			this._pendingWorkingTreeFlush = false;
-			const paths = this._pendingWorkingTreePaths;
-			if (paths == null) return;
-
-			const incomplete = this._pendingWorkingTreeIncomplete;
-			this._pendingWorkingTreePaths = undefined;
-			this._pendingWorkingTreeIncomplete = false;
-
-			this._onDidChangeWorkingTree.fire(new RepositoryWorkingTreeChangeEvent(this, paths, incomplete));
-		});
-	}
-
-	/**
-	 * Lazily acquires (and ref-counts) the shared {@link _watchHandle} for this repository, returning
-	 * the handle plus a one-shot lease whose disposal decrements the ref count (releasing the handle
-	 * when the last lease is gone). Returns `undefined` for repositories without a git directory.
-	 */
-	private acquireWatchHandle(): { handle: WatchHandle; lease: UnifiedDisposable } | undefined {
-		if (this._gitDir == null || this._disposed) return undefined;
-
-		this._watchHandle ??= this._watchService.watch(this.path, this._gitDir, {
-			onFetchHeadChanged: () => this.onFetchHeadChanged(),
-			onGitIgnoreChanged: () => this.onGitIgnoreChanged(),
-			onIgnoresChanged: () => this.onIgnoresChanged(),
-		} satisfies WatchHooks);
-		const handle = this._watchHandle;
-		if (handle == null) return undefined;
-
-		this._watchHandleRefs++;
-		const lease = createDisposable(
-			() => {
-				// Repo already torn down — the handle is gone; skip to avoid a negative refcount
-				if (this._disposed) return;
-
-				if (--this._watchHandleRefs === 0) {
-					this._watchHandle?.dispose();
-					this._watchHandle = undefined;
-				}
-			},
-			{ once: true },
-		);
-
-		return { handle: handle, lease: lease };
-	}
-
-	static is(repository: unknown): repository is Repository {
-		return repository instanceof Repository;
-	}
-}

package/src/git/models/repositoryChangeEvent.ts

@@ -1,30 +0,0 @@
-import { join } from '../../utils/iterable.js';
-import { WatcherRepoChangeEvent } from '../watching/changeEvent.js';
-import type { Repository, RepositoryChange } from './repository.js';
-
-/**
- * An event describing changes to a repository, with a reference to the
- * repository instance that changed. This is the public-facing event
- * consumed by views, services, and commands.
- *
- * Extends `WatcherRepoChangeEvent` so all change-testing logic
- * (`changed`, `changedExclusive`, `pausedOp` handling) lives in one place.
- */
-export class RepositoryChangeEvent extends WatcherRepoChangeEvent {
-	constructor(
-		public readonly repository: Repository,
-		changes: RepositoryChange[],
-	) {
-		super(repository.path, changes);
-	}
-
-	override toString(changesOnly: boolean = false): string {
-		return changesOnly
-			? `changes=${join(this._changes, ', ')}`
-			: `{ repository: ${this.repository?.name ?? ''}, changes: ${join(this._changes, ', ')} }`;
-	}
-
-	override with(changes: RepositoryChange[]): RepositoryChangeEvent {
-		return new RepositoryChangeEvent(this.repository, [...this._changes, ...changes]);
-	}
-}

package/src/git/models/repositoryIdentities.ts

@@ -1,99 +0,0 @@
-import type { Branded } from '../../utils/brand.js';
-
-export const missingRepositoryId = '-';
-
-export type GkProviderId = Branded<
-	'github' | 'githubEnterprise' | 'gitlab' | 'gitlabSelfHosted' | 'bitbucket' | 'bitbucketServer' | 'azureDevops',
-	'GkProviderId'
->;
-export type GkRepositoryId = Branded<string, 'GkRepositoryId'>;
-
-export interface RepositoryIdentityRemoteDescriptor {
-	readonly url?: string;
-	readonly domain?: string;
-	readonly path?: string;
-}
-
-export interface RepositoryIdentityProviderDescriptor<ID extends string | GkProviderId = GkProviderId> {
-	readonly id?: ID;
-	readonly domain?: string;
-	readonly repoDomain?: string;
-	readonly repoName?: string;
-	readonly repoOwnerDomain?: string;
-}
-
-// TODO: replace this string with GkProviderId eventually once we wrangle our backend provider ids
-export interface RepositoryIdentityDescriptor<ID extends string | GkProviderId = GkProviderId> {
-	readonly name: string;
-
-	readonly initialCommitSha?: string;
-	readonly remote?: RepositoryIdentityRemoteDescriptor;
-	readonly provider?: RepositoryIdentityProviderDescriptor<ID>;
-}
-
-export interface RepositoryIdentity extends RepositoryIdentityDescriptor {
-	readonly id: GkRepositoryId;
-	readonly createdAt: Date;
-	readonly updatedAt: Date;
-}
-
-type BaseRepositoryIdentityRequest = {
-	// name: string;
-	initialCommitSha?: string;
-};
-
-type BaseRepositoryIdentityRequestWithCommitSha = BaseRepositoryIdentityRequest & {
-	initialCommitSha: string;
-};
-
-type BaseRepositoryIdentityRequestWithRemote = BaseRepositoryIdentityRequest & {
-	remote: { url: string; domain: string; path: string };
-};
-
-type BaseRepositoryIdentityRequestWithRemoteProvider = BaseRepositoryIdentityRequestWithRemote & {
-	provider: {
-		id: GkProviderId;
-		repoDomain: string;
-		repoName: string;
-		repoOwnerDomain?: string;
-	};
-};
-
-type BaseRepositoryIdentityRequestWithoutRemoteProvider = BaseRepositoryIdentityRequestWithRemote & {
-	provider?: never;
-};
-
-export type RepositoryIdentityRequest =
-	| BaseRepositoryIdentityRequestWithCommitSha
-	| BaseRepositoryIdentityRequestWithRemote
-	| BaseRepositoryIdentityRequestWithRemoteProvider
-	| BaseRepositoryIdentityRequestWithoutRemoteProvider;
-
-export interface RepositoryIdentityResponse {
-	readonly id: GkRepositoryId;
-	readonly createdAt: string;
-	readonly updatedAt: string;
-
-	// readonly name: string;
-
-	readonly initialCommitSha?: string;
-	readonly remote?: {
-		readonly url?: string;
-		readonly domain?: string;
-		readonly path?: string;
-	};
-	readonly provider?: {
-		readonly id?: GkProviderId;
-		readonly repoDomain?: string;
-		readonly repoName?: string;
-		readonly repoOwnerDomain?: string;
-	};
-}
-
-export function getPathFromProviderIdentity<ID extends string | GkProviderId>(
-	provider: RepositoryIdentityProviderDescriptor<ID>,
-): string {
-	return provider.repoOwnerDomain
-		? `${provider.repoOwnerDomain}/${provider.repoDomain}/${provider.repoName}`
-		: `${provider.repoDomain}/${provider.repoName}`;
-}

package/src/git/models/repositoryMetadata.ts

@@ -1,12 +0,0 @@
-import type { ProviderReference } from './remoteProvider.js';
-
-export interface RepositoryMetadata {
-	provider: ProviderReference;
-	owner: string;
-	name: string;
-	isFork: boolean;
-	parent?: {
-		owner: string;
-		name: string;
-	};
-}

package/src/git/models/resourceDescriptor.ts

@@ -1,28 +0,0 @@
-export type ResourceDescriptor = { key: string } & Record<string, unknown>;
-
-export type IssueResourceDescriptor = ResourceDescriptor & {
-	id: string;
-	name: string;
-};
-
-export type RepositoryDescriptor = ResourceDescriptor & {
-	owner: string;
-	name: string;
-};
-
-/**
- * A normalized read scope that unifies the three provider scoping representations (repo-level
- * `ProviderReposInput`, per-provider `PagingMode`, and org/project `ResourceDescriptor`s). Consumers pass
- * this single shape; the integration resolves it to the provider-appropriate inputs. At least one field
- * should be set:
- * - `org`: GitHub login / Bitbucket workspace / Azure organization / GitLab namespace
- * - `project`: Azure project / Jira project key
- * - `resourceId`: Jira/Azure resource id
- * - `repos`: explicit repositories to scope to
- */
-export type ProviderScope = {
-	org?: string;
-	project?: string;
-	resourceId?: string;
-	repos?: RepositoryDescriptor[];
-};

package/src/git/models/revision.ts

@@ -1,12 +0,0 @@
-export const deletedOrMissing = '0000000000000000000000000000000000000000-';
-export const uncommitted = '0000000000000000000000000000000000000000';
-export const uncommittedStaged = '0000000000000000000000000000000000000000:';
-// This is a root sha of all git repo's if using sha1
-export const rootSha = '4b825dc642cb6eb9a060e54bf8d69288fbee4904';
-
-export type GitRevisionRange =
-	| `${GitRevisionRangeNotation}${string}`
-	| `${string}${GitRevisionRangeNotation}`
-	| `${string}${GitRevisionRangeNotation}${string}`;
-
-export type GitRevisionRangeNotation = '..' | '...';