@coldsmirk/inkstone-elasticsearch 0.22.0

package/dist/monaco.d.ts

@@ -0,0 +1,40 @@
+import { a as ElasticsearchAssist, t as ElasticsearchMarker } from "./markers-BctX905j.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 request under.
+ */
+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 {
+  /**
+   * 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: () => ElasticsearchAssist | null;
+}
+/**
+ * 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[];
+/**
+ * The owner Monaco files this package's markers under.
+ */
+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 };

package/dist/monaco.js

@@ -0,0 +1,145 @@
+//#region src/monaco.ts
+const ELASTICSEARCH_LANGUAGE_ID = "elasticsearch";
+const LANGUAGES_KEY = Symbol.for("coldsmirk.inkstone.elasticsearch.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() {
+	return {
+		ignoreCase: true,
+		unicode: true,
+		tokenizer: { root: [
+			[/^(?<blank>\s*)(?<method>get|post|put|delete|head|patch)(?<gap>\s+)(?<path>\/[^\s?]*)(?<query>\S*)/u, [
+				"white",
+				"keyword",
+				"white",
+				"entity.name.function",
+				"variable"
+			]],
+			[/"(?:[^"\\]|\\.)*"(?=\s*:)/u, "support.type.property-name.json"],
+			[/"(?:[^"\\]|\\.)*"/u, "string"],
+			[/-?\d+(?:\.\d+)?(?:e[+-]?\d+)?/u, "constant.numeric"],
+			[/\b(?:true|false|null)\b/u, "constant.language"],
+			[/[{}[\]]/u, "delimiter.bracket"],
+			[/[,:]/u, "delimiter"],
+			[/\s+/u, "white"],
+			[/[^\s"{}[\],:]+/u, "variable"]
+		] }
+	};
+}
+function defineElasticsearchLanguage(monaco, languageId = ELASTICSEARCH_LANGUAGE_ID) {
+	const defined = definedLanguages(monaco);
+	if (defined.has(languageId)) return;
+	defined.add(languageId);
+	monaco.languages.register({ id: languageId });
+	monaco.languages.setLanguageConfiguration(languageId, {
+		brackets: [["{", "}"], ["[", "]"]],
+		autoClosingPairs: [
+			{
+				open: "{",
+				close: "}"
+			},
+			{
+				open: "[",
+				close: "]"
+			},
+			{
+				open: "\"",
+				close: "\"",
+				notIn: ["string"]
+			}
+		],
+		surroundingPairs: [
+			{
+				open: "{",
+				close: "}"
+			},
+			{
+				open: "[",
+				close: "]"
+			},
+			{
+				open: "\"",
+				close: "\""
+			}
+		],
+		wordPattern: /[^\s"{}[\],:]+/u
+	});
+	monaco.languages.setMonarchTokensProvider(languageId, grammar());
+}
+function itemKinds(monaco) {
+	const kinds = monaco.languages.CompletionItemKind;
+	return {
+		method: kinds.Keyword,
+		endpoint: kinds.Function,
+		index: kinds.Struct,
+		alias: kinds.Interface,
+		key: kinds.Field
+	};
+}
+function registerElasticsearchLanguage(monaco, modelPath, hooks, languageId = ELASTICSEARCH_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, {
+		triggerCharacters: [
+			"/",
+			"\"",
+			"_"
+		],
+		provideCompletionItems: (model, position) => {
+			const assist = answering(model);
+			if (assist === null) return { suggestions: [] };
+			return { suggestions: assist.complete(model.getValue(), model.getOffsetAt(position)).map((candidate, index) => {
+				return {
+					label: candidate.label,
+					kind: kinds[candidate.kind],
+					insertText: candidate.insertText,
+					insertTextRules: candidate.snippet ? monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet : void 0,
+					detail: candidate.detail,
+					documentation: candidate.documentation,
+					range: new monaco.Range(position.lineNumber, Math.max(1, position.column - candidate.replace), position.lineNumber, position.column),
+					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 };
+			})
+		};
+	} })];
+}
+const ELASTICSEARCH_MARKER_OWNER = "inkstone-elasticsearch";
+function setElasticsearchMarkers(monaco, model, markers, wording) {
+	const severities = monaco.MarkerSeverity;
+	monaco.editor.setModelMarkers(model, ELASTICSEARCH_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 { ELASTICSEARCH_LANGUAGE_ID, ELASTICSEARCH_MARKER_OWNER, defineElasticsearchLanguage, registerElasticsearchLanguage, setElasticsearchMarkers };

package/dist/react.d.ts

@@ -0,0 +1,93 @@
+import { a as ElasticsearchAssist, t as ElasticsearchMarker } from "./markers-BctX905j.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 — an index tree is an input
+ * device — and the focus.
+ */
+interface ElasticsearchEditorHandle {
+  insert: (text: string) => void;
+  focus: () => void;
+}
+/**
+ * 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.
+ */
+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;
+  /**
+   * 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.
+   */
+  assist?: ElasticsearchAssist;
+  /**
+   * The words each marker shows, per code (`requestMarkers`) — the host's language. No
+   * markers are drawn without it.
+   */
+  markerWording?: (marker: ElasticsearchMarker) => string;
+}
+/**
+ * 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.
+ */
+declare function ElasticsearchEditor({ value, onChange, dark, height, fontSize, locale, placeholder, ariaLabel, languageId, loading, failure, onRun, runActionLabel, onCaret, onReady, onMount, assist, markerWording }: ElasticsearchEditorProps): import("react").JSX.Element;
+//#endregion
+export { ElasticsearchCaret, ElasticsearchEditor, ElasticsearchEditorHandle, ElasticsearchEditorProps };

package/dist/react.js

@@ -0,0 +1,104 @@
+import { t as requestMarkers } from "./markers-DBJshw-Y.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 { 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 }) {
+	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: { 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);
+			}
+		})
+	});
+}
+//#endregion
+export { ElasticsearchEditor };

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@coldsmirk/inkstone-elasticsearch",
+  "version": "0.22.0",
+  "description": "Elasticsearch request editing intelligence for Monaco: the console spelling (a method and a path, the body after), endpoint and index completion, body keys by context, request markers, and a drop-in React request editor.",
+  "keywords": [
+    "elasticsearch",
+    "monaco",
+    "completion",
+    "editor",
+    "autocomplete",
+    "kibana"
+  ],
+  "homepage": "https://github.com/coldsmirk/inkstone/tree/main/packages/elasticsearch#readme",
+  "bugs": "https://github.com/coldsmirk/inkstone/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/coldsmirk/inkstone.git",
+    "directory": "packages/elasticsearch"
+  },
+  "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"
+  }
+}