@licium/editor 3.2.3

package/types/index.d.ts

@@ -0,0 +1,70 @@
+// Type definitions for TOAST UI Editor v3.2.3
+// TypeScript Version: 4.2.3
+import {
+  EditorCore,
+  Editor,
+  Viewer,
+  EditorOptions,
+  ViewerOptions,
+  ExtendedAutolinks,
+  LinkAttributes,
+  Sanitizer,
+  EditorType,
+  PreviewStyle,
+  EventMap,
+  HookMap,
+  WidgetStyle,
+  WidgetRuleMap,
+  WidgetRule,
+  PluginContext,
+  I18n,
+  CustomHTMLRenderer,
+  HTMLMdNodeConvertor,
+  HTMLMdNodeConvertorMap,
+} from './editor';
+import './toastui-editor-viewer';
+
+export {
+  MdNode,
+  MdNodeType,
+  ListMdNode,
+  ListItemMdNode,
+  TableMdNode,
+  TableCellMdNode,
+  CodeBlockMdNode,
+  LinkMdNode,
+  ListData,
+  HeadingMdNode,
+  CodeMdNode,
+  HTMLConvertorMap,
+} from './toastmark';
+export { ToMdConvertorMap } from './convertor';
+export { Emitter, Handler } from './event';
+export {
+  EditorOptions,
+  ViewerOptions,
+  ExtendedAutolinks,
+  LinkAttributes,
+  Sanitizer,
+  EditorType,
+  PreviewStyle,
+  EventMap,
+  HookMap,
+  WidgetStyle,
+  WidgetRuleMap,
+  WidgetRule,
+  PluginContext,
+  I18n,
+  CustomHTMLRenderer,
+  HTMLMdNodeConvertor,
+  HTMLMdNodeConvertorMap,
+};
+export { Dispatch } from './spec';
+export { PluginInfo, PluginNodeViews, CommandFn, PluginCommandMap } from './plugin';
+export { MdLikeNode, HTMLMdNode } from './markdown';
+export { Editor, EditorCore, Viewer };
+export default Editor;
+
+export declare namespace toastui {
+  export { Editor };
+}

package/types/map.d.ts

@@ -0,0 +1,8 @@
+export interface Mapable<K, V> {
+  clear(): void;
+  delete(key: K): boolean;
+  forEach(callbackfn: (value: V, key: K, map: Mapable<K, V>) => void, thisArg?: any): void;
+  get(key: K): V | undefined;
+  has(key: K): boolean;
+  set(key: K, value: V): this;
+}

package/types/markdown.d.ts

@@ -0,0 +1,60 @@
+import { MdNode, TableMdNode, Sourcepos, NodeWalker } from './toastmark';
+
+export interface TableRowMdNode extends MdNode {
+  parent: TableBodyMdNode | TableHeadMdNode;
+}
+
+export interface TableBodyMdNode extends MdNode {
+  parent: TableMdNode;
+}
+
+export interface TableHeadMdNode extends MdNode {
+  parent: TableMdNode;
+  firstChild: TableRowMdNode;
+  lastChild: TableRowMdNode;
+  next: TableBodyMdNode;
+}
+
+export interface MdLikeNode {
+  type: string;
+  literal: string | null;
+  wysiwygNode?: boolean;
+  level?: number;
+  destination?: string;
+  title?: string;
+  info?: string;
+  cellType?: 'head' | 'body';
+  align?: 'left' | 'center' | 'right';
+  listData?: {
+    type?: 'bullet' | 'ordered';
+    start?: number;
+    task?: boolean;
+    checked?: boolean;
+  };
+  attrs?: Record<string, string | null>;
+  childrenHTML?: string;
+}
+
+export interface HTMLMdNode {
+  type: string;
+  id: number;
+  parent: MdNode | null;
+  prev: MdNode | null;
+  next: MdNode | null;
+  sourcepos?: Sourcepos;
+  firstChild: MdNode | null;
+  lastChild: MdNode | null;
+  literal: string | null;
+
+  isContainer(): boolean;
+  unlink(): void;
+  replaceWith(node: MdNode): void;
+  insertAfter(node: MdNode): void;
+  insertBefore(node: MdNode): void;
+  appendChild(child: MdNode): void;
+  prependChild(child: MdNode): void;
+  walker(): NodeWalker;
+
+  attrs?: Record<string, string | null>;
+  childrenHTML?: string;
+}

package/types/plugin.d.ts

@@ -0,0 +1,59 @@
+import { Plugin, EditorState } from 'prosemirror-state';
+import { EditorView, NodeView } from 'prosemirror-view';
+import { Node } from 'prosemirror-model';
+
+import { CustomParserMap } from './toastmark';
+import { CustomHTMLRenderer } from './editor';
+import { Emitter } from './event';
+import { ToMdConvertorMap } from './convertor';
+import { Dispatch, Payload, DefaultPayload } from './spec';
+import { ToolbarItemOptions } from './ui';
+
+export type PluginProp = (eventEmitter?: Emitter) => Plugin;
+
+export type PluginNodeViews = (
+  node: Node,
+  view: EditorView,
+  getPos: () => number,
+  eventEmitter: Emitter
+) => NodeView;
+
+type NodeViewPropMap = Record<string, PluginNodeViews>;
+
+export type CommandFn<T = DefaultPayload> = (
+  payload: Payload<T>,
+  state: EditorState,
+  dispatch: Dispatch,
+  view: EditorView
+) => boolean;
+export type PluginCommandMap = Record<string, CommandFn>;
+
+interface PluginToolbarItem {
+  groupIndex: number;
+  itemIndex: number;
+  item: string | ToolbarItemOptions;
+}
+
+export interface PluginInfo {
+  toHTMLRenderers?: CustomHTMLRenderer;
+  toMarkdownRenderers?: ToMdConvertorMap;
+  markdownPlugins?: PluginProp[];
+  wysiwygPlugins?: PluginProp[];
+  wysiwygNodeViews?: NodeViewPropMap;
+  markdownCommands?: PluginCommandMap;
+  wysiwygCommands?: PluginCommandMap;
+  toolbarItems?: PluginToolbarItem[];
+  markdownParsers?: CustomParserMap;
+}
+
+export interface PluginInfoResult {
+  toHTMLRenderers: CustomHTMLRenderer;
+  toMarkdownRenderers: ToMdConvertorMap;
+  mdPlugins: PluginProp[];
+  wwPlugins: PluginProp[];
+  wwNodeViews: NodeViewPropMap;
+  mdCommands: PluginCommandMap;
+  wwCommands: PluginCommandMap;
+  toolbarItems: PluginToolbarItem[];
+  markdownParsers: CustomParserMap;
+}

package/types/prosemirror-commands.d.ts

@@ -0,0 +1,15 @@
+import { EditorState, Transaction } from 'prosemirror-state';
+import { EditorView } from 'prosemirror-view';
+import { Schema } from 'prosemirror-model';
+
+import 'prosemirror-commands';
+
+declare module 'prosemirror-commands' {
+  export interface Command<S extends Schema = any> {
+    (state: EditorState<S>, dispatch?: (tr: Transaction<S>) => void, view?: EditorView<S>): boolean;
+  }
+
+  export interface Keymap<S extends Schema = any> {
+    [key: string]: Command<S>;
+  }
+}

package/types/prosemirror-model.d.ts

@@ -0,0 +1,15 @@
+import * as Model from 'prosemirror-model';
+
+declare module 'prosemirror-model' {
+  export interface Fragment {
+    textBetween(from: number, to: number, blockSeparator?: string, leafText?: string): string;
+    findIndex(pos: number, round?: number): { index: number; offset: number };
+    findDiffEnd(other: ProsemirrorNode | Fragment): { a: number; b: number } | null | undefined;
+  }
+
+  export type ProsemirrorNode = Model.Node;
+
+  export interface NodeType {
+    compatibleContent(node: NodeType): boolean;
+  }
+}

package/types/prosemirror-transform.d.ts

@@ -0,0 +1,35 @@
+import { Slice, Node, Mark, NodeType } from 'prosemirror-model';
+import 'prosemirror-transform';
+
+declare module 'prosemirror-transform' {
+  export interface Step {
+    slice: Slice;
+    from: number;
+    to: number;
+  }
+
+  export interface Transform {
+    setNodeMarkup(
+      pos: number,
+      type: Node | null,
+      attrs?: { [key: string]: any },
+      marks?: Mark[]
+    ): Transform;
+
+    split(
+      pos: number,
+      depth?: number | undefined,
+      typesAfter?:
+        | ({
+            type: NodeType;
+            attrs?:
+              | {
+                  [key: string]: any;
+                }
+              | null
+              | undefined;
+          } | null)[]
+        | undefined
+    ): Transform;
+  }
+}

package/types/spec.d.ts

@@ -0,0 +1,42 @@
+import { Schema } from 'prosemirror-model';
+import { Transaction, Plugin, Command } from 'prosemirror-state';
+import { EditorView } from 'prosemirror-view';
+import { ToastMark } from './toastmark';
+import { Emitter } from './event';
+
+export interface Context {
+  schema: Schema;
+  eventEmitter: Emitter;
+}
+
+export interface MdContext extends Context {
+  toastMark: ToastMark;
+}
+
+export interface SpecContext extends Context {
+  view: EditorView;
+}
+
+export interface MdSpecContext extends SpecContext {
+  toastMark: ToastMark;
+}
+
+export type DefaultPayload = Record<string, any>;
+export type Payload<T> = T extends infer P ? P : any;
+
+export type Dispatch = (tr: Transaction) => void;
+export type EditorCommand<T = DefaultPayload> = (payload?: Payload<T>) => Command;
+export type EditorCommandMap<T = DefaultPayload> = Record<string, EditorCommand<T>>;
+export type EditorCommandFn<T = DefaultPayload> = (payload?: Payload<T>) => boolean | void;
+export type EditorAllCommandMap<T = DefaultPayload> = Record<string, EditorCommandFn<T>>;
+
+export interface SpecManager {
+  commands(
+    view: EditorView,
+    addedCommands?: Record<string, EditorCommand>
+  ): EditorAllCommandMap<DefaultPayload>;
+
+  keymaps(useCommandShortcut: boolean): Plugin<any, any>[];
+
+  setContext(context: SpecContext): void;
+}

package/types/toastmark.d.ts

@@ -0,0 +1,357 @@
+// @TODO replace these definition for Definitely Type
+export type BlockNodeType =
+  | 'document'
+  | 'list'
+  | 'blockQuote'
+  | 'item'
+  | 'heading'
+  | 'thematicBreak'
+  | 'paragraph'
+  | 'codeBlock'
+  | 'htmlBlock'
+  | 'table'
+  | 'tableHead'
+  | 'tableBody'
+  | 'tableRow'
+  | 'tableCell'
+  | 'tableDelimRow'
+  | 'tableDelimCell'
+  | 'refDef'
+  | 'customBlock'
+  | 'frontMatter';
+
+export type InlineNodeType =
+  | 'code'
+  | 'text'
+  | 'emph'
+  | 'strong'
+  | 'strike'
+  | 'link'
+  | 'image'
+  | 'htmlInline'
+  | 'linebreak'
+  | 'softbreak'
+  | 'customInline';
+
+export type MdNodeType = BlockNodeType | InlineNodeType;
+
+export type Pos = [number, number];
+export type MdPos = Pos;
+export type Sourcepos = [Pos, Pos];
+
+export interface NodeWalker {
+  current: MdNode | null;
+  root: MdNode;
+  entering: boolean;
+
+  next(): { entering: boolean; node: MdNode } | null;
+  resumeAt(node: MdNode, entering: boolean): void;
+}
+
+export interface MdNode {
+  type: MdNodeType;
+  id: number;
+  parent: MdNode | null;
+  prev: MdNode | null;
+  next: MdNode | null;
+  sourcepos?: Sourcepos;
+  firstChild: MdNode | null;
+  lastChild: MdNode | null;
+  literal: string | null;
+
+  isContainer(): boolean;
+  unlink(): void;
+  replaceWith(node: MdNode): void;
+  insertAfter(node: MdNode): void;
+  insertBefore(node: MdNode): void;
+  appendChild(child: MdNode): void;
+  prependChild(child: MdNode): void;
+  walker(): NodeWalker;
+}
+
+export interface BlockMdNode extends MdNode {
+  type: BlockNodeType;
+
+  // temporal data (for parsing)
+  open: boolean;
+  lineOffsets: number[] | null;
+  stringContent: string | null;
+  lastLineBlank: boolean;
+  lastLineChecked: boolean;
+}
+
+export interface ListData {
+  type: 'ordered' | 'bullet';
+  tight: boolean;
+  start: number;
+  bulletChar: string;
+  delimiter: string;
+  markerOffset: number;
+  padding: number;
+  task: boolean;
+  checked: boolean;
+}
+
+export interface ListMdNode extends BlockMdNode {
+  listData: ListData | null;
+}
+
+export interface ListItemMdNode extends BlockMdNode {
+  parent: MdNode;
+  listData: ListData;
+}
+
+export interface HeadingMdNode extends BlockMdNode {
+  level: number;
+  headingType: 'atx' | 'setext';
+}
+
+export interface CodeBlockMdNode extends BlockMdNode {
+  fenceOffset: number;
+  fenceLength: number;
+  fenceChar: string | null;
+  info: string | null;
+  infoPadding: number;
+}
+
+export interface TableColumn {
+  align: 'left' | 'center' | 'right' | null;
+}
+
+export interface TableMdNode extends BlockMdNode {
+  columns: TableColumn[];
+}
+
+export interface TableCellMdNode extends BlockMdNode {
+  startIdx: number;
+  endIdx: number;
+  paddingLeft: number;
+  paddingRight: number;
+  ignored: boolean;
+  attrs?: Record<string, any>;
+}
+
+export interface RefDefMdNode extends BlockMdNode {
+  title: string;
+  dest: string;
+  label: string;
+}
+
+export interface CustomBlockMdNode extends BlockMdNode {
+  syntaxLength: number;
+  offset: number;
+  info: string;
+}
+
+export interface HtmlBlockMdNode extends BlockMdNode {
+  htmlBlockType: number;
+}
+
+export interface LinkMdNode extends MdNode {
+  destination: string | null;
+  title: string | null;
+  extendedAutolink: boolean;
+  lastChild: MdNode;
+}
+
+export interface CodeMdNode extends MdNode {
+  tickCount: number;
+}
+
+export interface CustomInlineMdNode extends MdNode {
+  info: string;
+}
+
+export type AutolinkParser = (
+  content: string
+) => {
+  url: string;
+  text: string;
+  range: [number, number];
+}[];
+
+export type CustomParser = (
+  node: MdNode,
+  context: { entering: boolean; options: ParserOptions }
+) => void;
+export type CustomParserMap = Partial<Record<MdNodeType, CustomParser>>;
+
+type RefDefState = {
+  id: number;
+  destination: string;
+  title: string;
+  unlinked: boolean;
+  sourcepos: Sourcepos;
+};
+
+export type RefMap = {
+  [k: string]: RefDefState;
+};
+
+export type RefLinkCandidateMap = {
+  [k: number]: {
+    node: BlockMdNode;
+    refLabel: string;
+  };
+};
+
+export type RefDefCandidateMap = {
+  [k: number]: RefDefMdNode;
+};
+
+export interface ParserOptions {
+  smart: boolean;
+  tagFilter: boolean;
+  extendedAutolinks: boolean | AutolinkParser;
+  disallowedHtmlBlockTags: string[];
+  referenceDefinition: boolean;
+  disallowDeepHeading: boolean;
+  frontMatter: boolean;
+  customParser: CustomParserMap | null;
+}
+
+export class Parser {
+  constructor(options?: Partial<ParserOptions>);
+
+  advanceOffset(count: number, columns?: boolean): void;
+
+  advanceNextNonspace(): void;
+
+  findNextNonspace(): void;
+
+  addLine(): void;
+
+  addChild(tag: BlockNodeType, offset: number): BlockMdNode;
+
+  closeUnmatchedBlocks(): void;
+
+  finalize(block: BlockMdNode, lineNumber: number): void;
+
+  processInlines(block: BlockMdNode): void;
+
+  incorporateLine(ln: string): void;
+
+  // The main parsing function.  Returns a parsed document AST.
+  parse(input: string, lineTexts?: string[]): MdNode;
+
+  partialParseStart(lineNumber: number, lines: string[]): MdNode;
+
+  partialParseExtends(lines: string[]): void;
+
+  partialParseFinish(): void;
+
+  setRefMaps(
+    refMap: RefMap,
+    refLinkCandidateMap: RefLinkCandidateMap,
+    refDefCandidateMap: RefDefCandidateMap
+  ): void;
+
+  clearRefMaps(): void;
+}
+
+export type HTMLConvertor = (
+  node: MdNode,
+  context: Context,
+  convertors?: HTMLConvertorMap
+) => HTMLToken | HTMLToken[] | null;
+
+export type HTMLConvertorMap = Partial<Record<string, HTMLConvertor>>;
+
+interface RendererOptions {
+  gfm: boolean;
+  softbreak: string;
+  nodeId: boolean;
+  tagFilter: boolean;
+  convertors?: HTMLConvertorMap;
+}
+
+interface Context {
+  entering: boolean;
+  leaf: boolean;
+  options: Omit<RendererOptions, 'convertors'>;
+  getChildrenText: (node: MdNode) => string;
+  skipChildren: () => void;
+  origin?: () => ReturnType<HTMLConvertor>;
+}
+
+interface TagToken {
+  tagName: string;
+  outerNewLine?: boolean;
+  innerNewLine?: boolean;
+}
+
+export interface OpenTagToken extends TagToken {
+  type: 'openTag';
+  classNames?: string[];
+  attributes?: Record<string, any>;
+  selfClose?: boolean;
+}
+
+export interface CloseTagToken extends TagToken {
+  type: 'closeTag';
+}
+
+export interface TextToken {
+  type: 'text';
+  content: string;
+}
+
+export interface RawHTMLToken {
+  type: 'html';
+  content: string;
+  outerNewLine?: boolean;
+}
+
+export type HTMLToken = OpenTagToken | CloseTagToken | TextToken | RawHTMLToken;
+
+export class Renderer {
+  constructor(customOptions?: Partial<RendererOptions>);
+
+  getConvertors(): HTMLConvertorMap;
+
+  getOptions(): RendererOptions;
+
+  render(rootNode: MdNode): string;
+
+  renderHTMLNode(node: HTMLToken): void;
+}
+
+export interface RemovedNodeRange {
+  id: [number, number];
+  line: [number, number];
+}
+
+export interface EditResult {
+  nodes: MdNode[];
+  removedNodeRange: RemovedNodeRange | null;
+}
+
+type EventName = 'change';
+
+type EventHandlerMap = {
+  [key in EventName]: Function[];
+};
+
+export class ToastMark {
+  constructor(contents?: string, options?: Partial<ParserOptions>);
+
+  lineTexts: string[];
+
+  editMarkdown(startPos: Pos, endPos: Pos, newText: string): EditResult[];
+
+  getLineTexts(): string[];
+
+  getRootNode(): MdNode;
+
+  findNodeAtPosition(pos: Pos): MdNode | null;
+
+  findFirstNodeAtLine(line: number): MdNode | null;
+
+  on(eventName: EventName, callback: () => void): void;
+
+  off(eventName: EventName, callback: () => void): void;
+
+  findNodeById(id: number): MdNode | null;
+
+  removeAllNode(): void;
+}

package/types/toastui-editor-viewer.d.ts

@@ -0,0 +1,39 @@
+declare module '@licium/editor/dist/toastui-editor-viewer' {
+  import {
+    Viewer,
+    ViewerOptions,
+    ExtendedAutolinks,
+    LinkAttributes,
+    Sanitizer,
+    EventMap,
+    WidgetRuleMap,
+    WidgetRule,
+    PluginContext,
+    I18n,
+    CustomHTMLRenderer,
+    HTMLMdNodeConvertor,
+    HTMLMdNodeConvertorMap,
+    PluginInfo,
+    PluginNodeViews,
+    PluginCommandMap,
+  } from '@licium/editor';
+
+  export {
+    ViewerOptions,
+    ExtendedAutolinks,
+    LinkAttributes,
+    Sanitizer,
+    EventMap,
+    WidgetRuleMap,
+    WidgetRule,
+    PluginContext,
+    I18n,
+    CustomHTMLRenderer,
+    HTMLMdNodeConvertor,
+    HTMLMdNodeConvertorMap,
+    PluginInfo,
+    PluginNodeViews,
+    PluginCommandMap,
+  };
+  export default Viewer;
+}