@thomasfosterau/effect-richtext 0.0.0-stage → 0.1.0

package/dist/view/viewdesc.d.ts

@@ -0,0 +1,236 @@
+import { TagParseRule } from "../model/from_dom.js";
+import { AnySchema, MarkNames, NodeNames } from "../model/schema.js";
+import { Mark } from "../model/mark.js";
+import { Node } from "../model/node.js";
+import "../model.js";
+import { Decoration, DecorationSource } from "./decoration.js";
+import { DOMNode } from "./dom.js";
+import { EditorView } from "./view.js";
+type AnyView = EditorView<any, any, any>;
+/**
+ * A `ViewMutationRecord` represents a DOM mutation or a selection
+ * change happens within the view. When the change is a selection
+ * change, the record will have a `type` property of `"selection"`
+ * (which doesn't occur for native mutation records).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type ViewMutationRecord = MutationRecord | {
+  readonly type: "selection";
+  readonly target: DOMNode;
+};
+/**
+ * By default, document nodes are rendered using the result of the
+ * `toDOM` method of their spec, and managed entirely by the editor. For
+ * some use cases, such as embedded node-specific editing interfaces,
+ * you want more control over the behavior of a node's in-editor
+ * representation, and need to define a custom node view.
+ *
+ * Objects returned as node views must conform to this interface. Node
+ * views are plain, synchronous objects.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface NodeView<Sc extends AnySchema = AnySchema> {
+  /** The outer DOM node that represents the document node. */
+  dom: DOMNode;
+  /**
+   * The DOM node that should hold the node's content. Only meaningful if
+   * the node view also defines a `dom` property and if its node type is
+   * not a leaf node type. When this is present, the view will take care
+   * of rendering the node's children into it. When it is not present,
+   * the node view itself is responsible for rendering (or deciding not
+   * to render) its child nodes.
+   */
+  contentDOM?: HTMLElement | null | undefined;
+  /**
+   * When given, this will be called when the view is updating itself.
+   * It will be given a node, an array of active decorations around the
+   * node (which are automatically drawn, and the node view may ignore if
+   * it isn't interested in them), and a decoration source that
+   * represents any decorations that apply to the content of the node
+   * (which again may be ignored). It should return true if it was able
+   * to update to that node, and false otherwise. If the node view has a
+   * `contentDOM` property (or no `dom` property), updating its child
+   * nodes will be handled by the view.
+   */
+  update?: ((node: Node<Sc>, decorations: ReadonlyArray<Decoration>, innerDecorations: DecorationSource) => boolean) | undefined;
+  /**
+   * By default, `update` will only be called when a node of the same
+   * node type appears in this view's position. When you set this to
+   * true, it will be called for any node, making it possible to have a
+   * node view that represents multiple types of nodes. You will need to
+   * check the type of the nodes you get in `update` and return `false`
+   * for types you cannot handle.
+   */
+  multiType?: boolean | undefined;
+  /**
+   * Can be used to override the way the node's selected status (as a
+   * node selection) is displayed.
+   */
+  selectNode?: (() => void) | undefined;
+  /**
+   * When defining a `selectNode` method, you should also provide a
+   * `deselectNode` method to remove the effect again.
+   */
+  deselectNode?: (() => void) | undefined;
+  /**
+   * This will be called to handle setting the selection inside the
+   * node. The `anchor` and `head` positions are relative to the start of
+   * the node. By default, a DOM selection will be created between the
+   * DOM positions corresponding to those positions, but if you override
+   * it you can do something else.
+   */
+  setSelection?: ((anchor: number, head: number, root: Document | ShadowRoot) => void) | undefined;
+  /**
+   * Can be used to prevent the editor view from trying to handle some
+   * or all DOM events that bubble up from the node view. Events for
+   * which this returns true are not handled by the editor.
+   */
+  stopEvent?: ((event: Event) => boolean) | undefined;
+  /**
+   * Called when a mutation happens within the view. Return false if the
+   * editor should re-read the selection or re-parse the range around
+   * the mutation, true if it can safely be ignored.
+   */
+  ignoreMutation?: ((mutation: ViewMutationRecord) => boolean) | undefined;
+  /** Called when the node view is removed from the editor or the whole editor is destroyed. */
+  destroy?: (() => void) | undefined;
+}
+/**
+ * By default, document marks are rendered using the result of the
+ * `toDOM` method of their spec, and managed entirely by the editor. For
+ * some use cases, you want more control over the behavior of a mark's
+ * in-editor representation, and need to define a custom mark view.
+ *
+ * Objects returned as mark views must conform to this interface.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface MarkView {
+  /** The outer DOM node that represents the document node. */
+  dom: HTMLElement;
+  /**
+   * The DOM node that should hold the mark's content. When this is not
+   * present, the `dom` property is used as the content DOM.
+   */
+  contentDOM?: HTMLElement | null | undefined;
+  /**
+   * Called when the mark at this position changes to another mark of the
+   * same type. Return true to keep this view (it now represents `mark`),
+   * false to have it redrawn.
+   */
+  update?: ((mark: Mark<any, any>) => boolean) | undefined;
+  /**
+   * Called when a mutation happens within the view. Return false if the
+   * editor should re-read the selection or re-parse the range around
+   * the mutation, true if it can safely be ignored.
+   */
+  ignoreMutation?: ((mutation: ViewMutationRecord) => boolean) | undefined;
+  /** Called when the mark view is removed from the editor or the whole editor is destroyed. */
+  destroy?: (() => void) | undefined;
+}
+/**
+ * The type of function provided to create node views for nodes named
+ * `N`. `getPos` returns the node's current position, or `undefined`
+ * when the node is not in the document.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type NodeViewConstructor<Sc extends AnySchema = AnySchema, N extends NodeNames<Sc> = NodeNames<Sc>> = (node: Node<Sc, N>, view: EditorView<Sc, any, any>, getPos: () => number | undefined, decorations: ReadonlyArray<Decoration>, innerDecorations: DecorationSource) => NodeView<Sc>;
+/**
+ * The function type used to create mark views for marks named `M`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type MarkViewConstructor<Sc extends AnySchema = AnySchema, M extends MarkNames<Sc> = MarkNames<Sc>> = (mark: Mark<Sc, M>, view: EditorView<Sc, any, any>, inline: boolean) => MarkView;
+type ParseRuleLike = Omit<TagParseRule, "tag">;
+/** @internal */
+export declare class ViewDesc {
+  parent: ViewDesc | undefined;
+  children: Array<ViewDesc>;
+  dom: DOMNode;
+  contentDOM: HTMLElement | null;
+  dirty: number;
+  node: Node<any, any> | null;
+  constructor(parent: ViewDesc | undefined, children: Array<ViewDesc>, dom: DOMNode, contentDOM: HTMLElement | null);
+  matchesWidget(_widget: Decoration): boolean;
+  matchesMark(_mark: Mark<any, any>): boolean;
+  matchesNode(_node: Node<any, any>, _outerDeco: ReadonlyArray<Decoration>, _innerDeco: DecorationSource): boolean;
+  matchesHack(_nodeName: string): boolean;
+  parseRule(_addedNodes?: ReadonlyArray<DOMNode>): ParseRuleLike | null;
+  stopEvent(_event: Event): boolean;
+  get size(): number;
+  get border(): number;
+  destroy(): void;
+  posBeforeChild(child: ViewDesc): number;
+  get posBefore(): number;
+  get posAtStart(): number;
+  get posAfter(): number;
+  get posAtEnd(): number;
+  localPosFromDOM(dom: DOMNode, offset: number, bias: number): number;
+  nearestDesc(dom: DOMNode): ViewDesc | undefined;
+  nearestDesc(dom: DOMNode, onlyNodes: true): NodeViewDesc | undefined;
+  getDesc(dom: DOMNode): ViewDesc | undefined;
+  posFromDOM(dom: DOMNode, offset: number, bias: number): number;
+  descAt(pos: number): ViewDesc | undefined;
+  domFromPos(pos: number, side: number): {
+    node: DOMNode;
+    offset: number;
+    atom?: number | undefined;
+  };
+  parseRange(from: number, to: number, base?: number): {
+    node: DOMNode;
+    from: number;
+    to: number;
+    fromOffset: number;
+    toOffset: number;
+  };
+  emptyChildAt(side: number): boolean;
+  domAfterPos(pos: number): DOMNode;
+  setSelection(anchor: number, head: number, view: AnyView, force?: boolean): void;
+  ignoreMutation(mutation: ViewMutationRecord): boolean;
+  get contentLost(): boolean;
+  markDirty(from: number, to: number): void;
+  markParentsDirty(): void;
+  get domAtom(): boolean;
+  get ignoreForCoords(): boolean;
+  get ignoreForSelection(): boolean;
+  isText(_text: string): boolean;
+}
+/** @internal */
+export declare class NodeViewDesc extends ViewDesc {
+  node: Node<any, any>;
+  outerDeco: ReadonlyArray<Decoration>;
+  innerDeco: DecorationSource;
+  readonly nodeDOM: DOMNode;
+  constructor(parent: ViewDesc | undefined, node: Node<any, any>, outerDeco: ReadonlyArray<Decoration>, innerDeco: DecorationSource, dom: DOMNode, contentDOM: HTMLElement | null, nodeDOM: DOMNode, _view: AnyView, _pos: number);
+  static create(parent: ViewDesc | undefined, node: Node<any, any>, outerDeco: ReadonlyArray<Decoration>, innerDeco: DecorationSource, view: AnyView, pos: number): NodeViewDesc;
+  parseRule(addedNodes?: ReadonlyArray<DOMNode>): ParseRuleLike | null;
+  matchesNode(node: Node<any, any>, outerDeco: ReadonlyArray<Decoration>, innerDeco: DecorationSource): boolean;
+  get size(): number;
+  get border(): 0 | 1;
+  updateChildren(view: AnyView, pos: number): void;
+  localCompositionInfo(view: AnyView, pos: number): {
+    node: Text;
+    pos: number;
+    text: string;
+  } | null;
+  protectLocalComposition(view: AnyView, { node, pos, text }: {
+    node: Text;
+    pos: number;
+    text: string;
+  }): void;
+  update(node: Node<any, any>, outerDeco: ReadonlyArray<Decoration>, innerDeco: DecorationSource, view: AnyView): boolean;
+  updateInner(node: Node<any, any>, outerDeco: ReadonlyArray<Decoration>, innerDeco: DecorationSource, view: AnyView): void;
+  updateOuterDeco(outerDeco: ReadonlyArray<Decoration>): void;
+  selectNode(): void;
+  deselectNode(): void;
+  get domAtom(): boolean;
+}
+export {};