@singapore-editor/scope-lines 0.1.1

package/README.md

@@ -0,0 +1,27 @@
+# @singapore-editor/scope-lines
+
+Scope-line view contribution plugin for `@singapore-editor/core`.
+
+## Install
+
+```sh
+npm install @singapore-editor/core @singapore-editor/scope-lines
+```
+
+## Usage
+
+```ts
+import { Editor } from '@singapore-editor/core/editor'
+import { createScopeLinesPlugin } from '@singapore-editor/scope-lines'
+import '@singapore-editor/core/style.css'
+import '@singapore-editor/scope-lines/style.css'
+
+const editor = new Editor(document.querySelector('#editor')!, {
+  plugins: [createScopeLinesPlugin()],
+})
+```
+
+## Exports
+
+- `createScopeLinesPlugin` renders vertical guides for visible syntax scopes.
+- `ScopeLinesPluginOptions` controls mode, active-scope rendering, minimum span, and custom classes.

package/dist/bracketColors.d.ts

@@ -0,0 +1,33 @@
+import type { EditorPlugin } from '@singapore-editor/core/extensions';
+export type BracketColorsPluginOptions = {
+    readonly enabled?: boolean;
+    /** Deepest nesting painted; anything nested deeper keeps the colour the grammar gave it. */
+    readonly maxLevel?: number;
+    /** A document with more brackets than this is left uncoloured. */
+    readonly maxBrackets?: number;
+};
+/**
+ * Where depth colouring sits in the shared highlight priority band.
+ *
+ * A level colour has to replace the one the grammar gave the bracket, and the grammar reaches that
+ * same glyph through the same painting mechanism at the default rank: left equal, which of the two
+ * wins would come down to the order the two happened to register in.
+ *
+ * Exported because the band is one document-global namespace shared across packages, and this is
+ * the fifth producer to declare a `color` in it. It sat on the semantic token layer's number until
+ * the band was renumbered — a tie no one had noticed because no semantic scope covers a bracket
+ * glyph today, which makes it the kind of thing that surfaces the first time a host writes a
+ * `scopeAliases` entry mapping a server's `brace` onto `operator`.
+ */
+export declare const BRACKET_COLOR_Z_INDEX = 1;
+/**
+ * Colours bracket characters by the nesting depth of the pair they belong to, rotating through the
+ * registered level palette.
+ *
+ * Off until a host installs it: the affordance divides opinion, and it overrides the grammar's own
+ * colouring of those characters. Depth comes from the structural parse, so brackets inside strings
+ * and comments are not part of the nesting and nothing is painted before a parse has covered the
+ * document — a plausible-looking wrong depth is worse here than no colour at all.
+ */
+export declare function createBracketColorsPlugin(options?: BracketColorsPluginOptions): EditorPlugin;
+//# sourceMappingURL=bracketColors.d.ts.map

package/dist/bracketColors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bracketColors.d.ts","sourceRoot":"","sources":["../src/bracketColors.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACV,YAAY,EAKb,MAAM,mCAAmC,CAAA;AAE1C,MAAM,MAAM,0BAA0B,GAAG;IACvC,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;IAC1B,4FAA4F;IAC5F,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;IAC1B,kEAAkE;IAClE,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAC9B,CAAA;AAwBD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,qBAAqB,IAAI,CAAA;AAmCtC;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,GAAE,0BAA+B,GAAG,YAAY,CAYhG"}

package/dist/bracketColors.js

@@ -0,0 +1,146 @@
+import { editorColorReference, firstEditorColor, registerEditorColor } from "@singapore-editor/core/rendering";
+import { collectBracketLevels } from "@singapore-editor/core/editor";
+//#region src/bracketColors.ts
+/**
+* Where depth colouring sits in the shared highlight priority band.
+*
+* A level colour has to replace the one the grammar gave the bracket, and the grammar reaches that
+* same glyph through the same painting mechanism at the default rank: left equal, which of the two
+* wins would come down to the order the two happened to register in.
+*
+* Exported because the band is one document-global namespace shared across packages, and this is
+* the fifth producer to declare a `color` in it. It sat on the semantic token layer's number until
+* the band was renumbered — a tie no one had noticed because no semantic scope covers a bracket
+* glyph today, which makes it the kind of thing that surfaces the first time a host writes a
+* `scopeAliases` entry mapping a server's `brace` onto `operator`.
+*/
+var BRACKET_COLOR_Z_INDEX = 1;
+var BRACKET_LEVEL_STYLES = [
+	"syntax.type",
+	"syntax.keyword",
+	"syntax.string",
+	"syntax.number",
+	"syntax.function",
+	"syntax.variableBuiltin"
+].map((syntaxColorId, level) => ({
+	color: bracketLevelColor(level, syntaxColorId),
+	zIndex: 1
+}));
+var BRACKET_UNEXPECTED_STYLE = {
+	color: registerEditorColor("brackets.unexpected", {
+		dark: "#f87171",
+		light: "#dc2626"
+	}),
+	zIndex: 1
+};
+var DEFAULT_MAX_LEVEL = 200;
+var DEFAULT_MAX_BRACKETS = 2e4;
+/**
+* Colours bracket characters by the nesting depth of the pair they belong to, rotating through the
+* registered level palette.
+*
+* Off until a host installs it: the affordance divides opinion, and it overrides the grammar's own
+* colouring of those characters. Depth comes from the structural parse, so brackets inside strings
+* and comments are not part of the nesting and nothing is painted before a parse has covered the
+* document — a plausible-looking wrong depth is worse here than no colour at all.
+*/
+function createBracketColorsPlugin(options = {}) {
+	const resolved = resolveBracketColorsOptions(options);
+	return {
+		name: "bracket-colors",
+		activate(context) {
+			return context.registerViewContribution({ createContribution: (contributionContext) => createBracketColorsContribution(contributionContext, resolved) });
+		}
+	};
+}
+function createBracketColorsContribution(context, options) {
+	if (!options.enabled) return null;
+	return new BracketColorsContribution(context, options);
+}
+var BracketColorsContribution = class {
+	context;
+	options;
+	levelPaints;
+	unexpectedName;
+	painted = null;
+	constructor(context, options) {
+		this.context = context;
+		this.options = options;
+		const prefix = context.highlightPrefix;
+		this.levelPaints = BRACKET_LEVEL_STYLES.map((style, level) => ({
+			name: `${prefix}-bracket-level-${level}`,
+			style
+		}));
+		this.unexpectedName = `${prefix}-bracket-unexpected`;
+		this.update(context.getSnapshot(), "document");
+	}
+	update(snapshot, kind) {
+		if (kind === "clear") {
+			this.clear();
+			return;
+		}
+		this.paint(snapshot);
+	}
+	dispose() {
+		this.clear();
+	}
+	paint(snapshot) {
+		if (this.painted === snapshot.brackets) return;
+		this.painted = snapshot.brackets;
+		const ranges = bracketColorRanges(snapshot.brackets, this.options);
+		this.levelPaints.forEach((paint, level) => {
+			this.setHighlight(paint.name, ranges.levels[level] ?? [], paint.style);
+		});
+		this.setHighlight(this.unexpectedName, ranges.unexpected, BRACKET_UNEXPECTED_STYLE);
+	}
+	clear() {
+		this.painted = null;
+		for (const paint of this.levelPaints) this.context.clearRangeHighlight(paint.name);
+		this.context.clearRangeHighlight(this.unexpectedName);
+	}
+	setHighlight(name, ranges, style) {
+		this.context.setRangeHighlight(name, ranges, style);
+	}
+};
+function bracketColorRanges(brackets, options) {
+	const levels = BRACKET_LEVEL_STYLES.map(() => []);
+	const unexpected = [];
+	if (brackets.length > options.maxBrackets) return {
+		levels,
+		unexpected
+	};
+	for (const bracket of collectBracketLevels(brackets, { maxLevel: options.maxLevel })) {
+		const range = {
+			start: bracket.offset,
+			end: bracket.offset + bracket.char.length
+		};
+		if (bracket.unexpected) {
+			unexpected.push(range);
+			continue;
+		}
+		levels[bracket.level % levels.length]?.push(range);
+	}
+	return {
+		levels,
+		unexpected
+	};
+}
+function resolveBracketColorsOptions(options) {
+	return {
+		enabled: options.enabled ?? true,
+		maxLevel: normalizeBracketColorsLimit(options.maxLevel, DEFAULT_MAX_LEVEL),
+		maxBrackets: normalizeBracketColorsLimit(options.maxBrackets, DEFAULT_MAX_BRACKETS)
+	};
+}
+function normalizeBracketColorsLimit(value, fallback) {
+	if (value === void 0) return fallback;
+	if (!Number.isFinite(value)) return fallback;
+	return Math.max(0, Math.floor(value));
+}
+function bracketLevelColor(level, syntaxColorId) {
+	return registerEditorColor(`brackets.level${level}`, firstEditorColor(editorColorReference(syntaxColorId), editorColorReference("syntax.bracket")));
+}
+//#endregion
+export { BRACKET_COLOR_Z_INDEX, createBracketColorsPlugin };
+
+//# sourceMappingURL=bracketColors.js.map

package/dist/bracketColors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bracketColors.js","names":[],"sources":["../src/bracketColors.ts"],"sourcesContent":["import type { BracketInfo } from '@singapore-editor/core/syntax'\nimport { collectBracketLevels } from '@singapore-editor/core/editor'\nimport {\n  editorColorReference,\n  firstEditorColor,\n  registerEditorColor,\n  type VirtualizedTextHighlightStyle,\n} from '@singapore-editor/core/rendering'\nimport type {\n  EditorPlugin,\n  EditorViewContribution,\n  EditorViewContributionContext,\n  EditorViewContributionUpdateKind,\n  EditorViewSnapshot,\n} from '@singapore-editor/core/extensions'\n\nexport type BracketColorsPluginOptions = {\n  readonly enabled?: boolean\n  /** Deepest nesting painted; anything nested deeper keeps the colour the grammar gave it. */\n  readonly maxLevel?: number\n  /** A document with more brackets than this is left uncoloured. */\n  readonly maxBrackets?: number\n}\n\ntype ResolvedBracketColorsOptions = {\n  readonly enabled: boolean\n  readonly maxLevel: number\n  readonly maxBrackets: number\n}\n\ntype BracketColorRange = {\n  readonly start: number\n  readonly end: number\n}\n\ntype BracketColorRanges = {\n  /** One bucket per level colour, in palette order. */\n  readonly levels: readonly (readonly BracketColorRange[])[]\n  readonly unexpected: readonly BracketColorRange[]\n}\n\ntype BracketLevelPaint = {\n  readonly name: string\n  readonly style: VirtualizedTextHighlightStyle\n}\n\n/**\n * Where depth colouring sits in the shared highlight priority band.\n *\n * A level colour has to replace the one the grammar gave the bracket, and the grammar reaches that\n * same glyph through the same painting mechanism at the default rank: left equal, which of the two\n * wins would come down to the order the two happened to register in.\n *\n * Exported because the band is one document-global namespace shared across packages, and this is\n * the fifth producer to declare a `color` in it. It sat on the semantic token layer's number until\n * the band was renumbered — a tie no one had noticed because no semantic scope covers a bracket\n * glyph today, which makes it the kind of thing that surfaces the first time a host writes a\n * `scopeAliases` entry mapping a server's `brace` onto `operator`.\n */\nexport const BRACKET_COLOR_Z_INDEX = 1\n\n/*\n * Depth is painted with registered colour ids, so a theme restyles nesting the way it restyles\n * anything else, and each level leans on a syntax colour the theme has already picked rather than on\n * a palette of its own: those hues are distinguishable from one another because the theme had to make\n * them distinguishable to be readable at all, and they follow a theme this file has never heard of. A\n * theme that names none of them leaves the declaration invalid, which drops it and leaves the bracket\n * the colour it already had — the honest outcome for a palette nobody supplied.\n */\nconst BRACKET_LEVEL_STYLES: readonly VirtualizedTextHighlightStyle[] = [\n  'syntax.type',\n  'syntax.keyword',\n  'syntax.string',\n  'syntax.number',\n  'syntax.function',\n  'syntax.variableBuiltin',\n].map((syntaxColorId, level) => ({\n  color: bracketLevelColor(level, syntaxColorId),\n  zIndex: BRACKET_COLOR_Z_INDEX,\n}))\n\n// A closer with nothing to close is a mistake rather than a depth, so it is the one bracket that does\n// not take part in the rotation. Nothing in the syntax palette is reliably an error colour to derive\n// it from, and the two canvases need different cuts of red to stay legible.\nconst BRACKET_UNEXPECTED_STYLE: VirtualizedTextHighlightStyle = {\n  color: registerEditorColor('brackets.unexpected', { dark: '#f87171', light: '#dc2626' }),\n  zIndex: BRACKET_COLOR_Z_INDEX,\n}\n\nconst DEFAULT_MAX_LEVEL = 200\n// Past this the pass and the ranges it produces cost more than the affordance is worth, and painting\n// only the part of the file that fit would read as brackets losing their colour halfway down.\nconst DEFAULT_MAX_BRACKETS = 20_000\n\n/**\n * Colours bracket characters by the nesting depth of the pair they belong to, rotating through the\n * registered level palette.\n *\n * Off until a host installs it: the affordance divides opinion, and it overrides the grammar's own\n * colouring of those characters. Depth comes from the structural parse, so brackets inside strings\n * and comments are not part of the nesting and nothing is painted before a parse has covered the\n * document — a plausible-looking wrong depth is worse here than no colour at all.\n */\nexport function createBracketColorsPlugin(options: BracketColorsPluginOptions = {}): EditorPlugin {\n  const resolved = resolveBracketColorsOptions(options)\n\n  return {\n    name: 'bracket-colors',\n    activate(context) {\n      return context.registerViewContribution({\n        createContribution: (contributionContext) =>\n          createBracketColorsContribution(contributionContext, resolved),\n      })\n    },\n  }\n}\n\nfunction createBracketColorsContribution(\n  context: EditorViewContributionContext,\n  options: ResolvedBracketColorsOptions,\n): EditorViewContribution | null {\n  if (!options.enabled) return null\n  return new BracketColorsContribution(context, options)\n}\n\nclass BracketColorsContribution implements EditorViewContribution {\n  private readonly context: EditorViewContributionContext\n  private readonly options: ResolvedBracketColorsOptions\n  private readonly levelPaints: readonly BracketLevelPaint[]\n  private readonly unexpectedName: string\n  private painted: readonly BracketInfo[] | null = null\n\n  public constructor(\n    context: EditorViewContributionContext,\n    options: ResolvedBracketColorsOptions,\n  ) {\n    this.context = context\n    this.options = options\n    const prefix = context.highlightPrefix\n    this.levelPaints = BRACKET_LEVEL_STYLES.map((style, level) => ({\n      name: `${prefix}-bracket-level-${level}`,\n      style,\n    }))\n    this.unexpectedName = `${prefix}-bracket-unexpected`\n    this.update(context.getSnapshot(), 'document')\n  }\n\n  // Every kind is considered rather than a chosen few: a parse that finishes between notifications\n  // reaches the first update published after it, whichever kind that happens to be, and a bracket\n  // list that only shows up on a scroll would otherwise stay unpainted until the next keystroke.\n  public update(snapshot: EditorViewSnapshot, kind: EditorViewContributionUpdateKind): void {\n    if (kind === 'clear') {\n      this.clear()\n      return\n    }\n\n    this.paint(snapshot)\n  }\n\n  public dispose(): void {\n    this.clear()\n  }\n\n  // A parse replaces the bracket list wholesale and every snapshot until the next one shares it, so\n  // its identity is the cheapest honest answer to 'has anything moved'.\n  private paint(snapshot: EditorViewSnapshot): void {\n    if (this.painted === snapshot.brackets) return\n\n    this.painted = snapshot.brackets\n    const ranges = bracketColorRanges(snapshot.brackets, this.options)\n    this.levelPaints.forEach((paint, level) => {\n      this.setHighlight(paint.name, ranges.levels[level] ?? [], paint.style)\n    })\n    this.setHighlight(this.unexpectedName, ranges.unexpected, BRACKET_UNEXPECTED_STYLE)\n  }\n\n  private clear(): void {\n    this.painted = null\n    for (const paint of this.levelPaints) this.context.clearRangeHighlight(paint.name)\n    this.context.clearRangeHighlight(this.unexpectedName)\n  }\n\n  private setHighlight(\n    name: string,\n    ranges: readonly BracketColorRange[],\n    style: VirtualizedTextHighlightStyle,\n  ): void {\n    this.context.setRangeHighlight(name, ranges, style)\n  }\n}\n\nfunction bracketColorRanges(\n  brackets: readonly BracketInfo[],\n  options: ResolvedBracketColorsOptions,\n): BracketColorRanges {\n  const levels: BracketColorRange[][] = BRACKET_LEVEL_STYLES.map(() => [])\n  const unexpected: BracketColorRange[] = []\n  if (brackets.length > options.maxBrackets) return { levels, unexpected }\n\n  for (const bracket of collectBracketLevels(brackets, { maxLevel: options.maxLevel })) {\n    const range = { start: bracket.offset, end: bracket.offset + bracket.char.length }\n    if (bracket.unexpected) {\n      unexpected.push(range)\n      continue\n    }\n\n    levels[bracket.level % levels.length]?.push(range)\n  }\n\n  return { levels, unexpected }\n}\n\nfunction resolveBracketColorsOptions(\n  options: BracketColorsPluginOptions,\n): ResolvedBracketColorsOptions {\n  return {\n    enabled: options.enabled ?? true,\n    maxLevel: normalizeBracketColorsLimit(options.maxLevel, DEFAULT_MAX_LEVEL),\n    maxBrackets: normalizeBracketColorsLimit(options.maxBrackets, DEFAULT_MAX_BRACKETS),\n  }\n}\n\nfunction normalizeBracketColorsLimit(value: number | undefined, fallback: number): number {\n  if (value === undefined) return fallback\n  if (!Number.isFinite(value)) return fallback\n  return Math.max(0, Math.floor(value))\n}\n\nfunction bracketLevelColor(level: number, syntaxColorId: string): string {\n  return registerEditorColor(\n    `brackets.level${level}`,\n    firstEditorColor(editorColorReference(syntaxColorId), editorColorReference('syntax.bracket')),\n  )\n}\n"],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+import type { EditorPlugin } from '@singapore-editor/core/extensions';
+import './style.css';
+export { BRACKET_COLOR_Z_INDEX, createBracketColorsPlugin } from './bracketColors';
+export type { BracketColorsPluginOptions } from './bracketColors';
+export { createStickyScrollPlugin } from './stickyScroll';
+export type { StickyScrollPluginOptions } from './stickyScroll';
+export type ScopeLinesPluginOptions = {
+    readonly enabled?: boolean;
+    readonly className?: string;
+    readonly minLineSpan?: number;
+    readonly mode?: ScopeLinesMode;
+    readonly showActive?: boolean;
+};
+export type ScopeLinesMode = 'all' | 'current';
+export declare function createScopeLinesPlugin(options?: ScopeLinesPluginOptions): EditorPlugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAEV,YAAY,EAQb,MAAM,mCAAmC,CAAA;AAC1C,OAAO,aAAa,CAAA;AAEpB,OAAO,EAAE,qBAAqB,EAAE,yBAAyB,EAAE,MAAM,iBAAiB,CAAA;AAClF,YAAY,EAAE,0BAA0B,EAAE,MAAM,iBAAiB,CAAA;AACjE,OAAO,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAA;AACzD,YAAY,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAA;AAE/D,MAAM,MAAM,uBAAuB,GAAG;IACpC,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;IAC1B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,IAAI,CAAC,EAAE,cAAc,CAAA;IAC9B,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAA;CAC9B,CAAA;AAED,MAAM,MAAM,cAAc,GAAG,KAAK,GAAG,SAAS,CAAA;AAgE9C,wBAAgB,sBAAsB,CAAC,OAAO,GAAE,uBAA4B,GAAG,YAAY,CAY1F"}