@coldsmirk/inkstone-redis 0.30.0 → 0.32.0

package/README.md

@@ -8,7 +8,7 @@ Part of [inkstone](https://github.com/coldsmirk/inkstone). Built for the [**poly
 
 - **`@coldsmirk/inkstone-redis`** — the framework-free core: the table, the line reader, the assist, the markers. Zero editor dependencies.
 - **`@coldsmirk/inkstone-redis/monaco`** — `defineRedisLanguage(monaco)` (the `redis` id with its Monarch grammar, once per monaco module), `registerRedisLanguage(monaco, modelPath, hooks)` (completion, hover and signature help for one model), `setRedisMarkers` (the markers as Monaco's own). Peer: `monaco-editor`.
-- **`@coldsmirk/inkstone-redis/react`** — `<RedisEditor>`: a controlled command editor built on `@coldsmirk/inkstone-react`'s `<MonacoEditor>`, with a run key (Ctrl/Cmd-Enter handing over the live caret), caret tracking, an insert handle for key trees, and each line's markers refreshed on every change. Peers: `monaco-editor`, `react`.
+- **`@coldsmirk/inkstone-redis/react`** — `<RedisEditor>`: a controlled command editor built on `@coldsmirk/inkstone-react`'s `<MonacoConsoleEditor>`, with a run key (Ctrl/Cmd-Enter handing over the live caret), caret tracking, an insert handle for key trees, and each line's markers refreshed on every change. Peers: `monaco-editor`, `react`.
 
 ## The shape
 

package/dist/monaco.d.ts

@@ -5,18 +5,18 @@ import { IDisposable, editor } from "monaco-editor";
 /**
  * The monaco module itself, as `onMount` hands it over.
  */
-type MonacoModule = typeof monacoEditor;
+export type MonacoModule = typeof monacoEditor;
 /**
  * The language id the editor registers a command line under.
  */
-declare const REDIS_LANGUAGE_ID = "redis";
+export 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 {
+export declare function defineRedisLanguage(monaco: MonacoModule, languageId?: string, commands?: readonly RedisCommand[]): void;
+export 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.
@@ -28,15 +28,14 @@ interface RedisLanguageHooks {
  * 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[];
+export 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";
+export 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 };
+export declare function setRedisMarkers(monaco: MonacoModule, model: editor.ITextModel, markers: readonly RedisMarker[], wording: (marker: RedisMarker) => string): void;
+//#endregion

package/dist/react.d.ts

@@ -1,79 +1,30 @@
 import { h as RedisAssist, t as RedisMarker } from "./markers-Bmqe2Tjf.js";
-import { MonacoModule } from "./monaco.js";
+import { ConsoleCaret, ConsoleEditorHandle, ConsoleEditorProps } from "@coldsmirk/inkstone-react/monaco";
 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;
-}
+export type RedisEditorHandle = ConsoleEditorHandle;
 /**
  * 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.
+ * line a run sends.
  */
-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;
+export type RedisCaret = ConsoleCaret;
+export interface RedisEditorProps extends ConsoleEditorProps<RedisEditorHandle> {
   /**
    * 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.
    */
@@ -83,20 +34,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
- * 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).
+ * The command-line editing surface: `<MonacoConsoleEditor>` under the `redis` grammar, one
+ * command a line, the run key handing the caret over (`runnableLine` reads the line to send off
+ * it), 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, options }: RedisEditorProps): import("react").JSX.Element;
-//#endregion
-export { RedisCaret, RedisEditor, RedisEditorHandle, RedisEditorProps };
+export declare function RedisEditor({ languageId, runActionLabel, assist, markerWording, ...props }: RedisEditorProps): ReactNode;
+//#endregion

package/dist/react.js

@@ -1,106 +1,32 @@
 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";
+import { MonacoConsoleEditor } from "@coldsmirk/inkstone-react/monaco";
 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, options }) {
-	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: {
-				...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);
-			}
-		})
+function RedisEditor({ languageId = REDIS_LANGUAGE_ID, runActionLabel = "Run command", assist, markerWording, ...props }) {
+	return /* @__PURE__ */ jsx(MonacoConsoleEditor, {
+		...props,
+		context: {
+			assist,
+			markerWording
+		},
+		extension: "redis",
+		language: languageId,
+		namespace: "inkstone-redis",
+		runActionLabel,
+		beforeMount: (monaco) => {
+			defineRedisLanguage(monaco, languageId);
+		},
+		register: ({ monaco, editor, path, context }) => {
+			const mark = () => {
+				const model = editor.getModel();
+				const wording = context().markerWording;
+				if (model !== null && wording !== void 0) setRedisMarkers(monaco, model, lineMarkers(model.getValue()), wording);
+			};
+			const registered = [editor.onDidChangeModelContent(mark), ...registerRedisLanguage(monaco, path, { assist: () => context().assist ?? null }, languageId)];
+			mark();
+			return registered;
+		}
 	});
 }
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coldsmirk/inkstone-redis",
-  "version": "0.30.0",
+  "version": "0.32.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",
@@ -42,15 +42,14 @@
     "dist"
   ],
   "devDependencies": {
-    "monaco-editor": "^0.56.0",
-    "react": "^19.2.8",
-    "react-dom": "^19.2.8",
-    "@coldsmirk/inkstone-react": "^0.30.0"
+    "monaco-editor": "^0.57.0",
+    "react": "^19.3.0",
+    "@coldsmirk/inkstone-react": "^0.32.0"
   },
   "peerDependencies": {
-    "monaco-editor": "^0.56.0",
+    "monaco-editor": "^0.57.0",
     "react": ">=19",
-    "@coldsmirk/inkstone-react": "^0.30.0"
+    "@coldsmirk/inkstone-react": "^0.32.0"
   },
   "peerDependenciesMeta": {
     "@coldsmirk/inkstone-react": {