@solidev/data 1.0.1 → 1.1.1

package/package.json

@@ -1,13 +1,26 @@
 {
   "name": "@solidev/data",
-  "version": "1.0.1",
+  "version": "1.1.1",
   "license": "AGPL-3.0-only",
   "peerDependencies": {
     "@angular/common": "^22",
     "@angular/core": "^22",
+    "@codemirror/commands": "^6",
+    "@codemirror/lang-markdown": "^6",
+    "@codemirror/language": "^6",
+    "@codemirror/state": "^6",
+    "@codemirror/view": "^6",
+    "@lezer/highlight": "^1",
     "@ng-bootstrap/ng-bootstrap": "^21",
     "jwt-decode": "^4",
-    "ngx-editor": "^19.0.0-beta.1"
+    "prosemirror-commands": "^1",
+    "prosemirror-history": "^1",
+    "prosemirror-inputrules": "^1",
+    "prosemirror-keymap": "^1",
+    "prosemirror-model": "^1",
+    "prosemirror-schema-list": "^1",
+    "prosemirror-state": "^1",
+    "prosemirror-view": "^1"
   },
   "dependencies": {
     "tslib": "^2.8"
@@ -23,6 +36,10 @@
       "types": "./types/solidev-data.d.ts",
       "default": "./fesm2022/solidev-data.mjs"
     },
+    "./mdedit": {
+      "types": "./types/solidev-data-mdedit.d.ts",
+      "default": "./fesm2022/solidev-data-mdedit.mjs"
+    },
     "./richedit": {
       "types": "./types/solidev-data-richedit.d.ts",
       "default": "./fesm2022/solidev-data-richedit.mjs"

package/types/solidev-data-mdedit.d.ts

@@ -0,0 +1,226 @@
+import * as _angular_core from '@angular/core';
+import { DataModel, FieldEditorBase } from '@solidev/data';
+import { StateCommand, EditorState, Compartment, Extension } from '@codemirror/state';
+import { HighlightStyle } from '@codemirror/language';
+
+/**
+ * Toggle a symmetric inline delimiter — `**` for bold, `*` for italic, `~~` for
+ * strikethrough, `` ` `` for code.
+ *
+ * Wraps the selection, or unwraps it when the delimiters are already there,
+ * whether they sit just outside the selection (the usual case after a previous
+ * toggle) or inside it (the user selected them along with the text). On an
+ * empty selection it inserts the pair and leaves the cursor between the two
+ * halves, so typing continues inside the mark.
+ */
+declare function toggleInlineMark(delim: string): StateCommand;
+/** Toggle `**bold**` around the selection. */
+declare const toggleBold: StateCommand;
+/** Toggle `*italic*` around the selection. */
+declare const toggleItalic: StateCommand;
+/** Toggle `~~strikethrough~~` around the selection (GFM). */
+declare const toggleStrikethrough: StateCommand;
+/** Toggle `` `code` `` around the selection. */
+declare const toggleInlineCode: StateCommand;
+/**
+ * Set the heading level of every selected line, `0` meaning plain paragraph.
+ *
+ * This sets rather than toggles: picking "Heading 2" twice leaves an `h2`, and
+ * the way back to a paragraph is `setHeading(0)` — which is what the toolbar's
+ * "Paragraphe" entry does. Returns false when nothing would change, as a
+ * CodeMirror command should.
+ */
+declare function setHeading(level: number): StateCommand;
+/** Toggle `> ` blockquote markers on the selected lines. */
+declare const toggleQuote: StateCommand;
+/** Toggle `- ` bullets on the selected lines; `*` and `+` bullets count as set. */
+declare const toggleBulletList: StateCommand;
+/** Toggle `1. ` numbering on the selected lines, renumbering from one. */
+declare const toggleOrderedList: StateCommand;
+/**
+ * Turn the selection into a link.
+ *
+ * With text selected it becomes `[text](url)` and the `url` placeholder is left
+ * selected, ready to be typed over. With no selection the whole
+ * `[text](url)` skeleton is inserted and `text` is selected instead.
+ */
+declare const insertLink: StateCommand;
+/** What the toolbar needs to know to render its buttons pressed or not. */
+interface MarkdownActiveState {
+    bold: boolean;
+    italic: boolean;
+    strike: boolean;
+    code: boolean;
+    quote: boolean;
+    bulletList: boolean;
+    orderedList: boolean;
+    link: boolean;
+    /** Heading level under the cursor, `0` outside any heading. */
+    heading: number;
+}
+/**
+ * Which markdown constructs the cursor currently sits in.
+ *
+ * Read from the syntax tree rather than by matching the raw text, so nesting
+ * and escapes are handled by the parser. Drives `aria-pressed` on the toolbar.
+ */
+declare function markdownActive(state: EditorState): MarkdownActiveState;
+
+/** A button the `mdedit` toolbar knows how to render. */
+type MdToolbarItem = 'bold' | 'italic' | 'strike' | 'code' | 'quote' | 'bullet_list' | 'ordered_list' | 'link' | 'heading';
+/** Toolbar layout: groups of items, rendered as Bootstrap button groups. */
+type MdToolbar = MdToolbarItem[][];
+/**
+ * Named toolbar presets for {@link MdeditComponent}, selectable through its
+ * `toolbar` input.
+ *
+ * - `default`: marks, a heading dropdown, quote and code, lists, links.
+ * - `light`: a reduced set — bold, italic, bullets, links.
+ * - `none`: empty; the component hides the toolbar entirely for this value.
+ *
+ * An `MdToolbar` can also be passed directly when neither preset fits.
+ */
+declare const MdEditToolbars: Record<string, MdToolbar>;
+/** What a plain toolbar button needs: an icon, a label, a command, a state. */
+interface MdButtonDefinition {
+    icon: string;
+    label: string;
+    command: StateCommand;
+    active: Exclude<keyof MarkdownActiveState, 'heading'>;
+}
+/** A resolved toolbar entry, ready for the template to render. */
+type MdToolbarEntry = ({
+    kind: 'button';
+} & MdButtonDefinition) | {
+    kind: 'heading';
+    label: string;
+};
+declare class MdeditComponent<FT, T extends DataModel> extends FieldEditorBase<FT, T> {
+    /** Toolbar preset name from {@link MdEditToolbars}, or an explicit toolbar. */
+    toolbar: _angular_core.InputSignal<MdToolbar | "none" | "default" | "light">;
+    /** Text shown while the document is empty. */
+    placeholder: _angular_core.InputSignal<string>;
+    /** Markdown constructs under the cursor, driving `aria-pressed`. */
+    readonly active: _angular_core.WritableSignal<MarkdownActiveState>;
+    /** Heading levels offered by the dropdown. */
+    readonly headingLevels: {
+        level: number;
+        label: string;
+    }[];
+    /** Toolbar resolved from {@link toolbar}, as entries the template can render. */
+    readonly groups: _angular_core.Signal<MdToolbarEntry[][]>;
+    private readonly host;
+    private readonly destroyRef;
+    /** Holds the read-only extensions, so editability can be reconfigured live. */
+    private readonly readOnly;
+    private view?;
+    constructor();
+    /**
+     * Wire the resolved control to the editor, in both directions.
+     *
+     * The base picks the control (`[fc]`, `[form]`, or its own) and seeds it;
+     * this adds the CodeMirror half.
+     */
+    ngOnInit(): void;
+    /**
+     * Run a toolbar command against the editor and hand focus back, so a click
+     * on the toolbar does not take the caret out of the document.
+     */
+    run(command: StateCommand): void;
+    /** Apply the heading level picked in the dropdown to the current line(s). */
+    setHeadingLevel(value: string): void;
+    /**
+     * Build or tear down the CodeMirror view, following the host element.
+     *
+     * Toggling back to the read-only view removes the host, which would leave a
+     * detached view behind and make the next mount a no-op. The control keeps the
+     * value across the round trip, so a fresh view is seeded correctly.
+     */
+    private syncView;
+    /** Build the CodeMirror view inside the host element. */
+    private mount;
+    /**
+     * Push a document into the control, unless it is already there.
+     *
+     * `setValue` emits even when the value is unchanged, so without this guard an
+     * external `setValue` would come back through the editor as a second
+     * `valueChanges` — and a second {@link changed} emission for one edit.
+     */
+    private pushToControl;
+    /** Push a control value into the document, unless it is already there. */
+    private applyValue;
+    /** Mirror the control's enabled/disabled status onto the editor. */
+    private applyEditable;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdeditComponent<any, any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MdeditComponent<any, any>, "data-mdedit", never, { "toolbar": { "alias": "toolbar"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/** Options accepted by {@link markdownSetup}. */
+interface MarkdownSetupOptions {
+    /**
+     * Compartment the read-only extensions are installed in, so the caller can
+     * flip editability later with `compartment.reconfigure(readOnlyExtension(v))`.
+     * Create one per editor instance — compartments are not shareable.
+     */
+    readOnly?: Compartment;
+    /** Whether the editor starts read-only. */
+    readOnlyInitially?: boolean;
+    /** Text shown while the document is empty. */
+    placeholder?: string;
+    /** Called with the full markdown source after every document change. */
+    onChange?: (doc: string) => void;
+    /** Called after every state update, for toolbar active-state tracking. */
+    onStateChange?: (state: EditorState) => void;
+    /** Id of the element labelling the editor, wired as `aria-labelledby`. */
+    labelledBy?: string;
+}
+/**
+ * The extensions that make an `EditorView` behave as a markdown source editor.
+ *
+ * Deliberately not CodeMirror's `basicSetup`: this edits prose, so there are no
+ * line numbers, no fold gutter and no bracket matching — just markdown parsing,
+ * history, wrapping, and the styling from {@link markdownStyling}.
+ *
+ * The markdown dialect is `markdownLanguage`, i.e. GFM: tables, strikethrough
+ * and task lists parse. Fenced code blocks are recognised but their content is
+ * not highlighted per-language; that would need `@codemirror/language-data` and
+ * its lazily loaded grammars, which is out of scope here.
+ */
+declare function markdownSetup(options?: MarkdownSetupOptions): Extension[];
+/**
+ * Read-only state for a given editability, meant to be reconfigured into the
+ * compartment passed to {@link markdownSetup}.
+ *
+ * Both facets are needed: `EditorState.readOnly` stops commands from changing
+ * the document, `EditorView.editable` takes `contenteditable` off the DOM node
+ * so the caret and the browser's own editing affordances go away too.
+ */
+declare function readOnlyExtension(readOnly: boolean): Extension;
+
+/**
+ * Syntax highlighting for the markdown *source*.
+ *
+ * The point of `mdedit` is that the markup stays on screen: `**bold**` keeps
+ * its asterisks, a heading keeps its `#`. What this style does is make the
+ * source read like the document it describes — headings get bigger, `**bold**`
+ * renders bold, code turns monospace — while the markers themselves
+ * ({@link tags.processingInstruction}, {@link tags.meta}) are dimmed so they
+ * stay visible but recede.
+ *
+ * Colours come from Bootstrap CSS variables so the editor follows the host
+ * theme, including its dark mode, without shipping a palette of its own.
+ */
+declare const markdownHighlightStyle: HighlightStyle;
+/**
+ * Editor chrome: a box that matches Bootstrap's `.form-control`, including its
+ * focus ring, so an `mdedit` sits in a form without looking foreign.
+ */
+declare const markdownTheme: Extension;
+/**
+ * The whole visual layer — chrome plus source highlighting — as one extension,
+ * which is what {@link markdownSetup} installs.
+ */
+declare function markdownStyling(): Extension;
+
+export { MdEditToolbars, MdeditComponent, insertLink, markdownActive, markdownHighlightStyle, markdownSetup, markdownStyling, markdownTheme, readOnlyExtension, setHeading, toggleBold, toggleBulletList, toggleInlineCode, toggleInlineMark, toggleItalic, toggleOrderedList, toggleQuote, toggleStrikethrough };
+export type { MarkdownActiveState, MarkdownSetupOptions, MdToolbar, MdToolbarEntry, MdToolbarItem };

package/types/solidev-data-richedit.d.ts

@@ -1,8 +1,116 @@
 import * as i0 from '@angular/core';
-import { OnInit, OnDestroy, EventEmitter } from '@angular/core';
-import { Toolbar, Editor } from 'ngx-editor';
-import { FormControl } from '@angular/forms';
-import { DataModel, BaseFieldManager } from '@solidev/data';
+import { OnInit } from '@angular/core';
+import { DataModel, FieldEditorBase } from '@solidev/data';
+import { EditorState, Command } from 'prosemirror-state';
+import { EditorView } from 'prosemirror-view';
+import * as prosemirror_model from 'prosemirror-model';
+import { Schema, Node, MarkType, NodeType, Attrs } from 'prosemirror-model';
+
+/** Options accepted by the {@link Editor} constructor. */
+interface EditorOptions {
+    /** Initial content, as an HTML string. */
+    content?: string;
+    /** Whether the document starts editable. */
+    editable?: boolean;
+    /** Text shown while the document is empty. */
+    placeholder?: string;
+    /** Id of the element labelling the editor, wired as `aria-labelledby`. */
+    labelledBy?: string;
+}
+/**
+ * The rich text engine behind `<data-richedit>`.
+ *
+ * Owns a ProseMirror `EditorView` and everything plugged into it, and speaks
+ * HTML at its edges — which is what the field values are. It replaces
+ * `ngx-editor`'s class of the same name and keeps the same shape of
+ * responsibility, so the Angular components around it stayed thin.
+ *
+ * The view is created detached: the menu bar and the editor component both
+ * receive the `Editor` before there is anywhere to put its DOM, and the editor
+ * component adopts {@link dom} when it renders.
+ *
+ * @example
+ * ```ts
+ * const editor = new Editor({ content: '<p>hello</p>' });
+ * editor.onChange((html) => console.log(html));
+ * document.body.appendChild(editor.dom);
+ * ```
+ */
+declare class Editor {
+    /** The underlying ProseMirror view. */
+    readonly view: EditorView;
+    private readonly changeListeners;
+    private readonly stateListeners;
+    /** Serialization of the current document — what {@link html} reports. */
+    private _html;
+    /**
+     * The last string handed in from outside.
+     *
+     * Parsing normalises (`<b>` becomes `<strong>`, `text-align:center` gains a
+     * space), so the loaded string and the serialized one often differ while
+     * meaning the same document. Keeping both is what lets {@link setContent}
+     * recognise "you are giving me back what you already gave me".
+     */
+    private _loaded;
+    private _editable;
+    constructor(options?: EditorOptions);
+    /** The editor's DOM node, ready to be placed in the document. */
+    get dom(): HTMLElement;
+    /** Current editor state, for menu bar queries. */
+    get state(): EditorState;
+    /** Current content, as an HTML string. */
+    get html(): string;
+    /** Whether the document accepts edits. */
+    get editable(): boolean;
+    /**
+     * Replace the content.
+     *
+     * A no-op when the HTML is the one already loaded, which is what keeps a
+     * form control writing its own value back from resetting the cursor on every
+     * keystroke. The replacement is kept out of the undo history — undoing back
+     * past a programmatic load is not something a user ever means.
+     */
+    setContent(html: string): void;
+    /** Enable or disable editing. */
+    setEditable(editable: boolean): void;
+    /** Run a command against the current state. Returns whether it applied. */
+    exec(command: Command): boolean;
+    /** Put the caret back in the document. */
+    focus(): void;
+    /** Listen to content changes. Returns a function that stops listening. */
+    onChange(listener: (html: string) => void): () => void;
+    /** Listen to state changes, including selection. Returns an unsubscribe. */
+    onStateChange(listener: (state: EditorState) => void): () => void;
+    /** Tear the view down and drop every listener. */
+    destroy(): void;
+}
+
+/**
+ * Toolbar configuration for `<data-richedit>`.
+ *
+ * The shape is the one `ngx-editor` used — an array of groups, each group an
+ * array of items, an item either a name or a `{heading: [...]}` dropdown — so
+ * toolbars written against the old editor keep compiling and keep working.
+ */
+/** Heading levels a heading dropdown can offer. */
+type TBHeadingItems = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
+/**
+ * Every item name the configuration accepts.
+ *
+ * The whole `ngx-editor` vocabulary is listed so existing configurations still
+ * type-check. Three of them — `image`, `indent` and `outdent` — have no
+ * implementation here and are skipped at render time with a warning naming
+ * them, rather than silently disappearing.
+ */
+type TBItems = 'bold' | 'italic' | 'code' | 'blockquote' | 'underline' | 'strike' | 'ordered_list' | 'bullet_list' | 'link' | 'image' | 'text_color' | 'background_color' | 'align_left' | 'align_center' | 'align_right' | 'align_justify' | 'horizontal_rule' | 'format_clear' | 'indent' | 'outdent' | 'superscript' | 'subscript' | 'undo' | 'redo';
+/** A heading dropdown, listing the levels it offers. */
+interface ToolbarDropdown {
+    heading?: TBHeadingItems[];
+}
+/** One entry in a toolbar group. */
+type ToolbarItem = TBItems | ToolbarDropdown;
+/** Groups of items, rendered as Bootstrap button groups. */
+type Toolbar = ToolbarItem[][];
 
 /**
  * Named toolbar presets for {@link RicheditComponent}, selectable through its
@@ -16,80 +124,189 @@ import { DataModel, BaseFieldManager } from '@solidev/data';
  * A `Toolbar` can also be passed directly to the component when neither preset
  * fits.
  */
-declare const RichEditToolbars: {
-    [index: string]: Toolbar;
-};
-declare class RicheditComponent<FT, T extends DataModel> implements OnInit, OnDestroy {
-    /** Model instance holding the field. */
-    model?: T;
-    /** Name of the rich text field to edit. */
-    field?: string;
-    /** Whether {@link toggleEdit} is allowed to enable editing. */
-    editable: boolean;
-    /** Whether the editor is currently enabled. Defaults to true. */
-    edit: boolean;
-    /**
-     * Layout, and whether {@link save} persists.
-     *
-     * `dd` renders a `<dt>`/`<dd>` block and is the only mode that saves to the
-     * API; `inline` and `form` render a label plus the editor and leave saving to
-     * the caller.
-     */
-    mode: "dd" | "inline" | "form";
-    /** Hide label (for inline forms) */
-    hideLabel: boolean;
-    /**
-     * Hide the built-in save button, for callers driving persistence themselves
-     * from the {@link changed} output.
-     */
-    hideButton: boolean;
-    /**
-     * Form control backing the editor.
-     *
-     * When supplied, the component uses it as-is and skips its own setup — no
-     * field manager lookup, no seeding from the model, and no {@link changed}
-     * emissions. When absent, one is created and wired up from `[model]` and
-     * `[field]`.
-     */
-    fc: FormControl<string | null>;
+declare const RichEditToolbars: Record<string, Toolbar>;
+declare class RicheditComponent<FT, T extends DataModel> extends FieldEditorBase<FT, T> implements OnInit {
     /** Toolbar preset name from {@link RichEditToolbars}, or an explicit toolbar. */
-    toolbar: "none" | "default" | "light" | Toolbar;
-    /** Emits the editor's HTML on every change. Only wired for an internal `fc`. */
-    changed: EventEmitter<string | null>;
-    /** Field manager for {@link field}; only resolved when `fc` is created here. */
-    manager?: BaseFieldManager<FT>;
-    /** Whether the manager declares the field required. */
-    required: boolean;
-    /** Underlying ngx-editor instance; destroyed with the component. */
+    toolbar: i0.InputSignal<Toolbar | "none" | "default" | "light">;
+    /** Underlying editor instance; destroyed with the component. */
     editor: Editor;
     /** Unused; kept for backwards compatibility. */
     html: string;
     /** Toolbar actually rendered, resolved from {@link toolbar}. */
     realToolbar: Toolbar;
+    private readonly destroyRef;
     /**
-     * Create the editor, resolve the toolbar, and — unless a `[fc]` was given —
-     * build a control seeded from the model field, enabled per `[edit]`, and
-     * relaying changes to {@link changed}.
+     * Build the engine and resolve the toolbar, then let the base resolve the
+     * control and relay its changes.
      */
     ngOnInit(): void;
-    /** Destroy the ngx-editor instance to release its resources. */
-    ngOnDestroy(): void;
-    /**
-     * Switch between read-only and editing by enabling or disabling the control.
-     * Forces read-only when `[editable]` is false.
-     */
-    toggleEdit(): void;
-    /**
-     * Write the editor content back to the model field, and persist it in `dd`
-     * mode only.
-     *
-     * In `inline` / `form` modes the model is updated in memory but no request is
-     * sent, leaving the save to the surrounding form. Does nothing without both a
-     * `[model]` and a `[field]`.
-     */
-    save(): Promise<void>;
     static ɵfac: i0.ɵɵFactoryDeclaration<RicheditComponent<any, any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<RicheditComponent<any, any>, "data-richedit", never, { "model": { "alias": "model"; "required": false; }; "field": { "alias": "field"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; "edit": { "alias": "edit"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "hideLabel": { "alias": "hideLabel"; "required": false; }; "hideButton": { "alias": "hideButton"; "required": false; }; "fc": { "alias": "fc"; "required": false; }; "toolbar": { "alias": "toolbar"; "required": false; }; }, { "changed": "changed"; }, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RicheditComponent<any, any>, "data-richedit", never, { "toolbar": { "alias": "toolbar"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
-export { RichEditToolbars, RicheditComponent };
+/** The schema itself — one instance, shared by every editor. */
+declare const schema: Schema<string, string>;
+/**
+ * Node types, resolved once and by name.
+ *
+ * `Schema.nodes` is an index signature, and this project turns on
+ * `noPropertyAccessFromIndexSignature`, so every lookup would otherwise need
+ * brackets at the call site.
+ */
+declare const nodeTypes: {
+    doc: prosemirror_model.NodeType;
+    paragraph: prosemirror_model.NodeType;
+    heading: prosemirror_model.NodeType;
+    blockquote: prosemirror_model.NodeType;
+    codeBlock: prosemirror_model.NodeType;
+    bulletList: prosemirror_model.NodeType;
+    orderedList: prosemirror_model.NodeType;
+    listItem: prosemirror_model.NodeType;
+    hardBreak: prosemirror_model.NodeType;
+    horizontalRule: prosemirror_model.NodeType;
+    image: prosemirror_model.NodeType;
+};
+/** Mark types, resolved once and by name. See {@link nodeTypes}. */
+declare const markTypes: {
+    strong: prosemirror_model.MarkType;
+    em: prosemirror_model.MarkType;
+    underline: prosemirror_model.MarkType;
+    strike: prosemirror_model.MarkType;
+    code: prosemirror_model.MarkType;
+    link: prosemirror_model.MarkType;
+    textColor: prosemirror_model.MarkType;
+    backgroundColor: prosemirror_model.MarkType;
+};
+/** Text alignments an alignable block accepts. */
+type Alignment = 'left' | 'center' | 'right' | 'justify';
+
+/**
+ * Parse an HTML string into a document node.
+ *
+ * Anything the schema has no rule for is dropped, which is why the schema keeps
+ * parse rules for constructs the toolbar cannot produce.
+ */
+declare function fromHTML(html: string, schema?: Schema): Node;
+/**
+ * Serialize a document node back to an HTML string.
+ *
+ * An empty document serializes to `''`, not to the `<p></p>` `ngx-editor`
+ * wrote. A field the user cleared should read as empty for the consumer — a
+ * paragraph containing nothing is truthy, and every `if (model.description)`
+ * built on it was quietly wrong.
+ */
+declare function toHTML(doc: Node, schema?: Schema): string;
+/**
+ * Whether a document holds nothing but one empty textblock.
+ *
+ * Drives both the placeholder decoration and {@link toHTML}'s empty case. Note
+ * that an empty *heading* counts: the user typed `# ` and nothing else, so
+ * there is still no content to store.
+ */
+declare function isEmpty(doc: Node): boolean;
+
+/**
+ * Whether the mark is on the whole selection — or, with the cursor collapsed,
+ * whether the next character typed would carry it.
+ */
+declare function isMarkActive(state: EditorState, type: MarkType): boolean;
+/**
+ * Whether a node of that type (with those attributes, if given) contains or
+ * intersects the selection.
+ *
+ * `nodesBetween` walks down from the document, so this reports ancestors too —
+ * which is what makes it work for blockquotes and lists, where the cursor sits
+ * in a paragraph nested inside the node being asked about.
+ */
+declare function isNodeActive(state: EditorState, type: NodeType, attrs?: Attrs): boolean;
+/** Toggle a mark over the selection. */
+declare function toggleMarkCommand(type: MarkType): Command;
+/** Toggle `<strong>` over the selection. */
+declare const toggleBold: Command;
+/** Toggle `<em>` over the selection. */
+declare const toggleItalic: Command;
+/** Toggle `<u>` over the selection. */
+declare const toggleUnderline: Command;
+/** Toggle `<s>` over the selection. */
+declare const toggleStrike: Command;
+/** Toggle `<code>` over the selection. */
+declare const toggleCode: Command;
+/**
+ * Make the selected blocks headings of that level.
+ *
+ * This is what the menu bar's dropdown uses: picking a level in a list should
+ * put you at that level, not toggle you out of it.
+ */
+declare function setHeading(level: number): Command;
+/**
+ * Switch the selected blocks between a heading of that level and a paragraph.
+ *
+ * Unlike {@link setHeading}, picking the level already in force turns it back
+ * into a paragraph — the behaviour a toggle button wants.
+ */
+declare function toggleHeading(level: number): Command;
+/** Turn the selected blocks into paragraphs. */
+declare const setParagraph: Command;
+/** Toggle a code block over the selected blocks. */
+declare const toggleCodeBlock: Command;
+/** Wrap the selection in a blockquote, or lift it back out. */
+declare const toggleBlockquote: Command;
+/** Wrap the selection in a list of that type, or lift it back out. */
+declare function toggleList(type: NodeType): Command;
+/** Toggle a bullet list around the selection. */
+declare const toggleBulletList: Command;
+/** Toggle an ordered list around the selection. */
+declare const toggleOrderedList: Command;
+/**
+ * Set the text alignment of every paragraph and heading in the selection.
+ *
+ * Alignment lives on the block as an attribute and serializes to
+ * `style="text-align:…"`, the way `ngx-editor` stored it. `null` clears it.
+ */
+declare function setAlign(align: Alignment | null): Command;
+/** The alignment in force on the block holding the cursor, if any. */
+declare function activeAlignment(state: EditorState): Alignment | null;
+/** The heading level in force, or 0 outside a heading. */
+declare function activeHeading(state: EditorState): number;
+/**
+ * Apply a colour mark to the selection, replacing any colour already there.
+ *
+ * With the cursor collapsed the mark is stored instead, so it applies to what
+ * the user types next — the same behaviour as bold on an empty selection.
+ */
+declare function setColor(type: MarkType, attrs: Attrs): Command;
+/** Drop a colour mark from the selection. */
+declare function removeColor(type: MarkType): Command;
+/** The colour currently carried by the selection, for the colour pickers. */
+declare function activeColor(state: EditorState, type: MarkType, attr: string): string | null;
+/**
+ * The span of the link under the cursor, or the selection when it is not
+ * collapsed.
+ *
+ * Walks outwards from the cursor over the sibling text nodes that carry the
+ * mark, so "remove link" works with the caret merely inside the link rather
+ * than with the whole thing selected.
+ */
+declare function linkRange(state: EditorState): {
+    from: number;
+    to: number;
+} | null;
+/** The href of the link under the cursor, for prefilling the link form. */
+declare function activeLink(state: EditorState): string | null;
+/**
+ * Link the selection.
+ *
+ * Takes the href as an argument rather than prompting, so the command stays
+ * free of DOM and the menu bar owns the form. With the caret inside an existing
+ * link and nothing selected, that link's whole span is re-linked.
+ */
+declare function addLink(href: string, title?: string | null): Command;
+/** Unlink the link under the cursor, or the selection. */
+declare const removeLink: Command;
+/** Insert a horizontal rule at the selection. */
+declare const insertHorizontalRule: Command;
+/** Drop every mark from the selection and put its blocks back to paragraphs. */
+declare const clearFormat: Command;
+
+export { Editor, RichEditToolbars, RicheditComponent, activeAlignment, activeColor, activeHeading, activeLink, addLink, clearFormat, fromHTML, insertHorizontalRule, isEmpty, isMarkActive, isNodeActive, linkRange, markTypes, nodeTypes, removeColor, removeLink, schema, setAlign, setColor, setHeading, setParagraph, toHTML, toggleBlockquote, toggleBold, toggleBulletList, toggleCode, toggleCodeBlock, toggleHeading, toggleItalic, toggleList, toggleMarkCommand, toggleOrderedList, toggleStrike, toggleUnderline };
+export type { Alignment, EditorOptions, TBHeadingItems, TBItems, Toolbar, ToolbarDropdown, ToolbarItem };