@singapore-editor/lsp-plugin 0.1.1

package/dist/documentSyncController.d.ts

@@ -0,0 +1,26 @@
+import type { LanguageServerDocumentSnapshot } from './types';
+import type { DocumentSyncPoint, TextSnapshot } from '@singapore-editor/core/document';
+import type { EditorDisposable } from '@singapore-editor/core/extensions';
+import type { LspWorkspace } from '@singapore-editor/lsp';
+import type * as lsp from 'vscode-languageserver-protocol';
+import type { DocumentSync } from './documentSync';
+export type LanguageServerDocumentUriTransition = {
+    readonly fromUri: lsp.DocumentUri;
+    readonly toUri: lsp.DocumentUri;
+    readonly textSnapshot: TextSnapshot;
+    readonly syncPoint: DocumentSyncPoint;
+};
+export type LanguageServerDocumentSyncControllerRegistration = {
+    readonly getSnapshot: () => LanguageServerDocumentSnapshot;
+    readonly sync: DocumentSync;
+    readonly workspace: LspWorkspace;
+};
+/**
+ * Projects a live document identity change through every mounted language-server lane immediately.
+ */
+export declare class LanguageServerDocumentSyncController {
+    private readonly registrations;
+    register(registration: LanguageServerDocumentSyncControllerRegistration): EditorDisposable;
+    transitionDocumentUri(transition: LanguageServerDocumentUriTransition): void;
+}
+//# sourceMappingURL=documentSyncController.d.ts.map

package/dist/documentSyncController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"documentSyncController.d.ts","sourceRoot":"","sources":["../src/documentSyncController.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,SAAS,CAAA;AAC7D,OAAO,KAAK,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAA;AACtF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAA;AACzE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AACzD,OAAO,KAAK,KAAK,GAAG,MAAM,gCAAgC,CAAA;AAE1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAElD,MAAM,MAAM,mCAAmC,GAAG;IAChD,QAAQ,CAAC,OAAO,EAAE,GAAG,CAAC,WAAW,CAAA;IACjC,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC,WAAW,CAAA;IAC/B,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAA;IACnC,QAAQ,CAAC,SAAS,EAAE,iBAAiB,CAAA;CACtC,CAAA;AAED,MAAM,MAAM,gDAAgD,GAAG;IAC7D,QAAQ,CAAC,WAAW,EAAE,MAAM,8BAA8B,CAAA;IAC1D,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAA;IAC3B,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAA;CACjC,CAAA;AAED;;GAEG;AACH,qBAAa,oCAAoC;IAC/C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA8D;IAErF,QAAQ,CACb,YAAY,EAAE,gDAAgD,GAC7D,gBAAgB;IAOZ,qBAAqB,CAAC,UAAU,EAAE,mCAAmC,GAAG,IAAI;CAcpF"}

package/dist/documentSyncController.js

@@ -0,0 +1,24 @@
+//#region src/documentSyncController.ts
+/**
+* Projects a live document identity change through every mounted language-server lane immediately.
+*/
+var LanguageServerDocumentSyncController = class {
+	registrations = /* @__PURE__ */ new Set();
+	register(registration) {
+		this.registrations.add(registration);
+		return { dispose: () => this.registrations.delete(registration) };
+	}
+	transitionDocumentUri(transition) {
+		const transitionedWorkspaces = /* @__PURE__ */ new Set();
+		for (const registration of this.registrations) {
+			if (transitionedWorkspaces.has(registration.workspace)) continue;
+			if (!registration.sync.transitionDocumentUri(registration.getSnapshot(), transition)) continue;
+			if (registration.sync.activeDocument?.uri !== transition.toUri) continue;
+			transitionedWorkspaces.add(registration.workspace);
+		}
+	}
+};
+//#endregion
+export { LanguageServerDocumentSyncController };
+
+//# sourceMappingURL=documentSyncController.js.map

package/dist/documentSyncController.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"documentSyncController.js","names":[],"sources":["../src/documentSyncController.ts"],"sourcesContent":["import type { LanguageServerDocumentSnapshot } from './types'\nimport type { DocumentSyncPoint, TextSnapshot } from '@singapore-editor/core/document'\nimport type { EditorDisposable } from '@singapore-editor/core/extensions'\nimport type { LspWorkspace } from '@singapore-editor/lsp'\nimport type * as lsp from 'vscode-languageserver-protocol'\n\nimport type { DocumentSync } from './documentSync'\n\nexport type LanguageServerDocumentUriTransition = {\n  readonly fromUri: lsp.DocumentUri\n  readonly toUri: lsp.DocumentUri\n  readonly textSnapshot: TextSnapshot\n  readonly syncPoint: DocumentSyncPoint\n}\n\nexport type LanguageServerDocumentSyncControllerRegistration = {\n  readonly getSnapshot: () => LanguageServerDocumentSnapshot\n  readonly sync: DocumentSync\n  readonly workspace: LspWorkspace\n}\n\n/**\n * Projects a live document identity change through every mounted language-server lane immediately.\n */\nexport class LanguageServerDocumentSyncController {\n  private readonly registrations = new Set<LanguageServerDocumentSyncControllerRegistration>()\n\n  public register(\n    registration: LanguageServerDocumentSyncControllerRegistration,\n  ): EditorDisposable {\n    this.registrations.add(registration)\n    return {\n      dispose: () => this.registrations.delete(registration),\n    }\n  }\n\n  public transitionDocumentUri(transition: LanguageServerDocumentUriTransition): void {\n    const transitionedWorkspaces = new Set<LspWorkspace>()\n    for (const registration of this.registrations) {\n      if (transitionedWorkspaces.has(registration.workspace)) continue\n\n      const handled = registration.sync.transitionDocumentUri(\n        registration.getSnapshot(),\n        transition,\n      )\n      if (!handled) continue\n      if (registration.sync.activeDocument?.uri !== transition.toUri) continue\n      transitionedWorkspaces.add(registration.workspace)\n    }\n  }\n}\n"],"mappings":";;;;AAwBA,IAAa,uCAAb,MAAkD;CAChD,gCAAiC,IAAI,IAAsD;CAE3F,SACE,cACkB;EAClB,KAAK,cAAc,IAAI,YAAY;EACnC,OAAO,EACL,eAAe,KAAK,cAAc,OAAO,YAAY,EACvD;CACF;CAEA,sBAA6B,YAAuD;EAClF,MAAM,yCAAyB,IAAI,IAAkB;EACrD,KAAK,MAAM,gBAAgB,KAAK,eAAe;GAC7C,IAAI,uBAAuB,IAAI,aAAa,SAAS,GAAG;GAMxD,IAAI,CAJY,aAAa,KAAK,sBAChC,aAAa,YAAY,GACzB,UAEG,GAAS;GACd,IAAI,aAAa,KAAK,gBAAgB,QAAQ,WAAW,OAAO;GAChE,uBAAuB,IAAI,aAAa,SAAS;EACnD;CACF;AACF"}

package/dist/formatOnType.d.ts

@@ -0,0 +1,43 @@
+import { type EditorContributionChange, type EditorCapabilityToken, type EditorViewContributionContext, type EditorViewContributionUpdateKind, type EditorViewSnapshot } from '@singapore-editor/core/extensions';
+import type { LanguageServerCompletionEditFeature } from './completion';
+/**
+ * Putting the row the caret is on back at the level its own text asks for, on the keystroke that
+ * changed which level that is.
+ *
+ * A closing delimiter is typed at the depth of the block it ends, one level in from where it
+ * belongs, and nothing afterwards moves it — every closed block is left a level too deep until
+ * somebody reindents the region by hand. The question "where does this row belong" is the one the
+ * reindent commands ask of the language's indentation rules, so it is asked of them here too
+ * rather than answered again beside them.
+ *
+ * Two narrow gates keep it from being a formatter that runs on every keystroke: which characters
+ * are watched at all, and whether the answer is still about the document by the time it is written.
+ * The second is a gate rather than a certainty because the edit is handed over a turn after it is
+ * computed — a row cannot be rewritten from inside the announcement of the keystroke that produced
+ * it.
+ */
+export type FormatOnTypeControllerOptions = {
+    readonly context: EditorViewContributionContext;
+    readonly editFeature: EditorCapabilityToken<LanguageServerCompletionEditFeature>;
+};
+export declare class FormatOnTypeController {
+    private readonly options;
+    private pending;
+    private scheduled;
+    private disposed;
+    constructor(options: FormatOnTypeControllerOptions);
+    update(snapshot: EditorViewSnapshot, kind: EditorViewContributionUpdateKind, change: EditorContributionChange | null): void;
+    dispose(): void;
+    /**
+     * Moves an edit onto the document an announced change has just produced, or drops it.
+     *
+     * Its range is a pair of offsets into one document. An edit arriving at or before the caret moves
+     * them, and replacing what now sits there would take a bite out of text the reader wrote in the
+     * meantime. An edit past the caret cannot reach the row's leading whitespace, so the answer still
+     * holds — and re-stamping is how it goes on holding for a document that has legitimately moved on.
+     */
+    private carryPendingForward;
+    private schedule;
+    private applyPending;
+}
+//# sourceMappingURL=formatOnType.d.ts.map

package/dist/formatOnType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatOnType.d.ts","sourceRoot":"","sources":["../src/formatOnType.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,wBAAwB,EAG7B,KAAK,qBAAqB,EAE1B,KAAK,6BAA6B,EAClC,KAAK,gCAAgC,EACrC,KAAK,kBAAkB,EACxB,MAAM,mCAAmC,CAAA;AAE1C,OAAO,KAAK,EAAE,mCAAmC,EAAE,MAAM,cAAc,CAAA;AAEvE;;;;;;;;;;;;;;;GAeG;AAEH,MAAM,MAAM,6BAA6B,GAAG;IAC1C,QAAQ,CAAC,OAAO,EAAE,6BAA6B,CAAA;IAC/C,QAAQ,CAAC,WAAW,EAAE,qBAAqB,CAAC,mCAAmC,CAAC,CAAA;CACjF,CAAA;AA4BD,qBAAa,sBAAsB;IAKd,OAAO,CAAC,QAAQ,CAAC,OAAO;IAJ3C,OAAO,CAAC,OAAO,CAAmC;IAClD,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,QAAQ,CAAQ;gBAEY,OAAO,EAAE,6BAA6B;IAEnE,MAAM,CACX,QAAQ,EAAE,kBAAkB,EAC5B,IAAI,EAAE,gCAAgC,EACtC,MAAM,EAAE,wBAAwB,GAAG,IAAI,GACtC,IAAI;IAkBA,OAAO,IAAI,IAAI;IAKtB;;;;;;;OAOG;IACH,OAAO,CAAC,mBAAmB;IAc3B,OAAO,CAAC,QAAQ;IAehB,OAAO,CAAC,YAAY;CAmBrB"}

package/dist/formatOnType.js

@@ -0,0 +1,198 @@
+import { editorLanguageConfiguration, reindentEditsForRanges } from "@singapore-editor/core/extensions";
+//#region src/formatOnType.ts
+var FORMAT_ON_TYPE_WINDOW = 4096;
+var FormatOnTypeController = class {
+	options;
+	pending = null;
+	scheduled = false;
+	disposed = false;
+	constructor(options) {
+		this.options = options;
+	}
+	update(snapshot, kind, change) {
+		if (kind === "document" || kind === "clear") {
+			this.pending = null;
+			return;
+		}
+		if (kind !== "content") return;
+		this.carryPendingForward(snapshot, change);
+		const caretOffset = formatOnTypeCaret(snapshot, change);
+		if (caretOffset === null) return;
+		const pending = pendingFormatOnType(snapshot, caretOffset);
+		if (!pending) return;
+		this.pending = pending;
+		this.schedule();
+	}
+	dispose() {
+		this.disposed = true;
+		this.pending = null;
+	}
+	/**
+	* Moves an edit onto the document an announced change has just produced, or drops it.
+	*
+	* Its range is a pair of offsets into one document. An edit arriving at or before the caret moves
+	* them, and replacing what now sits there would take a bite out of text the reader wrote in the
+	* meantime. An edit past the caret cannot reach the row's leading whitespace, so the answer still
+	* holds — and re-stamping is how it goes on holding for a document that has legitimately moved on.
+	*/
+	carryPendingForward(snapshot, change) {
+		const pending = this.pending;
+		if (!pending || !change) return;
+		if (change.edits.some((edit) => edit.from <= pending.caretOffset)) {
+			this.pending = null;
+			return;
+		}
+		this.pending = {
+			...pending,
+			textVersion: snapshot.textVersion
+		};
+	}
+	schedule() {
+		if (this.scheduled) return;
+		this.scheduled = true;
+		/**
+		* @justification Coalesces the re-indents a single keystroke can queue into one pass at the end
+		* of the turn, so the edit lands before the frame the character was typed in is painted;
+		* `scheduled` is what makes a second call in that turn a no-op rather than a second pass.
+		*/
+		queueMicrotask(() => {
+			this.scheduled = false;
+			this.applyPending();
+		});
+	}
+	applyPending() {
+		const pending = this.pending;
+		this.pending = null;
+		if (!pending || this.disposed) return;
+		if (this.options.context.getSnapshot().textVersion !== pending.textVersion) return;
+		const feature = this.options.context.getFeature(this.options.editFeature);
+		if (!feature) return;
+		const head = pending.caretOffset + pending.edit.text.length - (pending.edit.to - pending.edit.from);
+		feature.applyCompletion({
+			edits: [pending.edit],
+			selection: {
+				anchor: head,
+				head
+			}
+		});
+	}
+};
+/**
+* Where the caret sits after a keystroke that can have changed its row's level, or null for one
+* that cannot have.
+*
+* Several carets, or a caret with a selection behind it, describe an edit whose shape this cannot
+* read, so they ask for nothing.
+*/
+function formatOnTypeCaret(snapshot, change) {
+	if (!change || change.kind !== "edit") return null;
+	if (change.edits.length !== 1) return null;
+	const edit = change.edits[0];
+	if (!edit || edit.text.length !== 1) return null;
+	const configuration = ruledConfiguration(snapshot.languageId);
+	if (!configuration) return null;
+	if (!triggerCharacters(configuration).has(edit.text)) return null;
+	if (snapshot.selections.length !== 1) return null;
+	const selection = snapshot.selections[0];
+	if (!selection || selection.startOffset !== selection.endOffset) return null;
+	const caretOffset = selection.headOffset;
+	return caretOffset === edit.from + edit.text.length ? caretOffset : null;
+}
+/** The rules for a language whose rows have levels at all; without them there is nothing to say. */
+function ruledConfiguration(languageId) {
+	const configuration = editorLanguageConfiguration(languageId);
+	return configuration?.indentationRules ? configuration : null;
+}
+var triggerCharactersByConfiguration = /* @__PURE__ */ new WeakMap();
+/**
+* The characters whose arrival can put a row at a different level than the one it was typed on.
+*
+* A row drops a level by holding the delimiter that closes a block, so the closers the language
+* describes are the whole set — which is also what keeps prose, which describes none, out of this
+* without a list of exemptions. The last character is what finishes a closer, so blocks that end in
+* a word are watched by the keystroke completing the word rather than the one starting it.
+*
+* Every other keystroke stops here, on one lookup, rather than going on to read the row. The set is
+* kept against the record it was read from and not against the language's name, so a host replacing
+* a language's rules gets a set built from the rules it replaced them with; there is no moment at
+* which a stale set can answer.
+*/
+function triggerCharacters(configuration) {
+	const cached = triggerCharactersByConfiguration.get(configuration);
+	if (cached) return cached;
+	const characters = /* @__PURE__ */ new Set();
+	for (const pair of configuration.brackets) {
+		const last = pair.close.at(-1);
+		if (last !== void 0) characters.add(last);
+	}
+	triggerCharactersByConfiguration.set(configuration, characters);
+	return characters;
+}
+/**
+* Whether the closer ending at the caret is the whole of what its row holds.
+*
+* A closer that follows anything else was written to end an expression the row is carrying, not the
+* block the row sits in; moving the row would take that expression somewhere it was not put. Which
+* closer it is has to be decided here rather than from the single character typed, because a
+* multi-character delimiter is only itself once the whole of it is on the row.
+*/
+function closesItsOwnRow(configuration, window) {
+	const rowStart = window.text.lastIndexOf("\n", window.caretOffset - 1) + 1;
+	const before = window.text.slice(rowStart, window.caretOffset);
+	return configuration.brackets.some((pair) => before.endsWith(pair.close) && isBlank(before.slice(0, before.length - pair.close.length)));
+}
+function isBlank(text) {
+	return !/[^\t ]/u.test(text);
+}
+function pendingFormatOnType(snapshot, caretOffset) {
+	const configuration = ruledConfiguration(snapshot.languageId);
+	if (!configuration) return null;
+	const window = formatOnTypeWindow(snapshot, caretOffset);
+	if (!window || !closesItsOwnRow(configuration, window)) return null;
+	const [edit] = reindentEditsForRanges(window.text, [{
+		end: window.caretOffset,
+		start: window.caretOffset
+	}], {
+		languageId: snapshot.languageId,
+		tabSize: snapshot.tabSize
+	});
+	if (!edit) return null;
+	return {
+		caretOffset,
+		edit: {
+			from: edit.from + window.start,
+			text: edit.text,
+			to: edit.to + window.start
+		},
+		textVersion: snapshot.textVersion
+	};
+}
+/**
+* Whole rows back to the bound, and the caret's own row through to its end.
+*
+* The row is read to its end rather than to the caret because a language's rules are patterns over
+* the whole of it, and a closer with anything behind it on the row is a row that describes something
+* other than the block it sits in. A caret standing further than the bound from a row start has
+* nothing above it this can read, and says so rather than measuring against half a row.
+*/
+function formatOnTypeWindow(snapshot, caretOffset) {
+	const source = snapshot.textSnapshot;
+	const length = source.length;
+	const read = (start, end) => source.readRange(start, end);
+	const from = Math.max(0, caretOffset - FORMAT_ON_TYPE_WINDOW);
+	const before = read(from, caretOffset);
+	const firstBreak = before.indexOf("\n");
+	if (from > 0 && firstBreak === -1) return null;
+	const start = from === 0 ? 0 : from + firstBreak + 1;
+	const after = read(caretOffset, Math.min(length, caretOffset + FORMAT_ON_TYPE_WINDOW));
+	const rowEnd = after.indexOf("\n");
+	return {
+		text: before.slice(start - from) + (rowEnd === -1 ? after : after.slice(0, rowEnd)),
+		start,
+		caretOffset: caretOffset - start
+	};
+}
+//#endregion
+export { FormatOnTypeController };
+
+//# sourceMappingURL=formatOnType.js.map

package/dist/formatOnType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatOnType.js","names":[],"sources":["../src/formatOnType.ts"],"sourcesContent":["import type { TextEdit } from '@singapore-editor/core/document'\nimport {\n  type EditorContributionChange,\n  editorLanguageConfiguration,\n  reindentEditsForRanges,\n  type EditorCapabilityToken,\n  type EditorLanguageConfiguration,\n  type EditorViewContributionContext,\n  type EditorViewContributionUpdateKind,\n  type EditorViewSnapshot,\n} from '@singapore-editor/core/extensions'\n\nimport type { LanguageServerCompletionEditFeature } from './completion'\n\n/**\n * Putting the row the caret is on back at the level its own text asks for, on the keystroke that\n * changed which level that is.\n *\n * A closing delimiter is typed at the depth of the block it ends, one level in from where it\n * belongs, and nothing afterwards moves it — every closed block is left a level too deep until\n * somebody reindents the region by hand. The question \"where does this row belong\" is the one the\n * reindent commands ask of the language's indentation rules, so it is asked of them here too\n * rather than answered again beside them.\n *\n * Two narrow gates keep it from being a formatter that runs on every keystroke: which characters\n * are watched at all, and whether the answer is still about the document by the time it is written.\n * The second is a gate rather than a certainty because the edit is handed over a turn after it is\n * computed — a row cannot be rewritten from inside the announcement of the keystroke that produced\n * it.\n */\n\nexport type FormatOnTypeControllerOptions = {\n  readonly context: EditorViewContributionContext\n  readonly editFeature: EditorCapabilityToken<LanguageServerCompletionEditFeature>\n}\n\n/** An edit, and the document it was measured against. */\ntype PendingFormatOnType = {\n  readonly caretOffset: number\n  readonly edit: TextEdit\n  readonly textVersion: number\n}\n\n/**\n * The text one row's level is decided from, and where it sits in the document.\n *\n * A row belongs one level in from the row above it, unless either of them is inside a string or a\n * comment — and which literals are open is only settled by reading from wherever they were opened.\n * Reading from the top of the document scans the whole file on a keystroke and goes on growing with\n * it; reading back a fixed distance costs the same in a file of any size, and the only text the two\n * answer differently for is a literal left open for longer than that distance.\n */\ntype FormatOnTypeWindow = {\n  readonly text: string\n  /** Where `text` starts, always at a row start so the rows inside it are the document's rows. */\n  readonly start: number\n  /** The caret, in the window's own offsets. */\n  readonly caretOffset: number\n}\n\nconst FORMAT_ON_TYPE_WINDOW = 4096\n\nexport class FormatOnTypeController {\n  private pending: PendingFormatOnType | null = null\n  private scheduled = false\n  private disposed = false\n\n  public constructor(private readonly options: FormatOnTypeControllerOptions) {}\n\n  public update(\n    snapshot: EditorViewSnapshot,\n    kind: EditorViewContributionUpdateKind,\n    change: EditorContributionChange | null,\n  ): void {\n    if (kind === 'document' || kind === 'clear') {\n      this.pending = null\n      return\n    }\n    if (kind !== 'content') return\n\n    this.carryPendingForward(snapshot, change)\n    const caretOffset = formatOnTypeCaret(snapshot, change)\n    if (caretOffset === null) return\n\n    const pending = pendingFormatOnType(snapshot, caretOffset)\n    if (!pending) return\n\n    this.pending = pending\n    this.schedule()\n  }\n\n  public dispose(): void {\n    this.disposed = true\n    this.pending = null\n  }\n\n  /**\n   * Moves an edit onto the document an announced change has just produced, or drops it.\n   *\n   * Its range is a pair of offsets into one document. An edit arriving at or before the caret moves\n   * them, and replacing what now sits there would take a bite out of text the reader wrote in the\n   * meantime. An edit past the caret cannot reach the row's leading whitespace, so the answer still\n   * holds — and re-stamping is how it goes on holding for a document that has legitimately moved on.\n   */\n  private carryPendingForward(\n    snapshot: EditorViewSnapshot,\n    change: EditorContributionChange | null,\n  ): void {\n    const pending = this.pending\n    if (!pending || !change) return\n    if (change.edits.some((edit) => edit.from <= pending.caretOffset)) {\n      this.pending = null\n      return\n    }\n\n    this.pending = { ...pending, textVersion: snapshot.textVersion }\n  }\n\n  private schedule(): void {\n    if (this.scheduled) return\n\n    this.scheduled = true\n    /**\n     * @justification Coalesces the re-indents a single keystroke can queue into one pass at the end\n     * of the turn, so the edit lands before the frame the character was typed in is painted;\n     * `scheduled` is what makes a second call in that turn a no-op rather than a second pass.\n     */\n    queueMicrotask(() => {\n      this.scheduled = false\n      this.applyPending()\n    })\n  }\n\n  private applyPending(): void {\n    const pending = this.pending\n    this.pending = null\n    if (!pending || this.disposed) return\n\n    const snapshot = this.options.context.getSnapshot()\n    // A pass opened from inside another one is not announced a second time, so the guard above\n    // cannot have seen every edit. Reading the range back would only say that some whitespace still\n    // sits at those numbers, which an unannounced edit shifting the buffer leaves true of a row the\n    // reader never touched; the version is the one reading that counts every edit either way.\n    if (snapshot.textVersion !== pending.textVersion) return\n\n    const feature = this.options.context.getFeature(this.options.editFeature)\n    if (!feature) return\n\n    const head =\n      pending.caretOffset + pending.edit.text.length - (pending.edit.to - pending.edit.from)\n    feature.applyCompletion({ edits: [pending.edit], selection: { anchor: head, head } })\n  }\n}\n\n/**\n * Where the caret sits after a keystroke that can have changed its row's level, or null for one\n * that cannot have.\n *\n * Several carets, or a caret with a selection behind it, describe an edit whose shape this cannot\n * read, so they ask for nothing.\n */\nfunction formatOnTypeCaret(\n  snapshot: EditorViewSnapshot,\n  change: EditorContributionChange | null,\n): number | null {\n  if (!change || change.kind !== 'edit') return null\n  if (change.edits.length !== 1) return null\n\n  const edit = change.edits[0]\n  if (!edit || edit.text.length !== 1) return null\n\n  const configuration = ruledConfiguration(snapshot.languageId)\n  if (!configuration) return null\n  if (!triggerCharacters(configuration).has(edit.text)) return null\n\n  if (snapshot.selections.length !== 1) return null\n  const selection = snapshot.selections[0]\n  if (!selection || selection.startOffset !== selection.endOffset) return null\n\n  const caretOffset = selection.headOffset\n\n  return caretOffset === edit.from + edit.text.length ? caretOffset : null\n}\n\n/** The rules for a language whose rows have levels at all; without them there is nothing to say. */\nfunction ruledConfiguration(languageId: string | null): EditorLanguageConfiguration | null {\n  const configuration = editorLanguageConfiguration(languageId)\n\n  return configuration?.indentationRules ? configuration : null\n}\n\nconst triggerCharactersByConfiguration = new WeakMap<\n  EditorLanguageConfiguration,\n  ReadonlySet<string>\n>()\n\n/**\n * The characters whose arrival can put a row at a different level than the one it was typed on.\n *\n * A row drops a level by holding the delimiter that closes a block, so the closers the language\n * describes are the whole set — which is also what keeps prose, which describes none, out of this\n * without a list of exemptions. The last character is what finishes a closer, so blocks that end in\n * a word are watched by the keystroke completing the word rather than the one starting it.\n *\n * Every other keystroke stops here, on one lookup, rather than going on to read the row. The set is\n * kept against the record it was read from and not against the language's name, so a host replacing\n * a language's rules gets a set built from the rules it replaced them with; there is no moment at\n * which a stale set can answer.\n */\nfunction triggerCharacters(configuration: EditorLanguageConfiguration): ReadonlySet<string> {\n  const cached = triggerCharactersByConfiguration.get(configuration)\n  if (cached) return cached\n\n  const characters = new Set<string>()\n  for (const pair of configuration.brackets) {\n    const last = pair.close.at(-1)\n    if (last !== undefined) characters.add(last)\n  }\n\n  triggerCharactersByConfiguration.set(configuration, characters)\n  return characters\n}\n\n/**\n * Whether the closer ending at the caret is the whole of what its row holds.\n *\n * A closer that follows anything else was written to end an expression the row is carrying, not the\n * block the row sits in; moving the row would take that expression somewhere it was not put. Which\n * closer it is has to be decided here rather than from the single character typed, because a\n * multi-character delimiter is only itself once the whole of it is on the row.\n */\nfunction closesItsOwnRow(\n  configuration: EditorLanguageConfiguration,\n  window: FormatOnTypeWindow,\n): boolean {\n  const rowStart = window.text.lastIndexOf('\\n', window.caretOffset - 1) + 1\n  const before = window.text.slice(rowStart, window.caretOffset)\n\n  return configuration.brackets.some(\n    (pair) =>\n      before.endsWith(pair.close) && isBlank(before.slice(0, before.length - pair.close.length)),\n  )\n}\n\nfunction isBlank(text: string): boolean {\n  return !/[^\\t ]/u.test(text)\n}\n\nfunction pendingFormatOnType(\n  snapshot: EditorViewSnapshot,\n  caretOffset: number,\n): PendingFormatOnType | null {\n  const configuration = ruledConfiguration(snapshot.languageId)\n  if (!configuration) return null\n\n  const window = formatOnTypeWindow(snapshot, caretOffset)\n  if (!window || !closesItsOwnRow(configuration, window)) return null\n\n  const [edit] = reindentEditsForRanges(\n    window.text,\n    [{ end: window.caretOffset, start: window.caretOffset }],\n    { languageId: snapshot.languageId, tabSize: snapshot.tabSize },\n  )\n  if (!edit) return null\n\n  return {\n    caretOffset,\n    edit: { from: edit.from + window.start, text: edit.text, to: edit.to + window.start },\n    textVersion: snapshot.textVersion,\n  }\n}\n\n/**\n * Whole rows back to the bound, and the caret's own row through to its end.\n *\n * The row is read to its end rather than to the caret because a language's rules are patterns over\n * the whole of it, and a closer with anything behind it on the row is a row that describes something\n * other than the block it sits in. A caret standing further than the bound from a row start has\n * nothing above it this can read, and says so rather than measuring against half a row.\n */\nfunction formatOnTypeWindow(\n  snapshot: EditorViewSnapshot,\n  caretOffset: number,\n): FormatOnTypeWindow | null {\n  const source = snapshot.textSnapshot\n  const length = source.length\n  const read = (start: number, end: number): string => source.readRange(start, end)\n\n  const from = Math.max(0, caretOffset - FORMAT_ON_TYPE_WINDOW)\n  const before = read(from, caretOffset)\n  const firstBreak = before.indexOf('\\n')\n  if (from > 0 && firstBreak === -1) return null\n\n  const start = from === 0 ? 0 : from + firstBreak + 1\n  const after = read(caretOffset, Math.min(length, caretOffset + FORMAT_ON_TYPE_WINDOW))\n  const rowEnd = after.indexOf('\\n')\n\n  return {\n    text: before.slice(start - from) + (rowEnd === -1 ? after : after.slice(0, rowEnd)),\n    start,\n    caretOffset: caretOffset - start,\n  }\n}\n"],"mappings":"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"}

package/dist/formatting.d.ts

@@ -0,0 +1,18 @@
+import type * as lsp from 'vscode-languageserver-protocol';
+import type { TextEdit } from '@singapore-editor/core';
+import { type LspTextDocumentSnapshot, type LspTextSnapshot } from '@singapore-editor/lsp';
+/**
+ * Converts server formatting edits into buffer edits.
+ *
+ * Returned in descending order and with overlaps dropped, because the batch applicator rejects
+ * overlapping edits outright — a formatter that returns a whole-document edit plus a nested one
+ * would otherwise throw rather than format.
+ *
+ * What survives is re-diffed against the text it replaces, so a reply that rewrites the document to
+ * change one line touches only that line.
+ */
+export declare function prepareFormattingEdits(document: LspTextDocumentSnapshot, edits: readonly lsp.TextEdit[] | null): TextEdit[];
+/** Whether the edits would leave the document unchanged, so a no-op formatter records no change. */
+export declare function formattingChangesText(text: LspTextSnapshot, edits: readonly TextEdit[]): boolean;
+export declare function formattingOptions(tabSize: number): lsp.FormattingOptions;
+//# sourceMappingURL=formatting.d.ts.map

package/dist/formatting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatting.d.ts","sourceRoot":"","sources":["../src/formatting.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,GAAG,MAAM,gCAAgC,CAAA;AAE1D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAA;AACtD,OAAO,EAEL,KAAK,uBAAuB,EAC5B,KAAK,eAAe,EACrB,MAAM,uBAAuB,CAAA;AAI9B;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,uBAAuB,EACjC,KAAK,EAAE,SAAS,GAAG,CAAC,QAAQ,EAAE,GAAG,IAAI,GACpC,QAAQ,EAAE,CA8CZ;AAOD,oGAAoG;AACpG,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,eAAe,EAAE,KAAK,EAAE,SAAS,QAAQ,EAAE,GAAG,OAAO,CAEhG;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,GAAG,CAAC,iBAAiB,CAKxE"}

package/dist/formatting.js

@@ -0,0 +1,52 @@
+import { REDIFF_LENGTH_LIMIT, minimalReplacementEdits } from "./minimalEdits.js";
+import { lspPositionToOffsetInSnapshot } from "@singapore-editor/lsp";
+//#region src/formatting.ts
+/**
+* Converts server formatting edits into buffer edits.
+*
+* Returned in descending order and with overlaps dropped, because the batch applicator rejects
+* overlapping edits outright — a formatter that returns a whole-document edit plus a nested one
+* would otherwise throw rather than format.
+*
+* What survives is re-diffed against the text it replaces, so a reply that rewrites the document to
+* change one line touches only that line.
+*/
+function prepareFormattingEdits(document, edits) {
+	if (!edits || edits.length === 0) return [];
+	const converted = edits.map((edit) => ({
+		from: lspPositionToOffsetInSnapshot(document, edit.range.start),
+		text: edit.newText,
+		to: lspPositionToOffsetInSnapshot(document, edit.range.end)
+	})).filter((edit) => edit.from <= edit.to).sort((left, right) => left.from - right.from || right.to - left.to);
+	const applied = [];
+	let keptThrough = Number.NEGATIVE_INFINITY;
+	for (const edit of converted) {
+		if (edit.from < keptThrough) continue;
+		const previous = applied[applied.length - 1];
+		if (previous && previous.to === edit.from && joinFitsRediff(previous, edit)) applied[applied.length - 1] = {
+			from: previous.from,
+			text: previous.text + edit.text,
+			to: edit.to
+		};
+		else applied.push(edit);
+		keptThrough = edit.to;
+	}
+	return applied.flatMap((edit) => minimalReplacementEdits(document.textSnapshot.readRange(edit.from, edit.to), edit.text, edit.from)).reverse();
+}
+function joinFitsRediff(left, right) {
+	return Math.max(right.to - left.from, left.text.length + right.text.length) <= REDIFF_LENGTH_LIMIT;
+}
+/** Whether the edits would leave the document unchanged, so a no-op formatter records no change. */
+function formattingChangesText(text, edits) {
+	return edits.some((edit) => text.readRange(edit.from, edit.to) !== edit.text);
+}
+function formattingOptions(tabSize) {
+	return {
+		insertSpaces: true,
+		tabSize: Math.max(1, tabSize)
+	};
+}
+//#endregion
+export { formattingChangesText, formattingOptions, prepareFormattingEdits };
+
+//# sourceMappingURL=formatting.js.map

package/dist/formatting.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatting.js","names":[],"sources":["../src/formatting.ts"],"sourcesContent":["import type * as lsp from 'vscode-languageserver-protocol'\n\nimport type { TextEdit } from '@singapore-editor/core'\nimport {\n  lspPositionToOffsetInSnapshot,\n  type LspTextDocumentSnapshot,\n  type LspTextSnapshot,\n} from '@singapore-editor/lsp'\n\nimport { minimalReplacementEdits, REDIFF_LENGTH_LIMIT } from './minimalEdits'\n\n/**\n * Converts server formatting edits into buffer edits.\n *\n * Returned in descending order and with overlaps dropped, because the batch applicator rejects\n * overlapping edits outright — a formatter that returns a whole-document edit plus a nested one\n * would otherwise throw rather than format.\n *\n * What survives is re-diffed against the text it replaces, so a reply that rewrites the document to\n * change one line touches only that line.\n */\nexport function prepareFormattingEdits(\n  document: LspTextDocumentSnapshot,\n  edits: readonly lsp.TextEdit[] | null,\n): TextEdit[] {\n  if (!edits || edits.length === 0) return []\n\n  const converted = edits\n    .map((edit) => ({\n      from: lspPositionToOffsetInSnapshot(document, edit.range.start),\n      text: edit.newText,\n      to: lspPositionToOffsetInSnapshot(document, edit.range.end),\n    }))\n    .filter((edit) => edit.from <= edit.to)\n    // Earliest first, and the longest of any that start together: when a formatter sends a\n    // whole-document edit alongside a nested one, the outer edit is the real answer and keeping the\n    // fragment instead would rewrite a slice of the file with a slice of the result.\n    .sort((left, right) => left.from - right.from || right.to - left.to)\n\n  const applied: TextEdit[] = []\n  let keptThrough = Number.NEGATIVE_INFINITY\n  for (const edit of converted) {\n    if (edit.from < keptThrough) continue\n\n    const previous = applied[applied.length - 1]\n    // Edits that meet are joined first: two fragments that cancel each other out are invisible\n    // while they are compared apart. Joining stops at the length past which the comparison is\n    // skipped anyway, where a wider span would only buy a wider rewrite.\n    if (previous && previous.to === edit.from && joinFitsRediff(previous, edit)) {\n      applied[applied.length - 1] = {\n        from: previous.from,\n        text: previous.text + edit.text,\n        to: edit.to,\n      }\n    } else {\n      applied.push(edit)\n    }\n    keptThrough = edit.to\n  }\n\n  const minimal = applied.flatMap((edit) =>\n    minimalReplacementEdits(\n      document.textSnapshot.readRange(edit.from, edit.to),\n      edit.text,\n      edit.from,\n    ),\n  )\n\n  // Descending, so applying them in order cannot shift the offsets of the ones still to come.\n  return minimal.reverse()\n}\n\nfunction joinFitsRediff(left: TextEdit, right: TextEdit): boolean {\n  const joined = Math.max(right.to - left.from, left.text.length + right.text.length)\n  return joined <= REDIFF_LENGTH_LIMIT\n}\n\n/** Whether the edits would leave the document unchanged, so a no-op formatter records no change. */\nexport function formattingChangesText(text: LspTextSnapshot, edits: readonly TextEdit[]): boolean {\n  return edits.some((edit) => text.readRange(edit.from, edit.to) !== edit.text)\n}\n\nexport function formattingOptions(tabSize: number): lsp.FormattingOptions {\n  return {\n    insertSpaces: true,\n    tabSize: Math.max(1, tabSize),\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAqBA,SAAgB,uBACd,UACA,OACY;CACZ,IAAI,CAAC,SAAS,MAAM,WAAW,GAAG,OAAO,CAAC;CAE1C,MAAM,YAAY,MACf,KAAK,UAAU;EACd,MAAM,8BAA8B,UAAU,KAAK,MAAM,KAAK;EAC9D,MAAM,KAAK;EACX,IAAI,8BAA8B,UAAU,KAAK,MAAM,GAAG;CAC5D,EAAE,CAAC,CACF,QAAQ,SAAS,KAAK,QAAQ,KAAK,EAAE,CAAC,CAItC,MAAM,MAAM,UAAU,KAAK,OAAO,MAAM,QAAQ,MAAM,KAAK,KAAK,EAAE;CAErE,MAAM,UAAsB,CAAC;CAC7B,IAAI,cAAc,OAAO;CACzB,KAAK,MAAM,QAAQ,WAAW;EAC5B,IAAI,KAAK,OAAO,aAAa;EAE7B,MAAM,WAAW,QAAQ,QAAQ,SAAS;EAI1C,IAAI,YAAY,SAAS,OAAO,KAAK,QAAQ,eAAe,UAAU,IAAI,GACxE,QAAQ,QAAQ,SAAS,KAAK;GAC5B,MAAM,SAAS;GACf,MAAM,SAAS,OAAO,KAAK;GAC3B,IAAI,KAAK;EACX;OAEA,QAAQ,KAAK,IAAI;EAEnB,cAAc,KAAK;CACrB;CAWA,OATgB,QAAQ,SAAS,SAC/B,wBACE,SAAS,aAAa,UAAU,KAAK,MAAM,KAAK,EAAE,GAClD,KAAK,MACL,KAAK,IACP,CAIK,CAAA,CAAQ,QAAQ;AACzB;AAEA,SAAS,eAAe,MAAgB,OAA0B;CAEhE,OADe,KAAK,IAAI,MAAM,KAAK,KAAK,MAAM,KAAK,KAAK,SAAS,MAAM,KAAK,MACrE,KAAU;AACnB;;AAGA,SAAgB,sBAAsB,MAAuB,OAAqC;CAChG,OAAO,MAAM,MAAM,SAAS,KAAK,UAAU,KAAK,MAAM,KAAK,EAAE,MAAM,KAAK,IAAI;AAC9E;AAEA,SAAgB,kBAAkB,SAAwC;CACxE,OAAO;EACL,cAAc;EACd,SAAS,KAAK,IAAI,GAAG,OAAO;CAC9B;AACF"}

package/dist/fuzzyMatch.d.ts

@@ -0,0 +1,22 @@
+export type FuzzyMatch = {
+    readonly score: number;
+    /** Indices into the candidate that the pattern matched, ascending. */
+    readonly positions: readonly number[];
+};
+/**
+ * The match of the whole pattern, or null when there is none.
+ *
+ * The first character has to land somewhere the candidate begins something — its start, a camel-case
+ * hump, the far side of a separator. A pattern that only turns up in the middle of a word is a
+ * coincidence rather than what the user was reaching for.
+ */
+export declare function fuzzyMatch(pattern: string, candidate: string): FuzzyMatch | null;
+/**
+ * The match of the pattern, or of what is left of it after dropping leading characters, at any
+ * alignment at all.
+ *
+ * For a string the pattern was never ranked against there is no reason for all of it to be present,
+ * and marking the part that is beats marking nothing.
+ */
+export declare function looseFuzzyMatch(pattern: string, candidate: string): FuzzyMatch | null;
+//# sourceMappingURL=fuzzyMatch.d.ts.map

package/dist/fuzzyMatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fuzzyMatch.d.ts","sourceRoot":"","sources":["../src/fuzzyMatch.ts"],"names":[],"mappings":"AAcA,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,sEAAsE;IACtE,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAA;CACtC,CAAA;AAqCD;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAEhF;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAUrF"}