@coldsmirk/inkstone-redis 0.22.0

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { S as RedisCommand, _ as createRedisAssist, a as LineRefusal, b as REDIS_COMMANDS, c as SplitLine, d as runnableLine, f as splitLine, g as RedisSignatureHelp, h as RedisHoverCard, i as LineRead, l as lineBounds, m as RedisCompletionCandidate, n as RedisMarkerCode, o as LineWord, p as RedisAssist, r as lineMarkers, s as RunnableLine, t as RedisMarker, u as readLine, v as RedisVocabulary, x as REDIS_VERSION, y as createRedisVocabulary } from "./markers-gZmuOyuR.js";
+export { type LineRead, type LineRefusal, type LineWord, REDIS_COMMANDS, REDIS_VERSION, type RedisAssist, type RedisCommand, type RedisCompletionCandidate, type RedisHoverCard, type RedisMarker, type RedisMarkerCode, type RedisSignatureHelp, type RedisVocabulary, type RunnableLine, type SplitLine, createRedisAssist, createRedisVocabulary, lineBounds, lineMarkers, readLine, runnableLine, splitLine };

package/dist/index.js

@@ -0,0 +1,85 @@
+import { a as runnableLine, i as readLine, n as createRedisVocabulary, o as splitLine, r as lineBounds, t as lineMarkers } from "./markers-BlM8eKCj.js";
+import { n as REDIS_VERSION, t as REDIS_COMMANDS } from "./commands-BMa2ec02.js";
+//#region src/assist.ts
+function argumentsOf(command) {
+	const rest = command.syntax.slice(command.name.length).trim();
+	return rest === "" ? void 0 : rest;
+}
+function documentationOf(command) {
+	const parts = [command.summary];
+	if (command.since !== "") parts.push(`Since ${command.since}${command.deprecated === void 0 ? "" : `, deprecated since ${command.deprecated}`}.`);
+	const text = parts.filter((part) => part !== "").join("\n\n");
+	return text === "" ? void 0 : text;
+}
+function createRedisAssist(vocabulary = createRedisVocabulary()) {
+	const top = vocabulary.commands.filter((command) => !command.name.includes(" "));
+	return {
+		complete: (text, offset) => {
+			const read = readLine(text, offset);
+			const names = read.words.map((word) => word.text);
+			if (read.index === 0) return top.map((command) => {
+				return {
+					label: command.name,
+					kind: "command",
+					insertText: command.name,
+					detail: argumentsOf(command),
+					documentation: documentationOf(command),
+					sortGroup: command.deprecated === void 0 ? 0 : 1
+				};
+			});
+			const container = names[0].toUpperCase();
+			const subs = vocabulary.subcommands.get(container);
+			if (read.index === 1 && subs !== void 0) return subs.map((sub) => {
+				const name = sub.name.slice(container.length + 1);
+				return {
+					label: name,
+					kind: "subcommand",
+					insertText: name,
+					detail: argumentsOf(sub),
+					documentation: documentationOf(sub),
+					sortGroup: sub.deprecated === void 0 ? 0 : 1
+				};
+			});
+			const resolved = vocabulary.resolve(names);
+			if (resolved === null || read.index < resolved.consumed) return [];
+			return resolved.command.tokens.map((token) => {
+				return {
+					label: token,
+					kind: "token",
+					insertText: token,
+					detail: resolved.command.name,
+					sortGroup: 2
+				};
+			});
+		},
+		hover: (text, offset) => {
+			const read = readLine(text, offset);
+			if (read.word === null) return null;
+			const resolved = vocabulary.resolve(read.words.map((word) => word.text));
+			if (resolved === null || read.index >= resolved.consumed) return null;
+			const { command } = resolved;
+			const markdown = [`\`${command.syntax}\``];
+			const documentation = documentationOf(command);
+			if (documentation !== void 0) markdown.push(documentation);
+			return {
+				from: read.lineStart + read.words[0].from,
+				to: read.lineStart + read.words[resolved.consumed - 1].to,
+				markdown
+			};
+		},
+		signature: (text, offset) => {
+			const read = readLine(text, offset);
+			const resolved = vocabulary.resolve(read.words.map((word) => word.text));
+			if (resolved === null || read.index < resolved.consumed || resolved.command.parameters.length === 0) return null;
+			const { command } = resolved;
+			return {
+				label: command.syntax,
+				parameters: command.parameters,
+				active: Math.min(read.index - resolved.consumed, command.parameters.length - 1),
+				documentation: command.summary === "" ? void 0 : command.summary
+			};
+		}
+	};
+}
+//#endregion
+export { REDIS_COMMANDS, REDIS_VERSION, createRedisAssist, createRedisVocabulary, lineBounds, lineMarkers, readLine, runnableLine, splitLine };

package/dist/markers-BlM8eKCj.js

@@ -0,0 +1,250 @@
+import { t as REDIS_COMMANDS } from "./commands-BMa2ec02.js";
+//#region src/line.ts
+const ESCAPES = {
+	n: "\n",
+	r: "\r",
+	t: "	",
+	b: "\b",
+	a: String.fromCodePoint(7)
+};
+function blank(character) {
+	return /\s/u.test(character);
+}
+function hex(character) {
+	return /[0-9a-f]/iu.test(character);
+}
+function splitLine(line) {
+	const words = [];
+	const { length } = line;
+	let i = 0;
+	while (true) {
+		while (i < length && blank(line[i])) i++;
+		if (i >= length) break;
+		const from = i;
+		let text = "";
+		let inDouble = false;
+		let inSingle = false;
+		let done = false;
+		while (!done) {
+			const c = i < length ? line[i] : "";
+			if (inDouble) {
+				if (i >= length) return {
+					words,
+					refusal: {
+						code: "unbalanced-double-quote",
+						at: from
+					}
+				};
+				if (c === "\\" && i + 3 < length && line[i + 1] === "x" && hex(line[i + 2]) && hex(line[i + 3])) {
+					text += String.fromCodePoint(Number.parseInt(line.slice(i + 2, i + 4), 16));
+					i += 4;
+				} else if (c === "\\" && i + 1 < length) {
+					const escaped = line[i + 1];
+					text += ESCAPES[escaped] ?? escaped;
+					i += 2;
+				} else if (c === "\"") {
+					if (i + 1 < length && !blank(line[i + 1])) return {
+						words,
+						refusal: {
+							code: "quote-not-followed-by-blank",
+							at: i + 1
+						}
+					};
+					i++;
+					done = true;
+				} else {
+					text += c;
+					i++;
+				}
+			} else if (inSingle) {
+				if (i >= length) return {
+					words,
+					refusal: {
+						code: "unbalanced-single-quote",
+						at: from
+					}
+				};
+				if (c === "\\" && line[i + 1] === "'") {
+					text += "'";
+					i += 2;
+				} else if (c === "'") {
+					if (i + 1 < length && !blank(line[i + 1])) return {
+						words,
+						refusal: {
+							code: "quote-not-followed-by-blank",
+							at: i + 1
+						}
+					};
+					i++;
+					done = true;
+				} else {
+					text += c;
+					i++;
+				}
+			} else if (i >= length || blank(c)) done = true;
+			else if (c === "\"") {
+				inDouble = true;
+				i++;
+			} else if (c === "'") {
+				inSingle = true;
+				i++;
+			} else {
+				text += c;
+				i++;
+			}
+		}
+		words.push({
+			text,
+			from,
+			to: i
+		});
+	}
+	if (words.length === 0) return {
+		words,
+		refusal: {
+			code: "empty",
+			at: 0
+		}
+	};
+	return {
+		words,
+		refusal: null
+	};
+}
+function lineBounds(text, offset) {
+	const lineStart = text.lastIndexOf("\n", offset - 1) + 1;
+	const next = text.indexOf("\n", offset);
+	let lineEnd = next === -1 ? text.length : next;
+	if (lineEnd > lineStart && text[lineEnd - 1] === "\r") lineEnd--;
+	return {
+		lineStart,
+		lineEnd
+	};
+}
+function readLine(text, offset) {
+	const { lineStart, lineEnd } = lineBounds(text, offset);
+	const line = text.slice(lineStart, lineEnd);
+	const split = splitLine(line);
+	const caret = Math.min(Math.max(offset - lineStart, 0), line.length);
+	const inside = split.words.findIndex((word) => word.from <= caret && caret <= word.to);
+	if (inside !== -1) return {
+		...split,
+		line,
+		lineStart,
+		lineEnd,
+		index: inside,
+		word: split.words[inside]
+	};
+	return {
+		...split,
+		line,
+		lineStart,
+		lineEnd,
+		index: split.words.filter((word) => word.to < caret).length,
+		word: null
+	};
+}
+function runnableLine(text, from, to) {
+	if (from < to) {
+		const lines = text.slice(from, to).split(/\r?\n/u).filter((line) => line.trim() !== "");
+		if (lines.length === 0) return { kind: "none" };
+		if (lines.length > 1) return { kind: "several" };
+		return trimmed(text, from, to);
+	}
+	const { lineStart, lineEnd } = lineBounds(text, from);
+	return trimmed(text, lineStart, lineEnd);
+}
+function trimmed(text, from, to) {
+	const span = text.slice(from, to);
+	const start = from + (span.length - span.trimStart().length);
+	const end = to - (span.length - span.trimEnd().length);
+	return start >= end ? { kind: "none" } : {
+		kind: "one",
+		text: text.slice(start, end),
+		from: start,
+		to: end
+	};
+}
+//#endregion
+//#region src/vocabulary.ts
+function createRedisVocabulary(commands = REDIS_COMMANDS) {
+	const byName = /* @__PURE__ */ new Map();
+	const subcommands = /* @__PURE__ */ new Map();
+	for (const command of commands) {
+		byName.set(command.name, command);
+		const space = command.name.indexOf(" ");
+		if (space !== -1) {
+			const container = command.name.slice(0, space);
+			const listed = subcommands.get(container) ?? [];
+			listed.push(command);
+			subcommands.set(container, listed);
+		}
+	}
+	return {
+		commands,
+		byName,
+		subcommands,
+		resolve: (words) => {
+			const first = words[0]?.toUpperCase();
+			if (first === void 0) return null;
+			const second = words[1]?.toUpperCase();
+			if (subcommands.has(first) && second !== void 0) {
+				const sub = byName.get(`${first} ${second}`);
+				if (sub !== void 0) return {
+					command: sub,
+					consumed: 2
+				};
+			}
+			const command = byName.get(first);
+			return command === void 0 ? null : {
+				command,
+				consumed: 1
+			};
+		}
+	};
+}
+//#endregion
+//#region src/markers.ts
+const DEFAULT_VOCABULARY = createRedisVocabulary();
+function lineMarkers(text, vocabulary = DEFAULT_VOCABULARY) {
+	const markers = [];
+	let lineStart = 0;
+	for (const raw of text.split("\n")) {
+		const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
+		const { words, refusal } = splitLine(line);
+		if (refusal === null) {
+			const names = words.map((word) => word.text);
+			const resolved = vocabulary.resolve(names);
+			if (resolved === null) markers.push({
+				from: lineStart + words[0].from,
+				to: lineStart + words[0].to,
+				code: "unknown-command",
+				severity: "hint"
+			});
+			else {
+				const { command, consumed } = resolved;
+				if (consumed === 1 && vocabulary.subcommands.has(command.name) && words.length > 1) markers.push({
+					from: lineStart + words[1].from,
+					to: lineStart + words[1].to,
+					code: "unknown-command",
+					severity: "hint"
+				});
+				else if (command.arity >= 0 ? words.length !== command.arity : words.length < -command.arity) markers.push({
+					from: lineStart + words[0].from,
+					to: lineStart + words.at(-1).to,
+					code: "wrong-arity",
+					severity: "warning"
+				});
+			}
+		} else if (refusal.code !== "empty") markers.push({
+			from: lineStart + refusal.at,
+			to: lineStart + line.length,
+			code: refusal.code,
+			severity: "error"
+		});
+		lineStart += raw.length + 1;
+	}
+	return markers;
+}
+//#endregion
+export { runnableLine as a, readLine as i, createRedisVocabulary as n, splitLine as o, lineBounds as r, lineMarkers as t };

package/dist/markers-gZmuOyuR.d.ts

@@ -0,0 +1,244 @@
+//#region src/commands.d.ts
+/**
+ * One command as the server describes it.
+ */
+interface RedisCommand {
+  /**
+   * `SET`; a container's subcommand as `CLIENT LIST`.
+   */
+  name: string;
+  /**
+   * `COMMAND`'s arity: how many words the call takes, the name (and the subcommand) counted;
+   * negative for at least that many.
+   */
+  arity: number;
+  group: string;
+  since: string;
+  summary: string;
+  /**
+   * The call as redis.io spells it: `SET key value [NX | XX] [GET] …`.
+   */
+  syntax: string;
+  /**
+   * Each top-level argument's `[start, end)` within `syntax`, for signature help.
+   */
+  parameters: Array<[number, number]>;
+  /**
+   * Every fixed word the arguments take (`NX`, `EX`, `WITHSCORES`), uppercased, sorted.
+   */
+  tokens: string[];
+  /**
+   * The version that deprecated it, where one did.
+   */
+  deprecated?: string;
+}
+declare const REDIS_VERSION = "7.2.16";
+declare const REDIS_COMMANDS: readonly RedisCommand[];
+//#endregion
+//#region src/vocabulary.d.ts
+/**
+ * The command table indexed for the questions the editor asks of it: a name to its command, a
+ * container (`CLIENT`, `CONFIG`, `XINFO` …) to its subcommands, and a line's first words to the
+ * command they name — the subcommand where the first word is a container and the second is one
+ * of its own, the container itself otherwise.
+ */
+interface RedisVocabulary {
+  commands: readonly RedisCommand[];
+  /**
+   * Every command by its uppercased name, subcommands under `CONTAINER SUB`.
+   */
+  byName: ReadonlyMap<string, RedisCommand>;
+  /**
+   * Each container's subcommands, by the container's name.
+   */
+  subcommands: ReadonlyMap<string, readonly RedisCommand[]>;
+  /**
+   * The command a line's words name, and how many of them name it (two for a subcommand); null
+   * for a word the table does not know — a module's command, or a typo.
+   */
+  resolve: (words: readonly string[]) => {
+    command: RedisCommand;
+    consumed: number;
+  } | null;
+}
+declare function createRedisVocabulary(commands?: readonly RedisCommand[]): RedisVocabulary;
+//#endregion
+//#region src/assist.d.ts
+/**
+ * One suggestion: a command's name at the line's start, a container's subcommand after it, or
+ * a fixed word of the command's own syntax (`NX`, `WITHSCORES`) anywhere after.
+ */
+interface RedisCompletionCandidate {
+  label: string;
+  kind: "command" | "subcommand" | "token";
+  insertText: string;
+  detail?: string;
+  documentation?: string;
+  /**
+   * Rank band, lower first; within a band the table's own order stands.
+   */
+  sortGroup: number;
+}
+/**
+ * What hovering the command's name says about it. Offsets are into the text handed to
+ * `hover`, so the editor turns them into its own range without re-reading the line.
+ */
+interface RedisHoverCard {
+  from: number;
+  to: number;
+  /**
+   * Markdown blocks, rendered in order.
+   */
+  markdown: string[];
+}
+/**
+ * The command's syntax while the caret is among its arguments.
+ */
+interface RedisSignatureHelp {
+  /**
+   * The syntax line whole: `SET key value [NX | XX] …`.
+   */
+  label: string;
+  /**
+   * Each argument's `[start, end)` within `label`.
+   */
+  parameters: Array<[number, number]>;
+  /**
+   * The argument the caret's word stands at, clamped onto the last: the syntax's tail is the
+   * optional and repeated part, and every word past the fixed ones is in it.
+   */
+  active: number;
+  documentation?: string;
+}
+/**
+ * The editor's assist over one command table: everything the surface can ask that needs to
+ * know Redis. Synchronous, since the table is in memory and nothing is fetched.
+ */
+interface RedisAssist {
+  complete: (text: string, offset: number) => RedisCompletionCandidate[];
+  hover: (text: string, offset: number) => RedisHoverCard | null;
+  signature: (text: string, offset: number) => RedisSignatureHelp | null;
+}
+/**
+ * Completion, hover and signature help over the table, all reading the caret's line through
+ * `readLine` — redis-cli's own splitting — so they can never disagree about which word the
+ * caret is on.
+ */
+declare function createRedisAssist(vocabulary?: RedisVocabulary): RedisAssist;
+//#endregion
+//#region src/line.d.ts
+/**
+ * A Redis command is one line, split into words the way redis-cli splits one — and the way the
+ * polyglot sidecar's `RedisLine` splits it before the words go on the wire: bare words on
+ * blanks, double quotes with `\xHH`, `\n`, `\r`, `\t`, `\b`, `\a` and `\<c>` escapes, single
+ * quotes with `\'` alone, and a closing quote that must be followed by a blank. The two are
+ * mirrors: a line this reader refuses is a line the engine refuses, for the same reason, so
+ * the editor can say so before the round trip does.
+ */
+/**
+ * Why a line could not be read whole — a code, never a sentence; the host owns the wording.
+ * `"empty"` is a line of blanks alone.
+ */
+type LineRefusal = "unbalanced-double-quote" | "unbalanced-single-quote" | "quote-not-followed-by-blank" | "empty";
+/**
+ * One word of the line: its text with the quoting resolved, and its `[from, to)` in the line
+ * as written, quotes included.
+ */
+interface LineWord {
+  text: string;
+  from: number;
+  to: number;
+}
+interface SplitLine {
+  /**
+   * The words read, in order — every one of them where `refusal` is null, those before the
+   * fault where it is not.
+   */
+  words: LineWord[];
+  /**
+   * Where reading stopped, or null where the line read whole: `at` is the offset in the line
+   * the fault is at (the opening quote of an unbalanced pair, the character after a closing
+   * quote that should have been a blank).
+   */
+  refusal: {
+    code: LineRefusal;
+    at: number;
+  } | null;
+}
+/**
+ * The words of one line, redis-cli's way.
+ */
+declare function splitLine(line: string): SplitLine;
+/**
+ * The line the caret is on, read: its bounds in the whole text, its words, and where among
+ * them the caret stands.
+ */
+interface LineRead extends SplitLine {
+  line: string;
+  /**
+   * The line's `[lineStart, lineEnd)` in the text; a `\r` before the break is outside it.
+   */
+  lineStart: number;
+  lineEnd: number;
+  /**
+   * The word the caret is in or at the end of, or the number of words before the caret where
+   * it stands on a blank — the position a word typed now would take.
+   */
+  index: number;
+  /**
+   * The word the caret is in, or null on a blank.
+   */
+  word: LineWord | null;
+}
+/**
+ * Bounds of the line holding `offset`: from the character after the previous break to the
+ * next break, a `\r` before it left out.
+ */
+declare function lineBounds(text: string, offset: number): {
+  lineStart: number;
+  lineEnd: number;
+};
+declare function readLine(text: string, offset: number): LineRead;
+/**
+ * What one run should send: the selection where there is one, else the caret's line — one
+ * command, since the engine takes one; a selection over several lines is `several`, and a
+ * selection or a line of blanks is `none`.
+ */
+type RunnableLine = {
+  kind: "one";
+  text: string;
+  from: number;
+  to: number;
+} | {
+  kind: "none";
+} | {
+  kind: "several";
+};
+declare function runnableLine(text: string, from: number, to: number): RunnableLine;
+//#endregion
+//#region src/markers.d.ts
+/**
+ * What a line marker says — a code, never a sentence; the host owns the wording:
+ *
+ * - the three quoting faults `splitLine` refuses, which the engine refuses too (`error`);
+ * - `"unknown-command"` — a first word the table does not know, or a container's second word
+ * that is none of its subcommands (`hint`: a module's command is unknown here and runs fine);
+ * - `"wrong-arity"` — fewer words than the command takes, or, for a command of a fixed count,
+ * more (`warning`: the server answers `wrong number of arguments`).
+ */
+type RedisMarkerCode = Exclude<LineRefusal, "empty"> | "unknown-command" | "wrong-arity";
+interface RedisMarker {
+  /**
+   * The span marked, as offsets into the text handed to `lineMarkers`.
+   */
+  from: number;
+  to: number;
+  code: RedisMarkerCode;
+  severity: "error" | "warning" | "hint";
+}
+/**
+ * The markers of every line of the text, a line of blanks marked with nothing.
+ */
+declare function lineMarkers(text: string, vocabulary?: RedisVocabulary): RedisMarker[];
+//#endregion
+export { RedisCommand as S, createRedisAssist as _, LineRefusal as a, REDIS_COMMANDS as b, SplitLine as c, runnableLine as d, splitLine as f, RedisSignatureHelp as g, RedisHoverCard as h, LineRead as i, lineBounds as l, RedisCompletionCandidate as m, RedisMarkerCode as n, LineWord as o, RedisAssist as p, lineMarkers as r, RunnableLine as s, RedisMarker as t, readLine as u, RedisVocabulary as v, REDIS_VERSION as x, createRedisVocabulary as y };

package/dist/monaco.d.ts

@@ -0,0 +1,42 @@
+import { S as RedisCommand, p as RedisAssist, t as RedisMarker } from "./markers-gZmuOyuR.js";
+import * as monacoEditor from "monaco-editor";
+import { IDisposable, editor } from "monaco-editor";
+//#region src/monaco.d.ts
+/**
+ * The monaco module itself, as `onMount` hands it over.
+ */
+type MonacoModule = typeof monacoEditor;
+/**
+ * The language id the editor registers a command line under.
+ */
+declare const REDIS_LANGUAGE_ID = "redis";
+/**
+ * Register the language — the id, its Monarch grammar and its bracket configuration — once per
+ * monaco module. Call it before the first model of the language is created (`beforeMount`);
+ * a model created under an id Monaco does not know yet is plain text until it is.
+ */
+declare function defineRedisLanguage(monaco: MonacoModule, languageId?: string, commands?: readonly RedisCommand[]): void;
+interface RedisLanguageHooks {
+  /**
+   * The assist as it stands right now — read per request rather than captured, so the host
+   * can swap it without touching Monaco's registry; null answers nothing.
+   */
+  assist: () => RedisAssist | null;
+}
+/**
+ * Register completion, hover and signature help for one model. The disposables are the
+ * caller's to hold: Monaco's registry outlives any editor, and a provider left behind would
+ * answer for a model that no longer exists.
+ */
+declare function registerRedisLanguage(monaco: MonacoModule, modelPath: string, hooks: RedisLanguageHooks, languageId?: string): IDisposable[];
+/**
+ * The owner Monaco files this package's markers under.
+ */
+declare const REDIS_MARKER_OWNER = "inkstone-redis";
+/**
+ * Put `markers` on the model as Monaco's own, replacing this package's last set; the words
+ * beside each code are the host's, handed in per code.
+ */
+declare function setRedisMarkers(monaco: MonacoModule, model: editor.ITextModel, markers: readonly RedisMarker[], wording: (marker: RedisMarker) => string): void;
+//#endregion
+export { MonacoModule, REDIS_LANGUAGE_ID, REDIS_MARKER_OWNER, RedisLanguageHooks, defineRedisLanguage, registerRedisLanguage, setRedisMarkers };