@lobehub/editor 4.15.0 → 4.15.2

package/es/types/hotkey.d.ts

@@ -0,0 +1,76 @@
+import { CommandListenerPriority } from "lexical";
+
+//#region src/types/hotkey.d.ts
+declare const KeyEnum: {
+  readonly Alt: "alt";
+  readonly Backquote: "backquote";
+  readonly Backslash: "backslash";
+  readonly Backspace: "backspace";
+  readonly BracketLeft: "bracketleft";
+  readonly BracketRight: "bracketright";
+  readonly Comma: "comma";
+  readonly Ctrl: "ctrl";
+  readonly Down: "down";
+  readonly Enter: "enter";
+  readonly Equal: "equal";
+  readonly Esc: "esc";
+  readonly Left: "left";
+  readonly LeftClick: "left-click";
+  readonly LeftDoubleClick: "left-double-click";
+  readonly Meta: "meta";
+  readonly MiddleClick: "middle-click";
+  readonly Minus: "minus";
+  readonly Mod: "mod";
+  readonly Number: "1-9";
+  readonly Period: "period";
+  readonly Plus: "equal";
+  readonly QuestionMark: "slash";
+  readonly Quote: "quote";
+  readonly Right: "right";
+  readonly RightClick: "right-click";
+  readonly RightDoubleClick: "right-double-click";
+  readonly Semicolon: "semicolon";
+  readonly Shift: "shift";
+  readonly Slash: "slash";
+  readonly Space: "space";
+  readonly Tab: "tab";
+  readonly Up: "up";
+  readonly Zero: "0";
+};
+declare const HotkeyEnum: {
+  readonly Bold: "bold";
+  readonly BulletList: "bulletList";
+  readonly CodeInline: "codeInline";
+  readonly Italic: "italic";
+  readonly Link: "link";
+  readonly Mention: "mention";
+  readonly NumberList: "numberList";
+  readonly PasteAsPlainText: "pasteAsPlainText";
+  readonly Redo: "redo";
+  readonly Slash: "slash";
+  readonly Strikethrough: "strikethrough";
+  readonly Underline: "underline";
+  readonly Undo: "undo";
+};
+declare const HotkeyScopeEnum: {
+  readonly Format: "format";
+  readonly Insert: "insert";
+  readonly Plugin: "plugin";
+  readonly Slash: "slash";
+};
+type HotkeyId = (typeof HotkeyEnum)[keyof typeof HotkeyEnum];
+type HotkeyScopeId = (typeof HotkeyScopeEnum)[keyof typeof HotkeyScopeEnum];
+interface HotkeyItem {
+  id: HotkeyId;
+  keys: string;
+  priority: CommandListenerPriority;
+  scopes?: HotkeyScopeId[];
+}
+type ModifierCombination = {
+  altKey?: boolean;
+  ctrlKey?: boolean;
+  metaKey?: boolean;
+  shiftKey?: boolean;
+} | Record<string, never>;
+//#endregion
+export { HotkeyEnum, HotkeyId, HotkeyItem, HotkeyScopeEnum, HotkeyScopeId, KeyEnum, ModifierCombination };

package/es/types/hotkey.js

@@ -0,0 +1,65 @@
+import { __esmMin } from "../_virtual/_rolldown/runtime.js";
+//#region src/types/hotkey.ts
+var KeyEnum, HotkeyEnum, HotkeyScopeEnum;
+var init_hotkey = __esmMin((() => {
+	KeyEnum = {
+		Alt: "alt",
+		Backquote: "backquote",
+		Backslash: "backslash",
+		Backspace: "backspace",
+		BracketLeft: "bracketleft",
+		BracketRight: "bracketright",
+		Comma: "comma",
+		Ctrl: "ctrl",
+		Down: "down",
+		Enter: "enter",
+		Equal: "equal",
+		Esc: "esc",
+		Left: "left",
+		LeftClick: "left-click",
+		LeftDoubleClick: "left-double-click",
+		Meta: "meta",
+		MiddleClick: "middle-click",
+		Minus: "minus",
+		Mod: "mod",
+		Number: "1-9",
+		Period: "period",
+		Plus: "equal",
+		QuestionMark: "slash",
+		Quote: "quote",
+		Right: "right",
+		RightClick: "right-click",
+		RightDoubleClick: "right-double-click",
+		Semicolon: "semicolon",
+		Shift: "shift",
+		Slash: "slash",
+		Space: "space",
+		Tab: "tab",
+		Up: "up",
+		Zero: "0"
+	};
+	HotkeyEnum = {
+		Bold: "bold",
+		BulletList: "bulletList",
+		CodeInline: "codeInline",
+		Italic: "italic",
+		Link: "link",
+		Mention: "mention",
+		NumberList: "numberList",
+		PasteAsPlainText: "pasteAsPlainText",
+		Redo: "redo",
+		Slash: "slash",
+		Strikethrough: "strikethrough",
+		Underline: "underline",
+		Undo: "undo"
+	};
+	HotkeyScopeEnum = {
+		Format: "format",
+		Insert: "insert",
+		Plugin: "plugin",
+		Slash: "slash"
+	};
+}));
+//#endregion
+init_hotkey();
+export { HotkeyEnum, HotkeyScopeEnum, KeyEnum, init_hotkey };

package/es/types/index.d.ts

@@ -0,0 +1,2 @@
+import { ILocaleKeys, LocaleType } from "./locale.js";
+import { IBeforeEditorInitLifecycle, IDecorator, IDecoratorFunc, IDocumentOptions, IEditor, IEditorKernel, IEditorPlugin, IEditorPluginConstructor, IKernelEventMap, INodeRegistrationTransform, IPlugin, ISelectionObject, IServiceID } from "./kernel.js";

package/es/types/kernel.d.ts

@@ -0,0 +1,359 @@
+import { DataSource } from "../editor-kernel/data-source.js";
+import { HotkeyId } from "./hotkey.js";
+import { HotkeyOptions, HotkeysEvent } from "../utils/hotkey/registerHotkey.js";
+import { ILocaleKeys } from "./locale.js";
+import { HistoryState, HistoryStateEntry } from "@lexical/history";
+import { CommandListener, CommandListenerPriority, CommandPayloadType, EditorState, LexicalCommand, LexicalEditor, LexicalNode, LexicalNodeConfig } from "lexical";
+
+//#region src/types/kernel.d.ts
+type IDecoratorFunc = (_node: LexicalNode, _editor: LexicalEditor) => any;
+type INodeRegistrationTransform = (node: LexicalNodeConfig, index: number) => LexicalNodeConfig | null | undefined;
+type IBeforeEditorInitLifecycle = () => void;
+type IDecorator = {
+  queryDOM: (_element: HTMLElement) => HTMLElement;
+  render: IDecoratorFunc;
+} | IDecoratorFunc;
+/**
+ * Service ID type
+ */
+type IServiceID<Service> = {
+  readonly __serviceId: string;
+  __serviceType?: Service;
+};
+interface ISelectionObject {
+  endNodeId: string;
+  endOffset: number;
+  startNodeId: string;
+  startOffset: number;
+  type: 'range' | 'node' | 'table';
+}
+interface IDocumentOptions {
+  [key: string]: unknown;
+  keepHistory?: boolean;
+  /** only work for json datasource */
+  keepId?: boolean;
+}
+interface IKernelEventMap {
+  /**
+   * Document change event
+   */
+  documentChange: (type: string, content: any) => void;
+  /**
+   * Editor editable state change event
+   */
+  editableChange: (editable: boolean) => void;
+  /**
+   * Editor error event
+   */
+  error: (error: Error) => void;
+  /**
+   * Initialization event
+   * @param editor Lexical editor instance
+   * @returns
+   */
+  initialized: (editor: LexicalEditor) => void;
+  /**
+   * handle markdown parse event
+   */
+  markdownParse: (params: {
+    cacheState: EditorState;
+    historyState: HistoryStateEntry | null;
+    markdown: string;
+    matchedPatterns: string[];
+    score: number;
+  }) => void;
+  /**
+   * handle paste event
+   */
+  onPaste: (event: ClipboardEvent) => void;
+}
+/**
+ * External API
+ */
+interface IEditor {
+  /**
+   * Lose focus
+   */
+  blur(): void;
+  /**
+   * Clean editor content (clear all content)
+   */
+  cleanDocument(): void;
+  /**
+   * Destroy editor instance
+   */
+  destroy(): void;
+  /**
+   * Execute editor commands to manipulate editor content
+   * @param type
+   * @param payload
+   */
+  dispatchCommand<TCommand extends LexicalCommand<unknown>>(type: TCommand, payload: CommandPayloadType<TCommand>): boolean;
+  /**
+   * Focus editor
+   */
+  focus(): void;
+  /**
+   * Get editor content of specified type
+   */
+  getDocument(type: string): DataSource | undefined;
+  /**
+   * Lexical history state (undo stack metadata)
+   */
+  getHistoryState(): HistoryState;
+  /**
+   * Get Lexical editor instance
+   */
+  getLexicalEditor(): LexicalEditor | null;
+  /**
+   * Get document editor root node
+   */
+  getRootElement(): HTMLElement | null;
+  /**
+   * Get editor selection information
+   */
+  getSelection(): ISelectionObject | null;
+  /**
+   * Get document editor selection content of specified type
+   * @param type
+   */
+  getSelectionDocument(type: string): unknown | null;
+  /**
+   * Get editor theme
+   */
+  getTheme(): Record<string, string | Record<string, string>>;
+  /**
+   * Get headless editor instance
+   */
+  initHeadlessEditor(): LexicalEditor | null;
+  /**
+   * Get node editor instance
+   */
+  initNodeEditor(): LexicalEditor | null;
+  /**
+   * Check if editor is editable
+   */
+  isEditable(): boolean;
+  /**
+   * Check if editor content is empty
+   * @returns true if editor content is empty, false otherwise
+   */
+  get isEmpty(): boolean;
+  /**
+   * Check if editor has active selection
+   * @returns true if editor has selection, false otherwise
+   */
+  get isSelected(): boolean;
+  /**
+   * Remove editor event listener
+   * @param event
+   * @param listener
+   */
+  off<T extends keyof IKernelEventMap>(event: T, listener: IKernelEventMap[T]): this;
+  /**
+   * Add editor event listener
+   * @param event
+   * @param listener
+   */
+  on<T extends keyof IKernelEventMap>(event: T, listener: IKernelEventMap[T]): this;
+  /**
+   * Listen to event once, automatically remove listener after trigger
+   * @param event
+   * @param listener
+   */
+  once<T extends keyof IKernelEventMap>(event: T, listener: IKernelEventMap[T]): this;
+  /**
+   * Extends the priority level of Lexical commands.
+   * Registers a listener that triggers when the provided command is dispatched
+   * via {@link LexicalEditor.dispatch}. The listener is triggered based on its priority.
+   * Listeners with higher priority can "intercept" commands and prevent them
+   * from propagating to other handlers by returning true.
+   *
+   * Listeners are always invoked within {@link LexicalEditor.update} and can call dollar functions.
+   *
+   * Listeners registered at the same priority level will deterministically run
+   * in the order of registration.
+   *
+   * @param command - The command that triggers the callback.
+   * @param listener - The function executed when the command is dispatched.
+   * @param priority - The relative priority of the listener. 0 | 1 | 2 | 3 | 4
+   *   (or {@link COMMAND_PRIORITY_EDITOR} |
+   *     {@link COMMAND_PRIORITY_LOW} |
+   *     {@link COMMAND_PRIORITY_NORMAL} |
+   *     {@link COMMAND_PRIORITY_HIGH} |
+   *     {@link COMMAND_PRIORITY_CRITICAL})
+   * @returns A teardown function to clean up the listener.
+   */
+  registerHighCommand<P>(command: LexicalCommand<P>, listener: CommandListener<P>, priority: CommandListenerPriority): () => void;
+  /**
+   * Register keyboard shortcut
+   * @param hotkey
+   * @param callback
+   * @param options
+   */
+  registerHotkey(hotkey: HotkeyId, callback: (event: KeyboardEvent, handler: HotkeysEvent) => void, options?: HotkeyOptions): () => void;
+  /**
+   * Register internationalization text
+   * @param locale Internationalization text object
+   */
+  registerLocale(locale: Partial<Record<keyof ILocaleKeys, string>>): void;
+  /**
+   * Register editor plugin
+   */
+  registerPlugin<T>(plugin: IEditorPluginConstructor<T>, config?: T): IEditor;
+  /**
+   * Register multiple editor plugins
+   */
+  registerPlugins(plugins: Array<IPlugin>): IEditor;
+  /**
+   * Get editor Service, usually provided by plugins to extend certain functionalities
+   * @param serviceId
+   */
+  requireService<T>(serviceId: IServiceID<T>): T | null;
+  /**
+   * Set editor content, type is content type, content is content data
+   * @param type
+   * @param content
+   */
+  setDocument(type: string, content: any, options?: IDocumentOptions): void;
+  /**
+   * Enable or disable editor editing capability
+   * @param editable
+   */
+  setEditable(editable: boolean): void;
+  /**
+   * Set document editor root node
+   * @param dom
+   */
+  setRootElement(dom: HTMLElement, editable?: boolean): LexicalEditor;
+  /**
+   * set editor selection
+   * @param selection
+   */
+  setSelection(selection: ISelectionObject, opt?: {
+    collapseToEnd?: boolean;
+    collapseToStart?: boolean;
+  }): Promise<boolean>;
+  /**
+   * Get translation text
+   * @param key Translation key
+   * @param params Parameter replacement
+   */
+  t<K extends keyof ILocaleKeys>(key: K, params?: Record<string, any>): string;
+  /**
+   * Update editor theme
+   * @param key
+   * @param value
+   */
+  updateTheme(key: string, value: string | Record<string, string>): void;
+}
+/**
+ * API provided to plugins
+ */
+interface IEditorKernel extends IEditor {
+  /**
+   * Clone the current editor kernel instance
+   */
+  cloneNodeEditor(): IEditorKernel;
+  emit<T extends keyof IKernelEventMap>(event: T, params: Parameters<IKernelEventMap[T]>[0]): void;
+  /**
+   * Get editor Node decorator for specific Node rendering
+   * @param name
+   */
+  getDecorator(name: string): IDecorator | undefined;
+  /**
+   * Get all registered decorator names
+   */
+  getRegisteredDecorators(): string[];
+  /**
+   * Check if hot reload mode is enabled
+   */
+  isHotReloadMode(): boolean;
+  /**
+   * Register a lifecycle hook that runs right before editor initialization.
+   * @param hook
+   * @returns unregister function
+   */
+  registerBeforeEditorInit(hook: IBeforeEditorInitLifecycle): () => void;
+  /**
+   * Register data source for multi-format data conversion
+   * @param dataSource
+   */
+  registerDataSource(dataSource: DataSource): void;
+  /**
+   * Register editor node decorator
+   * @param name
+   * @param decorator
+   */
+  registerDecorator(name: string, decorator: IDecorator): void;
+  /**
+   * Register a transform hook that runs before editor initialization
+   * to rewrite registered nodes before createEditor/createHeadlessEditor is called.
+   * @param transform
+   * @returns unregister function
+   */
+  registerNodeTransform(transform: INodeRegistrationTransform): () => void;
+  /**
+   * Register Lexical Node
+   * @param nodes
+   */
+  registerNodes(nodes: Array<LexicalNodeConfig>): void;
+  /**
+   * Register className(s) to the contenteditable root element.
+   * @param className One or more class names separated by spaces
+   * @returns unregister function
+   */
+  registerRootClassName(className: string): () => void;
+  /**
+   * Register service
+   * @param serviceId
+   * @param service
+   */
+  registerService<T>(serviceId: IServiceID<T>, service: T): void;
+  /**
+   * Register service with hot reload support - allows overriding existing services
+   * @param serviceId Service identifier
+   * @param service Service instance
+   */
+  registerServiceHotReload<T>(serviceId: IServiceID<T>, service: T): void;
+  /**
+   * Register theme
+   * @param themes
+   */
+  registerThemes(themes: Record<string, any>): void;
+  /**
+   * Enable or disable hot reload mode
+   * @param enabled Whether to enable hot reload mode
+   */
+  setHotReloadMode(enabled: boolean): void;
+  /**
+   * Unregister editor node decorator
+   * @param name Decorator name
+   */
+  unregisterDecorator(name: string): boolean;
+}
+/**
+ * Plugin interface
+ */
+interface IEditorPlugin<IConfig> {
+  config?: IConfig;
+  /**
+   * Editor destruction
+   */
+  destroy(): void;
+  /**
+   * After Lexical editor instantiation
+   * @param editor Lexical editor instance
+   */
+  onInit?(editor: LexicalEditor): void;
+}
+/**
+ * Plugin class interface
+ */
+interface IEditorPluginConstructor<IConfig> {
+  readonly pluginName: string;
+  new (kernel: IEditorKernel, config?: IConfig): IEditorPlugin<IConfig>;
+}
+type IPlugin<T = any> = IEditorPluginConstructor<T> | [IEditorPluginConstructor<T>, T?];
+//#endregion
+export { IBeforeEditorInitLifecycle, IDecorator, IDecoratorFunc, IDocumentOptions, IEditor, IEditorKernel, IEditorPlugin, IEditorPluginConstructor, IKernelEventMap, INodeRegistrationTransform, IPlugin, ISelectionObject, IServiceID };

package/es/types/locale.d.ts

@@ -0,0 +1,11 @@
+import { _default } from "../locale/index.js";
+
+//#region src/types/locale.d.ts
+/**
+ * Internationalization key type declaration, plugins can extend through declaration merging
+ */
+type LocaleType = typeof _default;
+type FlattenKeys<T, Prefix extends string = ''> = { [K in keyof T & string]: T[K] extends string ? Prefix extends '' ? K : `${Prefix}.${K}` : T[K] extends Record<string, any> ? FlattenKeys<T[K], Prefix extends '' ? K : `${Prefix}.${K}`> : never }[keyof T & string];
+type ILocaleKeys = Record<FlattenKeys<LocaleType>, string>;
+//#endregion
+export { ILocaleKeys, LocaleType };

package/es/utils/cx.js

@@ -0,0 +1,4 @@
+//#region src/utils/cx.ts
+const cx = (...classNames) => classNames.filter(Boolean).join(" ");
+//#endregion
+export { cx };