@coldsmirk/inkstone-sql 0.30.0 → 0.31.0

package/dist/index.d.ts

@@ -51,13 +51,13 @@ interface SqlFunctions {
    */
   find: (name: string) => Promise<BenchFunction | null>;
 }
-declare function createSqlFunctions(kind: SqlKind, schema: SqlSchema): SqlFunctions;
+export declare function createSqlFunctions(kind: SqlKind, schema: SqlSchema): SqlFunctions;
 //#endregion
 //#region src/completion.d.ts
 /**
  * Completion for one system's data source, over the schema the tree already reads.
  */
-declare function createSqlCompletion(kind: SqlKind, schema: SqlSchema, functions: SqlFunctions): SqlAssist["complete"];
+export declare function createSqlCompletion(kind: SqlKind, schema: SqlSchema, functions: SqlFunctions): SqlAssist["complete"];
 //#endregion
 //#region src/dialect.d.ts
 /**
@@ -84,19 +84,19 @@ interface SqlDialect {
   keywords: string[];
   functions: SqlFunction[];
 }
-declare const SQL_DIALECTS: Record<SqlKind, SqlDialect>;
+export declare const SQL_DIALECTS: Record<SqlKind, SqlDialect>;
 /**
  * A signature's parameters as `[start, end)` offsets into the signature itself — offsets rather
  * than substrings so a call that repeats a parameter name still marks the right one. Everything
  * between the first `(` and the last `)`, split on the commas at that depth.
  */
-declare function signatureParameters(signature: string): Array<[number, number]>;
+export declare function signatureParameters(signature: string): Array<[number, number]>;
 //#endregion
 //#region src/format.d.ts
-declare function createSqlFormat(kind: SqlKind): SqlAssist["format"];
+export declare function createSqlFormat(kind: SqlKind): SqlAssist["format"];
 //#endregion
 //#region src/hover.d.ts
-declare function createSqlHover(kind: SqlKind, schema: SqlSchema, functions: SqlFunctions): SqlAssist["hover"];
+export declare function createSqlHover(kind: SqlKind, schema: SqlSchema, functions: SqlFunctions): SqlAssist["hover"];
 //#endregion
 //#region src/joins.d.ts
 /**
@@ -126,7 +126,7 @@ type JoinReason = "named-foreign-key" | "shared-key";
  * The equalities worth offering when `target` is joined onto tables the statement already reads.
  * The named foreign key leads, in both directions; the plainer shared-key reading follows.
  */
-declare function joinGuesses(kind: SqlKind, target: SqlSource, others: SqlSource[]): JoinGuess[];
+export declare function joinGuesses(kind: SqlKind, target: SqlSource, others: SqlSource[]): JoinGuess[];
 //#endregion
 //#region src/markers.d.ts
 /**
@@ -188,7 +188,7 @@ interface StatementMarkers {
    */
   refusal: MarkerRefusal | null;
 }
-declare function statementMarkers(statement: string, kind: SqlKind): StatementMarkers;
+export declare function statementMarkers(statement: string, kind: SqlKind): StatementMarkers;
 //#endregion
 //#region src/noise.d.ts
 /**
@@ -225,12 +225,12 @@ interface BlankedSql {
  * renderings the reader needs (see [BlankedSql]). One pass, mirroring the sidecar scanner's own
  * loop over its mutually exclusive lexical modes.
  */
-declare function blankNoise(text: string, kind: SqlKind): BlankedSql;
+export declare function blankNoise(text: string, kind: SqlKind): 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.
  */
-declare function insideNoise(spans: NoiseSpan[], cursor: number): boolean;
+export declare function insideNoise(spans: NoiseSpan[], cursor: number): boolean;
 //#endregion
 //#region src/origin.d.ts
 /**
@@ -247,7 +247,7 @@ interface StatementOrigin {
   schema: string;
   table: string;
 }
-declare function statementOrigin(statement: string): StatementOrigin | null;
+export declare function statementOrigin(statement: string): StatementOrigin | null;
 //#endregion
 //#region src/params.d.ts
 /**
@@ -282,7 +282,7 @@ interface ParamValue {
  * it is also the *shared default* a missing row falls back to — one consumer writing through it
  * would rewrite every untouched row on the page.
  */
-declare const TEXT_PARAM: ParamValue;
+export declare const TEXT_PARAM: ParamValue;
 /**
  * Whether a statement asks for values and the operator has entered none of them. This is the
  * host's cue to ask rather than to send: binding a row of empty strings is never what was meant,
@@ -290,7 +290,7 @@ declare const TEXT_PARAM: ParamValue;
  *
  * A statement that binds nothing is never untouched — there is nothing to touch.
  */
-declare function untouched(rows: Record<string, ParamValue>): boolean;
+export declare function untouched(rows: Record<string, ParamValue>): boolean;
 /**
  * Why one row could not bind.
  *
@@ -312,7 +312,7 @@ type Bound = {
   ok: false;
   refusal: BindRefusal;
 };
-declare function boundValue(param: ParamValue): Bound;
+export declare function boundValue(param: ParamValue): Bound;
 /**
  * Every row bound, in the shape the marker form chose: positional values keep slot order, named
  * values keep their keys. `undefined` is a statement that binds nothing.
@@ -330,7 +330,7 @@ type BoundParams = {
   key: string;
   refusal: BindRefusal;
 };
-declare function boundParams(markers: StatementMarkers, rows: Record<string, ParamValue>): BoundParams;
+export declare function boundParams(markers: StatementMarkers, rows: Record<string, ParamValue>): BoundParams;
 //#endregion
 //#region src/signature.d.ts
 /**
@@ -339,26 +339,26 @@ declare function boundParams(markers: StatementMarkers, rows: Record<string, Par
  * own routines raise their parameters exactly as the vendor's do. The argument is counted at the
  * caret's own paren depth, so a call nested in another's arguments still marks its own.
  */
-declare function createSqlSignature(kind: SqlKind, functions: SqlFunctions): SqlAssist["signature"];
+export declare function createSqlSignature(kind: SqlKind, functions: SqlFunctions): SqlAssist["signature"];
 //#endregion
 //#region src/spelling.d.ts
 /**
  * One catalog name as the statement must spell it.
  */
-declare function spellIdentifier(kind: SqlKind, name: string): string;
+export declare function spellIdentifier(kind: SqlKind, name: string): string;
 /**
  * A routine name as a call must spell it. Reservation does not delimit here: a reserved word in
  * call position is legal in every kind — `json_table(...)`, `left(...)` are the vendors' own
  * builtins — and delimiting one would un-call it; only a lexically irregular name needs the
  * delimiter.
  */
-declare function spellCallable(kind: SqlKind, name: string): string;
+export declare function spellCallable(kind: SqlKind, name: string): string;
 /**
  * The qualifier a generated expression writes before a source's columns: the alias exactly as
  * the operator wrote it — re-spelling the unquoted form would be lossy — or, where the ref has
  * no alias, the catalog's table name in the kind's own spelling.
  */
-declare function spellQualifier(kind: SqlKind, source: {
+export declare function spellQualifier(kind: SqlKind, source: {
   aliasWritten: string;
   table: {
     name: string;
@@ -368,9 +368,9 @@ declare function spellQualifier(kind: SqlKind, source: {
  * A table's qualified name as the statement must spell it. Kinds whose catalog reports no schema
  * (or whose objects sit in the session's own) get the bare name.
  */
-declare function spellQualifiedName(kind: SqlKind, table: {
+export declare function spellQualifiedName(kind: SqlKind, table: {
   schema: string;
   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, SQL_DIALECTS, 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, TEXT_PARAM, type TableRef, blankNoise, boundParams, boundValue, createSqlAssist, createSqlCompletion, createSqlFormat, createSqlFunctions, createSqlHover, createSqlSchema, createSqlSignature, insideNoise, joinGuesses, qualifiedName, readCall, readIdentifier, readStatement, runnableStatement, signatureParameters, spellCallable, spellIdentifier, spellQualifiedName, spellQualifier, statementMarkers, statementOrigin, untouched };
+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 };

package/dist/monaco.d.ts

@@ -6,8 +6,8 @@ import { IDisposable } from "monaco-editor";
  * The monaco module itself, as `onMount` hands it over — typed structurally so this entry needs
  * no dependency beyond `monaco-editor`'s own types.
  */
-type MonacoModule = typeof monacoEditor;
-interface SqlLanguageHooks {
+export type MonacoModule = typeof monacoEditor;
+export interface SqlLanguageHooks {
   /**
    * The assist as it stands right now — read per request rather than captured, so switching
    * connections swaps the schema behind every feature without touching Monaco's registry.
@@ -25,6 +25,5 @@ interface SqlLanguageHooks {
  * answer for a model that no longer exists. `languageId` is the language the model is registered
  * under — the stock `"sql"` unless the host runs a dialect id of its own.
  */
-declare function registerSqlLanguage(monaco: MonacoModule, modelPath: string, hooks: SqlLanguageHooks, languageId?: string): IDisposable[];
-//#endregion
-export { MonacoModule, SqlLanguageHooks, registerSqlLanguage };
+export declare function registerSqlLanguage(monaco: MonacoModule, modelPath: string, hooks: SqlLanguageHooks, languageId?: string): IDisposable[];
+//#endregion

package/dist/monaco.js

@@ -1,2 +1 @@
-import { t as registerSqlLanguage } from "./monaco-DEMsSuzD.js";
-export { registerSqlLanguage };
+export { t as registerSqlLanguage } from "./monaco-DEMsSuzD.js";

package/dist/react.d.ts

@@ -8,7 +8,7 @@ import { editor } from "monaco-editor";
  * 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.
  */
-interface SqlEditorHandle {
+export interface SqlEditorHandle {
   insert: (text: string) => void;
   format: () => void;
 }
@@ -21,12 +21,12 @@ interface SqlEditorHandle {
  * 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.
  */
-interface SqlCaret {
+export interface SqlCaret {
   text: string;
   from: number;
   to: number;
 }
-interface SqlEditorProps {
+export interface SqlEditorProps {
   value: string;
   onChange: (value: string) => void;
   /**
@@ -138,6 +138,5 @@ interface SqlEditorProps {
  * 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.
  */
-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;
-//#endregion
-export { SqlCaret, SqlEditor, SqlEditorHandle, SqlEditorProps };
+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;
+//#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coldsmirk/inkstone-sql",
-  "version": "0.30.0",
+  "version": "0.31.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",
@@ -43,18 +43,17 @@
     "dist"
   ],
   "dependencies": {
-    "sql-formatter": "^15.8.2"
+    "sql-formatter": "^15.9.0"
   },
   "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.31.0"
   },
   "peerDependencies": {
-    "monaco-editor": "^0.56.0",
+    "monaco-editor": "^0.57.0",
     "react": ">=19",
-    "@coldsmirk/inkstone-react": "^0.30.0"
+    "@coldsmirk/inkstone-react": "^0.31.0"
   },
   "peerDependenciesMeta": {
     "@coldsmirk/inkstone-react": {