@coldsmirk/inkstone-redis 0.22.0 → 0.24.0

package/dist/index.d.ts

@@ -1,2 +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 };
+import { C as REDIS_COMMANDS, S as createRedisVocabulary, T as RedisCommand, _ as RedisCompletionCandidate, a as LineRefusal, b as createRedisAssist, c as SplitLine, d as runnableLine, f as spellWord, g as RedisCatalog, h as RedisAssist, i as LineRead, l as lineBounds, m as CatalogKey, n as RedisMarkerCode, o as LineWord, p as splitLine, r as lineMarkers, s as RunnableLine, t as RedisMarker, u as readLine, v as RedisHoverCard, w as REDIS_VERSION, x as RedisVocabulary, y as RedisSignatureHelp } from "./markers-Bmqe2Tjf.js";
+export { type CatalogKey, type LineRead, type LineRefusal, type LineWord, REDIS_COMMANDS, REDIS_VERSION, type RedisAssist, type RedisCatalog, type RedisCommand, type RedisCompletionCandidate, type RedisHoverCard, type RedisMarker, type RedisMarkerCode, type RedisSignatureHelp, type RedisVocabulary, type RunnableLine, type SplitLine, createRedisAssist, createRedisVocabulary, lineBounds, lineMarkers, readLine, runnableLine, spellWord, splitLine };

package/dist/index.js

@@ -1,6 +1,12 @@
-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";
+import { a as runnableLine, i as readLine, n as createRedisVocabulary, o as spellWord, r as lineBounds, s as splitLine, t as lineMarkers } from "./markers-DFpfcLLE.js";
+import { n as REDIS_VERSION, t as REDIS_COMMANDS } from "./commands-B2cgDRf7.js";
 //#region src/assist.ts
+const NO_CATALOG = { keys: () => [] };
+function keyAt(command, index) {
+	if (command.keys === void 0) return false;
+	const [first, last, step] = command.keys;
+	return index >= first && (index - first) % step === 0 && (last < 0 || index <= last);
+}
 function argumentsOf(command) {
 	const rest = command.syntax.slice(command.name.length).trim();
 	return rest === "" ? void 0 : rest;
@@ -11,7 +17,7 @@ function documentationOf(command) {
 	const text = parts.filter((part) => part !== "").join("\n\n");
 	return text === "" ? void 0 : text;
 }
-function createRedisAssist(vocabulary = createRedisVocabulary()) {
+function createRedisAssist(catalog = NO_CATALOG, vocabulary = createRedisVocabulary()) {
 	const top = vocabulary.commands.filter((command) => !command.name.includes(" "));
 	return {
 		complete: (text, offset) => {
@@ -42,15 +48,26 @@ function createRedisAssist(vocabulary = createRedisVocabulary()) {
 			});
 			const resolved = vocabulary.resolve(names);
 			if (resolved === null || read.index < resolved.consumed) return [];
-			return resolved.command.tokens.map((token) => {
+			const { command } = resolved;
+			const tokens = command.tokens.map((token) => {
 				return {
 					label: token,
 					kind: "token",
 					insertText: token,
-					detail: resolved.command.name,
-					sortGroup: 2
+					detail: command.name,
+					sortGroup: 3
 				};
 			});
+			if (!keyAt(command, read.index)) return tokens;
+			return [...catalog.keys().map((key) => {
+				return {
+					label: key.name,
+					kind: "key",
+					insertText: spellWord(key.name),
+					...key.type !== "" && { detail: key.type },
+					sortGroup: 2
+				};
+			}), ...tokens];
 		},
 		hover: (text, offset) => {
 			const read = readLine(text, offset);
@@ -82,4 +99,4 @@ function createRedisAssist(vocabulary = createRedisVocabulary()) {
 	};
 }
 //#endregion
-export { REDIS_COMMANDS, REDIS_VERSION, createRedisAssist, createRedisVocabulary, lineBounds, lineMarkers, readLine, runnableLine, splitLine };
+export { REDIS_COMMANDS, REDIS_VERSION, createRedisAssist, createRedisVocabulary, lineBounds, lineMarkers, readLine, runnableLine, spellWord, splitLine };

package/dist/{markers-gZmuOyuR.d.ts → markers-Bmqe2Tjf.d.ts}

@@ -27,6 +27,14 @@ interface RedisCommand {
    * Every fixed word the arguments take (`NX`, `EX`, `WITHSCORES`), uppercased, sorted.
    */
   tokens: string[];
+  /**
+   * Where the call's keys stand, as `COMMAND` states it: the first key's word (the name is
+   * word 0), the last's — negative counts back from the call's end — and the step from one
+   * key to the next. `[1, 1, 1]` for `GET key`, `[1, -1, 1]` for `DEL key [key ...]`,
+   * `[1, -1, 2]` for `MSET key value [key value ...]`. Absent where the call takes no key,
+   * and where only its own arguments can say which words are keys (`EVAL`, `GEORADIUS`).
+   */
+  keys?: [first: number, last: number, step: number];
   /**
    * The version that deprecated it, where one did.
    */
@@ -65,12 +73,30 @@ declare function createRedisVocabulary(commands?: readonly RedisCommand[]): Redi
 //#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.
+ * One key as the catalog lists it, with the type the keyspace answered for it.
+ */
+interface CatalogKey {
+  name: string;
+  /**
+   * `string`, `hash`, `list`, … as `TYPE` answers; `""` where the catalog read none.
+   */
+  type: string;
+}
+/**
+ * The keyspace as the host lists it — and it MUST be a cache-backed read (the tree's own
+ * list), never a fresh one: completion reads it on every keystroke in a key.
+ */
+interface RedisCatalog {
+  keys: () => readonly CatalogKey[];
+}
+/**
+ * One suggestion: a command's name at the line's start, a container's subcommand after it, a
+ * key of the keyspace where the command takes one, or a fixed word of the command's own syntax
+ * (`NX`, `WITHSCORES`) anywhere after.
  */
 interface RedisCompletionCandidate {
   label: string;
-  kind: "command" | "subcommand" | "token";
+  kind: "command" | "subcommand" | "key" | "token";
   insertText: string;
   detail?: string;
   documentation?: string;
@@ -124,7 +150,7 @@ interface RedisAssist {
  * `readLine` — redis-cli's own splitting — so they can never disagree about which word the
  * caret is on.
  */
-declare function createRedisAssist(vocabulary?: RedisVocabulary): RedisAssist;
+declare function createRedisAssist(catalog?: RedisCatalog, vocabulary?: RedisVocabulary): RedisAssist;
 //#endregion
 //#region src/line.d.ts
 /**
@@ -169,6 +195,14 @@ interface SplitLine {
  * The words of one line, redis-cli's way.
  */
 declare function splitLine(line: string): SplitLine;
+/**
+ * One word spelled as a line this reader splits back into exactly it: bare where every
+ * character of it stands on its own, and double-quoted with that form's own escapes where one
+ * does not — a blank, either quote, a backslash or a character below the printable range. The
+ * inverse of [`splitLine`], for a word something other than the reader puts on a line: a key a
+ * completion inserts, a name a tool writes.
+ */
+declare function spellWord(word: string): string;
 /**
  * The line the caret is on, read: its bounds in the whole text, its words, and where among
  * them the caret stands.
@@ -241,4 +275,4 @@ interface RedisMarker {
  */
 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 };
+export { REDIS_COMMANDS as C, createRedisVocabulary as S, RedisCommand as T, RedisCompletionCandidate as _, LineRefusal as a, createRedisAssist as b, SplitLine as c, runnableLine as d, spellWord as f, RedisCatalog as g, RedisAssist as h, LineRead as i, lineBounds as l, CatalogKey as m, RedisMarkerCode as n, LineWord as o, splitLine as p, lineMarkers as r, RunnableLine as s, RedisMarker as t, readLine as u, RedisHoverCard as v, REDIS_VERSION as w, RedisVocabulary as x, RedisSignatureHelp as y };

package/dist/{markers-BlM8eKCj.js → markers-DFpfcLLE.js}

@@ -1,4 +1,4 @@
-import { t as REDIS_COMMANDS } from "./commands-BMa2ec02.js";
+import { t as REDIS_COMMANDS } from "./commands-B2cgDRf7.js";
 //#region src/line.ts
 const ESCAPES = {
 	n: "\n",
@@ -7,6 +7,11 @@ const ESCAPES = {
 	b: "\b",
 	a: String.fromCodePoint(7)
 };
+const NAMED = new Map([
+	...Object.entries(ESCAPES).map(([escape, character]) => [character, escape]),
+	["\"", "\""],
+	["\\", "\\"]
+]);
 function blank(character) {
 	return /\s/u.test(character);
 }
@@ -111,6 +116,14 @@ function splitLine(line) {
 		refusal: null
 	};
 }
+function spellWord(word) {
+	if (word !== "" && !/["'\\\s\p{Cc}]/u.test(word)) return word;
+	return `"${[...word].map((character) => {
+		const escape = NAMED.get(character);
+		if (escape !== void 0) return `\\${escape}`;
+		return /\p{Cc}/u.test(character) ? String.raw`\x${character.codePointAt(0).toString(16).padStart(2, "0")}` : character;
+	}).join("")}"`;
+}
 function lineBounds(text, offset) {
 	const lineStart = text.lastIndexOf("\n", offset - 1) + 1;
 	const next = text.indexOf("\n", offset);
@@ -247,4 +260,4 @@ function lineMarkers(text, vocabulary = DEFAULT_VOCABULARY) {
 	return markers;
 }
 //#endregion
-export { runnableLine as a, readLine as i, createRedisVocabulary as n, splitLine as o, lineBounds as r, lineMarkers as t };
+export { runnableLine as a, readLine as i, createRedisVocabulary as n, spellWord as o, lineBounds as r, splitLine as s, lineMarkers as t };

package/dist/monaco.d.ts

@@ -1,4 +1,4 @@
-import { S as RedisCommand, p as RedisAssist, t as RedisMarker } from "./markers-gZmuOyuR.js";
+import { T as RedisCommand, h as RedisAssist, t as RedisMarker } from "./markers-Bmqe2Tjf.js";
 import * as monacoEditor from "monaco-editor";
 import { IDisposable, editor } from "monaco-editor";
 //#region src/monaco.d.ts

package/dist/monaco.js

@@ -1,4 +1,4 @@
-import { t as REDIS_COMMANDS } from "./commands-BMa2ec02.js";
+import { t as REDIS_COMMANDS } from "./commands-B2cgDRf7.js";
 //#region src/monaco.ts
 const REDIS_LANGUAGE_ID = "redis";
 const LANGUAGES_KEY = Symbol.for("coldsmirk.inkstone.redis.languages");
@@ -98,6 +98,7 @@ function itemKinds(monaco) {
 	return {
 		command: kinds.Function,
 		subcommand: kinds.Method,
+		key: kinds.Struct,
 		token: kinds.Keyword
 	};
 }

package/dist/react.d.ts

@@ -1,4 +1,4 @@
-import { p as RedisAssist, t as RedisMarker } from "./markers-gZmuOyuR.js";
+import { h as RedisAssist, t as RedisMarker } from "./markers-Bmqe2Tjf.js";
 import { MonacoModule } from "./monaco.js";
 import { ReactNode } from "react";
 import { editor } from "monaco-editor";
@@ -83,6 +83,13 @@ interface RedisEditorProps {
    * markers are drawn without it.
    */
   markerWording?: (marker: RedisMarker) => string;
+  /**
+   * Extra construction options, merged under this editor's own (`ariaLabel`): the escape hatch
+   * a host reaches for a construction option no prop names — `overflowWidgetsDomNode`, where
+   * the page's own layers would otherwise stand over the editor's floating widgets (hover,
+   * completion, parameter hints) left inside it.
+   */
+  options?: editor.IStandaloneEditorConstructionOptions;
 }
 /**
  * The command-line editing surface: Monaco under the `redis` grammar, one command a line, the
@@ -90,6 +97,6 @@ interface RedisEditorProps {
  * through `registerRedisLanguage`, and each line's markers refreshed on every change (they are
  * one split per line, cheap enough to run synchronously).
  */
-declare function RedisEditor({ value, onChange, dark, height, fontSize, locale, placeholder, ariaLabel, languageId, loading, failure, onRun, runActionLabel, onCaret, onReady, onMount, assist, markerWording }: RedisEditorProps): import("react").JSX.Element;
+declare function RedisEditor({ value, onChange, dark, height, fontSize, locale, placeholder, ariaLabel, languageId, loading, failure, onRun, runActionLabel, onCaret, onReady, onMount, assist, markerWording, options }: RedisEditorProps): import("react").JSX.Element;
 //#endregion
 export { RedisCaret, RedisEditor, RedisEditorHandle, RedisEditorProps };

package/dist/react.js

@@ -1,4 +1,4 @@
-import { t as lineMarkers } from "./markers-BlM8eKCj.js";
+import { t as lineMarkers } from "./markers-DFpfcLLE.js";
 import { REDIS_LANGUAGE_ID, defineRedisLanguage, registerRedisLanguage, setRedisMarkers } from "./monaco.js";
 import { MonacoEditor } from "@coldsmirk/inkstone-react/monaco";
 import { useEffect, useInsertionEffect, useRef, useState } from "react";
@@ -32,7 +32,7 @@ function caretOf(instance) {
 		to: model.getOffsetAt(selection.getEndPosition())
 	};
 }
-function RedisEditor({ value, onChange, dark = false, height = 200, fontSize, locale, placeholder, ariaLabel, languageId = REDIS_LANGUAGE_ID, loading, failure, onRun, runActionLabel = "Run command", onCaret, onReady, onMount, assist, markerWording }) {
+function RedisEditor({ value, onChange, dark = false, height = 200, fontSize, locale, placeholder, ariaLabel, languageId = REDIS_LANGUAGE_ID, loading, failure, onRun, runActionLabel = "Run command", onCaret, onReady, onMount, assist, markerWording, options }) {
 	const [modelPath] = useState(() => `file:///inkstone-redis/${String(nextEditorId())}.redis`);
 	const bindings = useRef([]);
 	const assistRef = useLatest(assist ?? null);
@@ -60,7 +60,10 @@ function RedisEditor({ value, onChange, dark = false, height = 200, fontSize, lo
 			language: languageId,
 			loading,
 			locale,
-			options: { ariaLabel },
+			options: {
+				...options,
+				ariaLabel
+			},
 			path: modelPath,
 			placeholder,
 			value,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coldsmirk/inkstone-redis",
-  "version": "0.22.0",
+  "version": "0.24.0",
   "description": "Redis command-line editing intelligence for Monaco: the command table of Redis 7.2 (names, syntax, arity), redis-cli's own line splitting, completion / hover / signature help, line markers, and a drop-in React command editor.",
   "keywords": [
     "redis",
@@ -45,12 +45,12 @@
     "monaco-editor": "^0.56.0",
     "react": "^19.2.8",
     "react-dom": "^19.2.8",
-    "@coldsmirk/inkstone-react": "^0.22.0"
+    "@coldsmirk/inkstone-react": "^0.24.0"
   },
   "peerDependencies": {
     "monaco-editor": "^0.56.0",
     "react": ">=19",
-    "@coldsmirk/inkstone-react": "^0.22.0"
+    "@coldsmirk/inkstone-react": "^0.24.0"
   },
   "peerDependenciesMeta": {
     "@coldsmirk/inkstone-react": {