lexical 0.2.9 → 0.3.2

package/Lexical.js.flow

@@ -18,7 +18,7 @@ declare export var CLICK_COMMAND: LexicalCommand<MouseEvent>;
 declare export var DELETE_CHARACTER_COMMAND: LexicalCommand<boolean>;
 declare export var INSERT_LINE_BREAK_COMMAND: LexicalCommand<boolean>;
 declare export var INSERT_PARAGRAPH_COMMAND: LexicalCommand<void>;
-declare export var INSERT_TEXT_COMMAND: LexicalCommand<string>;
+declare export var CONTROLLED_TEXT_INSERTION_COMMAND: LexicalCommand<string>;
 declare export var PASTE_COMMAND: LexicalCommand<ClipboardEvent>;
 declare export var REMOVE_TEXT_COMMAND: LexicalCommand<void>;
 declare export var DELETE_WORD_COMMAND: LexicalCommand<boolean>;
@@ -42,6 +42,7 @@ declare export var OUTDENT_CONTENT_COMMAND: LexicalCommand<void>;
 declare export var DROP_COMMAND: LexicalCommand<DragEvent>;
 declare export var FORMAT_ELEMENT_COMMAND: LexicalCommand<ElementFormatType>;
 declare export var DRAGSTART_COMMAND: LexicalCommand<DragEvent>;
+declare export var DRAGOVER_COMMAND: LexicalCommand<DragEvent>;
 declare export var DRAGEND_COMMAND: LexicalCommand<DragEvent>;
 declare export var COPY_COMMAND: LexicalCommand<ClipboardEvent>;
 declare export var CUT_COMMAND: LexicalCommand<ClipboardEvent>;
@@ -163,14 +164,16 @@ declare export class LexicalEditor {
   getElementByKey(key: NodeKey): null | HTMLElement;
   getEditorState(): EditorState;
   setEditorState(editorState: EditorState, options?: EditorSetOptions): void;
-  parseEditorState(
-    maybeStringifiedEditorState: string | ParsedEditorState,
+  parseEditorState<SerializedNode>(
+    maybeStringifiedEditorState: string | SerializedEditorState<SerializedNode>,
+    updateFn?: () => void,
   ): EditorState;
   update(updateFn: () => void, options?: EditorUpdateOptions): boolean;
   focus(callbackFn?: () => void): void;
   blur(): void;
   isReadOnly(): boolean;
   setReadOnly(readOnly: boolean): void;
+  toJSON(): SerializedEditor<>;
 }
 type EditorUpdateOptions = {
   onUpdate?: () => void,
@@ -233,7 +236,6 @@ export type EditorThemeClasses = {
   [string]: EditorThemeClassName | {[string]: EditorThemeClassName},
 };
 export type EditorConfig = {
-  namespace: string,
   theme: EditorThemeClasses,
   disableEvents?: boolean,
 };
@@ -246,7 +248,6 @@ export const COMMAND_PRIORITY_CRITICAL = 4;
 
 export type IntentionallyMarkedAsDirtyElement = boolean;
 declare export function createEditor(editorConfig?: {
-  namespace?: string,
   editorState?: EditorState,
   theme?: EditorThemeClasses,
   parentEditor?: LexicalEditor,
@@ -259,25 +260,6 @@ declare export function createEditor(editorConfig?: {
 /**
  * LexicalEditorState
  */
-export type ParsedEditorState = {
-  _selection: null | {
-    anchor: {
-      key: string,
-      offset: number,
-      type: 'text' | 'element',
-    },
-    focus: {
-      key: string,
-      offset: number,
-      type: 'text' | 'element',
-    },
-  },
-  _nodeMap: Array<[NodeKey, ParsedNode]>,
-};
-type JSONEditorState = {
-  _nodeMap: Array<[NodeKey, LexicalNode]>,
-  _selection: null | ParsedSelection,
-};
 
 export interface EditorState {
   _nodeMap: NodeMap;
@@ -290,7 +272,7 @@ export interface EditorState {
   ): void;
   isEmpty(): boolean;
   read<V>(callbackFn: () => V): V;
-  toJSON(space?: string | number): JSONEditorState;
+  toJSON<SerializedNode>(): SerializedEditorState<SerializedNode>;
   clone(
     selection?: RangeSelection | NodeSelection | GridSelection | null,
   ): EditorState;
@@ -335,22 +317,23 @@ declare export class LexicalNode {
   static importDOM(): DOMConversionMap | null;
   constructor(key?: NodeKey): void;
   exportDOM(editor: LexicalEditor): DOMExportOutput;
+  exportJSON(): SerializedLexicalNode;
   getType(): string;
   isAttached(): boolean;
   isSelected(): boolean;
   getKey(): NodeKey;
   getIndexWithinParent(): number;
-  getParent(): ElementNode | null;
-  getParentOrThrow(): ElementNode;
-  getTopLevelElement(): null | ElementNode;
+  getParent<T: ElementNode>(): T | null;
+  getParentOrThrow<T: ElementNode>(): T;
+  getTopLevelElement(): ElementNode | null;
   getTopLevelElementOrThrow(): ElementNode;
-  getParents(): Array<ElementNode>;
+  getParents<T: ElementNode>(): Array<T>;
   getParentKeys(): Array<NodeKey>;
-  getPreviousSibling(): LexicalNode | null;
-  getPreviousSiblings(): Array<LexicalNode>;
-  getNextSibling(): LexicalNode | null;
-  getNextSiblings(): Array<LexicalNode>;
-  getCommonAncestor(node: LexicalNode): ElementNode | null;
+  getPreviousSibling<T: LexicalNode>(): T | null;
+  getPreviousSiblings<T: LexicalNode>(): Array<T>;
+  getNextSibling<T: LexicalNode>(): T | null;
+  getNextSiblings<T: LexicalNode>(): Array<T>;
+  getCommonAncestor<T: ElementNode>(node: LexicalNode): T | null;
   is(object: ?LexicalNode): boolean;
   isBefore(targetNode: LexicalNode): boolean;
   isParentOf(targetNode: LexicalNode): boolean;
@@ -376,40 +359,12 @@ declare export class LexicalNode {
   replace<N: LexicalNode>(replaceWith: N): N;
   insertAfter(nodeToInsert: LexicalNode): LexicalNode;
   insertBefore(nodeToInsert: LexicalNode): LexicalNode;
-  selectPrevious(anchorOffset?: number, focusOffset?: number): Selection;
-  selectNext(anchorOffset?: number, focusOffset?: number): Selection;
+  selectPrevious(anchorOffset?: number, focusOffset?: number): RangeSelection;
+  selectNext(anchorOffset?: number, focusOffset?: number): RangeSelection;
   markDirty(): void;
 }
 export type NodeMap = Map<NodeKey, LexicalNode>;
 
-/**
- * LexicalParsing
- */
-
-export type ParsedNode = {
-  __key: NodeKey,
-  __type: string,
-  __parent: null | NodeKey,
-  ...
-};
-export type ParsedNodeMap = Map<NodeKey, ParsedNode>;
-declare export function $createNodeFromParse(
-  parsedNode: ParsedNode,
-  parsedNodeMap: ParsedNodeMap,
-): LexicalNode;
-type ParsedSelection = {
-  anchor: {
-    key: NodeKey,
-    offset: number,
-    type: 'text' | 'element',
-  },
-  focus: {
-    key: NodeKey,
-    offset: number,
-    type: 'text' | 'element',
-  },
-};
-
 /**
  * LexicalSelection
  */
@@ -630,6 +585,9 @@ declare export class TextNode extends LexicalNode {
   toggleDirectionless(): this;
   toggleUnmergeable(): this;
   setMode(type: TextModeType): this;
+  setDetail(detail: number): this;
+  getDetail(): number;
+  getMode(): TextModeType;
   setTextContent(text: string): TextNode;
   select(_anchorOffset?: number, _focusOffset?: number): RangeSelection;
   spliceText(
@@ -643,6 +601,8 @@ declare export class TextNode extends LexicalNode {
   splitText(...splitOffsets: Array<number>): Array<TextNode>;
   mergeWithSibling(target: TextNode): TextNode;
   isTextEntity(): boolean;
+  static importJSON(serializedTextNode: SerializedTextNode): TextNode;
+  exportJSON(): SerializedTextNode;
 }
 declare export function $createTextNode(text?: string): TextNode;
 declare export function $isTextNode(
@@ -660,6 +620,10 @@ declare export class LineBreakNode extends LexicalNode {
   getTextContent(): '\n';
   createDOM(): HTMLElement;
   updateDOM(): false;
+  static importJSON(
+    serializedLineBreakNode: SerializedLineBreakNode,
+  ): LineBreakNode;
+  exportJSON(): SerializedLexicalNode;
 }
 declare export function $createLineBreakNode(): LineBreakNode;
 declare export function $isLineBreakNode(
@@ -679,10 +643,10 @@ declare export class RootNode extends ElementNode {
   select(): RangeSelection;
   remove(): void;
   replace<N: LexicalNode>(node: N): N;
-  insertBefore(): LexicalNode;
-  insertAfter(node: LexicalNode): LexicalNode;
+  insertBefore<T: LexicalNode>(nodeToInsert: T): T;
+  insertAfter<T: LexicalNode>(nodeToInsert: T): T;
   updateDOM(prevNode: RootNode, dom: HTMLElement): false;
-  append(...nodesToAppend: Array<LexicalNode>): ElementNode;
+  append(...nodesToAppend: Array<LexicalNode>): this;
   canBeEmpty(): false;
 }
 declare export function $isRootNode(
@@ -692,7 +656,7 @@ declare export function $isRootNode(
 /**
  * LexicalElementNode
  */
-export type ElementFormatType = 'left' | 'center' | 'right' | 'justify';
+export type ElementFormatType = 'left' | 'center' | 'right' | 'justify' | '';
 declare export class ElementNode extends LexicalNode {
   __children: Array<NodeKey>;
   __format: number;
@@ -700,28 +664,30 @@ declare export class ElementNode extends LexicalNode {
   __dir: 'ltr' | 'rtl' | null;
   constructor(key?: NodeKey): void;
   getFormat(): number;
+  getFormatType(): ElementFormatType;
   getIndent(): number;
-  getChildren(): Array<LexicalNode>;
+  getChildren<T: LexicalNode>(): Array<T>;
+  getChildren<T: Array<LexicalNode>>(): T;
   getChildrenKeys(): Array<NodeKey>;
   getChildrenSize(): number;
   isEmpty(): boolean;
   isDirty(): boolean;
   getAllTextNodes(includeInert?: boolean): Array<TextNode>;
-  getFirstDescendant(): null | LexicalNode;
-  getLastDescendant(): null | LexicalNode;
-  getDescendantByIndex(index: number): LexicalNode;
+  getFirstDescendant<T: LexicalNode>(): null | T;
+  getLastDescendant<T: LexicalNode>(): null | T;
+  getDescendantByIndex<T: LexicalNode>(index: number): null | T;
   getFirstChild<T: LexicalNode>(): null | T;
   getFirstChildOrThrow<T: LexicalNode>(): T;
-  getLastChild(): null | LexicalNode;
-  getChildAtIndex(index: number): null | LexicalNode;
+  getLastChild<T: LexicalNode>(): null | T;
+  getChildAtIndex<T: LexicalNode>(index: number): null | T;
   getTextContent(includeInert?: boolean, includeDirectionless?: false): string;
   getDirection(): 'ltr' | 'rtl' | null;
   hasFormat(type: ElementFormatType): boolean;
   select(_anchorOffset?: number, _focusOffset?: number): RangeSelection;
   selectStart(): RangeSelection;
   selectEnd(): RangeSelection;
-  clear(): ElementNode;
-  append(...nodesToAppend: Array<LexicalNode>): ElementNode;
+  clear(): this;
+  append(...nodesToAppend: Array<LexicalNode>): this;
   setDirection(direction: 'ltr' | 'rtl' | null): this;
   setFormat(type: ElementFormatType): this;
   setIndent(indentLevel: number): this;
@@ -747,7 +713,8 @@ declare export class ElementNode extends LexicalNode {
     start: number,
     deleteCount: number,
     nodesToInsert: Array<LexicalNode>,
-  ): ElementNode;
+  ): this;
+  exportJSON(): SerializedElementNode;
 }
 declare export function $isElementNode(
   node: ?LexicalNode,
@@ -778,6 +745,10 @@ declare export class ParagraphNode extends ElementNode {
   updateDOM(prevNode: ParagraphNode, dom: HTMLElement): boolean;
   insertNewAfter(): ParagraphNode;
   collapseAtStart(): boolean;
+  static importJSON(
+    serializedParagraphNode: SerializedParagraphNode,
+  ): ParagraphNode;
+  exportJSON(): SerializedElementNode;
 }
 declare export function $createParagraphNode(): ParagraphNode;
 declare export function $isParagraphNode(
@@ -809,6 +780,8 @@ declare export function $isGridCellNode(
 /**
  * LexicalUtils
  */
+declare export function $hasUpdateTag(tag: string): boolean;
+declare export function $addUpdateTag(tag: string): void;
 declare export function $getNearestNodeFromDOMNode(
   startingDOM: Node,
 ): LexicalNode | null;
@@ -831,14 +804,80 @@ declare export function $getDecoratorNode(
   isBackward: boolean,
 ): null | LexicalNode;
 
-// TODO the Flow types here needs fixing
-export type EventHandler = (
-  // $FlowFixMe: not sure how to handle this generic properly
-  event: Object,
-  editor: LexicalEditor,
-) => void;
+export type EventHandler = (event: Event, editor: LexicalEditor) => void;
 
 /**
  * LexicalVersion
  */
 declare export var VERSION: string;
+
+/**
+ * Serialization/Deserialization
+ * */
+
+type InternalSerializedNode = {
+  children?: Array<InternalSerializedNode>,
+  type: string,
+  version: number,
+};
+
+declare export function $parseSerializedNode(
+  serializedNode: InternalSerializedNode,
+): LexicalNode;
+
+export type SerializedLexicalNode = {
+  type: string,
+  version: number,
+  ...
+};
+
+export type SerializedTextNode = {
+  ...SerializedLexicalNode,
+  detail: number,
+  format: number,
+  mode: TextModeType,
+  style: string,
+  text: string,
+  ...
+};
+
+export type SerializedElementNode = {
+  ...SerializedLexicalNode,
+  children: Array<SerializedLexicalNode>,
+  direction: 'ltr' | 'rtl' | null,
+  format: ElementFormatType,
+  indent: number,
+  ...
+};
+
+export type SerializedParagraphNode = {
+  ...SerializedElementNode,
+  type: 'paragraph',
+  ...
+};
+
+export type SerializedLineBreakNode = {
+  ...SerializedLexicalNode,
+  type: 'linebreak',
+  ...
+};
+
+export type SerializedRootNode = {
+  ...SerializedElementNode,
+  type: 'root',
+  ...
+};
+
+export type SerializedGridCellNode = {
+  ...SerializedElementNode,
+  colSpan: number,
+  ...
+};
+
+export interface SerializedEditorState<SerializedNode> {
+  root: SerializedRootNode<SerializedNode>;
+}
+
+export type SerializedEditor<SerializedNode> = {
+  editorState: SerializedEditorState<SerializedNode>,
+};