@lobehub/editor 4.15.1 → 4.15.2

package/es/const/hotkey.js

@@ -0,0 +1,100 @@
+import { __esmMin } from "../_virtual/_rolldown/runtime.js";
+import { HotkeyEnum, HotkeyScopeEnum, KeyEnum, init_hotkey as init_hotkey$1 } from "../types/hotkey.js";
+import { COMMAND_PRIORITY_LOW } from "lexical";
+//#region src/const/hotkey.ts
+var combineKeys, HOTKEYS_REGISTRATION;
+var init_hotkey = __esmMin((() => {
+	init_hotkey$1();
+	combineKeys = (keys) => keys.join("+");
+	HOTKEYS_REGISTRATION = [
+		{
+			id: HotkeyEnum.Undo,
+			keys: combineKeys([KeyEnum.Mod, "z"]),
+			priority: COMMAND_PRIORITY_LOW,
+			scopes: [HotkeyScopeEnum.Format]
+		},
+		{
+			id: HotkeyEnum.Redo,
+			keys: combineKeys([KeyEnum.Mod, "y"]),
+			priority: COMMAND_PRIORITY_LOW,
+			scopes: [HotkeyScopeEnum.Format]
+		},
+		{
+			id: HotkeyEnum.Bold,
+			keys: combineKeys([KeyEnum.Mod, "b"]),
+			priority: COMMAND_PRIORITY_LOW,
+			scopes: [HotkeyScopeEnum.Format]
+		},
+		{
+			id: HotkeyEnum.Italic,
+			keys: combineKeys([KeyEnum.Mod, "i"]),
+			priority: COMMAND_PRIORITY_LOW,
+			scopes: [HotkeyScopeEnum.Format]
+		},
+		{
+			id: HotkeyEnum.Underline,
+			keys: combineKeys([KeyEnum.Mod, "u"]),
+			priority: COMMAND_PRIORITY_LOW,
+			scopes: [HotkeyScopeEnum.Format]
+		},
+		{
+			id: HotkeyEnum.Strikethrough,
+			keys: combineKeys([
+				KeyEnum.Mod,
+				KeyEnum.Shift,
+				"x"
+			]),
+			priority: COMMAND_PRIORITY_LOW,
+			scopes: [HotkeyScopeEnum.Format]
+		},
+		{
+			id: HotkeyEnum.CodeInline,
+			keys: combineKeys([KeyEnum.Mod, "e"]),
+			priority: COMMAND_PRIORITY_LOW,
+			scopes: [HotkeyScopeEnum.Format, HotkeyScopeEnum.Plugin]
+		},
+		{
+			id: HotkeyEnum.Link,
+			keys: combineKeys([
+				KeyEnum.Mod,
+				KeyEnum.Shift,
+				"k"
+			]),
+			priority: COMMAND_PRIORITY_LOW,
+			scopes: [HotkeyScopeEnum.Format, HotkeyScopeEnum.Plugin]
+		},
+		{
+			id: HotkeyEnum.NumberList,
+			keys: combineKeys([
+				KeyEnum.Mod,
+				KeyEnum.Shift,
+				"7"
+			]),
+			priority: COMMAND_PRIORITY_LOW,
+			scopes: [HotkeyScopeEnum.Insert, HotkeyScopeEnum.Plugin]
+		},
+		{
+			id: HotkeyEnum.BulletList,
+			keys: combineKeys([
+				KeyEnum.Mod,
+				KeyEnum.Shift,
+				"8"
+			]),
+			priority: COMMAND_PRIORITY_LOW,
+			scopes: [HotkeyScopeEnum.Insert, HotkeyScopeEnum.Plugin]
+		},
+		{
+			id: HotkeyEnum.PasteAsPlainText,
+			keys: combineKeys([
+				KeyEnum.Mod,
+				KeyEnum.Shift,
+				"v"
+			]),
+			priority: COMMAND_PRIORITY_LOW,
+			scopes: [HotkeyScopeEnum.Format]
+		}
+	];
+}));
+//#endregion
+init_hotkey();
+export { HOTKEYS_REGISTRATION, init_hotkey };

package/es/editor-kernel/data-source.d.ts

@@ -0,0 +1,15 @@
+import { LexicalEditor } from "lexical";
+
+//#region src/editor-kernel/data-source.d.ts
+interface IWriteOptions {
+  selection?: boolean;
+}
+declare class DataSource {
+  protected dataType: string;
+  constructor(dataType: string);
+  get type(): string;
+  read(editor: LexicalEditor, data: any, options?: Record<string, unknown>): void;
+  write(editor: LexicalEditor, options?: IWriteOptions): any;
+}
+//#endregion
+export { DataSource, IWriteOptions };

package/es/editor-kernel/data-source.js

@@ -0,0 +1,15 @@
+//#region src/editor-kernel/data-source.ts
+var DataSource = class {
+	constructor(dataType) {
+		this.dataType = dataType;
+	}
+	get type() {
+		return this.dataType;
+	}
+	read(editor, data, options) {}
+	write(editor, options) {
+		return null;
+	}
+};
+//#endregion
+export { DataSource as default };

package/es/editor-kernel/event.d.ts

@@ -0,0 +1,7 @@
+import * as _$lexical from "lexical";
+import { LexicalEditor } from "lexical";
+
+//#region src/editor-kernel/event.d.ts
+declare const HOVER_COMMAND: _$lexical.LexicalCommand<MouseEvent>;
+//#endregion
+export { HOVER_COMMAND };

package/es/editor-kernel/event.js

@@ -0,0 +1,19 @@
+import { __esmMin } from "../_virtual/_rolldown/runtime.js";
+import { createCommand } from "lexical";
+//#region src/editor-kernel/event.ts
+function registerEvent(editor, dom) {
+	const hoverHandler = (event) => {
+		editor.dispatchCommand(HOVER_COMMAND, event);
+	};
+	dom.addEventListener("mouseenter", hoverHandler);
+	return () => {
+		dom.removeEventListener("mouseenter", hoverHandler);
+	};
+}
+var HOVER_COMMAND;
+var init_event = __esmMin((() => {
+	HOVER_COMMAND = createCommand();
+}));
+//#endregion
+init_event();
+export { HOVER_COMMAND, init_event, registerEvent };

package/es/editor-kernel/index.d.ts

@@ -0,0 +1,5 @@
+import { DataSource } from "./data-source.js";
+import { $closest, $closestNodeType, $getNearestNodeFromDOMNode as $getNearestNodeFromDOMNode$1, $getNodeFromDOMNode, DOM_DOCUMENT_FRAGMENT_TYPE, DOM_DOCUMENT_TYPE, DOM_ELEMENT_TYPE, DOM_TEXT_TYPE, EDITOR_THEME_KEY, assert, compareNodeOrder, createEmptyEditorState, genServiceId, generateEditorId, getKernelFromEditor, getKernelFromEditorConfig, getNodeKeyFromDOMNode, getParentElement, isDOMNode, isDocumentFragment, moment, noop, reconcileDecorator, registerEditorKernel, unregisterEditorKernel } from "./utils.js";
+import { HOVER_COMMAND } from "./event.js";
+import { resetRandomKey as resetRandomKey$1 } from "lexical";
+export { resetRandomKey$1 as resetRandomKey };

package/es/editor-kernel/index.js

@@ -0,0 +1,17 @@
+import { init_event } from "./event.js";
+import { init_utils } from "./utils.js";
+import { Kernel, init_kernel } from "./kernel.js";
+import "./data-source.js";
+import { resetRandomKey as resetRandomKey$1 } from "lexical";
+//#region src/editor-kernel/index.ts
+init_kernel();
+init_utils();
+init_event();
+/**
+* Editor object to create an instance of the editor
+*/
+const Editor = { createEditor() {
+	return new Kernel();
+} };
+//#endregion
+export { Editor as default, resetRandomKey$1 as resetRandomKey };

package/es/editor-kernel/inode/helper.js

@@ -0,0 +1,87 @@
+import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
+//#region src/editor-kernel/inode/helper.ts
+var BaseContent, INodeHelper;
+var init_helper = __esmMin((() => {
+	BaseContent = {
+		direction: "ltr",
+		format: "",
+		indent: 0,
+		type: "",
+		version: 1
+	};
+	INodeHelper = {
+		appendChild(parent, ...child) {
+			if (!parent.children) parent.children = [];
+			parent.children.push(...child);
+		},
+		createElementNode(type, attrs = {}) {
+			return {
+				...BaseContent,
+				children: [],
+				...attrs,
+				type
+			};
+		},
+		createLikeTextNode(type, text, attrs = {}) {
+			return {
+				...BaseContent,
+				detail: 0,
+				format: 0,
+				mode: "normal",
+				style: "",
+				...attrs,
+				text,
+				type
+			};
+		},
+		createParagraph(attrs = {}) {
+			return {
+				...BaseContent,
+				children: [],
+				textFormat: 0,
+				textStyle: "",
+				...attrs,
+				type: "paragraph"
+			};
+		},
+		createRootNode(attrs = {}) {
+			return {
+				...BaseContent,
+				...attrs,
+				children: [],
+				type: "root"
+			};
+		},
+		createTextNode(text, attrs = {}) {
+			return {
+				...BaseContent,
+				detail: 0,
+				format: 0,
+				mode: "normal",
+				style: "",
+				...attrs,
+				text,
+				type: "text"
+			};
+		},
+		createTypeNode(type, attrs = {}) {
+			return {
+				...BaseContent,
+				...attrs,
+				type
+			};
+		},
+		isParagraphNode(node) {
+			return node.type === "paragraph";
+		},
+		isRootNode(node) {
+			return node.type === "root";
+		},
+		isTextNode(node) {
+			return node.type === "text";
+		}
+	};
+}));
+//#endregion
+init_helper();
+export { INodeHelper, init_helper };

package/es/editor-kernel/inode/i-element-node.d.ts

@@ -0,0 +1,6 @@
+import { SerializedElementNode } from "lexical";
+
+//#region src/editor-kernel/inode/i-element-node.d.ts
+type IElementNode = SerializedElementNode;
+//#endregion
+export { IElementNode };

package/es/editor-kernel/inode/i-node.d.ts

@@ -0,0 +1,6 @@
+import { SerializedLexicalNode } from "lexical";
+
+//#region src/editor-kernel/inode/i-node.d.ts
+type INode = SerializedLexicalNode;
+//#endregion
+export { INode };

package/es/editor-kernel/inode/index.d.ts

@@ -0,0 +1,4 @@
+import { IElementNode } from "./i-element-node.js";
+import { INode } from "./i-node.js";
+import { IRootNode } from "./root-node.js";
+import { ITextNode } from "./text-node.js";

package/es/editor-kernel/inode/paragraph-node.d.ts

@@ -0,0 +1 @@
+export { };

package/es/editor-kernel/inode/root-node.d.ts

@@ -0,0 +1,9 @@
+import { SerializedRootNode } from "lexical";
+
+//#region src/editor-kernel/inode/root-node.d.ts
+/**
+ * Root node
+ */
+type IRootNode = SerializedRootNode;
+//#endregion
+export { IRootNode };

package/es/editor-kernel/inode/text-node.d.ts

@@ -0,0 +1,9 @@
+import { SerializedTextNode } from "lexical";
+
+//#region src/editor-kernel/inode/text-node.d.ts
+/**
+ * Text node
+ */
+type ITextNode = SerializedTextNode;
+//#endregion
+export { ITextNode };

package/es/editor-kernel/kernel.d.ts

@@ -0,0 +1,122 @@
+import { DataSource } from "./data-source.js";
+import { HotkeyId } from "../types/hotkey.js";
+import { HotkeyOptions, HotkeysEvent } from "../utils/hotkey/registerHotkey.js";
+import { ILocaleKeys } from "../types/locale.js";
+import { IBeforeEditorInitLifecycle, IDecorator, IDocumentOptions, IEditor, IEditorKernel, IEditorPluginConstructor, INodeRegistrationTransform, IPlugin, ISelectionObject, IServiceID } from "../types/kernel.js";
+import { HistoryState } from "@lexical/history";
+import EventEmitter from "eventemitter3";
+import { CommandListener, CommandListenerPriority, CommandPayloadType, LexicalCommand, LexicalEditor, LexicalNodeConfig } from "lexical";
+
+//#region src/editor-kernel/kernel.d.ts
+declare class Kernel extends EventEmitter implements IEditorKernel {
+  private static globalHotReloadMode;
+  private dataTypeMap;
+  private plugins;
+  private pluginsConfig;
+  private pluginsInstances;
+  private beforeEditorInitHooks;
+  private nodeTransforms;
+  private rootClassNames;
+  private nodes;
+  private themes;
+  private decorators;
+  private serviceMap;
+  private localeMap;
+  private hotReloadMode;
+  private logger;
+  private historyState;
+  private editor?;
+  private headlessEditor;
+  constructor();
+  cloneNodeEditor(): IEditorKernel;
+  getHistoryState(): HistoryState;
+  isEditable(): boolean;
+  private detectDevelopmentMode;
+  /**
+   * Globally enable or disable hot reload mode for all kernel instances
+   * @param enabled Whether to enable hot reload mode globally
+   */
+  static setGlobalHotReloadMode(enabled: boolean): void;
+  /**
+   * Reset global hot reload mode to automatic detection
+   */
+  static resetGlobalHotReloadMode(): void;
+  getLexicalEditor(): LexicalEditor | null;
+  destroy(): void;
+  getRootElement(): HTMLElement | null;
+  setRootElement(dom: HTMLElement, editable?: boolean): LexicalEditor;
+  setEditable(editable: boolean): void;
+  initNodeEditor(): LexicalEditor;
+  initHeadlessEditor(): LexicalEditor;
+  setDocument(type: string, content: any, options?: IDocumentOptions): void;
+  setSelection(selection: ISelectionObject, opt?: {
+    collapseToEnd?: boolean;
+    collapseToStart?: boolean;
+  }): Promise<boolean>;
+  getSelection(): ISelectionObject | null;
+  focus(): void;
+  blur(): void;
+  getDocument(type: string): DataSource | undefined;
+  getSelectionDocument(type: string): unknown | null;
+  registerDecorator(name: string, decorator: IDecorator): this;
+  getDecorator(name: string): IDecorator | undefined;
+  /**
+   * Unregister a decorator
+   * @param name Decorator name
+   */
+  unregisterDecorator(name: string): boolean;
+  /**
+   * Get all registered decorator names
+   */
+  getRegisteredDecorators(): string[];
+  /**
+   * Support registering target data source
+   * @param dataSource Data source
+   */
+  registerDataSource(dataSource: DataSource): void;
+  registerThemes(themes: Record<string, any>): void;
+  registerPlugin<T>(plugin: IEditorPluginConstructor<T>, config?: T): IEditor;
+  registerPlugins(plugins: Array<IPlugin>): IEditor;
+  registerNodes(nodes: Array<LexicalNodeConfig>): void;
+  registerNodeTransform(transform: INodeRegistrationTransform): () => void;
+  registerBeforeEditorInit(hook: IBeforeEditorInitLifecycle): () => void;
+  registerRootClassName(className: string): () => void;
+  private runBeforeEditorInitLifecycle;
+  private applyRootClassNames;
+  private resolveNodesForInitialization;
+  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;
+  /**
+   * Enable or disable hot reload mode
+   * @param enabled Whether to enable hot reload mode
+   */
+  setHotReloadMode(enabled: boolean): void;
+  /**
+   * Check if hot reload mode is enabled
+   */
+  isHotReloadMode(): boolean;
+  /**
+   * Get service
+   * @param serviceId Service ID
+   */
+  requireService<T>(serviceId: IServiceID<T>): T | null;
+  dispatchCommand<TCommand extends LexicalCommand<unknown>>(type: TCommand, payload: CommandPayloadType<TCommand>): boolean;
+  getTheme(): Record<string, any>;
+  updateTheme(key: string, value: string | Record<string, string>): void;
+  registerLocale(locale: Partial<Record<keyof ILocaleKeys, string>>): void;
+  t<K extends keyof ILocaleKeys>(key: K, params?: Record<string, any>): string;
+  get isEmpty(): boolean;
+  get isSelected(): boolean;
+  cleanDocument(): void;
+  private _commands;
+  private _commandsClean;
+  registerHotkey(hotkeyId: HotkeyId, callback: (event: KeyboardEvent, handler: HotkeysEvent) => void, options?: HotkeyOptions): () => void;
+  registerHighCommand<P>(command: LexicalCommand<P>, listener: CommandListener<P>, priority: CommandListenerPriority): () => void;
+}
+//#endregion
+export { Kernel };