Enhance Matrix Shortcut with Multi-selection

src/features/matrix_shortcuts.ts

@@ -1,59 +1,174 @@
 import { EditorView } from "@codemirror/view";
-import { setCursor } from "src/utils/editor_utils";
-import { getLatexSuiteConfig } from "src/snippets/codemirror/config";
+import { EditorSelection, SelectionRange } from "@codemirror/state";
 import { Context } from "src/utils/context";
+import { setCursor, replaceRange } from "src/utils/editor_utils";
+import { getLatexSuiteConfig } from "src/snippets/codemirror/config";
 import { tabout } from "src/features/tabout";
 
+
+const ALIGNMENT = " & ";
+const LINE_BREAK = " \\\\\n"
+const LINE_BREAK_INLINE = " \\\\ "
+const END_LINE_BREAK = LINE_BREAK.trimEnd();
+let trimWhitespace = false;
+let trimAlignment = false;
+let hlineLineBreakEnabled = false;
+let trimEmptyLineAfterEnv = false;
+let addLineBreakAfterEnv = false;
+
+
+const isLineBreak = (separator: string) => {
+	return separator.contains("\\\\");
+}
+
+
+const isMultiLineBreak = (separator: string): boolean => {
+	return separator.contains("\\\\") && separator.contains("\n");
+}
+
+
+const isHline = (line: string): boolean => {
+	return line.trimEnd().endsWith("\\hline");
+}
+
+
+const generateSeparatorChange = (separator: string, view: EditorView, range: SelectionRange): { from: number, to: number, insert: string } => {
+	const d = view.state.doc;
+
+	const fromLine = d.lineAt(range.from);
+	const textBeforeFrom = d.sliceString(fromLine.from, range.from).trimStart();  // Preserve indents
+
+	const toLine = d.lineAt(range.from);
+	const textAfterTo = d.sliceString(range.to, toLine.to);
+
+	let from = range.from;
+	let to = range.to;
+
+	if (!hlineLineBreakEnabled && isMultiLineBreak(separator) && isHline(textBeforeFrom)) {
+		separator = "\n";
+	}
+
+	if (trimWhitespace) {
+		// If at the beginning of the line
+		if (textBeforeFrom === "") {
+			separator = separator.match(/^[ \t]*([\s\S]*)$/)[1];
+		}
+
+		// Extend selection to include trailing whitespace before `from`
+		if (trimAlignment && isLineBreak(separator)) {
+			from -= textBeforeFrom.match(/\s*\&?\s*$/)[0].length;
+		}
+		else {
+			from -= textBeforeFrom.match(/\s*$/)[0].length;
+		}
+		to += textAfterTo.match(/^\s*/)[0].length;  // Extend selection to include leading whitespace after `to`
+	}
+
+	// Insert indents
+	const leadingIndents = fromLine.text.match(/^\s*/)[0];
+	separator = separator.replaceAll("\n", `\n${leadingIndents}`);
+
+	return { from: from, to: to, insert: separator };
+}
+
+
+const applySeparator = (separator: string, view: EditorView) => {
+	const sel = view.state.selection;
+	const changes = sel.ranges.map(range => generateSeparatorChange(separator, view, range));
+
+	const tempTransaction = view.state.update({ changes });
+
+	const newSelection = EditorSelection.create(
+		changes.map(({ from, to, insert }) =>
+			EditorSelection.cursor(tempTransaction.changes.mapPos(from) + insert.length)
+		),
+		sel.mainIndex
+	);
+
+	view.dispatch(view.state.update({ changes, selection: newSelection }));
+}
+
+
 export const runMatrixShortcuts = (view: EditorView, ctx: Context, key: string, shiftKey: boolean): boolean => {
 	const settings = getLatexSuiteConfig(view);
 
 	// Check whether we are inside a matrix / align / case environment
 	let isInsideAnEnv = false;
-
+	let env;
 	for (const envName of settings.matrixShortcutsEnvNames) {
-		const env = { openSymbol: "\\begin{" + envName + "}", closeSymbol: "\\end{" + envName + "}" };
+		env = { openSymbol: "\\begin{" + envName + "}", closeSymbol: "\\end{" + envName + "}" };
 
 		isInsideAnEnv = ctx.isWithinEnvironment(ctx.pos, env);
 		if (isInsideAnEnv) break;
 	}
 
 	if (!isInsideAnEnv) return false;
 
-	// Take main cursor since ctx.mode takes the main cursor, weird behaviour is expected with multicursor because of this.
+	trimWhitespace = settings.matrixShortcutsTrimWhitespace;
+	trimAlignment = settings.matrixShortcutsTrimAlignment;
+	hlineLineBreakEnabled = settings.matrixShortcutsHlineLineBreakEnabled;
+
 	if (key === "Tab" && view.state.selection.main.empty) {
-		view.dispatch(view.state.replaceSelection(" & "));
+		applySeparator(ALIGNMENT, view);
 
 		return true;
 	}
+
 	else if (key === "Enter") {
-		if (shiftKey && ctx.mode.blockMath) {
-			// Move cursor to end of next line
-			const d = view.state.doc;
+		if (shiftKey) {
+			if (ctx.mode.inlineMath) {
+				tabout(view, ctx);
+			}
+			else {
+				// Move cursor to end of next line
+				let d = view.state.doc;
+				const envBound = ctx.getEnvironmentBound(ctx.pos, env);
+				const envText = d.sliceString(envBound.start, envBound.end);
 
-			const nextLineNo = d.lineAt(ctx.pos).number + 1;
-			const nextLine = d.line(nextLineNo);
+				trimEmptyLineAfterEnv = settings.matrixShortcutsTrimEmptyLineAfterEnv;
+				addLineBreakAfterEnv = settings.matrixShortcutsAddLineBreakAfterEnv;
 
-			setCursor(view, nextLine.to);
-		}
-		else if (shiftKey && ctx.mode.inlineMath) {
-			tabout(view, ctx);
-		}
-		else if (ctx.mode.blockMath) {
-			const d = view.state.doc;
-			const lineText = d.lineAt(ctx.pos).text;
-			const matchIndents = lineText.match(/^\s*/);
-			const leadingIndents = matchIndents ? matchIndents[0] : "";
+				let line = d.lineAt(ctx.pos);
+				let lineNo = line.number;
+				let nextLine = d.line(lineNo + 1);
+				let newPos = nextLine.to;
 
-			view.dispatch(view.state.replaceSelection(` \\\\\n${leadingIndents}`));
+				if (newPos > envBound.end) {
+					if (trimEmptyLineAfterEnv && line.text.trim() === "") {
+						replaceRange(view, line.from, nextLine.from, "");
+
+						d = view.state.doc;
+						lineNo--;
+						line = d.line(lineNo);
+						nextLine = d.line(lineNo + 1);
+						newPos = nextLine.to;
+					}
+
+					if (addLineBreakAfterEnv && !envText.trimEnd().endsWith("\\\\")) {
+						setCursor(view, line.to);
+
+						applySeparator(END_LINE_BREAK, view);
+
+						d = view.state.doc;
+						nextLine = d.line(lineNo + 1);
+						newPos = nextLine.to;
+					}
+				}
+
+				setCursor(view, newPos);
+			}
 		}
 		else {
-			view.dispatch(view.state.replaceSelection(" \\\\ "));
+			if (ctx.mode.inlineMath) {
+				applySeparator(LINE_BREAK_INLINE, view);
+			}
+			else {
+				applySeparator(LINE_BREAK, view);
+			}
 		}
 
 		return true;
 	}
-	else {
-		return false;
-	}
 
+	return false;
 }

src/settings/settings.ts

@@ -23,6 +23,11 @@ interface LatexSuiteBasicSettings {
 	autofractionSymbol: string;
 	autofractionBreakingChars: string;
 	matrixShortcutsEnabled: boolean;
+	matrixShortcutsTrimWhitespace: boolean;
+	matrixShortcutsTrimAlignment: boolean;
+	matrixShortcutsHlineLineBreakEnabled: boolean;
+	matrixShortcutsTrimEmptyLineAfterEnv: boolean;
+	matrixShortcutsAddLineBreakAfterEnv: boolean;
 	taboutEnabled: boolean;
 	autoEnlargeBrackets: boolean;
 	wordDelimiters: string;
@@ -72,6 +77,11 @@ export const DEFAULT_SETTINGS: LatexSuitePluginSettings = {
 	autofractionSymbol: "\\frac",
 	autofractionBreakingChars: "+-=\t",
 	matrixShortcutsEnabled: true,
+	matrixShortcutsTrimWhitespace: true,
+	matrixShortcutsTrimAlignment: true,
+	matrixShortcutsHlineLineBreakEnabled: false,
+	matrixShortcutsTrimEmptyLineAfterEnv: true,
+	matrixShortcutsAddLineBreakAfterEnv: false,
 	taboutEnabled: true,
 	autoEnlargeBrackets: true,
 	wordDelimiters: "., +-\\n\t:;!?\\/{}[]()=~$",

src/settings/settings_tab.ts

@@ -312,6 +312,7 @@ export class LatexSuiteSettingTab extends PluginSettingTab {
 				.setValue(this.plugin.settings.matrixShortcutsEnabled)
 				.onChange(async (value) => {
 					this.plugin.settings.matrixShortcutsEnabled = value;
+
 					await this.plugin.saveSettings();
 				}));
 
@@ -327,6 +328,66 @@ export class LatexSuiteSettingTab extends PluginSettingTab {
 					await this.plugin.saveSettings();
 				}));
 
+		new Setting(containerEl)
+			.setName("Trim Excess Whitespace")
+			.setDesc("When enabled, Tab and Enter will trim surrounding whitespace to prevent excessive spaces.")
+			.addToggle(toggle => toggle
+				.setValue(this.plugin.settings.matrixShortcutsTrimWhitespace)
+				.onChange(async (value) => {
+					this.plugin.settings.matrixShortcutsTrimWhitespace = value;
+
+					trimAlignmentSetting.settingEl.toggleClass("hidden", !value);
+
+					await this.plugin.saveSettings();
+				}));
+
+		const trimAlignmentSetting = new Setting(containerEl)
+			.setName("Trim Excess Alignment")
+			.setDesc("When enabled, Enter will trim the extra '&' to prevent excessive spacing.")
+			.addToggle(toggle => toggle
+				.setValue(this.plugin.settings.matrixShortcutsTrimAlignment)
+				.onChange(async (value) => {
+					this.plugin.settings.matrixShortcutsTrimAlignment = value;
+
+					await this.plugin.saveSettings();
+				}));
+
+		// Hide settings that are not relevant when "matrixShortcutsTrimWhitespace" is set to true/false
+		const matrixShortcutsTrimWhitespace = this.plugin.settings.matrixShortcutsTrimWhitespace;
+		trimAlignmentSetting.settingEl.toggleClass("hidden", !matrixShortcutsTrimWhitespace);
+
+		new Setting(containerEl)
+			.setName("Enable '\\\\' After '\\hline'")
+			.setDesc("When enabled, '\\\\' will be inserted after '\\hline'.")
+			.addToggle(toggle => toggle
+				.setValue(this.plugin.settings.matrixShortcutsHlineLineBreakEnabled)
+				.onChange(async (value) => {
+					this.plugin.settings.matrixShortcutsHlineLineBreakEnabled = value;
+
+					await this.plugin.saveSettings();
+				}));
+
+		new Setting(containerEl)
+			.setName("Trim Empty Line After Environment")
+			.setDesc("When enabled, Shift + Enter will remove an empty line when exiting an environment to prevent excessive spaces.")
+			.addToggle(toggle => toggle
+				.setValue(this.plugin.settings.matrixShortcutsTrimEmptyLineAfterEnv)
+				.onChange(async (value) => {
+					this.plugin.settings.matrixShortcutsTrimEmptyLineAfterEnv = value;
+
+					await this.plugin.saveSettings();
+				}));
+
+		new Setting(containerEl)
+			.setName("Add Line Break After Environment")
+			.setDesc("When enabled, Shift + Enter will add a line break when exiting an environment to ensure proper formatting.")
+			.addToggle(toggle => toggle
+				.setValue(this.plugin.settings.matrixShortcutsAddLineBreakAfterEnv)
+				.onChange(async (value) => {
+					this.plugin.settings.matrixShortcutsAddLineBreakAfterEnv = value;
+
+					await this.plugin.saveSettings();
+				}));
 	}
 
 	private displayTaboutSettings() {

src/utils/context.ts

@@ -60,13 +60,13 @@ export class Context {
 		return Context.fromState(view.state);
 	}
 
-	isWithinEnvironment(pos: number, env: Environment): boolean {
-		if (!this.mode.inMath()) return false;
+	getEnvironmentBound(pos: number, env: Environment): Bounds {
+		if (!this.mode.inMath()) return null;
 
 		const bounds = this.getInnerBounds();
 		if (!bounds) return;
 
-		const {start, end} = bounds;
+		const { start, end } = bounds;
 		const text = this.state.sliceDoc(start, end);
 		// pos referred to the absolute position in the whole document, but we just sliced the text
 		// so now pos must be relative to the start in order to be any useful
@@ -93,20 +93,24 @@ export class Context {
 		while (left != -1) {
 			const right = findMatchingBracket(text, left + offset, openSearchSymbol, env.closeSymbol, false);
 
-			if (right === -1) return false;
+			if (right === -1) return null;
 
 			// Check whether the cursor lies inside the environment symbols
 			if ((right >= pos) && (pos >= left + env.openSymbol.length)) {
-				return true;
+				return { start: start + left + env.openSymbol.length, end: start + right };
 			}
 
-			if (left <= 0) return false;
+			if (left <= 0) return null;
 
 			// Find the next open symbol
 			left = text.lastIndexOf(env.openSymbol, left - 1);
 		}
 
-		return false;
+		return null;
+	}
+
+	isWithinEnvironment(pos: number, env: Environment): boolean {
+		return this.getEnvironmentBound(pos, env) !== null;
 	}
 
 	inTextEnvironment(): boolean {