@coldsmirk/inkstone-redis 0.22.0

package/dist/monaco.js

@@ -0,0 +1,184 @@
+import { t as REDIS_COMMANDS } from "./commands-BMa2ec02.js";
+//#region src/monaco.ts
+const REDIS_LANGUAGE_ID = "redis";
+const LANGUAGES_KEY = Symbol.for("coldsmirk.inkstone.redis.languages");
+function definedLanguages(monaco) {
+	const holder = globalThis;
+	const registry = holder[LANGUAGES_KEY] ?? /* @__PURE__ */ new WeakMap();
+	holder[LANGUAGES_KEY] = registry;
+	const existing = registry.get(monaco);
+	if (existing) return existing;
+	const created = /* @__PURE__ */ new Set();
+	registry.set(monaco, created);
+	return created;
+}
+function grammar(commands) {
+	const names = /* @__PURE__ */ new Set();
+	const tokens = /* @__PURE__ */ new Set();
+	for (const command of commands) {
+		const [container, sub] = command.name.split(" ");
+		names.add(container);
+		if (sub !== void 0) tokens.add(sub);
+		for (const token of command.tokens) tokens.add(token);
+	}
+	return {
+		ignoreCase: true,
+		unicode: true,
+		commands: [...names],
+		tokens: [...tokens],
+		tokenizer: {
+			root: [
+				[/^(?<blank>\s*)(?<word>[^\s"']+)/u, ["white", { cases: {
+					"$2@commands": "support.function",
+					"@default": "variable"
+				} }]],
+				[/"/u, {
+					token: "string",
+					next: "@double"
+				}],
+				[/'/u, {
+					token: "string",
+					next: "@single"
+				}],
+				[/-?\d+(?:\.\d+)?(?=\s|$)/u, "constant.numeric"],
+				[/[^\s"']+/u, { cases: {
+					"@tokens": "keyword",
+					"@default": "variable"
+				} }],
+				[/\s+/u, "white"]
+			],
+			double: [
+				[/\\x[0-9a-fA-F]{2}/u, "constant.character.escape"],
+				[/\\./u, "constant.character.escape"],
+				[/"/u, {
+					token: "string",
+					next: "@pop"
+				}],
+				[/[^\\"]+/u, "string"],
+				[/\\/u, "string"]
+			],
+			single: [
+				[/\\'/u, "constant.character.escape"],
+				[/'/u, {
+					token: "string",
+					next: "@pop"
+				}],
+				[/[^\\']+/u, "string"],
+				[/\\/u, "string"]
+			]
+		}
+	};
+}
+function defineRedisLanguage(monaco, languageId = REDIS_LANGUAGE_ID, commands = REDIS_COMMANDS) {
+	const defined = definedLanguages(monaco);
+	if (defined.has(languageId)) return;
+	defined.add(languageId);
+	monaco.languages.register({ id: languageId });
+	monaco.languages.setLanguageConfiguration(languageId, {
+		autoClosingPairs: [{
+			open: "\"",
+			close: "\""
+		}, {
+			open: "'",
+			close: "'"
+		}],
+		surroundingPairs: [{
+			open: "\"",
+			close: "\""
+		}, {
+			open: "'",
+			close: "'"
+		}],
+		wordPattern: /[^\s"']+/u
+	});
+	monaco.languages.setMonarchTokensProvider(languageId, grammar(commands));
+}
+function itemKinds(monaco) {
+	const kinds = monaco.languages.CompletionItemKind;
+	return {
+		command: kinds.Function,
+		subcommand: kinds.Method,
+		token: kinds.Keyword
+	};
+}
+function registerRedisLanguage(monaco, modelPath, hooks, languageId = REDIS_LANGUAGE_ID) {
+	const kinds = itemKinds(monaco);
+	const path = monaco.Uri.parse(modelPath).toString();
+	const answering = (model) => model.uri.toString() === path ? hooks.assist() : null;
+	return [
+		monaco.languages.registerCompletionItemProvider(languageId, { provideCompletionItems: (model, position) => {
+			const assist = answering(model);
+			if (assist === null) return { suggestions: [] };
+			const candidates = assist.complete(model.getValue(), model.getOffsetAt(position));
+			const word = model.getWordUntilPosition(position);
+			const range = new monaco.Range(position.lineNumber, word.startColumn, position.lineNumber, word.endColumn);
+			return { suggestions: candidates.map((candidate, index) => {
+				return {
+					label: candidate.label,
+					kind: kinds[candidate.kind],
+					insertText: candidate.insertText,
+					detail: candidate.detail,
+					documentation: candidate.documentation,
+					range,
+					sortText: `${String(candidate.sortGroup)}:${String(index).padStart(4, "0")}`
+				};
+			}) };
+		} }),
+		monaco.languages.registerHoverProvider(languageId, { provideHover: (model, position) => {
+			const assist = answering(model);
+			if (assist === null) return null;
+			const card = assist.hover(model.getValue(), model.getOffsetAt(position));
+			if (card === null) return null;
+			const from = model.getPositionAt(card.from);
+			const to = model.getPositionAt(card.to);
+			return {
+				range: new monaco.Range(from.lineNumber, from.column, to.lineNumber, to.column),
+				contents: card.markdown.map((value) => {
+					return { value };
+				})
+			};
+		} }),
+		monaco.languages.registerSignatureHelpProvider(languageId, {
+			signatureHelpTriggerCharacters: [" "],
+			signatureHelpRetriggerCharacters: [" "],
+			provideSignatureHelp: (model, position) => {
+				const assist = answering(model);
+				if (assist === null) return null;
+				const help = assist.signature(model.getValue(), model.getOffsetAt(position));
+				if (help === null) return null;
+				return {
+					value: {
+						signatures: [{
+							label: help.label,
+							documentation: help.documentation,
+							parameters: help.parameters.map((span) => {
+								return { label: span };
+							})
+						}],
+						activeSignature: 0,
+						activeParameter: help.active
+					},
+					dispose: () => void 0
+				};
+			}
+		})
+	];
+}
+const REDIS_MARKER_OWNER = "inkstone-redis";
+function setRedisMarkers(monaco, model, markers, wording) {
+	const severities = monaco.MarkerSeverity;
+	monaco.editor.setModelMarkers(model, REDIS_MARKER_OWNER, markers.map((marker) => {
+		const from = model.getPositionAt(marker.from);
+		const to = model.getPositionAt(marker.to);
+		return {
+			severity: marker.severity === "error" ? severities.Error : marker.severity === "warning" ? severities.Warning : severities.Hint,
+			message: wording(marker),
+			startLineNumber: from.lineNumber,
+			startColumn: from.column,
+			endLineNumber: to.lineNumber,
+			endColumn: to.column
+		};
+	}));
+}
+//#endregion
+export { REDIS_LANGUAGE_ID, REDIS_MARKER_OWNER, defineRedisLanguage, registerRedisLanguage, setRedisMarkers };

package/dist/react.d.ts

@@ -0,0 +1,95 @@
+import { p as RedisAssist, t as RedisMarker } from "./markers-gZmuOyuR.js";
+import { MonacoModule } from "./monaco.js";
+import { ReactNode } from "react";
+import { editor } from "monaco-editor";
+//#region src/react.d.ts
+/**
+ * What a host reaches into the editor for: inserting at the caret — a key tree is an input
+ * device — and the focus.
+ */
+interface RedisEditorHandle {
+  insert: (text: string) => void;
+  focus: () => void;
+}
+/**
+ * Where the operator is in the document, in offsets — what `runnableLine` reads to decide the
+ * line a run sends. `from` and `to` are the selection's bounds and equal where nothing is
+ * selected. It rides with the text because the two must belong to the same instant: the
+ * controlled `value` is one render behind the keystroke that triggered a run.
+ */
+interface RedisCaret {
+  text: string;
+  from: number;
+  to: number;
+}
+interface RedisEditorProps {
+  value: string;
+  onChange: (value: string) => void;
+  /**
+   * Render with the dark theme; the component never reads the OS `prefers-color-scheme`.
+   *
+   * @default false
+   */
+  dark?: boolean;
+  /**
+   * Editor height in px, or `"fill"` to consume the parent's resolved height (the parent must be
+   * a `min-height: 0` flex item).
+   */
+  height?: number | "fill";
+  fontSize?: number;
+  /**
+   * UI locale for Monaco's chrome — page-global and locked by the first editor to mount.
+   */
+  locale?: "en" | "zh-cn";
+  placeholder?: string;
+  /**
+   * The editor's accessible name, set on Monaco's own input surface.
+   */
+  ariaLabel: string;
+  /**
+   * The Monaco language id the model registers under; the grammar is defined under it.
+   *
+   * @default "redis"
+   */
+  languageId?: string;
+  loading?: ReactNode;
+  failure?: ReactNode;
+  /**
+   * Ctrl/Cmd-Enter — the run key, handed the editor's live caret; the host reads the line to
+   * send off it with `runnableLine`.
+   */
+  onRun?: (caret: RedisCaret) => void;
+  /**
+   * The label the run action shows in Monaco's own chrome.
+   *
+   * @default "Run command"
+   */
+  runActionLabel?: string;
+  /**
+   * The caret moved, or the text under it changed.
+   */
+  onCaret?: (caret: RedisCaret) => void;
+  onReady?: (handle: RedisEditorHandle) => void;
+  /**
+   * Runs after this component's own mount wiring, with the live editor and the monaco module.
+   */
+  onMount?: (instance: editor.IStandaloneCodeEditor, monaco: MonacoModule) => void;
+  /**
+   * What completion, hover and signature help answer from; none of the three without it.
+   */
+  assist?: RedisAssist;
+  /**
+   * The words each line marker shows, per code (`lineMarkers`) — the host's language. No
+   * markers are drawn without it.
+   */
+  markerWording?: (marker: RedisMarker) => string;
+}
+/**
+ * The command-line editing surface: Monaco under the `redis` grammar, one command a line, the
+ * run key handing the caret over, the table's completion, hover and signature help wired
+ * 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;
+//#endregion
+export { RedisCaret, RedisEditor, RedisEditorHandle, RedisEditorProps };

package/dist/react.js

@@ -0,0 +1,104 @@
+import { t as lineMarkers } from "./markers-BlM8eKCj.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";
+import { jsx } from "react/jsx-runtime";
+//#region src/react.tsx
+const EDITOR_ID_KEY = Symbol.for("coldsmirk.inkstone.redis.editorId");
+function nextEditorId() {
+	const holder = globalThis;
+	const id = holder[EDITOR_ID_KEY] ?? 0;
+	holder[EDITOR_ID_KEY] = id + 1;
+	return id;
+}
+function useLatest(value) {
+	const ref = useRef(value);
+	useInsertionEffect(() => {
+		ref.current = value;
+	});
+	return ref;
+}
+function caretOf(instance) {
+	const model = instance.getModel();
+	const selection = instance.getSelection();
+	if (model === null || selection === null) return {
+		text: "",
+		from: 0,
+		to: 0
+	};
+	return {
+		text: model.getValue(),
+		from: model.getOffsetAt(selection.getStartPosition()),
+		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 }) {
+	const [modelPath] = useState(() => `file:///inkstone-redis/${String(nextEditorId())}.redis`);
+	const bindings = useRef([]);
+	const assistRef = useLatest(assist ?? null);
+	const runRef = useLatest(onRun);
+	const caretChangedRef = useLatest(onCaret);
+	const readyRef = useLatest(onReady);
+	const mountRef = useLatest(onMount);
+	const wordingRef = useLatest(markerWording);
+	useEffect(() => () => {
+		for (const binding of bindings.current) binding.dispose();
+		bindings.current = [];
+	}, []);
+	const fill = height === "fill";
+	return /* @__PURE__ */ jsx("div", {
+		style: fill ? {
+			height: "100%",
+			minHeight: 0
+		} : { height },
+		children: /* @__PURE__ */ jsx(MonacoEditor, {
+			showLineNumbers: true,
+			dark,
+			failure,
+			fontSize,
+			height: fill ? "100%" : height,
+			language: languageId,
+			loading,
+			locale,
+			options: { ariaLabel },
+			path: modelPath,
+			placeholder,
+			value,
+			beforeMount: (monaco) => {
+				defineRedisLanguage(monaco, languageId);
+			},
+			onChange,
+			onMount: (live, monaco) => {
+				const mark = () => {
+					const model = live.getModel();
+					const wording = wordingRef.current;
+					if (model !== null && wording !== void 0) setRedisMarkers(monaco, model, lineMarkers(model.getValue()), wording);
+				};
+				bindings.current.push(live.onDidChangeCursorSelection(() => caretChangedRef.current?.(caretOf(live))), live.onDidChangeModelContent(mark), live.addAction({
+					id: "inkstone-redis.run",
+					label: runActionLabel,
+					keybindings: [monaco.KeyMod.CtrlCmd | monaco.KeyCode.Enter],
+					run: (current) => runRef.current?.(caretOf(current))
+				}), ...registerRedisLanguage(monaco, modelPath, { assist: () => assistRef.current }, languageId));
+				mark();
+				readyRef.current?.({
+					insert: (text) => {
+						const selection = live.getSelection();
+						if (selection) live.executeEdits("inkstone-redis-insert", [{
+							range: selection,
+							text,
+							forceMoveMarkers: true
+						}]);
+						live.focus();
+					},
+					focus: () => {
+						live.focus();
+					}
+				});
+				mountRef.current?.(live, monaco);
+			}
+		})
+	});
+}
+//#endregion
+export { RedisEditor };

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@coldsmirk/inkstone-redis",
+  "version": "0.22.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",
+    "monaco",
+    "completion",
+    "editor",
+    "autocomplete"
+  ],
+  "homepage": "https://github.com/coldsmirk/inkstone/tree/main/packages/redis#readme",
+  "bugs": "https://github.com/coldsmirk/inkstone/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/coldsmirk/inkstone.git",
+    "directory": "packages/redis"
+  },
+  "license": "UNLICENSED",
+  "author": {
+    "name": "Venus"
+  },
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./monaco": {
+      "types": "./dist/monaco.d.ts",
+      "default": "./dist/monaco.js"
+    },
+    "./react": {
+      "types": "./dist/react.d.ts",
+      "default": "./dist/react.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "monaco-editor": "^0.56.0",
+    "react": "^19.2.8",
+    "react-dom": "^19.2.8",
+    "@coldsmirk/inkstone-react": "^0.22.0"
+  },
+  "peerDependencies": {
+    "monaco-editor": "^0.56.0",
+    "react": ">=19",
+    "@coldsmirk/inkstone-react": "^0.22.0"
+  },
+  "peerDependenciesMeta": {
+    "@coldsmirk/inkstone-react": {
+      "optional": true
+    },
+    "monaco-editor": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "clean": "rimraf dist",
+    "typecheck": "tsc --noEmit"
+  }
+}