feat: add Ace compatibility shims for plugins

Add editor.getSelectionRange(), editor.scrollToRow(), and ace.require('ace/ext/modelist') compatibility mapping.

Author: bajrangCoder

src/lib/editorManager.js

@@ -921,6 +921,62 @@ async function EditorManager($header, $body) {
 		}
 	};
 
+	/**
+	 * Ace-compatible selection range getter with 0-based rows.
+	 * @returns {{start: {row: number, column: number}, end: {row: number, column: number}}}
+	 */
+	editor.getSelectionRange = function () {
+		try {
+			const { from, to } = editor.state.selection.main;
+			const fromLine = editor.state.doc.lineAt(from);
+			const toLine = editor.state.doc.lineAt(to);
+			return {
+				start: {
+					row: Math.max(0, fromLine.number - 1),
+					column: from - fromLine.from,
+				},
+				end: {
+					row: Math.max(0, toLine.number - 1),
+					column: to - toLine.from,
+				},
+			};
+		} catch (_) {
+			return { start: { row: 0, column: 0 }, end: { row: 0, column: 0 } };
+		}
+	};
+
+	/**
+	 * Ace-compatible row scrolling helper.
+	 * @param {number} row - 0-based row index, supports Infinity to jump to end.
+	 * @returns {boolean}
+	 */
+	editor.scrollToRow = function (row) {
+		try {
+			const scroller = editor.scrollDOM;
+			if (!scroller) return false;
+
+			if (row === Number.POSITIVE_INFINITY) {
+				scroller.scrollTop = Math.max(
+					scroller.scrollHeight - scroller.clientHeight,
+					0,
+				);
+				return true;
+			}
+
+			const parsedRow = Number(row);
+			if (!Number.isFinite(parsedRow)) return false;
+			const aceRow = Math.max(0, Math.floor(parsedRow));
+			const lineNum = Math.min(editor.state.doc.lines, aceRow + 1);
+			const line = editor.state.doc.line(lineNum);
+			editor.dispatch({
+				effects: EditorView.scrollIntoView(line.from, { y: "start" }),
+			});
+			return true;
+		} catch (_) {
+			return false;
+		}
+	};
+
 	/**
 	 * Move cursor to specific position
 	 * @param {{row: number, column: number}} pos - Position to move to

src/main.js

@@ -15,7 +15,12 @@ import fsOperation from "fileSystem";
 import sidebarApps from "sidebarApps";
 import ajax from "@deadlyjack/ajax";
 import { setKeyBindings } from "cm/commandRegistry";
-import { initModes } from "cm/modelist";
+import {
+	getModeForPath,
+	getModes,
+	getModesByName,
+	initModes,
+} from "cm/modelist";
 import Contextmenu from "components/contextmenu";
 import { hasConnectedServers } from "components/lspInfoDialog";
 import Sidebar from "components/sidebar";
@@ -64,6 +69,59 @@ const previousVersionCode = Number.parseInt(localStorage.versionCode, 10);
 window.onload = Main;
 const logger = new Logger();
 
+function createAceModelistCompatModule() {
+	const toAceMode = (mode) => {
+		const resolved = mode || getModeForPath("");
+		if (!resolved) return null;
+		const name = resolved.name || "text";
+		const rawMode = String(resolved.mode || name);
+		const modePath = rawMode.startsWith("ace/mode/")
+			? rawMode
+			: `ace/mode/${rawMode}`;
+		return {
+			...resolved,
+			name,
+			caption: resolved.caption || name,
+			mode: modePath,
+		};
+	};
+
+	return {
+		get modes() {
+			return getModes()
+				.map((mode) => toAceMode(mode))
+				.filter(Boolean);
+		},
+		get modesByName() {
+			const source = getModesByName();
+			const result = {};
+			Object.keys(source).forEach((name) => {
+				result[name] = toAceMode(source[name]);
+			});
+			return result;
+		},
+		getModeForPath(path) {
+			return toAceMode(getModeForPath(String(path || "")));
+		},
+	};
+}
+
+function ensureAceCompatApi() {
+	const ace = window.ace || {};
+	const modelistModule = createAceModelistCompatModule();
+	const originalRequire =
+		typeof ace.require === "function" ? ace.require.bind(ace) : null;
+
+	ace.require = (moduleId) => {
+		if (moduleId === "ace/ext/modelist" || moduleId === "ace/ext/modelist.js") {
+			return modelistModule;
+		}
+		return originalRequire?.(moduleId);
+	};
+
+	window.ace = ace;
+}
+
 async function Main() {
 	const oldPreventDefault = TouchEvent.prototype.preventDefault;
 
@@ -179,6 +237,7 @@ async function onDeviceReady() {
 		return true;
 	})();
 	window.acode = new Acode();
+	ensureAceCompatApi();
 
 	system.requestPermission("android.permission.READ_EXTERNAL_STORAGE");
 	system.requestPermission("android.permission.WRITE_EXTERNAL_STORAGE");

src/test/ace.test.js

@@ -99,6 +99,27 @@ export async function runAceCompatibilityTests(writeOutput) {
 		test.assert(range.end != null, "range should have end");
 	});
 
+	runner.test("editor.getSelectionRange()", (test) => {
+		const editor = getEditor();
+		test.assert(
+			typeof editor.getSelectionRange === "function",
+			"getSelectionRange should be a function",
+		);
+		const range = editor.getSelectionRange();
+		test.assert(range.start != null, "range should have start");
+		test.assert(range.end != null, "range should have end");
+	});
+
+	runner.test("editor.scrollToRow()", (test) => {
+		const editor = getEditor();
+		test.assert(
+			typeof editor.scrollToRow === "function",
+			"scrollToRow should be a function",
+		);
+		const ok = editor.scrollToRow(0);
+		test.assert(ok === true || ok === undefined, "scrollToRow should not fail");
+	});
+
 	runner.test("editor.selection.getCursor()", (test) => {
 		const editor = getEditor();
 		test.assert(
@@ -199,6 +220,20 @@ export async function runAceCompatibilityTests(writeOutput) {
 		test.assert(editor.contentDOM != null, "contentDOM should exist");
 	});
 
+	runner.test("ace.require('ace/ext/modelist')", (test) => {
+		test.assert(window.ace != null, "window.ace should exist");
+		test.assert(
+			typeof window.ace.require === "function",
+			"ace.require should be a function",
+		);
+		const modelist = window.ace.require("ace/ext/modelist");
+		test.assert(modelist != null, "modelist should be available");
+		test.assert(
+			typeof modelist.getModeForPath === "function",
+			"modelist.getModeForPath should be a function",
+		);
+	});
+
 	// Session API tests
 
 	runner.test("session.getValue()", async (test) => {