@coldsmirk/inkstone-elasticsearch 0.30.0 → 0.32.0

package/README.md

@@ -9,7 +9,7 @@ Part of [inkstone](https://github.com/coldsmirk/inkstone). Built for the [**poly
 - **`@coldsmirk/inkstone-elasticsearch`** — the framework-free core: the request reader, the endpoint table, the body vocabulary, the assist, the markers. Zero editor dependencies.
 - **`@coldsmirk/inkstone-elasticsearch/monaco`** — `defineElasticsearchLanguage(monaco)` (the `elasticsearch` id with its Monarch grammar, once per monaco module), `registerElasticsearchLanguage(monaco, modelPath, hooks)` (completion and hover for one model), `setElasticsearchMarkers`. Peer: `monaco-editor`.
 - **`@coldsmirk/inkstone-elasticsearch/codemirror`** — the same assist bound to CodeMirror 6: `elasticsearchCompletion(assist)` and `elasticsearchBodyCompletion(assist)` (completion sources), `elasticsearchHover(assist, wording)`, `elasticsearchDiagnostics(markers, wording)`. No grammar of its own — a body is JSON, so pair it with `@codemirror/lang-json`; it does not close brackets or quotes either, so add `closeBrackets()` where a key's own quotes matter. Peers: `@codemirror/autocomplete`, `@codemirror/view`.
-- **`@coldsmirk/inkstone-elasticsearch/react`** — `<ElasticsearchEditor>`: a controlled request 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 index trees, and the markers refreshed on every change. Peers: `monaco-editor`, `react`.
+- **`@coldsmirk/inkstone-elasticsearch/react`** — `<ElasticsearchEditor>`: a controlled request 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 index trees, and the markers refreshed on every change. Peers: `monaco-editor`, `react`.
 
 ## The shape
 

package/dist/codemirror.d.ts

@@ -10,23 +10,22 @@ import { Extension } from "@codemirror/state";
  * places `./monaco` names as trigger characters, and the engine half answers nothing where
  * the caret is nowhere in particular.
  */
-declare function elasticsearchCompletion(assist: ElasticsearchAssist): CompletionSource;
+export declare function elasticsearchCompletion(assist: ElasticsearchAssist): CompletionSource;
 /**
  * Completion over a body standing on its own — a one-line filter field, whose document is a
  * `query` object and nothing else (`createElasticsearchBodyAssist`).
  */
-declare function elasticsearchBodyCompletion(assist: ElasticsearchBodyAssist): CompletionSource;
+export declare function elasticsearchBodyCompletion(assist: ElasticsearchBodyAssist): CompletionSource;
 /**
  * The endpoint's card under the pointer, as `./monaco`'s hover provider gives it.
  *
  * The markdown is handed over as text: rendering it is the host's, since a tooltip's DOM is
  * the host's design and this package ships none.
  */
-declare function elasticsearchHover(assist: ElasticsearchAssist, render: (markdown: string[]) => HTMLElement): Extension;
+export declare function elasticsearchHover(assist: ElasticsearchAssist, render: (markdown: string[]) => HTMLElement): Extension;
 /**
  * This package's markers as CodeMirror's diagnostics, the words beside each code the host's,
  * as `setElasticsearchMarkers` takes them.
  */
-declare function elasticsearchDiagnostics(markers: readonly ElasticsearchMarker[], wording: (marker: ElasticsearchMarker) => string): Diagnostic[];
-//#endregion
-export { elasticsearchBodyCompletion, elasticsearchCompletion, elasticsearchDiagnostics, elasticsearchHover };
+export declare function elasticsearchDiagnostics(markers: readonly ElasticsearchMarker[], wording: (marker: ElasticsearchMarker) => string): Diagnostic[];
+//#endregion

package/dist/monaco.d.ts

@@ -5,17 +5,17 @@ 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 request under.
  */
-declare const ELASTICSEARCH_LANGUAGE_ID = "elasticsearch";
+export declare const ELASTICSEARCH_LANGUAGE_ID = "elasticsearch";
 /**
  * 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`).
  */
-declare function defineElasticsearchLanguage(monaco: MonacoModule, languageId?: string): void;
-interface ElasticsearchLanguageHooks {
+export declare function defineElasticsearchLanguage(monaco: MonacoModule, languageId?: string): void;
+export interface ElasticsearchLanguageHooks {
   /**
    * 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.
@@ -26,15 +26,14 @@ interface ElasticsearchLanguageHooks {
  * Register completion and hover for one model. The disposables are the caller's to hold:
  * Monaco's registry outlives any editor.
  */
-declare function registerElasticsearchLanguage(monaco: MonacoModule, modelPath: string, hooks: ElasticsearchLanguageHooks, languageId?: string): IDisposable[];
+export declare function registerElasticsearchLanguage(monaco: MonacoModule, modelPath: string, hooks: ElasticsearchLanguageHooks, languageId?: string): IDisposable[];
 /**
  * The owner Monaco files this package's markers under.
  */
-declare const ELASTICSEARCH_MARKER_OWNER = "inkstone-elasticsearch";
+export declare const ELASTICSEARCH_MARKER_OWNER = "inkstone-elasticsearch";
 /**
  * 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 setElasticsearchMarkers(monaco: MonacoModule, model: editor.ITextModel, markers: readonly ElasticsearchMarker[], wording: (marker: ElasticsearchMarker) => string): void;
-//#endregion
-export { ELASTICSEARCH_LANGUAGE_ID, ELASTICSEARCH_MARKER_OWNER, ElasticsearchLanguageHooks, MonacoModule, defineElasticsearchLanguage, registerElasticsearchLanguage, setElasticsearchMarkers };
+export declare function setElasticsearchMarkers(monaco: MonacoModule, model: editor.ITextModel, markers: readonly ElasticsearchMarker[], wording: (marker: ElasticsearchMarker) => string): void;
+//#endregion

package/dist/react.d.ts

@@ -1,78 +1,30 @@
 import { a as ElasticsearchAssist, t as ElasticsearchMarker } from "./markers-CCVlVnBt.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 — an index tree is an input
  * device — and the focus.
  */
-interface ElasticsearchEditorHandle {
-  insert: (text: string) => void;
-  focus: () => void;
-}
+export type ElasticsearchEditorHandle = ConsoleEditorHandle;
 /**
  * Where the operator is in the document, in offsets — what `runnableRequest` reads to decide
- * the request a run sends. `from` and `to` are the selection's bounds and equal where nothing
- * is selected; the text rides with them because the two must belong to the same instant.
+ * the request a run sends.
  */
-interface ElasticsearchCaret {
-  text: string;
-  from: number;
-  to: number;
-}
-interface ElasticsearchEditorProps {
-  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 ElasticsearchCaret = ConsoleCaret;
+export interface ElasticsearchEditorProps extends ConsoleEditorProps<ElasticsearchEditorHandle> {
   /**
    * The Monaco language id the model registers under; the grammar is defined under it.
    *
    * @default "elasticsearch"
    */
   languageId?: string;
-  loading?: ReactNode;
-  failure?: ReactNode;
-  /**
-   * Ctrl/Cmd-Enter — the run key, handed the editor's live caret; the host reads the request
-   * to send off it with `runnableRequest`.
-   */
-  onRun?: (caret: ElasticsearchCaret) => void;
   /**
    * The label the run action shows in Monaco's own chrome.
    *
    * @default "Run request"
    */
   runActionLabel?: string;
-  /**
-   * The caret moved, or the text under it changed.
-   */
-  onCaret?: (caret: ElasticsearchCaret) => void;
-  onReady?: (handle: ElasticsearchEditorHandle) => 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 and hover answer from; neither without it.
    */
@@ -82,19 +34,12 @@ interface ElasticsearchEditorProps {
    * markers are drawn without it.
    */
   markerWording?: (marker: ElasticsearchMarker) => 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 request editing surface: Monaco under the `elasticsearch` grammar, one or more requests
- * in the console's spelling, the run key handing the caret over, completion and hover wired
- * through `registerElasticsearchLanguage`, and the markers refreshed on every change.
+ * The request editing surface: `<MonacoConsoleEditor>` under the `elasticsearch` grammar, one or
+ * more requests in the console's spelling, the run key handing the caret over (`runnableRequest`
+ * reads the request to send off it), completion and hover wired through
+ * `registerElasticsearchLanguage`, and the markers refreshed on every change.
  */
-declare function ElasticsearchEditor({ value, onChange, dark, height, fontSize, locale, placeholder, ariaLabel, languageId, loading, failure, onRun, runActionLabel, onCaret, onReady, onMount, assist, markerWording, options }: ElasticsearchEditorProps): import("react").JSX.Element;
-//#endregion
-export { ElasticsearchCaret, ElasticsearchEditor, ElasticsearchEditorHandle, ElasticsearchEditorProps };
+export declare function ElasticsearchEditor({ languageId, runActionLabel, assist, markerWording, ...props }: ElasticsearchEditorProps): ReactNode;
+//#endregion

package/dist/react.js

@@ -1,106 +1,32 @@
 import { t as requestMarkers } from "./markers-DDAAW21w.js";
 import { ELASTICSEARCH_LANGUAGE_ID, defineElasticsearchLanguage, registerElasticsearchLanguage, setElasticsearchMarkers } 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.elasticsearch.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 ElasticsearchEditor({ value, onChange, dark = false, height = 200, fontSize, locale, placeholder, ariaLabel, languageId = ELASTICSEARCH_LANGUAGE_ID, loading, failure, onRun, runActionLabel = "Run request", onCaret, onReady, onMount, assist, markerWording, options }) {
-	const [modelPath] = useState(() => `file:///inkstone-elasticsearch/${String(nextEditorId())}.es`);
-	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) => {
-				defineElasticsearchLanguage(monaco, languageId);
-			},
-			onChange,
-			onMount: (live, monaco) => {
-				const mark = () => {
-					const model = live.getModel();
-					const wording = wordingRef.current;
-					if (model !== null && wording !== void 0) setElasticsearchMarkers(monaco, model, requestMarkers(model.getValue()), wording);
-				};
-				bindings.current.push(live.onDidChangeCursorSelection(() => caretChangedRef.current?.(caretOf(live))), live.onDidChangeModelContent(mark), live.addAction({
-					id: "inkstone-elasticsearch.run",
-					label: runActionLabel,
-					keybindings: [monaco.KeyMod.CtrlCmd | monaco.KeyCode.Enter],
-					run: (current) => runRef.current?.(caretOf(current))
-				}), ...registerElasticsearchLanguage(monaco, modelPath, { assist: () => assistRef.current }, languageId));
-				mark();
-				readyRef.current?.({
-					insert: (text) => {
-						const selection = live.getSelection();
-						if (selection) live.executeEdits("inkstone-elasticsearch-insert", [{
-							range: selection,
-							text,
-							forceMoveMarkers: true
-						}]);
-						live.focus();
-					},
-					focus: () => {
-						live.focus();
-					}
-				});
-				mountRef.current?.(live, monaco);
-			}
-		})
+function ElasticsearchEditor({ languageId = ELASTICSEARCH_LANGUAGE_ID, runActionLabel = "Run request", assist, markerWording, ...props }) {
+	return /* @__PURE__ */ jsx(MonacoConsoleEditor, {
+		...props,
+		context: {
+			assist,
+			markerWording
+		},
+		extension: "es",
+		language: languageId,
+		namespace: "inkstone-elasticsearch",
+		runActionLabel,
+		beforeMount: (monaco) => {
+			defineElasticsearchLanguage(monaco, languageId);
+		},
+		register: ({ monaco, editor, path, context }) => {
+			const mark = () => {
+				const model = editor.getModel();
+				const wording = context().markerWording;
+				if (model !== null && wording !== void 0) setElasticsearchMarkers(monaco, model, requestMarkers(model.getValue()), wording);
+			};
+			const registered = [editor.onDidChangeModelContent(mark), ...registerElasticsearchLanguage(monaco, path, { assist: () => context().assist ?? null }, languageId)];
+			mark();
+			return registered;
+		}
 	});
 }
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coldsmirk/inkstone-elasticsearch",
-  "version": "0.30.0",
+  "version": "0.32.0",
   "description": "Elasticsearch request editing intelligence for Monaco and CodeMirror: the console spelling (a method and a path, the body after), endpoint and index completion, body keys by context — a bare `_search` body included — request markers, and a drop-in React request editor.",
   "keywords": [
     "elasticsearch",
@@ -50,21 +50,20 @@
   "devDependencies": {
     "@codemirror/autocomplete": "^6.20.3",
     "@codemirror/lint": "^6.9.7",
-    "@codemirror/state": "^6.6.0",
-    "@codemirror/view": "^6.43.0",
-    "monaco-editor": "^0.56.0",
-    "react": "^19.2.8",
-    "react-dom": "^19.2.8",
-    "@coldsmirk/inkstone-react": "^0.30.0"
+    "@codemirror/state": "^6.7.6",
+    "@codemirror/view": "^6.43.14",
+    "monaco-editor": "^0.57.0",
+    "react": "^19.3.0",
+    "@coldsmirk/inkstone-react": "^0.32.0"
   },
   "peerDependencies": {
     "@codemirror/autocomplete": "^6.20.3",
     "@codemirror/lint": "^6.9.7",
     "@codemirror/state": "^6.6.0",
     "@codemirror/view": "^6.43.0",
-    "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": {
     "@codemirror/autocomplete": {