@coldsmirk/inkstone-react 0.8.3 → 0.10.0

package/dist/{index.d.cts → codemirror-B3GlIVaX.d.ts}

@@ -1,12 +1,164 @@
 import { Extension } from "@codemirror/state";
-import { CodeMirrorLanguage, CodeMirrorLanguage as CodeMirrorLanguage$1, EditorContext, EditorContext as EditorContext$1, codeMirrorLanguages, normalizeContext, searchPhrasesZhCn } from "@coldsmirk/inkstone-codemirror";
-import { ReactNode, RefObject } from "react";
 import { EditorView } from "@codemirror/view";
-import { MonacoHostOptions, MonacoLanguage, MonacoLanguage as MonacoLanguage$1, MonacoUiLocale } from "@coldsmirk/inkstone-monaco";
-import { BeforeMount, OnMount } from "@monaco-editor/react";
-import { editor } from "monaco-editor";
-import { HighlighterCore } from "@coldsmirk/inkstone-core";
+import { CodeMirrorLanguage, CodeMirrorLanguage as CodeMirrorLanguage$1, EditorContext, EditorContext as EditorContext$1, MergeView, MergeView as MergeView$1, SqlSchema, SqlSchema as SqlSchema$1, codeMirrorLanguages, normalizeContext as normalizeContext$1, searchPhrasesZhCn as searchPhrasesZhCn$1 } from "@coldsmirk/inkstone-codemirror";
+import { ReactNode } from "react";
 
+//#region src/codemirror-diff-editor.d.ts
+interface CodeMirrorDiffEditorProps {
+  /**
+   * The controlled original text (the left side). Always read-only in the view — it changes
+   * only through this prop, and external changes reconcile in place without a rebuild.
+   */
+  original: string;
+  /**
+   * The controlled modified text (the right side) — editable unless `readOnly`; external
+   * changes reconcile into the live editor without resetting the caret.
+   */
+  modified: string;
+  /**
+   * Called with the full modified document after every edit made in the view — typing, or a
+   * revert-control copy from the original side. Same contract as `<CodeMirrorEditor>`'s
+   * `onChange`.
+   */
+  onChange?: (value: string) => void;
+  /**
+   * Language id, applied to both sides — lazily loads the matching CodeMirror grammar as its
+   * own chunk, exactly like `<CodeMirrorEditor>`. For anything beyond the built-in set, pass
+   * your own support through `extensions`.
+   */
+  language?: CodeMirrorLanguage;
+  /**
+   * Lock the modified side too, turning the component into a pure diff viewer. The original
+   * side is read-only regardless. Revert controls stay disabled while this is set.
+   *
+   * @default false
+   */
+  readOnly?: boolean;
+  /**
+   * Show a per-chunk revert arrow between the editors that copies the original chunk into
+   * the modified document (the edit flows through `onChange`). Swaps in place, and remains
+   * unavailable while `readOnly` is set.
+   *
+   * @default false
+   */
+  revertControls?: boolean;
+  /**
+   * Collapse long unchanged stretches behind an expandable "⦚ n lines ⦚" bar, keeping a few
+   * context lines around each change. Swaps in place.
+   *
+   * @default false
+   */
+  collapseUnchanged?: boolean;
+  /**
+   * Soft-wrap long lines on both sides. Swaps in place.
+   *
+   * @default false
+   */
+  lineWrapping?: boolean;
+  /**
+   * Show the line-number gutters. On by default — unlike a single document field, a diff
+   * reads by line reference. Swaps in place.
+   *
+   * @default true
+   */
+  showLineNumbers?: boolean;
+  /**
+   * Static extensions applied to both sides, fixed for the view's lifetime. Hoist the
+   * array — a new identity per render is ignored by design (create-once).
+   */
+  extensions?: Extension[];
+  /**
+   * Extensions swapped in place on both sides when the identity changes — memoize with
+   * `useMemo` keyed on what actually changes. Layered after (and so able to override)
+   * inkstone's default catppuccin theme.
+   */
+  dynamicExtensions?: Extension[];
+  /**
+   * Use the dark catppuccin flavor (macchiato) instead of the light one (latte). The
+   * component never reads the OS `prefers-color-scheme` — same policy as every inkstone
+   * editor.
+   *
+   * @default false
+   */
+  dark?: boolean;
+  /**
+   * View height — a number is treated as px. The merge view scrolls as one surface (both
+   * sides together, which is what keeps chunks aligned); omit to grow with content.
+   */
+  height?: string | number;
+  /**
+   * View width — a number is treated as px. Omit to fill the container.
+   */
+  width?: string | number;
+  /**
+   * Editor font size in px, applied to both sides.
+   *
+   * @default 14
+   */
+  fontSize?: number;
+  /**
+   * Line height, both sides — same convention as the other inkstone editors: values below 8
+   * multiply the font size, larger values are absolute pixels.
+   *
+   * @default 1.6
+   */
+  lineHeight?: number;
+  className?: string;
+  /**
+   * Accessible name for the original (read-only) textbox. English by default — same policy
+   * as every inkstone label; localizing hosts pass their own. Fixed for the view's lifetime,
+   * like the other create-once wiring.
+   *
+   * @default "Original content"
+   */
+  originalAriaLabel?: string;
+  /**
+   * Accessible name for the modified (editable) textbox. Fixed for the view's lifetime.
+   *
+   * @default "Modified content"
+   */
+  modifiedAriaLabel?: string;
+  /**
+   * Runs once after the view is created, with the `MergeView` — the imperative handle to
+   * both `EditorView`s (`view.a` is the original, `view.b` the modified) and the computed
+   * chunks.
+   */
+  onMount?: (view: MergeView) => void;
+}
+/**
+ * A controlled side-by-side CodeMirror diff editor: `@codemirror/merge`'s `MergeView` behind
+ * the same create-once / reconcile-in-place discipline as `<CodeMirrorEditor>`, with the
+ * catppuccin flavors extended to the diff chrome (red deletions, green insertions, themed
+ * collapse bars and revert controls).
+ *
+ * The original side is read-only and follows the `original` prop; the modified side is the
+ * editable document behind `modified` / `onChange` (set `readOnly` for a pure viewer). Both
+ * sides share `language`, `extensions`, and the theme; dark flips, language loads, and
+ * `revertControls` / `collapseUnchanged` all swap in place without rebuilding the view.
+ */
+declare function CodeMirrorDiffEditor({
+  original,
+  modified,
+  onChange,
+  language,
+  readOnly,
+  revertControls,
+  collapseUnchanged,
+  lineWrapping,
+  showLineNumbers,
+  extensions,
+  dynamicExtensions,
+  dark,
+  height,
+  width,
+  fontSize,
+  lineHeight,
+  className,
+  originalAriaLabel,
+  modifiedAriaLabel,
+  onMount
+}: CodeMirrorDiffEditorProps): ReactNode;
+//#endregion
 //#region src/codemirror-editor.d.ts
 interface CodeMirrorEditorProps {
   /**
@@ -20,7 +172,7 @@ interface CodeMirrorEditorProps {
    * selected language is fetched, never the whole catalog). For a language outside this set,
    * or for parser options / mixed languages, pass your own support through `extensions`.
    */
-  language?: CodeMirrorLanguage$1;
+  language?: CodeMirrorLanguage;
   /**
    * Render-context schema for variable / member autocomplete — currently consumed by the
    * `minijinja` languages, where it makes `{{ }}` / `{% if %}` / `{% for x in %}` suggest the
@@ -29,7 +181,13 @@ interface CodeMirrorEditorProps {
    * reactively without recreating the editor. Memoize/hoist it — a new identity each render
    * re-normalizes and re-dispatches. No effect on languages that don't read it.
    */
-  context?: EditorContext$1;
+  context?: EditorContext;
+  /**
+   * Database schema for SQL table / column autocomplete. Updates reactively without
+   * recreating the editor; memoize/hoist it to avoid redundant serialization. No effect on
+   * languages that do not consume it.
+   */
+  sqlSchema?: SqlSchema;
   placeholder?: string;
   /**
    * Soft-wrap long lines.
@@ -142,6 +300,12 @@ interface CodeMirrorEditorProps {
    * Called when the editor loses focus.
    */
   onBlur?: () => void;
+  /**
+   * Accessible name for the editor textbox.
+   *
+   * @default "Editor content"
+   */
+  ariaLabel?: string;
 }
 /**
  * A controlled CodeMirror 6 document editor: the standard document extension bundle
@@ -158,6 +322,7 @@ declare function CodeMirrorEditor({
   onChange,
   language,
   context,
+  sqlSchema,
   placeholder,
   lineWrapping,
   showLineNumbers,
@@ -176,215 +341,8 @@ declare function CodeMirrorEditor({
   className,
   onMount,
   onFocus,
-  onBlur
+  onBlur,
+  ariaLabel
 }: CodeMirrorEditorProps): ReactNode;
 //#endregion
-//#region src/monaco-editor.d.ts
-/**
- * Baseline construction options shared by every inkstone Monaco editor: no minimap, compact
- * code type, in-place layout tracking, widgets floated above clipping containers, completion
- * tuned for API-assisted editing, thin scrollbars, and an embedded-friendly find widget.
- * Spread these to extend rather than replace: `options={{ ...DEFAULT_MONACO_OPTIONS, wordWrap: "on" }}`.
- */
-declare const DEFAULT_MONACO_OPTIONS: editor.IStandaloneEditorConstructionOptions;
-interface MonacoEditorProps {
-  /**
-   * The controlled document text.
-   */
-  value: string;
-  onChange?: (value: string) => void;
-  /**
-   * Monaco language id. Built-in ids autocomplete; any custom-registered id is also accepted.
-   *
-   * @default "javascript"
-   */
-  language?: MonacoLanguage$1;
-  /**
-   * Render with the dark theme. The component never reads the OS `prefers-color-scheme`;
-   * wire this to your app's color-scheme state.
-   *
-   * @default false
-   */
-  dark?: boolean;
-  /**
-   * UI locale for Monaco's built-in chrome (context menu, find widget, command palette …).
-   * Unlike everything else on this component, the locale is **page-global and locked by the
-   * first editor to mount** — Monaco resolves its UI strings once, at module evaluation — so
-   * later editors with a different value are ignored. Overrides `hostOptions.locale` (the
-   * same knob on the framework-agnostic host layer).
-   *
-   * @default "en"
-   */
-  locale?: MonacoUiLocale;
-  /**
-   * Placeholder shown while the document is empty. Maps to Monaco's native `placeholder`
-   * editor option (0.47+); an explicit `options.placeholder` still wins.
-   */
-  placeholder?: string;
-  /**
-   * Soft-wrap long lines (Monaco `wordWrap`).
-   *
-   * @default false
-   */
-  lineWrapping?: boolean;
-  /**
-   * Show the line-number gutter (Monaco `lineNumbers`). For relative/interval modes pass an
-   * explicit `options.lineNumbers`.
-   *
-   * @default false
-   */
-  showLineNumbers?: boolean;
-  /**
-   * Editor font size in px (Monaco `fontSize`). Omit to keep the inkstone default (14).
-   */
-  fontSize?: number;
-  /**
-   * Line height (Monaco `lineHeight`, and its convention): values below 8 multiply the font
-   * size (e.g. `1.6`), larger values are absolute pixels (e.g. `22`). `<CodeMirrorEditor>`
-   * mirrors the same semantics. Omit to keep the inkstone default (1.6).
-   */
-  lineHeight?: number;
-  /**
-   * Tab width in spaces (Monaco `tabSize`).
-   *
-   * @default 2
-   */
-  tabSize?: number;
-  /**
-   * Enable code folding (fold gutter + fold ranges). Unifies the toggle with
-   * `<CodeMirrorEditor>`; note Monaco folds by default, so this turns its folding off unless
-   * set.
-   *
-   * @default false
-   */
-  folding?: boolean;
-  /**
-   * Disable Monaco's right-click context menu (`contextmenu: false`). Right-clicks then fall
-   * through to the browser, so its native menu applies — intercept `contextmenu` on a
-   * wrapping element to suppress that as well.
-   *
-   * @default false
-   */
-  disableContextMenu?: boolean;
-  /**
-   * Swallow the find/replace widget's keyboard entries — Ctrl/Cmd+F (find), Ctrl+H and
-   * Cmd+Alt+F (replace). Scoped to this editor via a context key: the standalone keybinding
-   * service is page-global, so an unscoped rule would rewire every editor on the page.
-   * Fixed at creation.
-   *
-   * @default false
-   */
-  disableFind?: boolean;
-  /**
-   * Swallow the command palette's keyboard entry, F1 — Monaco never binds Ctrl+Shift+P
-   * (that is a VS Code binding). While the context menu is enabled, its "Command Palette"
-   * item still opens the palette; pair with {@link disableContextMenu} to remove every
-   * entry point. Fixed at creation.
-   *
-   * @default false
-   */
-  disableCommandPalette?: boolean;
-  /**
-   * Model path — give each logically distinct document its own so view state (cursor,
-   * folds) survives remounts.
-   */
-  path?: string;
-  height?: string | number;
-  width?: string | number;
-  className?: string;
-  /**
-   * Extra construction options, merged over {@link DEFAULT_MONACO_OPTIONS}.
-   */
-  options?: editor.IStandaloneEditorConstructionOptions;
-  /**
-   * Host bring-up options (UI locale, language workers). The Monaco host is a process-wide
-   * singleton, so the first mounted editor wins and later values are ignored.
-   */
-  hostOptions?: MonacoHostOptions;
-  /**
-   * Shown while the host, highlighter, and editor chunk load.
-   *
-   * @default "Loading editor…"
-   */
-  loading?: ReactNode;
-  /**
-   * Shown when the Monaco host fails to load (e.g. a stale chunk 404 after a redeploy).
-   * The failure is not cached by the host singleton, so a fresh mount retries.
-   *
-   * @default "Editor failed to load"
-   */
-  failure?: ReactNode;
-  /**
-   * Runs after inkstone's own pre-mount setup (Shiki theme registration).
-   */
-  beforeMount?: BeforeMount;
-  onMount?: OnMount;
-  /**
-   * Called when the editor's text area gains focus (Monaco `onDidFocusEditorText`).
-   */
-  onFocus?: () => void;
-  /**
-   * Called when the editor's text area loses focus (Monaco `onDidBlurEditorText`).
-   */
-  onBlur?: () => void;
-}
-/**
- * A preconfigured, offline Monaco editor: bundled workers (no CDN), Shiki catppuccin
- * highlighting with light/dark switching, and sensible document defaults — drop it in with
- * `value` / `onChange` and everything else is wired. The UI speaks Monaco's stock English;
- * pass `hostOptions={{ locale: "zh-cn" }}` for the official Simplified-Chinese chrome.
- *
- * Mounting is gated on the Monaco host and the Shiki highlighter so the first paint already
- * has the right theme; if the highlighter fails to load, the editor falls back to Monaco's
- * built-in themes and stays usable.
- *
- * Do not `import "monaco-editor"` statically elsewhere in the app — that would evaluate
- * Monaco before its UI locale is set (see `ensureMonacoHost`). Type-only imports are fine.
- */
-declare function MonacoEditor({
-  value,
-  onChange,
-  language,
-  dark,
-  locale,
-  placeholder,
-  lineWrapping,
-  showLineNumbers,
-  folding,
-  disableContextMenu,
-  disableFind,
-  disableCommandPalette,
-  fontSize,
-  lineHeight,
-  tabSize,
-  path,
-  height,
-  width,
-  className,
-  options,
-  hostOptions,
-  loading,
-  failure,
-  beforeMount,
-  onMount,
-  onFocus,
-  onBlur
-}: MonacoEditorProps): ReactNode;
-//#endregion
-//#region src/use-shiki-highlighter.d.ts
-type ShikiState = "loading" | "ready" | "failed";
-/**
- * Load the shared Shiki highlighter and expose its lifecycle to gate editor mounting:
- * waiting for `ready` before creating the editor avoids a default-theme flash (and the
- * "theme not found" console error) on first paint; on `failed` the caller falls back to
- * the engine's built-in theme so the editor stays usable.
- *
- * `highlighterRef` is for pre-mount hooks (Monaco `beforeMount`) that must read the
- * instance synchronously before the editor is created.
- */
-declare function useShikiHighlighter(): {
-  state: ShikiState;
-  highlighterRef: RefObject<HighlighterCore | null>;
-};
-//#endregion
-export { CodeMirrorEditor, type CodeMirrorEditorProps, type CodeMirrorLanguage, DEFAULT_MONACO_OPTIONS, type EditorContext, MonacoEditor, type MonacoEditorProps, type MonacoLanguage, type ShikiState, codeMirrorLanguages, normalizeContext, searchPhrasesZhCn, useShikiHighlighter };
+export { codeMirrorLanguages as a, CodeMirrorEditor as c, CodeMirrorDiffEditorProps as d, SqlSchema$1 as i, CodeMirrorEditorProps as l, EditorContext$1 as n, normalizeContext$1 as o, MergeView$1 as r, searchPhrasesZhCn$1 as s, CodeMirrorLanguage$1 as t, CodeMirrorDiffEditor as u };

package/dist/codemirror.d.ts

@@ -0,0 +1,2 @@
+import { a as codeMirrorLanguages, c as CodeMirrorEditor, d as CodeMirrorDiffEditorProps, i as SqlSchema, l as CodeMirrorEditorProps, n as EditorContext, o as normalizeContext, r as MergeView, s as searchPhrasesZhCn, t as CodeMirrorLanguage, u as CodeMirrorDiffEditor } from "./codemirror-B3GlIVaX.js";
+export { CodeMirrorDiffEditor, type CodeMirrorDiffEditorProps, CodeMirrorEditor, type CodeMirrorEditorProps, type CodeMirrorLanguage, type EditorContext, type MergeView, type SqlSchema, codeMirrorLanguages, normalizeContext, searchPhrasesZhCn };

package/dist/codemirror.js

@@ -0,0 +1,2 @@
+import { a as CodeMirrorDiffEditor, i as CodeMirrorEditor, n as normalizeContext, r as searchPhrasesZhCn, t as codeMirrorLanguages } from "./codemirror-B27C5np1.js";
+export { CodeMirrorDiffEditor, CodeMirrorEditor, codeMirrorLanguages, normalizeContext, searchPhrasesZhCn };