@coldsmirk/inkstone-sql 0.31.0 → 0.33.0

package/README.md

@@ -8,7 +8,7 @@ Part of [inkstone](https://github.com/coldsmirk/inkstone). Extracted from dragom
 
 - **`@coldsmirk/inkstone-sql`** — the framework-free core. Zero editor dependencies; runs anywhere.
 - **`@coldsmirk/inkstone-sql/monaco`** — `registerSqlLanguage(monaco, modelPath, hooks)`: the Monaco providers (completion, hover, signature help, formatting) over an assist read per-request through a hook. Peer: `monaco-editor`.
-- **`@coldsmirk/inkstone-sql/react`** — `<SqlEditor>`: a controlled SQL editor built on `@coldsmirk/inkstone-react`'s `<MonacoEditor>`, with a run key (Ctrl/Cmd-Enter handing over the live caret), a runnable-statement gutter mark, caret tracking, and an insert/format handle for schema trees and toolbars. Peers: `monaco-editor`, `react`.
+- **`@coldsmirk/inkstone-sql/react`** — `<SqlEditor>`: a controlled SQL editor built on `@coldsmirk/inkstone-react`'s `<MonacoConsoleEditor>`, with a run key (Ctrl/Cmd-Enter handing over the live caret), a runnable-statement gutter mark, caret tracking, and an insert/focus/format handle for schema trees and toolbars. Peers: `monaco-editor`, `react`.
 
 ## The shape
 
@@ -31,7 +31,7 @@ const runnable = runnableStatement(text, from, to, "postgres");
 if (runnable.kind === "one") {
   // Markers are read off the BLANKED form — `select '?'` binds nothing — and under the kind's
   // own binding rules: `markers.refusal` mirrors the engine scanner's own faults (mixed forms,
-  // `??` on mysql/dm, a hand-written `$1` beside a minted marker), so the editor can say so
+  // `??` on mysql/dm/clickhouse, a hand-written `$1` beside a minted marker), so the editor can say so
   // before the round trip does.
   const markers = statementMarkers(runnable.blanked, "postgres");
 }
@@ -41,7 +41,7 @@ Everything the intelligence answers goes through one lexical reader taken under
 
 ## The mirror invariant
 
-`noise.ts` (which runs of a statement are strings / comments / quoted names, per kind) and the marker grammar mirror [**polyglot's engine scanner**](https://github.com/coldsmirk/polyglot) (`internal/scan`) flag for flag. The scanner decides what actually binds; a reader that diverged would prompt for a parameter the engine refuses, or send a statement short of one it binds. **A scanner change requires a matching release of this package**, and the per-kind cases in `reader.test.ts` are the invariant's guard.
+`noise.ts` (which runs of a statement are strings / comments / quoted names, per kind) and the marker grammar mirror [**polyglot's engine scanner**](https://github.com/coldsmirk/polyglot) (`sql/Placeholders`, over its profiles in `kinds/Dialect`) flag for flag, each kind under the two lexicons the sidecar reads it by: the database's own says where a statement ends and what is prose, and the one the kind's driver finds a `?` by says where the markers are — SQL Server nests a block comment, but Microsoft's driver ends one at its first close and binds a `?` past it. The scanner decides what actually binds; a reader that diverged would prompt for a parameter the engine refuses, or send a statement short of one it binds. **A scanner change requires a matching release of this package**, and the per-kind cases in `reader.test.ts` are the invariant's guard.
 
 ## Structured refusals
 

package/dist/{assist-BM4bNDhw.d.ts → assist-Cr2idunB.d.ts}

@@ -14,8 +14,11 @@
  * Doris (`doris`, StarRocks and SelectDB with it) speaks MySQL's protocol and grammar and reads
  * here as the MySQL idiom throughout, but its own parser admits no identifier past ASCII bare —
  * `患者` must be backticked where MySQL takes it as written — so it earned a kind for its spelling.
+ * ClickHouse (`clickhouse`) is a lexicon of its own on the engine — backslash escapes and backtick
+ * names as MySQL's, but `--` a comment without its space, `?` its own bind marker — and names its
+ * functions by their case (`toDate`, never `TODATE`).
  */
-type SqlKind = "postgres" | "mysql" | "oracle" | "sqlserver" | "dm" | "kingbase" | "doris";
+type SqlKind = "postgres" | "mysql" | "oracle" | "sqlserver" | "dm" | "kingbase" | "doris" | "clickhouse";
 /**
  * One table or view as the catalog reports it. Names carry the vendor's own casing — that casing
  * is information, and everything downstream preserves it.
@@ -170,9 +173,10 @@ type Runnable = {
    */
   text: string;
   /**
-   * The same span with everything the engine's own scanner skips whole — literals, comments and
-   * quoted names — overwritten by spaces, character for character, so offsets still line up with
-   * `text`. Anything reading the statement's syntax rather than its content must read this: in
+   * The statement as the engine's own scanner reads it when it is sent — under the lexicon the
+   * kind's driver finds a `?` by, from the statement's own start — with everything the scanner
+   * skips whole (literals, comments and quoted names) overwritten by spaces, character for
+   * character, so offsets still line up with `text`. A marker scan must read this: in
    * `select '?'` the `?` is prose, and a marker scan of the raw text would ask the operator for
    * a value the engine then refuses as an extra argument.
    */

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { C as CatalogTable, S as CatalogFunction, _ as readCall, a as createSqlAssist, b as runnableStatement, c as SqlSource, d as CallRead, f as IdentifierRead, g as TableRef, h as StatementRead, i as SqlSignatureHelp, l as createSqlSchema, m as StatementContext, n as SqlCompletionCandidate, o as SqlCatalog, p as Runnable, r as SqlHoverCard, s as SqlSchema, t as SqlAssist, u as qualifiedName, v as readIdentifier, w as SqlKind, x as CatalogColumn, y as readStatement } from "./assist-BM4bNDhw.js";
+import { C as CatalogTable, S as CatalogFunction, _ as readCall, a as createSqlAssist, b as runnableStatement, c as SqlSource, d as CallRead, f as IdentifierRead, g as TableRef, h as StatementRead, i as SqlSignatureHelp, l as createSqlSchema, m as StatementContext, n as SqlCompletionCandidate, o as SqlCatalog, p as Runnable, r as SqlHoverCard, s as SqlSchema, t as SqlAssist, u as qualifiedName, v as readIdentifier, w as SqlKind, x as CatalogColumn, y as readStatement } from "./assist-Cr2idunB.js";
 //#region src/functions.d.ts
 /**
  * The function vocabulary this bench speaks: the curated floor this project wrote
@@ -78,11 +78,17 @@ interface SqlFunction {
  * manual: the words an integration engineer writes at this console, weighted toward reading — a
  * keyword or function missing here costs one suggestion, so the lists stay honest rather than
  * exhaustive. Everything is lowercase, the casing the bench itself writes (the tree's
- * `select * from`, the editor placeholder); completion re-cases it to follow the operator's hand.
+ * `select * from`, the editor placeholder); completion re-cases it to follow the operator's hand —
+ * but for the functions of a kind that names them by their case, spelled as the vendor spells them.
  */
 interface SqlDialect {
   keywords: string[];
   functions: SqlFunction[];
+  /**
+   * The kind names a function by its case (ClickHouse's `toDate`, never `TODATE`): its curated
+   * functions are written as listed, whatever the operator's hand.
+   */
+  functionsByCase?: boolean;
 }
 export declare const SQL_DIALECTS: Record<SqlKind, SqlDialect>;
 /**
@@ -133,11 +139,11 @@ export declare function joinGuesses(kind: SqlKind, target: SqlSource, others: Sq
  * Placeholder detection for what a run asks the operator for.
  *
  * This is **not** validation and must never become it: the engine-side scanner (the polyglot
- * sidecar's `internal/scan`) is the authority on what binds, it is lexical and per-dialect, and a second
- * implementation here would drift from it the first time a dialect gained a quoting form. All
- * this decides is whether the run has values to ask for, which form the parameter dialog
- * offers, and — where the statement is one the scanner refuses outright — the refusal, as a
- * code, so the editor can say so before the round trip does.
+ * sidecar's `sql/Placeholders`) is the authority on what binds, it is lexical and per-dialect,
+ * and a second implementation here would drift from it the first time a dialect gained a quoting
+ * form. All this decides is whether the run has values to ask for, which form the parameter
+ * dialog offers, and — where the statement is one the scanner refuses outright — the refusal, as
+ * a code, so the editor can say so before the round trip does.
  *
  * **Callers pass the statement's blanked form** (`Runnable.blanked`), never its raw text. A
  * disagreement with the engine's scanner is not cosmetic in either direction — it answers both
@@ -146,8 +152,9 @@ export declare function joinGuesses(kind: SqlKind, target: SqlSource, others: Sq
  * has no placeholder in it. Blanking is the reader's job because the reader already owns what is
  * prose and what is SQL for this page, and it takes that decision under the data source's own
  * lexical profile (`noise.ts`), mode for mode with the scanner — MySQL's `#` comments and
- * backslash escapes, Postgres's `$tag$` bodies, Oracle's `q'…'`, every kind's quoted names — so
- * what reaches this file is exactly the text the engine would mint markers from.
+ * backslash escapes, Postgres's `$tag$` bodies, Oracle's `q'…'`, every kind's quoted names, and
+ * SQL Server's block comments as its driver ends them — so what reaches this file is exactly the
+ * text the engine would mint markers from.
  */
 /**
  * The binding form a statement's markers suggest.
@@ -159,8 +166,8 @@ type MarkerForm = "none" | "positional" | "named";
  *
  * - `"mixed-forms"` — the statement writes both `?` and `:name`; the scanner binds neither.
  * - `"question-escape-unsupported"` — `??` on a kind whose native form is itself `?` (MySQL,
- * 达梦): the escape has no rendering that survives, and neither dialect has a `?` operator to
- * escape in the first place.
+ * 达梦, ClickHouse): the escape has no rendering that survives, and none of them has a `?`
+ * operator to escape in the first place.
  * - `"native-marker-collision"` — a marker hand-written in the kind's own bind form (`$1`,
  * `:1`, `@p1`) beside a `?`/`:name` the scanner would mint: both would bind the same slot.
  */
@@ -191,6 +198,11 @@ interface StatementMarkers {
 export declare function statementMarkers(statement: string, kind: SqlKind): StatementMarkers;
 //#endregion
 //#region src/noise.d.ts
+/**
+ * Which lexicon a text is read under: the database's own — where a statement ends, what is prose
+ * — or the one the kind's driver finds a `?` by, which the sidecar mints its markers under.
+ */
+type NoiseLexicon = "database" | "driver";
 /**
  * A run the reader must not look inside. `sealed` says the closing delimiter was found: a caret
  * right after a sealed run is back in the statement, while a caret at the end of an unterminated
@@ -223,9 +235,10 @@ interface BlankedSql {
 /**
  * The statement with its noise blanked out, char for char, so every offset survives — in the two
  * renderings the reader needs (see [BlankedSql]). One pass, mirroring the sidecar scanner's own
- * loop over its mutually exclusive lexical modes.
+ * loop over its mutually exclusive lexical modes, under the database's own lexicon unless the
+ * driver's is asked for.
  */
-export declare function blankNoise(text: string, kind: SqlKind): BlankedSql;
+export declare function blankNoise(text: string, kind: SqlKind, lexicon?: NoiseLexicon): BlankedSql;
 /**
  * Whether the caret sits inside a string or a comment, where the bench has nothing to say. A
  * quoted name is not one: it is a name the operator is writing, and the reader is about names.
@@ -373,4 +386,4 @@ export declare function spellQualifiedName(kind: SqlKind, table: {
   name: string;
 }): string;
 //#endregion
-export { type BenchFunction, type BindRefusal, type BlankedSql, type Bound, type BoundParams, type CallRead, type CatalogColumn, type CatalogFunction, type CatalogTable, type IdentifierRead, type JoinGuess, type JoinReason, type MarkerForm, type MarkerRefusal, type NoiseSpan, type ParamType, type ParamValue, type Runnable, type SqlAssist, type SqlCatalog, type SqlCompletionCandidate, type SqlDialect, type SqlFunction, type SqlFunctions, type SqlHoverCard, type SqlKind, type SqlScalar, type SqlSchema, type SqlSignatureHelp, type SqlSource, type StatementContext, type StatementMarkers, type StatementOrigin, type StatementRead, type TableRef, createSqlAssist, createSqlSchema, qualifiedName, readCall, readIdentifier, readStatement, runnableStatement };
+export { type BenchFunction, type BindRefusal, type BlankedSql, type Bound, type BoundParams, type CallRead, type CatalogColumn, type CatalogFunction, type CatalogTable, type IdentifierRead, type JoinGuess, type JoinReason, type MarkerForm, type MarkerRefusal, type NoiseLexicon, type NoiseSpan, type ParamType, type ParamValue, type Runnable, type SqlAssist, type SqlCatalog, type SqlCompletionCandidate, type SqlDialect, type SqlFunction, type SqlFunctions, type SqlHoverCard, type SqlKind, type SqlScalar, type SqlSchema, type SqlSignatureHelp, type SqlSource, type StatementContext, type StatementMarkers, type StatementOrigin, type StatementRead, type TableRef, createSqlAssist, createSqlSchema, qualifiedName, readCall, readIdentifier, readStatement, runnableStatement };

package/dist/index.js

@@ -181,6 +181,63 @@ const MYSQL = dialect([
 	fn("group_concat", "group_concat(expr)", "Aggregate: joins each row's value into one string; takes `separator '…'`."),
 	fn("json_extract", "json_extract(json, path)", "Reads a JSON path, as in `'$.id'`.")
 ]);
+const CLICKHOUSE = {
+	...dialect([
+		"final",
+		"prewhere",
+		"sample",
+		"array",
+		"global",
+		"any",
+		"asof",
+		"semi",
+		"anti",
+		"limit",
+		"offset",
+		"settings",
+		"format",
+		"totals",
+		"rollup",
+		"cube",
+		"ilike",
+		"interval",
+		"true",
+		"false"
+	], [
+		fn("now", "now(timezone)", "Current date and time, in the server's time zone unless one is named."),
+		fn("today", "today()", "Current date."),
+		fn("toDate", "toDate(value)", "Converts to a Date."),
+		fn("toDateTime", "toDateTime(value, timezone)", "Converts to a DateTime, in a time zone where one is named."),
+		fn("toString", "toString(value)", "Converts to a String."),
+		fn("toInt64", "toInt64(value)", "Converts to a 64-bit integer."),
+		fn("toFloat64", "toFloat64(value)", "Converts to a 64-bit float."),
+		fn("toStartOfDay", "toStartOfDay(time)", "Rounds a time down to the start of its day."),
+		fn("toStartOfHour", "toStartOfHour(time)", "Rounds a time down to the start of its hour."),
+		fn("toStartOfMonth", "toStartOfMonth(date)", "Rounds a date down to the first day of its month."),
+		fn("formatDateTime", "formatDateTime(time, format)", "Formats a time through a format string, as in `'%Y-%m-%d'`."),
+		fn("dateDiff", "dateDiff(unit, start, end)", "Unit boundaries crossed between two times, as in `dateDiff('day', a, b)`."),
+		fn("if", "if(condition, then, else)", "Ternary choice."),
+		fn("multiIf", "multiIf(condition, then, …, else)", "The value of the first condition that holds, or the last argument."),
+		fn("ifNull", "ifNull(value, fallback)", "The second argument when the first is NULL."),
+		fn("concat", "concat(value, …)", "Joins the arguments as strings."),
+		fn("length", "length(value)", "Bytes in a string, elements in an array; `lengthUTF8` counts characters."),
+		fn("substring", "substring(text, offset, length)", "`length` bytes from byte `offset`, counting from 1; `substringUTF8` counts characters."),
+		fn("position", "position(text, search)", "Byte position of a substring, counting from 1, or 0 when it is absent."),
+		fn("replaceAll", "replaceAll(text, search, replacement)", "Replaces every occurrence of a substring."),
+		fn("splitByChar", "splitByChar(separator, text)", "Splits a string on a one-character separator into an array."),
+		fn("JSONExtractString", "JSONExtractString(json, key, …)", "A string read out of JSON by key or index, empty where there is none."),
+		fn("has", "has(array, value)", "Whether the array holds the value."),
+		fn("arrayJoin", "arrayJoin(array)", "One row per element of the array."),
+		fn("countIf", "countIf(condition)", "Aggregate: rows for which the condition holds."),
+		fn("sumIf", "sumIf(value, condition)", "Aggregate: the sum over the rows for which the condition holds."),
+		fn("uniq", "uniq(expr)", "Aggregate: the distinct values, counted approximately."),
+		fn("uniqExact", "uniqExact(expr)", "Aggregate: the distinct values, counted exactly."),
+		fn("groupArray", "groupArray(expr)", "Aggregate: collects each row's value into an array."),
+		fn("argMax", "argMax(value, by)", "Aggregate: `value` from the row where `by` is largest."),
+		fn("any", "any(expr)", "Aggregate: one value of the group, whichever is met first.")
+	]),
+	functionsByCase: true
+};
 const SQL_DIALECTS = {
 	postgres: POSTGRES$1,
 	kingbase: POSTGRES$1,
@@ -222,7 +279,8 @@ const SQL_DIALECTS = {
 		fn("rtrim", "rtrim(text)", "Strips trailing whitespace."),
 		fn("string_agg", "string_agg(expr, delimiter)", "Aggregate: joins each row's value with a delimiter.")
 	]),
-	dm: ORACLE$1
+	dm: ORACLE$1,
+	clickhouse: CLICKHOUSE
 };
 function signatureParameters(signature) {
 	const open = signature.indexOf("(");
@@ -323,6 +381,13 @@ const TSQL_RESERVED = reservedWords(`
   tran transaction trigger truncate try_convert tsequal union unique unpivot update updatetext
   use user values varying view waitfor when where while with within writetext
 `);
+const CLICKHOUSE_RESERVED = reservedWords(`
+  all and anti any array as asc asof between by case cast collate cross cube desc distinct else
+  end except exists false fill final first format from full global group having ilike in inner
+  insert interpolate intersect interval into is join last left like limit not null nulls offset
+  on or order outer paste prewhere qualify right rollup sample select semi settings step table
+  then totals true union using values when where window with
+`);
 const ORACLE = {
 	open: "\"",
 	close: "\"",
@@ -357,10 +422,18 @@ const SPELLINGS = {
 		regular: /^[a-z_@#][\w@#$]*$/i,
 		reserved: TSQL_RESERVED
 	},
-	dm: ORACLE
+	dm: ORACLE,
+	clickhouse: {
+		open: "`",
+		close: "`",
+		backslash: true,
+		regular: /^[a-z_]\w*$/i,
+		reserved: CLICKHOUSE_RESERVED
+	}
 };
 function delimited(spelling, name) {
-	return `${spelling.open}${name.replaceAll(spelling.close, () => spelling.close + spelling.close)}${spelling.close}`;
+	const escaped = spelling.backslash === true ? name.replaceAll("\\", () => "\\\\") : name;
+	return `${spelling.open}${escaped.replaceAll(spelling.close, () => spelling.close + spelling.close)}${spelling.close}`;
 }
 function spellIdentifier(kind, name) {
 	const spelling = SPELLINGS[kind];
@@ -434,6 +507,11 @@ const BASE = {
 	nestedBlockComments: false,
 	alternativeQuoting: false
 };
+const SQLSERVER = {
+	...BASE,
+	bracketIdentifiers: true,
+	nestedBlockComments: true
+};
 const NOISE_PROFILES = {
 	postgres: {
 		...BASE,
@@ -461,18 +539,25 @@ const NOISE_PROFILES = {
 		...BASE,
 		alternativeQuoting: true
 	},
-	sqlserver: {
-		...BASE,
-		bracketIdentifiers: true
-	},
+	sqlserver: SQLSERVER,
 	dm: BASE,
 	kingbase: {
 		...BASE,
 		escapeStrings: true,
 		nestedBlockComments: true,
 		dollarQuoting: true
+	},
+	clickhouse: {
+		...BASE,
+		backslashEscapes: true,
+		hashLineComments: true,
+		backtickIdentifiers: true
 	}
 };
+const DRIVER_PROFILES = { sqlserver: {
+	...SQLSERVER,
+	nestedBlockComments: false
+} };
 const WORD_START = /[a-z_\u{0080}-\u{FFFF}]/iu;
 const WORD_BYTE = /[\w$\u{0080}-\u{FFFF}]/u;
 const NAME_BYTE = /\w/;
@@ -575,10 +660,14 @@ function opensLineComment(text, from, profile) {
 	const after = text[from + 2];
 	return !profile.lineCommentNeedsSpace || after === void 0 || after <= " ";
 }
-let lastBlanked = null;
-function blankNoise(text, kind) {
-	if (lastBlanked !== null && lastBlanked.text === text && lastBlanked.kind === kind) return lastBlanked.result;
-	const profile = NOISE_PROFILES[kind];
+const lastBlanked = {
+	database: null,
+	driver: null
+};
+function blankNoise(text, kind, lexicon = "database") {
+	const last = lastBlanked[lexicon];
+	if (last !== null && last.text === text && last.kind === kind) return last.result;
+	const profile = lexicon === "driver" ? DRIVER_PROFILES[kind] ?? NOISE_PROFILES[kind] : NOISE_PROFILES[kind];
 	const withNames = text.split("");
 	const blanked = text.split("");
 	const spans = [];
@@ -622,7 +711,7 @@ function blankNoise(text, kind) {
 		blanked: blanked.join(""),
 		spans
 	};
-	lastBlanked = {
+	lastBlanked[lexicon] = {
 		text,
 		kind,
 		result
@@ -918,10 +1007,11 @@ function runnableStatement(text, from, to, kind) {
 	if (spans.length === 0) return { kind: "none" };
 	if (selected && spans.length > 1) return { kind: "several" };
 	const span = spans[0];
+	const statement = text.slice(span.from, span.to);
 	return {
 		kind: "one",
-		text: text.slice(span.from, span.to),
-		blanked: blanked.slice(span.from, span.to),
+		text: statement,
+		blanked: blankNoise(statement, kind, "driver").blanked,
 		from: span.from,
 		to: span.to,
 		alone: statementSpans(text, blanked, 0, text.length).length <= 1
@@ -1023,7 +1113,7 @@ function expansionCandidate(kind, sources, replacesStar) {
 	};
 }
 function createSqlCompletion(kind, schema, functions) {
-	const { keywords } = SQL_DIALECTS[kind];
+	const { keywords, functionsByCase = false } = SQL_DIALECTS[kind];
 	const spelled = /* @__PURE__ */ new Map();
 	async function wordCandidates(typed) {
 		const upper = typed !== "" && typed === typed.toUpperCase() && typed !== typed.toLowerCase();
@@ -1039,7 +1129,7 @@ function createSqlCompletion(kind, schema, functions) {
 				sortGroup: RANK_KEYWORD
 			};
 		}), ...known.map((entry) => {
-			const name = entry.origin === "curated" ? spell(entry.name) : entry.name;
+			const name = entry.origin === "curated" && !functionsByCase ? spell(entry.name) : entry.name;
 			const written = entry.origin === "curated" ? name : spellCallable(kind, name);
 			const call = entry.qualifier === "" ? written : `${spellIdentifier(kind, entry.qualifier)}.${written}`;
 			return {
@@ -1161,7 +1251,8 @@ const DIALECTS = {
 	oracle: "plsql",
 	dm: "plsql",
 	sqlserver: "transactsql",
-	kingbase: "postgresql"
+	kingbase: "postgresql",
+	clickhouse: "clickhouse"
 };
 const PLACEHOLDERS = String.raw`\?|:[A-Za-z_]\w*`;
 function sentinelFor(text) {
@@ -1427,7 +1518,11 @@ function createSqlAssist(kind, catalog) {
 //#endregion
 //#region src/markers.ts
 const SCAN = /[A-Z_\u0080-\uFFFF][\w$\u0080-\uFFFF]*|(?<qq>\?\?)|::|(?<q>\?)|:(?<name>[A-Z_]\w*)|(?<colonDigits>:\d+)|(?<dollarDigits>\$\d+)|(?<atDigits>@P\d+)/gi;
-const QUESTION_IS_NATIVE = /* @__PURE__ */ new Set(["mysql", "dm"]);
+const QUESTION_IS_NATIVE = /* @__PURE__ */ new Set([
+	"mysql",
+	"dm",
+	"clickhouse"
+]);
 const NATIVE_GROUP = {
 	postgres: "dollarDigits",
 	mysql: null,
@@ -1435,7 +1530,8 @@ const NATIVE_GROUP = {
 	oracle: "colonDigits",
 	sqlserver: "atDigits",
 	dm: null,
-	kingbase: "dollarDigits"
+	kingbase: "dollarDigits",
+	clickhouse: null
 };
 function statementMarkers(statement, kind) {
 	const names = [];

package/dist/monaco.d.ts

@@ -1,4 +1,4 @@
-import { t as SqlAssist } from "./assist-BM4bNDhw.js";
+import { t as SqlAssist } from "./assist-Cr2idunB.js";
 import * as monacoEditor from "monaco-editor";
 import { IDisposable } from "monaco-editor";
 //#region src/monaco.d.ts

package/dist/react.d.ts

@@ -1,92 +1,33 @@
-import { t as SqlAssist } from "./assist-BM4bNDhw.js";
-import { MonacoModule } from "./monaco.js";
+import { t as SqlAssist } from "./assist-Cr2idunB.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 needs to reach into the editor for: inserting at the caret (a schema tree is an
- * input device, not a browser), and reformatting from a toolbar — which goes through Monaco's own
- * formatting action, so the button and `Shift+Alt+F` are one path and one undo.
+ * input device, not a browser), the focus, and reformatting from a toolbar — which goes through
+ * Monaco's own formatting action, so the button and `Shift+Alt+F` are one path and one undo.
  */
-export interface SqlEditorHandle {
-  insert: (text: string) => void;
+export interface SqlEditorHandle extends ConsoleEditorHandle {
   format: () => void;
 }
 /**
  * Where the operator is in the document, in offsets — everything a host needs to decide which
- * statement a run should send, and nothing about SQL. `from` and `to` are the selection's own
- * bounds and are equal where nothing is selected: a caret is a selection of nothing.
- *
- * It rides with the text rather than beside it because the two must belong to the same instant.
- * The controlled `value` is one React render behind the keystroke that triggered a run, and a
- * console must run the statement the operator is looking at.
+ * statement a run should send, and nothing about SQL.
  */
-export interface SqlCaret {
-  text: string;
-  from: number;
-  to: number;
-}
-export interface SqlEditorProps {
-  value: string;
-  onChange: (value: string) => void;
-  /**
-   * Render with the dark theme. Like every inkstone editor, the component never reads the OS
-   * `prefers-color-scheme`; wire this to the app's color-scheme state.
-   *
-   * @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). Monaco's loading placeholder is `height: 100%`, so a height
-   * that resolves to nothing collapses the field to one line while the editor loads.
-   */
-  height?: number | "fill";
-  /**
-   * Editor font size in px. Omit to keep the inkstone default.
-   */
-  fontSize?: number;
-  /**
-   * UI locale for Monaco's built-in chrome — page-global and locked by the first editor to
-   * mount, exactly as on `<MonacoEditor>`.
-   */
-  locale?: "en" | "zh-cn";
-  placeholder?: string;
-  /**
-   * The editor's accessible name, set on Monaco's own input surface — several SQL editors on one
-   * page are indistinguishable to assistive tech without one.
-   */
-  ariaLabel: string;
+export type SqlCaret = ConsoleCaret;
+export interface SqlEditorProps extends ConsoleEditorProps<SqlEditorHandle> {
   /**
    * The Monaco language id the model registers under.
    *
    * @default "sql"
    */
   languageId?: string;
-  /**
-   * Shown while the Monaco host loads / when it fails to load — passed through to
-   * `<MonacoEditor>`, whose English defaults apply when omitted.
-   */
-  loading?: ReactNode;
-  failure?: ReactNode;
-  /**
-   * Ctrl/Cmd-Enter — the run key, bound inside the editor because that is where the operator's
-   * hands are. It is handed the editor's live caret, from which the host works out what to send.
-   * Read through a ref at every press, so it always runs against the connection the *current*
-   * render is bound to.
-   */
-  onRun?: (caret: SqlCaret) => void;
   /**
    * The label the run action shows in Monaco's own chrome (command palette, context menu).
    *
    * @default "Run statement"
    */
   runActionLabel?: string;
-  /**
-   * The caret moved, or the text under it changed. The host tracks it to show what a run would
-   * send; the run key does not depend on that tracking having caught up.
-   */
-  onCaret?: (caret: SqlCaret) => void;
   /**
    * The span to mark as the one a run would send. Null leaves the gutter clean, which is the
    * right answer while there is nothing to choose between.
@@ -108,35 +49,19 @@ export interface SqlEditorProps {
    * says so — a deliberate keystroke that changes nothing needs to explain itself.
    */
   onFormatRefused?: () => void;
-  onReady?: (handle: SqlEditorHandle) => void;
-  /**
-   * Runs after this component's own mount wiring, with the live editor and the monaco module —
-   * the escape hatch for host-specific concerns (focus shields, extra actions).
-   */
-  onMount?: (instance: editor.IStandaloneCodeEditor, monaco: MonacoModule) => void;
-  /**
-   * 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;
   /**
    * What the editor's language features answer from — the schema and dialect of the connection
-   * being edited (`createSqlAssist`). Read through a ref at every request, so the host can swap
-   * it without re-registering anything with Monaco.
+   * being edited (`createSqlAssist`). Read at every request, so the host can swap it without
+   * re-registering anything with Monaco.
    */
   assist?: SqlAssist;
 }
 /**
- * The SQL editing surface: Monaco in `sql`, highlighted by the same shared Shiki grammar every
- * other inkstone surface uses. It is deliberately not a script editor — a TypeScript language
- * service and an ambient profile have no meaning for a vendor's SQL. Its language features are
- * the host's: the `assist` knows the catalog and the dialect and this component only wires it to
- * Monaco (`registerSqlLanguage`) — it never guesses at SQL itself.
- *
- * The editor draws no chrome of its own: it is a band of its host's surface, and the separation
- * is the host's hairline rules — a border here would dress a pane up as a form input.
+ * The SQL editing surface: `<MonacoConsoleEditor>` in `sql`, highlighted by the same shared Shiki
+ * grammar every other inkstone surface uses. It is deliberately not a script editor — a
+ * TypeScript language service and an ambient profile have no meaning for a vendor's SQL. Its
+ * language features are the host's: the `assist` knows the catalog and the dialect and this
+ * component only wires it to Monaco (`registerSqlLanguage`) — it never guesses at SQL itself.
  */
-export declare function SqlEditor({ value, onChange, dark, height, fontSize, locale, placeholder, ariaLabel, languageId, loading, failure, onRun, runActionLabel, onCaret, highlight, highlightClassName, onFormatRefused, onReady, onMount, options, assist }: SqlEditorProps): import("react").JSX.Element;
+export declare function SqlEditor({ languageId, runActionLabel, assist, onFormatRefused, onReady, options, ...props }: SqlEditorProps): ReactNode;
 //#endregion

package/dist/react.js

@@ -1,135 +1,46 @@
 import { t as registerSqlLanguage } from "./monaco-DEMsSuzD.js";
-import { MonacoEditor } from "@coldsmirk/inkstone-react/monaco";
-import { useEffect, useInsertionEffect, useRef, useState } from "react";
+import { MonacoConsoleEditor } from "@coldsmirk/inkstone-react/monaco";
+import { useMemo, useRef } from "react";
 import { jsx } from "react/jsx-runtime";
 //#region src/react.tsx
-const EDITOR_ID_KEY = Symbol.for("coldsmirk.inkstone.sql.editorId");
-function nextEditorId() {
-	const holder = globalThis;
-	const id = holder[EDITOR_ID_KEY] ?? 0;
-	holder[EDITOR_ID_KEY] = id + 1;
-	return id;
-}
 const FORMAT_CHORD_CONTEXT_KEY = "inkstoneSqlFormatChord";
-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 monacoRange(model, span) {
-	const from = model.getPositionAt(span.from);
-	const to = model.getPositionAt(span.to);
-	return {
-		startLineNumber: from.lineNumber,
-		startColumn: from.column,
-		endLineNumber: to.lineNumber,
-		endColumn: to.column
-	};
-}
-function SqlEditor({ value, onChange, dark = false, height = 200, fontSize, locale, placeholder, ariaLabel, languageId = "sql", loading, failure, onRun, runActionLabel = "Run statement", onCaret, highlight = null, highlightClassName = "inkstone-sql-runnable", onFormatRefused, onReady, onMount, options, assist }) {
-	const [modelPath] = useState(() => `file:///inkstone-sql/${nextEditorId()}.sql`);
-	const bindings = useRef([]);
-	const assistRef = useLatest(assist ?? null);
-	const formatRefusedRef = useLatest(onFormatRefused);
-	const runRef = useLatest(onRun);
-	const caretChangedRef = useLatest(onCaret);
-	const readyRef = useLatest(onReady);
-	const mountRef = useLatest(onMount);
-	const instance = useRef(null);
-	const marked = useRef(null);
-	const [mounted, setMounted] = useState(false);
-	useEffect(() => {
-		const model = instance.current?.getModel();
-		if (model === null || model === void 0) return;
-		marked.current?.clear();
-		marked.current = highlight === null ? null : instance.current.createDecorationsCollection([{
-			range: monacoRange(model, highlight),
-			options: {
-				linesDecorationsClassName: highlightClassName,
-				isWholeLine: true
-			}
-		}]);
-	}, [
-		highlight,
-		highlightClassName,
-		mounted
-	]);
-	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,
-			path: modelPath,
-			placeholder,
-			value,
-			options: {
-				...options,
-				ariaLabel,
-				suggest: { snippetsPreventQuickSuggestions: false }
-			},
-			onChange,
-			onMount: (live, monaco) => {
-				instance.current = live;
-				live.createContextKey(FORMAT_CHORD_CONTEXT_KEY, true);
-				bindings.current.push(live.onDidChangeCursorSelection(() => caretChangedRef.current?.(caretOf(live))), live.addAction({
-					id: "inkstone-sql.run",
-					label: runActionLabel,
-					keybindings: [monaco.KeyMod.CtrlCmd | monaco.KeyCode.Enter],
-					run: (current) => runRef.current?.(caretOf(current))
-				}), monaco.editor.addKeybindingRule({
-					keybinding: monaco.KeyMod.Shift | monaco.KeyMod.Alt | monaco.KeyCode.KeyF,
-					command: "editor.action.formatDocument",
-					when: `${FORMAT_CHORD_CONTEXT_KEY} && editorTextFocus && !editorReadonly`
-				}), ...registerSqlLanguage(monaco, modelPath, {
-					assist: () => assistRef.current,
-					onFormatRefused: () => formatRefusedRef.current?.()
-				}, languageId));
-				readyRef.current?.({
-					format: () => void live.getAction("editor.action.formatDocument")?.run(),
-					insert: (text) => {
-						const selection = live.getSelection();
-						if (selection) live.executeEdits("inkstone-sql-insert", [{
-							range: selection,
-							text,
-							forceMoveMarkers: true
-						}]);
-						live.focus();
-					}
-				});
-				mountRef.current?.(live, monaco);
-				setMounted(true);
-			}
-		})
+function SqlEditor({ languageId = "sql", runActionLabel = "Run statement", assist, onFormatRefused, onReady, options, ...props }) {
+	const live = useRef(null);
+	const sqlOptions = useMemo(() => {
+		return {
+			...options,
+			suggest: { snippetsPreventQuickSuggestions: false }
+		};
+	}, [options]);
+	return /* @__PURE__ */ jsx(MonacoConsoleEditor, {
+		...props,
+		context: {
+			assist,
+			onFormatRefused
+		},
+		extension: "sql",
+		language: languageId,
+		namespace: "inkstone-sql",
+		options: sqlOptions,
+		runActionLabel,
+		register: ({ monaco, editor: instance, path, context }) => {
+			live.current = instance;
+			instance.createContextKey(FORMAT_CHORD_CONTEXT_KEY, true);
+			return [monaco.editor.addKeybindingRule({
+				keybinding: monaco.KeyMod.Shift | monaco.KeyMod.Alt | monaco.KeyCode.KeyF,
+				command: "editor.action.formatDocument",
+				when: `${FORMAT_CHORD_CONTEXT_KEY} && editorTextFocus && !editorReadonly`
+			}), ...registerSqlLanguage(monaco, path, {
+				assist: () => context().assist ?? null,
+				onFormatRefused: () => context().onFormatRefused?.()
+			}, languageId)];
+		},
+		onReady: (handle) => {
+			onReady?.({
+				...handle,
+				format: () => void live.current?.getAction("editor.action.formatDocument")?.run()
+			});
+		}
 	});
 }
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coldsmirk/inkstone-sql",
-  "version": "0.31.0",
+  "version": "0.33.0",
   "description": "Schema-aware SQL editing intelligence for Monaco: lexical statement reading under per-dialect noise profiles, catalog-driven completion/hover/signature help, unified-placeholder awareness, formatting, and a drop-in React SQL editor.",
   "keywords": [
     "sql",
@@ -48,12 +48,12 @@
   "devDependencies": {
     "monaco-editor": "^0.57.0",
     "react": "^19.3.0",
-    "@coldsmirk/inkstone-react": "^0.31.0"
+    "@coldsmirk/inkstone-react": "^0.33.0"
   },
   "peerDependencies": {
     "monaco-editor": "^0.57.0",
     "react": ">=19",
-    "@coldsmirk/inkstone-react": "^0.31.0"
+    "@coldsmirk/inkstone-react": "^0.33.0"
   },
   "peerDependenciesMeta": {
     "@coldsmirk/inkstone-react": {