@techie_doubts/tui.editor.2026 3.2.2

package/package.json

@@ -0,0 +1,97 @@
+{
+  "name": "@techie_doubts/tui.editor.2026",
+  "version": "3.2.2",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "GFM  Markdown Wysiwyg Editor - Productive and Extensible",
+  "keywords": [
+    "nhn",
+    "nhn cloud",
+    "toast",
+    "toastui",
+    "toast-ui",
+    "markdown",
+    "wysiwyg",
+    "editor",
+    "preview",
+    "gfm"
+  ],
+  "main": "dist/td-editor.js",
+  "module": "dist/esm/",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/td-editor.js"
+    },
+    "./viewer": {
+      "import": "./dist/esm/indexViewer.js",
+      "require": "./dist/td-editor-viewer.js"
+    },
+    "./dist/i18n/*": {
+      "import": "./dist/esm/i18n/*.js",
+      "require": "./dist/i18n/*.js"
+    },
+    "./dist/td-editor-viewer": "./dist/td-editor-viewer.js",
+    "./dist/td-editor.css": "./dist/td-editor.css",
+    "./dist/td-editor-viewer.css": "./dist/td-editor-viewer.css",
+    "./dist/td-editor-only.css": "./dist/td-editor-only.css",
+    "./dist/theme/td-editor-dark.css": "./dist/theme/td-editor-dark.css",
+    "./td-editor.css": "./dist/td-editor.css",
+    "./td-editor-viewer.css": "./dist/td-editor-viewer.css",
+    "./td-editor-only.css": "./dist/td-editor-only.css",
+    "./td-editor-dark.css": "./dist/theme/td-editor-dark.css"
+  },
+  "types": "types/index.d.ts",
+  "files": [
+    "dist/*.js",
+    "dist/*.css",
+    "dist/theme",
+    "dist/esm",
+    "dist/i18n",
+    "types"
+  ],
+  "author": "NHN Cloud FE Development Lab <dl_javascript@nhn.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nhn/tui.editor.git",
+    "directory": "apps/editor"
+  },
+  "bugs": {
+    "url": "https://github.com/nhn/tui.editor/issues"
+  },
+  "homepage": "https://ui.toast.com",
+  "browserslist": "last 2 versions, not ie <= 10",
+  "scripts": {
+    "lint": "eslint .",
+    "test:types": "tsc",
+    "test": "jest --watch",
+    "test:ci": "jest",
+    "serve": "webpack serve",
+    "serve:ie": "webpack serve",
+    "build:i18n": "cross-env webpack --config scripts/webpack.config.i18n.js && webpack --config scripts/webpack.config.i18n.js --env minify",
+    "build:prod": "cross-env webpack build && webpack build --env minify && node tsBannerGenerator.js",
+    "build": "npm run build:esm && npm run build:i18n && npm run build:prod",
+    "build:esm": "rollup -c",
+    "note": "tui-note --tag=$(git describe --tags)",
+    "ts2js": "tsc --outDir tmpdoc --sourceMap false --target ES2015 --noEmit false",
+    "doc:dev": "npm run ts2js && tuidoc --serv",
+    "doc": "npm run ts2js && tuidoc"
+  },
+  "devDependencies": {
+    "@techie_doubts/tui.release-notes.2026": "^2.0.1",
+    "@types/dompurify": "2.3.3",
+    "cross-env": "^6.0.3"
+  },
+  "dependencies": {
+    "dompurify": "^2.3.3",
+    "prosemirror-commands": "1.5.0",
+    "prosemirror-history": "1.3.0",
+    "prosemirror-inputrules": "1.2.1",
+    "prosemirror-keymap": "1.2.0",
+    "prosemirror-model": "1.17.0",
+    "prosemirror-state": "1.3.4",
+    "prosemirror-view": "1.18.1"
+  }
+}

package/types/convertor.d.ts

@@ -0,0 +1,142 @@
+import { NodeType, MarkType, Schema, ProsemirrorNode, Mark } from 'prosemirror-model';
+import { MdNode, MdNodeType, RendererOptions, HTMLToken, MdPos } from './toastmark';
+import { WwNodeType, WwMarkType } from './wysiwyg';
+
+export type Attrs = { [name: string]: any } | null;
+
+export interface StackItem {
+  type: NodeType;
+  attrs: Attrs | null;
+  content: ProsemirrorNode[];
+}
+
+export interface ToWwConvertorState {
+  schema: Schema;
+  top(): StackItem;
+  push(node: ProsemirrorNode): void;
+  addText(text: string): void;
+  openMark(mark: Mark): void;
+  closeMark(mark: MarkType): void;
+  addNode(type: NodeType, attrs?: Attrs, content?: ProsemirrorNode[]): ProsemirrorNode | null;
+  openNode(type: NodeType, attrs?: Attrs): void;
+  closeNode(): ProsemirrorNode | null;
+  convertNode(mdNode: MdNode, infoForPosSync: InfoForPosSync): ProsemirrorNode | null;
+  convertByDOMParser(root: HTMLElement): void;
+}
+
+type ToWwConvertor = (
+  state: ToWwConvertorState,
+  node: MdNode,
+  context: {
+    entering: boolean;
+    skipChildren: () => void;
+    leaf: boolean;
+    options: Omit<RendererOptions, 'convertors'>;
+    getChildrenText: (mdNode: MdNode) => string;
+    origin?: () => HTMLToken | HTMLToken[] | null;
+  },
+  customAttrs?: { htmlAttrs?: Record<string, any>; classNames?: string[] }
+) => void;
+
+export type ToWwConvertorMap = Partial<Record<string, ToWwConvertor>>;
+
+export type FirstDelimFn = (index: number) => string;
+
+export interface ToMdConvertorState {
+  stopNewline: boolean;
+  inTable: boolean;
+  getDelim(): string;
+  setDelim(delim: string): void;
+  flushClose(size?: number): void;
+  wrapBlock(delim: string, firstDelim: string | null, node: ProsemirrorNode, fn: () => void): void;
+  ensureNewLine(): void;
+  write(content?: string): void;
+  closeBlock(node: ProsemirrorNode): void;
+  text(text: string, escaped?: boolean): void;
+  convertBlock(node: ProsemirrorNode, parent: ProsemirrorNode, index: number): void;
+  convertInline(parent: ProsemirrorNode): void;
+  convertList(node: ProsemirrorNode, delim: string, firstDelimFn: FirstDelimFn): void;
+  convertTableCell(node: ProsemirrorNode): void;
+  convertNode(parent: ProsemirrorNode, infoForPosSync?: InfoForPosSync): string;
+}
+
+export interface ToDOMAdaptor {
+  getToDOMNode(type: string): ((node: ProsemirrorNode | Mark) => Node) | null;
+}
+
+type HTMLToWwConvertor = (state: ToWwConvertorState, node: MdNode, openTagName: string) => void;
+
+export type HTMLToWwConvertorMap = Partial<Record<string, HTMLToWwConvertor>>;
+
+export interface FlattenHTMLToWwConvertorMap {
+  [k: string]: HTMLToWwConvertor;
+}
+
+export interface NodeInfo {
+  node: ProsemirrorNode;
+  parent?: ProsemirrorNode;
+  index?: number;
+}
+
+export interface MarkInfo {
+  node: Mark;
+  parent?: ProsemirrorNode;
+  index?: number;
+}
+
+interface ToMdConvertorReturnValues {
+  delim?: string | string[];
+  rawHTML?: string | string[] | null;
+  text?: string;
+  attrs?: Attrs;
+}
+
+type ToMdNodeTypeWriter = (
+  state: ToMdConvertorState,
+  nodeInfo: NodeInfo,
+  params: ToMdConvertorReturnValues
+) => void;
+
+export type ToMdNodeTypeWriterMap = Partial<Record<WwNodeType, ToMdNodeTypeWriter>>;
+
+interface ToMdMarkTypeOption {
+  mixable?: boolean;
+  removedEnclosingWhitespace?: boolean;
+  escape?: boolean;
+}
+
+export type ToMdMarkTypeOptions = Partial<Record<WwMarkType, ToMdMarkTypeOption | null>>;
+
+type ToMdNodeTypeConvertor = (state: ToMdConvertorState, nodeInfo: NodeInfo) => void;
+
+export type ToMdNodeTypeConvertorMap = Partial<Record<WwNodeType, ToMdNodeTypeConvertor>>;
+
+type ToMdMarkTypeConvertor = (
+  nodeInfo?: MarkInfo,
+  entering?: boolean
+) => ToMdConvertorReturnValues & ToMdMarkTypeOption;
+
+export type ToMdMarkTypeConvertorMap = Partial<Record<WwMarkType, ToMdMarkTypeConvertor>>;
+
+interface ToMdConvertorContext {
+  origin?: () => ReturnType<ToMdConvertor>;
+  entering?: boolean;
+  inTable?: boolean;
+}
+
+type ToMdConvertor = (
+  nodeInfo: NodeInfo | MarkInfo,
+  context: ToMdConvertorContext
+) => ToMdConvertorReturnValues;
+
+export type ToMdConvertorMap = Partial<Record<WwNodeType | MdNodeType, ToMdConvertor>>;
+
+export interface ToMdConvertors {
+  nodeTypeConvertors: ToMdNodeTypeConvertorMap;
+  markTypeConvertors: ToMdMarkTypeConvertorMap;
+}
+
+export interface InfoForPosSync {
+  node: MdNode | ProsemirrorNode | null;
+  setMappedPos: (pos: MdPos | number) => void;
+}

package/types/editor.d.ts

@@ -0,0 +1,383 @@
+import { Schema, NodeSpec, MarkSpec, Fragment } from 'prosemirror-model';
+import { EditorView, Decoration, DecorationSet } from 'prosemirror-view';
+import { EditorState, Plugin, PluginKey, Selection, TextSelection } from 'prosemirror-state';
+import { undoInputRule, InputRule, inputRules } from 'prosemirror-inputrules';
+import { keymap } from 'prosemirror-keymap';
+import { Editor } from '@t/index';
+
+import {
+  HTMLConvertor,
+  MdPos,
+  Sourcepos,
+  Context as MdContext,
+  HTMLToken,
+  HTMLConvertorMap,
+} from './toastmark';
+import { Emitter, Handler } from './event';
+import { Context, EditorAllCommandMap, EditorCommandFn, SpecManager } from './spec';
+import { ToMdConvertorMap } from './convertor';
+import { ToolbarItemOptions, IndexList } from './ui';
+import { CommandFn, PluginInfo } from './plugin';
+import { HTMLMdNode } from './markdown';
+
+export type PreviewStyle = 'tab' | 'vertical';
+export type EditorType = 'markdown' | 'wysiwyg';
+export type WidgetStyle = 'top' | 'bottom';
+export interface WidgetRule {
+  rule: RegExp;
+  toDOM: (text: string) => HTMLElement;
+}
+
+export type WidgetRuleMap = Record<string, WidgetRule>;
+
+export interface EventMap {
+  load?: (param: Editor) => void;
+  change?: (editorType: EditorType) => void;
+  caretChange?: (editorType: EditorType) => void;
+  focus?: (editorType: EditorType) => void;
+  blur?: (editorType: EditorType) => void;
+  keydown?: (editorType: EditorType, ev: KeyboardEvent) => void;
+  keyup?: (editorType: EditorType, ev: KeyboardEvent) => void;
+  beforePreviewRender?: (html: string) => string;
+  beforeConvertWysiwygToMarkdown?: (markdownText: string) => string;
+}
+
+type HookCallback = (url: string, text?: string) => void;
+
+export type HookMap = {
+  addImageBlobHook?: (blob: Blob | File, callback: HookCallback) => void;
+};
+
+export type AutolinkParser = (
+  content: string
+) => {
+  url: string;
+  text: string;
+  range: [number, number];
+}[];
+
+export type ExtendedAutolinks = boolean | AutolinkParser;
+
+export type LinkAttributeNames = 'rel' | 'target' | 'hreflang' | 'type';
+
+// @TODO change option and type name from singular to plural
+export type LinkAttributes = Partial<Record<LinkAttributeNames, string>>;
+
+export type Sanitizer = (content: string) => string;
+
+export type HTMLMdNodeConvertor = (
+  node: HTMLMdNode,
+  context: MdContext,
+  convertors?: HTMLConvertorMap
+) => HTMLToken | HTMLToken[] | null;
+
+export type HTMLMdNodeConvertorMap = Record<string, HTMLMdNodeConvertor>;
+
+export type CustomHTMLRenderer = Partial<Record<string, HTMLConvertor | HTMLMdNodeConvertorMap>>;
+
+export interface ViewerOptions {
+  el: HTMLElement;
+  initialValue?: string;
+  events?: EventMap;
+  plugins?: EditorPlugin[];
+  extendedAutolinks?: ExtendedAutolinks;
+  linkAttributes?: LinkAttributes;
+  customHTMLRenderer?: CustomHTMLRenderer;
+  referenceDefinition?: boolean;
+  customHTMLSanitizer?: Sanitizer;
+  frontMatter?: boolean;
+  usageStatistics?: boolean;
+  theme?: string;
+}
+
+export class Viewer {
+  static isViewer: boolean;
+
+  constructor(options: ViewerOptions);
+
+  setMarkdown(markdown: string): void;
+
+  on(type: string, handler: Handler): void;
+
+  off(type: string): void;
+
+  destroy(): void;
+
+  isViewer(): boolean;
+
+  isMarkdownMode(): boolean;
+
+  isWysiwygMode(): boolean;
+
+  addHook(type: string, handler: Handler): void;
+}
+
+export interface I18n {
+  setCode(code?: string): void;
+
+  setLanguage(codes: string | string[], data: Record<string, string>): void;
+
+  get(key: string, code?: string): string;
+}
+
+export interface PluginContext {
+  eventEmitter: Emitter;
+  usageStatistics?: boolean;
+  i18n: I18n;
+  instance: Editor | Viewer;
+  pmState: {
+    Plugin: typeof Plugin;
+    PluginKey: typeof PluginKey;
+    Selection: typeof Selection;
+    TextSelection: typeof TextSelection;
+  };
+  pmView: { Decoration: typeof Decoration; DecorationSet: typeof DecorationSet };
+  pmModel: { Fragment: typeof Fragment };
+  pmRules: {
+    inputRules: typeof inputRules;
+    InputRule: typeof InputRule;
+    undoInputRule: typeof undoInputRule;
+  };
+  pmKeymap: {
+    keymap: typeof keymap;
+  };
+}
+
+export type PluginFn = (context: PluginContext, options?: any) => PluginInfo | null;
+export type EditorPlugin = PluginFn | [PluginFn, any];
+type ContextInfo = {
+  eventEmitter: Emitter;
+  usageStatistics: boolean;
+  instance: Editor | Viewer;
+};
+
+export type EditorPluginInfo = ContextInfo & {
+  plugin: EditorPlugin;
+};
+
+export type EditorPluginsInfo = ContextInfo & {
+  plugins: EditorPlugin[];
+};
+
+export interface EditorOptions {
+  el: HTMLElement;
+  height?: string;
+  minHeight?: string;
+  initialValue?: string;
+  previewStyle?: PreviewStyle;
+  initialEditType?: EditorType;
+  events?: EventMap;
+  hooks?: HookMap;
+  language?: string;
+  useCommandShortcut?: boolean;
+  usageStatistics?: boolean;
+  toolbarItems?: (string | ToolbarItemOptions)[][];
+  hideModeSwitch?: boolean;
+  plugins?: EditorPlugin[];
+  extendedAutolinks?: ExtendedAutolinks;
+  placeholder?: string;
+  linkAttributes?: LinkAttributes;
+  customHTMLRenderer?: CustomHTMLRenderer;
+  customMarkdownRenderer?: ToMdConvertorMap;
+  referenceDefinition?: boolean;
+  customHTMLSanitizer?: Sanitizer;
+  previewHighlight?: boolean;
+  frontMatter?: boolean;
+  widgetRules?: WidgetRule[];
+  theme?: string;
+  autofocus?: boolean;
+  viewer?: boolean;
+}
+
+interface Slots {
+  mdEditor: HTMLElement;
+  mdPreview: HTMLElement;
+  wwEditor: HTMLElement;
+}
+
+export class EditorCore {
+  constructor(options: EditorOptions);
+
+  public eventEmitter: Emitter;
+
+  public static factory(options: EditorOptions): EditorCore | Viewer;
+
+  public static setLanguage(code: string, data: Record<string, string>): void;
+
+  changePreviewStyle(style: PreviewStyle): void;
+
+  exec(name: string, payload?: Record<string, any>): void;
+
+  addCommand(type: EditorType, name: string, command: CommandFn): void;
+
+  on(type: string, handler: Handler): void;
+
+  off(type: string): void;
+
+  addHook(type: string, handler: Handler): void;
+
+  removeHook(type: string): void;
+
+  focus(): void;
+
+  blur(): void;
+
+  moveCursorToEnd(focus?: boolean): void;
+
+  moveCursorToStart(focus?: boolean): void;
+
+  setMarkdown(markdown: string, cursorToEnd?: boolean): void;
+
+  setHTML(html: string, cursorToEnd?: boolean): void;
+
+  getMarkdown(): string;
+
+  getHTML(): string;
+
+  insertText(text: string): void;
+
+  setSelection(start: EditorPos, end?: EditorPos): void;
+
+  replaceSelection(text: string, start?: EditorPos, end?: EditorPos): void;
+
+  deleteSelection(start?: EditorPos, end?: EditorPos): void;
+
+  getSelectedText(start?: EditorPos, end?: EditorPos): string;
+
+  getRangeInfoOfNode(pos?: EditorPos): NodeRangeInfo;
+
+  addWidget(node: Node, style: WidgetStyle, pos?: EditorPos): void;
+
+  replaceWithWidget(start: EditorPos, end: EditorPos, text: string): void;
+
+  setHeight(height: string): void;
+
+  getHeight(): string;
+
+  setMinHeight(minHeight: string): void;
+
+  getMinHeight(): string;
+
+  isMarkdownMode(): boolean;
+
+  isWysiwygMode(): boolean;
+
+  isViewer(): boolean;
+
+  getCurrentPreviewStyle(): PreviewStyle;
+
+  changeMode(mode: EditorType, isWithoutFocus?: boolean): void;
+
+  destroy(): void;
+
+  hide(): void;
+
+  show(): void;
+
+  setScrollTop(value: number): void;
+
+  getScrollTop(): number;
+
+  reset(): void;
+
+  getSelection(): SelectionPos;
+
+  setPlaceholder(placeholder: string): void;
+
+  getEditorElements(): Slots;
+
+  convertPosToMatchEditorMode(start: EditorPos, end?: EditorPos, mode?: EditorType): EditorPos[];
+}
+
+export class Editor extends EditorCore {
+  insertToolbarItem({ groupIndex, itemIndex }: IndexList, item: string | ToolbarItemOptions): void;
+
+  removeToolbarItem(itemName: string): void;
+}
+
+export type SelectionPos = Sourcepos | [from: number, to: number];
+export type EditorPos = MdPos | number;
+export interface NodeRangeInfo {
+  range: SelectionPos;
+  type: string;
+}
+
+export interface Base {
+  el: HTMLElement;
+
+  editorType: EditorType;
+
+  eventEmitter: Emitter;
+
+  context: Context;
+
+  schema: Schema;
+
+  keymaps: Plugin[];
+
+  view: EditorView;
+
+  commands: EditorAllCommandMap;
+
+  specs: SpecManager;
+
+  placeholder: { text: string };
+
+  createSpecs(): SpecManager;
+
+  createContext(): Context;
+
+  createState(): EditorState;
+
+  createView(): EditorView;
+
+  createSchema(): Schema;
+
+  createKeymaps(useCommandShortcut: boolean): Plugin<any, any>[];
+
+  createCommands(): Record<string, EditorCommandFn<Record<string, any>>>;
+
+  focus(): void;
+
+  blur(): void;
+
+  destroy(): void;
+
+  moveCursorToStart(focus: boolean): void;
+
+  moveCursorToEnd(focus: boolean): void;
+
+  setScrollTop(top: number): void;
+
+  getScrollTop(): number;
+
+  setPlaceholder(text: string): void;
+
+  setHeight(height: number): void;
+
+  setMinHeight(minHeight: number): void;
+
+  getElement(): HTMLElement;
+
+  setSelection(start: EditorPos, end?: EditorPos): void;
+
+  replaceWithWidget(start: EditorPos, end: EditorPos, text: string): void;
+
+  addWidget(node: Node, style: WidgetStyle, pos?: EditorPos): void;
+
+  replaceSelection(text: string, start?: EditorPos, end?: EditorPos): void;
+
+  deleteSelection(start?: EditorPos, end?: EditorPos): void;
+
+  getSelectedText(start?: EditorPos, end?: EditorPos): string;
+
+  getSelection(): SelectionPos;
+
+  getRangeInfoOfNode(pos?: EditorPos): NodeRangeInfo;
+}
+
+export type SchemaMap = Record<string, NodeSpec | MarkSpec>;
+export interface HTMLSchemaMap {
+  nodes: SchemaMap;
+  marks: SchemaMap;
+}

package/types/event.d.ts

@@ -0,0 +1,60 @@
+import { Mapable } from './map';
+
+export interface Handler {
+  (...args: any[]): any;
+  namespace?: string;
+}
+
+export interface Emitter {
+  listen(type: string, handler: Handler): void;
+  emit(type: string, ...args: any[]): any[];
+  emitReduce(type: string, source: any, ...args: any[]): any;
+  addEventType(type: string): void;
+  removeEventHandler(type: string, handler?: Handler): void;
+  getEvents(): Mapable<string, Handler[] | undefined>;
+  holdEventInvoke(fn: Function): void;
+}
+
+export interface EmitterConstructor {
+  new (): Emitter;
+}
+
+export type EventTypes =
+  | 'afterPreviewRender'
+  | 'updatePreview'
+  | 'changeMode'
+  | 'needChangeMode'
+  | 'changeTheme'
+  | 'command'
+  | 'changePreviewStyle'
+  | 'changePreviewTabPreview'
+  | 'changePreviewTabWrite'
+  | 'scroll'
+  | 'contextmenu'
+  | 'show'
+  | 'hide'
+  | 'changeLanguage'
+  | 'changeToolbarState'
+  | 'toggleScrollSync'
+  | 'mixinTableOffsetMapPrototype'
+  | 'setFocusedNode'
+  | 'removePopupWidget'
+  | 'query'
+  // provide event for user
+  | 'openPopup'
+  | 'closePopup'
+  | 'addImageBlobHook'
+  | 'beforePreviewRender'
+  | 'beforeConvertWysiwygToMarkdown'
+  | 'load'
+  | 'loadUI'
+  | 'change'
+  | 'caretChange'
+  | 'destroy'
+  | 'focus'
+  | 'blur'
+  | 'keydown'
+  | 'keyup'
+  | 'wwUserEdit'
+  | 'beforeExportHtml'
+  | 'afterExportHtml';