jj-plus 0.10.10

package/dist/extension/index.cjs

@@ -0,0 +1,657 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_constants = require("./constants.cjs");
+const require_package = require("../package.cjs");
+const require_command_runner = require("./command-runner.cjs");
+const require_blame_codelens = require("./blame-codelens.cjs");
+const require_resolve_file_path = require("./resolve-file-path.cjs");
+const require_editor_extra_features = require("./editor-extra-features.cjs");
+const require_history_adapters = require("./history-adapters.cjs");
+const require_list_file_revisions = require("../shared/list-file-revisions.cjs");
+const require_revision_diff_nav = require("./revision-diff-nav.cjs");
+const require_uri_utils = require("./uri-utils.cjs");
+const require_timeline_panel = require("./timeline-panel.cjs");
+const require_repo_timeline_panel = require("./repo-timeline-panel.cjs");
+const require_timeline_service = require("./timeline-service.cjs");
+let node_path = require("node:path");
+node_path = require_runtime.__toESM(node_path, 1);
+let vscode = require("vscode");
+vscode = require_runtime.__toESM(vscode, 1);
+//#region src/extension/index.ts
+function activate(context) {
+	const outputChannel = vscode.window.createOutputChannel("JJ Plus");
+	const runner = require_command_runner.createCommandRunner({ outputChannel });
+	const service = require_timeline_service.createTimelineService({ runner });
+	const panelController = require_timeline_panel.createTimelinePanelController({
+		context,
+		service,
+		getPreferences: () => getTimelinePreferences(context),
+		savePreferences: (nextPreferences) => saveTimelinePreferences(context, nextPreferences),
+		version: require_package.version
+	});
+	const repoTimelineController = require_repo_timeline_panel.createRepoTimelinePanelController({
+		context,
+		runner,
+		version: require_package.version
+	});
+	const provider = new SnapshotContentProvider({ runner });
+	const openRangeMultiDiff = async (rawArgs) => {
+		if (rawArgs?.verbose) outputChannel.show(true);
+		const workspaceUri = await resolveWorkspaceUri({
+			context,
+			args: rawArgs
+		});
+		if (workspaceUri === "redirected") return;
+		if (!workspaceUri) {
+			vscode.window.showErrorMessage("No workspace folder available");
+			return;
+		}
+		const base = shouldPromptForInputs(rawArgs) ? await resolveInput({
+			value: getFromValue(rawArgs),
+			prompt: "From change id or revset",
+			placeHolder: require_constants.DEFAULT_FROM_REVSET
+		}) : getFromValue(rawArgs);
+		if (!base) return;
+		const target = shouldPromptForInputs(rawArgs) ? await resolveInput({
+			value: getToValue(rawArgs),
+			prompt: "To change id or revset",
+			placeHolder: "@"
+		}) : getToValue(rawArgs);
+		if (!target) return;
+		const title = rawArgs?.title?.trim() || `${base}..${target}`;
+		try {
+			const { resolvedTitle, resources } = await buildWorkspaceMultiDiffResources({
+				runner,
+				workspacePath: workspaceUri.fsPath,
+				base,
+				target,
+				title
+			});
+			if (!resources.length) {
+				vscode.window.showInformationMessage(`No changes found for ${title}`);
+				return;
+			}
+			await vscode.commands.executeCommand(require_constants.OPEN_MULTI_DIFF_COMMAND, {
+				title: resolvedTitle,
+				resources
+			});
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			vscode.window.showErrorMessage(`Failed to open JJ Plus range diff: ${message}`);
+		}
+	};
+	const openFileRangeDiff = async (rawArgs) => {
+		if (rawArgs?.verbose) outputChannel.show(true);
+		const workspaceUri = await resolveWorkspaceUri({
+			context,
+			args: rawArgs
+		});
+		if (workspaceUri === "redirected") return;
+		if (!workspaceUri) {
+			vscode.window.showErrorMessage("No workspace folder available");
+			return;
+		}
+		const fileTarget = await resolveFileDiffTarget({
+			workspaceUri,
+			absolutePath: rawArgs?.absolutePath
+		});
+		if (!fileTarget) {
+			vscode.window.showErrorMessage("No workspace file available from the active editor or open tabs");
+			return;
+		}
+		const base = shouldPromptForInputs(rawArgs) ? await resolveInput({
+			value: getFromValue(rawArgs),
+			prompt: "From change id or revset",
+			placeHolder: require_constants.DEFAULT_FROM_REVSET
+		}) : getFromValue(rawArgs);
+		if (!base) return;
+		const target = shouldPromptForInputs(rawArgs) ? await resolveInput({
+			value: getToValue(rawArgs),
+			prompt: "To change id or revset",
+			placeHolder: "@"
+		}) : getToValue(rawArgs);
+		if (!target) return;
+		const title = rawArgs?.title?.trim() || `${fileTarget.fileName}: ${base} -> ${target}`;
+		try {
+			const preferredWorkspacePath = node_path.default.dirname(fileTarget.absolutePath);
+			const historyWorkspacePath = await require_history_adapters.resolveHistoryWorkspacePath({
+				workspacePath: preferredWorkspacePath,
+				runner
+			});
+			const relativePath = toHistoryRelativePath({
+				historyWorkspacePath,
+				absolutePath: fileTarget.absolutePath
+			});
+			if (!relativePath) throw new Error("The selected file is outside the resolved repository root");
+			let adapter = await require_history_adapters.resolveHistoryAdapter({
+				workspacePath: historyWorkspacePath,
+				runner
+			});
+			let resolvedWorkspacePath = historyWorkspacePath;
+			let resolvedRelativePath = relativePath;
+			let originalContent = "";
+			let modifiedContent = "";
+			try {
+				[originalContent, modifiedContent] = await Promise.all([adapter.showFileAtRevision({
+					workspacePath: resolvedWorkspacePath,
+					revset: base,
+					filePath: resolvedRelativePath
+				}), adapter.showFileAtRevision({
+					workspacePath: resolvedWorkspacePath,
+					revset: target,
+					filePath: resolvedRelativePath
+				})]);
+			} catch (error) {
+				const fallback = await resolveJjFileFallback({
+					error,
+					adapter,
+					runner,
+					absolutePath: fileTarget.absolutePath,
+					base,
+					target
+				});
+				if (!fallback) throw error;
+				adapter = fallback.adapter;
+				resolvedWorkspacePath = fallback.workspacePath;
+				resolvedRelativePath = fallback.relativePath;
+				[originalContent, modifiedContent] = await Promise.all([adapter.showFileAtRevision({
+					workspacePath: resolvedWorkspacePath,
+					revset: base,
+					filePath: resolvedRelativePath
+				}), adapter.showFileAtRevision({
+					workspacePath: resolvedWorkspacePath,
+					revset: target,
+					filePath: resolvedRelativePath
+				})]);
+			}
+			const originalUri = provider.createInlineContentUri({
+				workspacePath: resolvedWorkspacePath,
+				revset: base,
+				relativePath: resolvedRelativePath,
+				content: originalContent
+			});
+			const modifiedUri = provider.createInlineContentUri({
+				workspacePath: resolvedWorkspacePath,
+				revset: target,
+				relativePath: resolvedRelativePath,
+				content: modifiedContent
+			});
+			await vscode.commands.executeCommand("vscode.diff", originalUri, modifiedUri, title, { preview: true });
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			vscode.window.showErrorMessage(`Failed to open file diff: ${message}`);
+		}
+	};
+	const revisionDiffNav = require_revision_diff_nav.createRevisionDiffNavigator({
+		showFile: async ({ workspacePath, revset, filePath }) => {
+			return (await require_history_adapters.resolveHistoryAdapter({
+				workspacePath,
+				runner
+			})).showFileAtRevision({
+				workspacePath,
+				revset,
+				filePath
+			});
+		},
+		createUri: (uriArgs) => provider.createInlineContentUri(uriArgs),
+		listRevisions: async ({ workspacePath, relativePath, backend }) => require_list_file_revisions.listFileRevisionIds({
+			runner,
+			workspacePath,
+			relativePath,
+			backend
+		}),
+		resolveBackend: async ({ workspacePath }) => require_history_adapters.resolveHistoryAdapter({
+			workspacePath,
+			runner
+		}),
+		resolveHistoryWorkspacePath: async ({ workspacePath }) => require_history_adapters.resolveHistoryWorkspacePath({
+			workspacePath,
+			runner
+		}),
+		toRelativePath: toHistoryRelativePath
+	});
+	context.subscriptions.push(outputChannel, vscode.workspace.registerTextDocumentContentProvider("jj-plus", provider), vscode.commands.registerCommand(require_constants.HELPER_COMMAND, openRangeMultiDiff), vscode.commands.registerCommand(require_constants.OPEN_FILE_RANGE_DIFF_COMMAND, openFileRangeDiff), vscode.commands.registerCommand(require_constants.OPEN_CHANGES_WITH_PREVIOUS_COMMAND, (arg) => revisionDiffNav.openWithPrevious(arg)), vscode.commands.registerCommand(require_constants.OPEN_REVISION_DIFF_PREVIOUS_COMMAND, () => revisionDiffNav.openPrevious()), vscode.commands.registerCommand(require_constants.OPEN_REVISION_DIFF_NEXT_COMMAND, () => revisionDiffNav.openNext()), vscode.commands.registerCommand(require_constants.OPEN_REVISION_DIFF_TIMELINE_COMMAND, () => revisionDiffNav.openTimelineHere()), vscode.commands.registerCommand(require_constants.OPEN_FILE_TIMELINE_COMMAND, (arg) => panelController.openFileRevisionTimeline({
+		context,
+		absolutePath: require_resolve_file_path.resolveCommandFilePath(arg)
+	})), vscode.commands.registerCommand(require_constants.OPEN_REPO_TIMELINE_COMMAND, () => repoTimelineController.open()), vscode.commands.registerCommand(require_constants.OPEN_FILE_LINE_TIMELINE_COMMAND, async () => {
+		const editor = vscode.window.activeTextEditor;
+		if (!editor || editor.document.uri.scheme !== "file") {
+			vscode.window.showErrorMessage("Open a workspace file and select lines to browse line history");
+			return;
+		}
+		const startLine = Math.min(editor.selection.start.line, editor.selection.end.line) + 1;
+		const endLine = Math.max(editor.selection.start.line, editor.selection.end.line) + 1;
+		await panelController.openFileRevisionTimeline({
+			context,
+			absolutePath: editor.document.uri.fsPath,
+			lineHistory: {
+				startLine,
+				endLine
+			}
+		});
+	}), vscode.commands.registerCommand(require_constants.CLEAR_LINE_HISTORY_COMMAND, () => panelController.clearLineHistoryFilter()), vscode.commands.registerCommand(require_constants.OPEN_TIMELINE_AT_LINE_COMMAND, async (args) => {
+		const parsed = typeof args === "string" ? JSON.parse(args) : args || {};
+		const editor = vscode.window.activeTextEditor;
+		const absolutePath = parsed.absolutePath || editor?.document.uri.fsPath;
+		const line = typeof parsed.line === "number" ? parsed.line : editor ? editor.selection.active.line + 1 : void 0;
+		if (!absolutePath || !line) {
+			vscode.window.showErrorMessage("Place the cursor on a workspace file line to open timeline");
+			return;
+		}
+		const workspaceFolder = vscode.workspace.getWorkspaceFolder(vscode.Uri.file(absolutePath));
+		if (!workspaceFolder) {
+			vscode.window.showErrorMessage("The file must belong to a workspace folder");
+			return;
+		}
+		const relativePath = node_path.default.relative(workspaceFolder.uri.fsPath, absolutePath).replace(/\\/g, "/");
+		const adapter = await require_history_adapters.resolveHistoryAdapter({
+			workspacePath: workspaceFolder.uri.fsPath,
+			runner
+		});
+		const focusRevision = await service.resolveBlameRevisionForLine({
+			workspacePath: workspaceFolder.uri.fsPath,
+			relativePath,
+			line,
+			backend: adapter.backend
+		});
+		await panelController.openFileRevisionTimeline({
+			context,
+			absolutePath,
+			lineHistory: {
+				startLine: line,
+				endLine: line
+			},
+			focusRevision
+		});
+	}), require_blame_codelens.createEditorBlameDecorations({
+		runner,
+		resolveBackend: async ({ workspacePath }) => require_history_adapters.resolveHistoryAdapter({
+			workspacePath,
+			runner
+		})
+	}), require_editor_extra_features.registerEditorExtraFeatures({
+		context,
+		runner,
+		resolveBackend: async ({ workspacePath }) => require_history_adapters.resolveHistoryAdapter({
+			workspacePath,
+			runner
+		}),
+		createInlineContentUri: (uriArgs) => provider.createInlineContentUri(uriArgs),
+		getRemoteBaseUrl: async ({ workspacePath }) => {
+			return (await require_history_adapters.resolveHistoryAdapter({
+				workspacePath,
+				runner
+			})).getRemoteBaseUrl({ workspacePath });
+		},
+		showFileAtRevision: async ({ workspacePath, revset, filePath }) => {
+			return (await require_history_adapters.resolveHistoryAdapter({
+				workspacePath,
+				runner
+			})).showFileAtRevision({
+				workspacePath,
+				revset,
+				filePath
+			});
+		},
+		openRevisionMultiDiff: async ({ workspacePath, revision }) => {
+			await openRevisionMultiDiff({
+				workspacePath,
+				revision,
+				runner
+			});
+		}
+	}), revisionDiffNav, vscode.commands.registerCommand(require_constants.GET_TIMELINE_DEBUG_STATE_COMMAND, () => panelController.getDebugState()), vscode.commands.registerCommand(require_constants.GET_DIFF_LAYOUT_METRICS_COMMAND, () => panelController.getDiffLayoutMetrics()), vscode.commands.registerCommand(require_constants.DEBUG_SELECT_TIMELINE_RANGE_COMMAND, (args) => panelController.selectTimelineRange(args)), vscode.commands.registerCommand(require_constants.DEBUG_SET_LAYOUT_MODE_COMMAND, (layoutMode) => panelController.setLayoutMode(layoutMode)), vscode.window.registerUriHandler({ async handleUri(uri) {
+		if (!require_uri_utils.isRangeDiffUriTarget({
+			uri,
+			extensionId: "astahmer.jj-plus"
+		})) return;
+		await openRangeMultiDiff(require_uri_utils.parseRangeDiffUri(uri));
+	} }), { dispose: () => panelController.dispose() }, { dispose: () => repoTimelineController.dispose() });
+	resumePendingRangeDiff({
+		context,
+		openRangeMultiDiff
+	});
+}
+function deactivate() {}
+var SnapshotContentProvider = class {
+	runner;
+	inlineContent = /* @__PURE__ */ new Map();
+	constructor(args) {
+		this.runner = args.runner;
+	}
+	createInlineContentUri(args) {
+		const contentId = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+		this.inlineContent.set(contentId, args.content);
+		return vscode.Uri.from({
+			scheme: require_constants.SNAPSHOT_SCHEME,
+			path: `/${args.relativePath}`,
+			query: JSON.stringify({
+				workspacePath: args.workspacePath,
+				filePath: args.relativePath,
+				revset: args.revset,
+				contentId
+			})
+		});
+	}
+	async provideTextDocumentContent(uri) {
+		const query = require_uri_utils.parseSnapshotUri(uri);
+		if (query.contentId) return this.inlineContent.get(query.contentId) || "";
+		if (!query.workspacePath || !query.revset || !query.filePath) return "";
+		try {
+			return await (await require_history_adapters.resolveHistoryAdapter({
+				workspacePath: query.workspacePath,
+				runner: this.runner
+			})).showFileAtRevision({
+				workspacePath: query.workspacePath,
+				revset: query.revset,
+				filePath: query.filePath
+			});
+		} catch {
+			return "";
+		}
+	}
+};
+function getTimelinePreferences(context) {
+	const rawValue = context.globalState.get(require_constants.TIMELINE_PREFERENCES_KEY);
+	return require_timeline_service.normalizeTimelinePreferences(rawValue);
+}
+async function saveTimelinePreferences(context, nextPreferences) {
+	const currentPreferences = getTimelinePreferences(context);
+	await context.globalState.update(require_constants.TIMELINE_PREFERENCES_KEY, {
+		...currentPreferences,
+		...nextPreferences
+	});
+}
+async function buildWorkspaceMultiDiffResources(args) {
+	let changedFiles = await listChangedFiles(args);
+	let originalRevset = args.base;
+	let modifiedRevset = args.target;
+	let resolvedTitle = args.title;
+	if (!changedFiles.length && args.target === "@" && args.base !== args.target) {
+		const revisionFiles = await listRevisionFiles({
+			runner: args.runner,
+			workspacePath: args.workspacePath,
+			revision: args.base
+		});
+		if (revisionFiles.length) {
+			changedFiles = revisionFiles;
+			originalRevset = `${args.base}-`;
+			modifiedRevset = args.base;
+			if (args.title === `${args.base}..${args.target}`) resolvedTitle = args.base;
+		}
+	}
+	return {
+		resolvedTitle,
+		resources: await Promise.all(changedFiles.map(async (relativePath) => ({
+			originalUri: require_uri_utils.createSnapshotUri({
+				workspacePath: args.workspacePath,
+				revset: originalRevset,
+				relativePath
+			}),
+			modifiedUri: await createTargetUri({
+				workspacePath: args.workspacePath,
+				revset: modifiedRevset,
+				relativePath
+			})
+		})))
+	};
+}
+async function listChangedFiles(args) {
+	const { stdout } = await args.runner.runJj({
+		workspacePath: args.workspacePath,
+		args: [
+			"diff",
+			"--name-only",
+			"--from",
+			args.base,
+			"--to",
+			args.target
+		]
+	});
+	return stdout.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean);
+}
+async function listRevisionFiles(args) {
+	const { stdout } = await args.runner.runJj({
+		workspacePath: args.workspacePath,
+		args: [
+			"diff",
+			"--name-only",
+			"-r",
+			args.revision
+		]
+	});
+	return stdout.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean);
+}
+async function openRevisionMultiDiff(args) {
+	const adapter = await require_history_adapters.resolveHistoryAdapter({
+		workspacePath: args.workspacePath,
+		runner: args.runner
+	});
+	const files = await adapter.listRevisionFiles({
+		workspacePath: args.workspacePath,
+		revision: args.revision
+	});
+	if (!files.length) {
+		vscode.window.showInformationMessage(`No files changed in ${args.revision.slice(0, 12)}`);
+		return;
+	}
+	let parentRevision = `${args.revision}-`;
+	if (adapter.backend === "git") try {
+		const { stdout } = await args.runner.runGit({
+			workspacePath: args.workspacePath,
+			args: ["rev-parse", `${args.revision}^`]
+		});
+		parentRevision = stdout.trim() || "EMPTY";
+	} catch {
+		parentRevision = "EMPTY";
+	}
+	await vscode.commands.executeCommand(require_constants.OPEN_MULTI_DIFF_COMMAND, {
+		title: `JJ Plus: ${args.revision.slice(0, 12)} · revision diff`,
+		resources: files.map((relativePath) => ({
+			originalUri: require_uri_utils.createSnapshotUri({
+				workspacePath: args.workspacePath,
+				revset: parentRevision,
+				relativePath,
+				backend: adapter.backend
+			}),
+			modifiedUri: require_uri_utils.createSnapshotUri({
+				workspacePath: args.workspacePath,
+				revset: args.revision,
+				relativePath,
+				backend: adapter.backend
+			})
+		}))
+	});
+}
+async function createTargetUri(args) {
+	if (args.revset === "@") {
+		const fileUri = vscode.Uri.file(node_path.default.join(args.workspacePath, args.relativePath));
+		if (await vscode.workspace.fs.stat(fileUri).then(() => true, () => false)) return fileUri;
+	}
+	return require_uri_utils.createSnapshotUri({
+		workspacePath: args.workspacePath,
+		revset: args.revset,
+		relativePath: args.relativePath
+	});
+}
+function toHistoryRelativePath(args) {
+	const relativePath = node_path.default.relative(args.historyWorkspacePath, args.absolutePath).replace(/\\/g, "/");
+	if (!relativePath || relativePath.startsWith("..")) return;
+	return relativePath;
+}
+async function resolveJjFileFallback(args) {
+	if (args.adapter.backend !== "git") return;
+	if (!looksLikeGitRejectedJjRevset({
+		error: args.error,
+		base: args.base,
+		target: args.target
+	})) return;
+	const preferredWorkspacePath = node_path.default.dirname(args.absolutePath);
+	const { stdout } = await args.runner.runJj({
+		workspacePath: preferredWorkspacePath,
+		args: ["root"]
+	});
+	const jjRoot = stdout.trim();
+	if (!jjRoot) return;
+	const relativePath = toHistoryRelativePath({
+		historyWorkspacePath: jjRoot,
+		absolutePath: args.absolutePath
+	});
+	if (!relativePath) return;
+	const adapter = await require_history_adapters.resolveHistoryAdapter({
+		workspacePath: jjRoot,
+		runner: args.runner
+	});
+	if (adapter.backend !== "jj") return;
+	return {
+		adapter,
+		workspacePath: jjRoot,
+		relativePath
+	};
+}
+function looksLikeGitRejectedJjRevset(args) {
+	const errorMessage = args.error instanceof Error ? args.error.message : String(args.error || "");
+	if (!/invalid\s+object\s+name|unknown\s+revision|ambiguous\s+argument/iu.test(errorMessage)) return false;
+	return [args.base, args.target].some((candidate) => isLikelyJjRevset(candidate));
+}
+function isLikelyJjRevset(value) {
+	const revset = value.trim();
+	if (!revset) return false;
+	if (revset.includes("closest_bookmark(") || revset.includes("latest(") || revset.includes("::")) return true;
+	if (revset === "@" || revset.startsWith("@-") || revset.startsWith("@+")) return true;
+	return /^@[0-9]+$/u.test(revset);
+}
+async function resolveFileDiffTarget(args) {
+	const explicitTarget = getWorkspaceFileTargetFromAbsolutePath(args);
+	if (explicitTarget) return explicitTarget;
+	const activeEditorTarget = getActiveWorkspaceFileTarget(args.workspaceUri);
+	if (activeEditorTarget) return activeEditorTarget;
+	return pickOpenWorkspaceFileTarget(args.workspaceUri);
+}
+function getWorkspaceFileTargetFromAbsolutePath(args) {
+	const trimmedPath = args.absolutePath?.trim();
+	if (!trimmedPath) return;
+	return toWorkspaceFileTarget({
+		workspaceUri: args.workspaceUri,
+		fileUri: vscode.Uri.file(trimmedPath)
+	});
+}
+function getActiveWorkspaceFileTarget(workspaceUri) {
+	const activeEditor = vscode.window.activeTextEditor;
+	if (!activeEditor) return;
+	return toWorkspaceFileTarget({
+		workspaceUri,
+		fileUri: activeEditor.document.uri
+	});
+}
+async function pickOpenWorkspaceFileTarget(workspaceUri) {
+	const candidates = getOpenWorkspaceFileTargets(workspaceUri);
+	if (!candidates.length) return;
+	return (await vscode.window.showQuickPick(candidates.map((candidate) => ({
+		label: candidate.fileName,
+		description: candidate.relativePath,
+		detail: node_path.default.dirname(candidate.relativePath) === "." ? void 0 : node_path.default.dirname(candidate.relativePath),
+		target: candidate
+	})), { placeHolder: "Select a workspace file to diff between revisions" }))?.target;
+}
+function getOpenWorkspaceFileTargets(workspaceUri) {
+	const candidates = [];
+	const seenPaths = /* @__PURE__ */ new Set();
+	for (const group of vscode.window.tabGroups?.all || []) for (const tab of group.tabs) {
+		const uri = getTabUri(tab);
+		if (!uri || uri.scheme !== "file") continue;
+		const absolutePath = uri.fsPath;
+		if (seenPaths.has(absolutePath)) continue;
+		const target = toWorkspaceFileTarget({
+			workspaceUri,
+			fileUri: uri
+		});
+		if (!target) continue;
+		seenPaths.add(absolutePath);
+		candidates.push(target);
+	}
+	return candidates;
+}
+function toWorkspaceFileTarget(args) {
+	if (args.fileUri.scheme !== "file") return;
+	const workspaceFolder = vscode.workspace.getWorkspaceFolder(args.fileUri);
+	if (!workspaceFolder || !require_uri_utils.areSamePath({
+		left: workspaceFolder.uri.fsPath,
+		right: args.workspaceUri.fsPath
+	})) return;
+	const relativePath = node_path.default.relative(args.workspaceUri.fsPath, args.fileUri.fsPath).replace(/\\/g, "/");
+	if (!relativePath || relativePath.startsWith("..")) return;
+	return {
+		absolutePath: args.fileUri.fsPath,
+		relativePath,
+		fileName: node_path.default.basename(args.fileUri.fsPath)
+	};
+}
+function getTabUri(tab) {
+	return tab.input?.uri;
+}
+async function resolveWorkspaceUri(args) {
+	const explicitUri = getExplicitWorkspaceUri(args.args?.workspacePath);
+	if (explicitUri) {
+		const openWorkspaceUri = getOpenWorkspaceUri(explicitUri);
+		if (openWorkspaceUri) return openWorkspaceUri;
+		await args.context.globalState.update(require_constants.PENDING_RANGE_DIFF_KEY, require_uri_utils.sanitizeRangeDiffArgs(args.args));
+		await vscode.commands.executeCommand("vscode.openFolder", explicitUri, {
+			forceReuseWindow: true,
+			noRecentEntry: true
+		});
+		return "redirected";
+	}
+	const activeEditorFolder = vscode.window.activeTextEditor ? vscode.workspace.getWorkspaceFolder(vscode.window.activeTextEditor.document.uri) : void 0;
+	if (activeEditorFolder) return activeEditorFolder.uri;
+	if (vscode.workspace.workspaceFolders?.length === 1) return vscode.workspace.workspaceFolders[0].uri;
+	if (!vscode.workspace.workspaceFolders?.length) return;
+	return (await vscode.window.showWorkspaceFolderPick({ placeHolder: "Select the workspace to open the JJ Plus range diff in" }))?.uri;
+}
+async function resumePendingRangeDiff(args) {
+	const pendingArgs = args.context.globalState.get(require_constants.PENDING_RANGE_DIFF_KEY);
+	if (!pendingArgs) return;
+	const explicitUri = getExplicitWorkspaceUri(pendingArgs.workspacePath);
+	if (!explicitUri) {
+		await args.context.globalState.update(require_constants.PENDING_RANGE_DIFF_KEY, void 0);
+		return;
+	}
+	if (!getOpenWorkspaceUri(explicitUri)) return;
+	await args.context.globalState.update(require_constants.PENDING_RANGE_DIFF_KEY, void 0);
+	await args.openRangeMultiDiff(pendingArgs);
+}
+function getExplicitWorkspaceUri(workspacePath) {
+	const trimmed = workspacePath?.trim();
+	return trimmed ? vscode.Uri.file(trimmed) : void 0;
+}
+function getOpenWorkspaceUri(explicitUri) {
+	return (vscode.workspace.workspaceFolders?.find((folder) => require_uri_utils.areSamePath({
+		left: folder.uri.fsPath,
+		right: explicitUri.fsPath
+	})))?.uri;
+}
+function getFromValue(args) {
+	return args?.from?.trim() || args?.base?.trim() || "closest_bookmark(@)";
+}
+function getToValue(args) {
+	return args?.to?.trim() || args?.target?.trim() || "@";
+}
+function shouldPromptForInputs(args) {
+	return args?.source !== "cli" || args?.confirm === true;
+}
+async function resolveInput(args) {
+	return (await vscode.window.showInputBox({
+		prompt: args.prompt,
+		placeHolder: args.placeHolder,
+		value: args.value?.trim() || args.placeHolder,
+		ignoreFocusOut: true,
+		validateInput(value) {
+			return value.trim() ? void 0 : "Value is required";
+		}
+	}))?.trim() || void 0;
+}
+//#endregion
+exports.activate = activate;
+exports.deactivate = deactivate;
+
+//# sourceMappingURL=index.cjs.map