@thomasfosterau/effect-richtext 0.0.0-stage → 0.1.0

package/dist/compat/state.d.ts

@@ -0,0 +1,415 @@
+import { Mappable } from "../transform/map.js";
+import { Command as Command$1, Transaction as Transaction$1 } from "../state/transaction.js";
+import { AllSelection as AllSelection$1, NodeSelection as NodeSelection$1, Selection as Selection$1, SelectionBookmark as SelectionBookmark$1, SelectionRange as SelectionRange$1, TextSelection as TextSelection$1 } from "../state/selection.js";
+import { EditorState as EditorState$1 } from "../state/state.js";
+import { Plugin as Plugin$1, PluginKey as PluginKey$1 } from "../state/plugin.js";
+import "../state.js";
+import { CORE } from "./internal/core.js";
+import { Mark, MarkType, Node, ResolvedPos, Schema, Slice } from "./model.js";
+import { Transform } from "./transform.js";
+import { EditorProps, EditorView } from "./view.js";
+/**
+ * Represents a selected range in a document.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class SelectionRange {
+  /** @internal */
+  readonly [CORE]: SelectionRange$1;
+  /** Create a range. */
+  constructor($from: ResolvedPos, $to: ResolvedPos);
+  /** The lower bound of the range. */
+  get $from(): ResolvedPos;
+  /** The upper bound of the range. */
+  get $to(): ResolvedPos;
+}
+/**
+ * A lightweight, document-independent representation of a selection.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface SelectionBookmark {
+  map(mapping: Mappable): SelectionBookmark;
+  resolve(doc: Node): Selection;
+}
+/**
+ * Superclass for editor selections. Subclass it to define custom
+ * selection types: subclasses are adapted into core selections.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare abstract class Selection {
+  /** @internal */
+  readonly [CORE]: Selection$1;
+  /** Initialize a selection with the head and anchor and ranges. */
+  constructor($anchor: ResolvedPos, $head: ResolvedPos, ranges?: ReadonlyArray<SelectionRange>);
+  /** The ranges covered by the selection. */
+  get ranges(): ReadonlyArray<SelectionRange>;
+  /** The resolved anchor of the selection. */
+  get $anchor(): ResolvedPos;
+  /** The resolved head of the selection. */
+  get $head(): ResolvedPos;
+  /** The selection's anchor, as an unresolved position. */
+  get anchor(): number;
+  /** The selection's head. */
+  get head(): number;
+  /** The lower bound of the selection's main range. */
+  get from(): number;
+  /** The upper bound of the selection's main range. */
+  get to(): number;
+  /** The resolved lower bound of the selection's main range. */
+  get $from(): ResolvedPos;
+  /** The resolved upper bound of the selection's main range. */
+  get $to(): ResolvedPos;
+  /** Indicates whether the selection contains any content. */
+  get empty(): boolean;
+  /** Controls whether, when a selection of this type is active in the browser, the selected range should be visible to the user. */
+  get visible(): boolean;
+  /** Test whether the selection is the same as another selection. */
+  abstract eq(selection: Selection): boolean;
+  /** Map this selection through a mappable thing. */
+  abstract map(doc: Node, mapping: Mappable): Selection;
+  /** Get the content of this selection as a slice. */
+  content(): Slice;
+  /** Replace the selection with a slice or, if no slice is given, delete the selection. */
+  replace(tr: Transaction, content?: Slice): void;
+  /** Replace the selection with the given node, appending the changes to the given transaction. */
+  replaceWith(tr: Transaction, node: Node): void;
+  /** Convert the selection to a JSON representation. */
+  abstract toJSON(): any;
+  /** Find a valid cursor or leaf node selection starting at the given position and searching back if `dir` is negative, and forward if positive. */
+  static findFrom($pos: ResolvedPos, dir: number, textOnly?: boolean): Selection | null;
+  /** Find a valid cursor or leaf node selection near the given position. */
+  static near($pos: ResolvedPos, bias?: number): Selection;
+  /** Find the cursor or leaf node selection closest to the start of the given document. */
+  static atStart(doc: Node): Selection;
+  /** Find the cursor or leaf node selection closest to the end of the given document. */
+  static atEnd(doc: Node): Selection;
+  /** Deserialize the JSON representation of a selection. */
+  static fromJSON(doc: Node, json: any): Selection;
+  /** To be able to deserialize selections from JSON, custom selection classes must register themselves with an ID string. */
+  static jsonID(id: string, selectionClass: {
+    fromJSON(doc: Node, json: any): Selection;
+  }): any;
+  /** Get a bookmark for this selection. */
+  getBookmark(): SelectionBookmark;
+}
+/**
+ * A text selection represents a classical editor selection, with a
+ * head (the moving side) and anchor (immobile side), both of which
+ * point into textblock nodes.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class TextSelection extends Selection {
+  /** @internal */
+  readonly [CORE]: TextSelection$1;
+  /** Construct a text selection between the given points. */
+  constructor($anchor: ResolvedPos, $head?: ResolvedPos);
+  /** Returns a resolved position if this is a cursor selection (an empty text selection), and null otherwise. */
+  get $cursor(): ResolvedPos | null;
+  map(doc: Node, mapping: Mappable): Selection;
+  eq(other: Selection): boolean;
+  toJSON(): any;
+  /** @internal */
+  static fromJSON(doc: Node, json: any): TextSelection;
+  /** Create a text selection from non-resolved positions. */
+  static create(doc: Node, anchor: number, head?: number): TextSelection;
+  /** Return a text selection that spans the given positions or, if they aren't text positions, find a text selection near them. */
+  static between($anchor: ResolvedPos, $head: ResolvedPos, bias?: number): Selection;
+}
+/**
+ * A node selection is a selection that points at a single node.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class NodeSelection extends Selection {
+  /** @internal */
+  readonly [CORE]: NodeSelection$1;
+  /** Create a node selection. Does not verify the validity of its argument. */
+  constructor($pos: ResolvedPos);
+  /** The selected node. */
+  get node(): Node;
+  map(doc: Node, mapping: Mappable): Selection;
+  eq(other: Selection): boolean;
+  toJSON(): any;
+  /** @internal */
+  static fromJSON(doc: Node, json: any): NodeSelection;
+  /** Create a node selection from non-resolved positions. */
+  static create(doc: Node, from: number): NodeSelection;
+  /** Determines whether the given node may be selected as a node selection. */
+  static isSelectable(node: Node): boolean;
+}
+/**
+ * A selection type that represents selecting the whole document.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class AllSelection extends Selection {
+  /** @internal */
+  readonly [CORE]: AllSelection$1;
+  /** Create an all-selection over the given document. */
+  constructor(doc: Node);
+  map(doc: Node): Selection;
+  eq(other: Selection): boolean;
+  toJSON(): any;
+}
+/**
+ * Commands are functions that take a state and a an optional
+ * transaction dispatch function and determine whether they are
+ * applicable for the given state.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type Command = (state: EditorState, dispatch?: (tr: Transaction) => void, view?: EditorView) => boolean;
+/**
+ * An editor state transaction, which can be applied to a state to
+ * create an updated state.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class Transaction extends Transform {
+  /** @internal */
+  readonly [CORE]: Transaction$1;
+  /** @internal */
+  private constructor();
+  /** The timestamp associated with this transaction. */
+  get time(): number;
+  set time(value: number);
+  /** The stored marks set by this transaction, if any. */
+  get storedMarks(): ReadonlyArray<Mark> | null;
+  /** The transaction's current selection. */
+  get selection(): Selection;
+  /** Update the transaction's current selection. */
+  setSelection(selection: Selection): this;
+  /** Whether the selection was explicitly updated by this transaction. */
+  get selectionSet(): boolean;
+  /** Set the current stored marks. */
+  setStoredMarks(marks: ReadonlyArray<Mark> | null): this;
+  /** Make sure the current stored marks or, if that is null, the marks at the selection, match the given set of marks. */
+  ensureMarks(marks: ReadonlyArray<Mark>): this;
+  /** Add a mark to the set of stored marks. */
+  addStoredMark(mark: Mark): this;
+  /** Remove a mark or mark type from the set of stored marks. */
+  removeStoredMark(mark: Mark | MarkType): this;
+  /** Whether the stored marks were explicitly set for this transaction. */
+  get storedMarksSet(): boolean;
+  /** Update the timestamp for the transaction. */
+  setTime(time: number): this;
+  /** Replace the current selection with the given slice. */
+  replaceSelection(slice: Slice): this;
+  /** Replace the selection with the given node. */
+  replaceSelectionWith(node: Node, inheritMarks?: boolean): this;
+  /** Delete the selection. */
+  deleteSelection(): this;
+  /** Replace the given range, or the selection if no range is given, with a text node containing the given string. */
+  insertText(text: string, from?: number, to?: number): this;
+  /** Store a metadata property in this transaction, keyed either by name or by plugin. */
+  setMeta(key: string | Plugin | PluginKey, value: any): this;
+  /** Retrieve a metadata property for a given name or plugin. */
+  getMeta(key: string | Plugin | PluginKey): any;
+  /** Returns true if this transaction doesn't contain any metadata, and can thus safely be extended. */
+  get isGeneric(): boolean;
+  /** Indicate that the editor should scroll the selection into view when updated to the state produced by this transaction. */
+  scrollIntoView(): this;
+  /** True when this transaction has had `scrollIntoView` called on it. */
+  get scrolledIntoView(): boolean;
+}
+/**
+ * A plugin's state field.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface StateField<T> {
+  init: (config: EditorStateConfig, instance: EditorState) => T;
+  apply: (tr: Transaction, value: T, oldState: EditorState, newState: EditorState) => T;
+  toJSON?: ((value: T) => any) | undefined;
+  fromJSON?: ((config: EditorStateConfig, value: any, state: EditorState) => T) | undefined;
+}
+/**
+ * A stateful object that can be installed in an editor by a plugin.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type PluginView = {
+  update?: (view: EditorView, prevState: EditorState) => void;
+  destroy?: () => void;
+};
+/**
+ * This is the type passed to the `Plugin` constructor.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface PluginSpec<PluginState> {
+  props?: EditorProps<Plugin<PluginState>> | undefined;
+  state?: StateField<PluginState> | undefined;
+  key?: PluginKey | undefined;
+  view?: ((view: EditorView) => PluginView) | undefined;
+  filterTransaction?: ((tr: Transaction, state: EditorState) => boolean) | undefined;
+  appendTransaction?: (transactions: ReadonlyArray<Transaction>, oldState: EditorState, newState: EditorState) => Transaction | null | undefined | void;
+  [key: string]: any;
+}
+/**
+ * Plugins bundle functionality that can be added to an editor.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class Plugin<PluginState = any> {
+  /** @internal */
+  readonly [CORE]: Plugin$1<any, any, any, any>;
+  /** The props exported by this plugin. */
+  readonly props: EditorProps<Plugin<PluginState>>;
+  /** The plugin's spec object. */
+  readonly spec: PluginSpec<PluginState>;
+  /** Create a plugin. */
+  constructor(spec: PluginSpec<PluginState>);
+  /** @internal */
+  get key(): string;
+  /** Extract the plugin's state field from an editor state. */
+  getState(state: EditorState): PluginState | undefined;
+}
+/**
+ * A key is used to tag plugins in a way that makes it possible to find
+ * them, given an editor state.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class PluginKey<PluginState = any> {
+  /** @internal */
+  readonly [CORE]: PluginKey$1<PluginState>;
+  /** Create a plugin key. */
+  constructor(name?: string);
+  /** @internal */
+  get key(): string;
+  /** Get the active plugin with this key, if any, from an editor state. */
+  get(state: EditorState): Plugin<PluginState> | undefined;
+  /** Get the plugin's state from an editor state. */
+  getState(state: EditorState): PluginState | undefined;
+}
+/**
+ * The type of object passed to `EditorState.create`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface EditorStateConfig {
+  schema?: Schema | undefined;
+  doc?: Node | undefined;
+  selection?: Selection | undefined;
+  storedMarks?: ReadonlyArray<Mark> | null | undefined;
+  plugins?: ReadonlyArray<Plugin> | undefined;
+}
+/**
+ * The state of a ProseMirror editor.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class EditorState {
+  /** @internal */
+  readonly [CORE]: EditorState$1<any, any, any>;
+  /** @internal */
+  private constructor();
+  /** The current document. */
+  get doc(): Node;
+  /** The selection. */
+  get selection(): Selection;
+  /** A set of marks to apply to the next input. Will be null when no explicit marks have been set. */
+  get storedMarks(): ReadonlyArray<Mark> | null;
+  /** @internal */
+  get scrollToSelection(): number;
+  /** The schema of the state's document. */
+  get schema(): Schema;
+  /** The plugins that are active in this state. */
+  get plugins(): ReadonlyArray<Plugin>;
+  /** Apply the given transaction to produce a new state. */
+  apply(tr: Transaction): EditorState;
+  /** @internal */
+  filterTransaction(tr: Transaction, ignore?: number): boolean;
+  /** Verbose variant of `apply` that returns the precise transactions that were applied and the new state. */
+  applyTransaction(rootTr: Transaction): {
+    state: EditorState;
+    transactions: ReadonlyArray<Transaction>;
+  };
+  /** Start a transaction from this state. */
+  get tr(): Transaction;
+  /** Create a new state based on this one, but with an adjusted set of active plugins. */
+  reconfigure(config: {
+    plugins?: ReadonlyArray<Plugin>;
+  }): EditorState;
+  /** Serialize this state to JSON. */
+  toJSON(pluginFields?: {
+    [propName: string]: Plugin;
+  }): any;
+  /** Create a new state. */
+  static create(config: EditorStateConfig): EditorState;
+  /** Deserialize a JSON representation of a state. */
+  static fromJSON(config: {
+    schema: Schema;
+    plugins?: ReadonlyArray<Plugin>;
+  }, json: any, pluginFields?: {
+    [propName: string]: Plugin;
+  }): EditorState;
+}
+/**
+ * Convert a core (Effect) command into a ProseMirror-style command. The
+ * command is run synchronously; failures are thrown.
+ *
+ * @since 0.1.0
+ * @category conversions
+ */
+export declare const fromCoreCommand: (command: Command$1<any, any, never>) => Command;
+/**
+ * Convert a ProseMirror-style command into a core (Effect) command.
+ *
+ * @since 0.1.0
+ * @category conversions
+ */
+export declare const toCoreCommand: (command: Command) => Command$1<any>;
+/**
+ * Get the core (Effect API) object behind a facade. For a user-defined
+ * `Selection` subclass, this is a core selection that delegates to it.
+ *
+ * @since 0.1.0
+ * @category conversions
+ */
+export declare function toCore(state: EditorState): EditorState$1<any, never, any>;
+export declare function toCore(tr: Transaction): Transaction$1;
+export declare function toCore(selection: TextSelection): TextSelection$1;
+export declare function toCore(selection: NodeSelection): NodeSelection$1;
+export declare function toCore(selection: AllSelection): AllSelection$1;
+export declare function toCore(selection: Selection): Selection$1;
+export declare function toCore(range: SelectionRange): SelectionRange$1;
+export declare function toCore(plugin: Plugin): Plugin$1<any, any, never, never>;
+export declare function toCore(key: PluginKey): PluginKey$1;
+export declare function toCore(bookmark: SelectionBookmark): SelectionBookmark$1;
+export declare function toCore(command: Command): Command$1<any>;
+/**
+ * Get the facade for a core (Effect API) object.
+ *
+ * @since 0.1.0
+ * @category conversions
+ */
+export declare function fromCore(state: EditorState$1<any, any, any>): EditorState;
+export declare function fromCore(tr: Transaction$1<any>): Transaction;
+export declare function fromCore(selection: TextSelection$1<any>): TextSelection;
+export declare function fromCore(selection: NodeSelection$1<any>): NodeSelection;
+export declare function fromCore(selection: AllSelection$1<any>): AllSelection;
+export declare function fromCore(selection: Selection$1<any>): Selection;
+export declare function fromCore(range: SelectionRange$1<any>): SelectionRange;
+export declare function fromCore(plugin: Plugin$1<any, any, any, any>): Plugin;
+export declare function fromCore(key: PluginKey$1<any>): PluginKey;
+export declare function fromCore(command: Command$1<any, any, never>): Command;