@lobehub/editor 4.15.1 → 4.15.2

package/es/utils/debug.d.ts

@@ -0,0 +1,425 @@
+import createDebug from "debug";
+
+//#region src/utils/debug.d.ts
+/**
+ * Debug utility factory for LobeHub Editor
+ * Creates namespaced debug functions following the pattern: lobe-editor:category
+ */
+declare class DebugLogger {
+  private debuggers;
+  /**
+   * Get or create a debug function for a specific namespace
+   * @param category - The debug category (e.g., 'kernel', 'plugin', 'upload')
+   * @param subcategory - Optional subcategory for more specific debugging
+   * @returns Debug function
+   */
+  getDebugger(category: string, subcategory?: string): createDebug.Debugger;
+  /**
+   * Create a scoped debug logger for a specific component/service
+   * @param category - Main category
+   * @param subcategory - Optional subcategory
+   * @returns Object with debug methods
+   */
+  createLogger(category: string, subcategory?: string): {
+    /**
+     * General debug logging
+     */
+    debug: createDebug.Debugger;
+    /**
+     * Error level logging - uses console.error for proper browser dev tool support
+     */
+    error: (...args: any[]) => void;
+    /**
+     * Info level logging
+     */
+    info: createDebug.Debugger;
+    /**
+     * Log function - alias for debug for compatibility
+     */
+    log: createDebug.Debugger;
+    /**
+     * Warning level logging - uses console.warn for proper browser dev tool support
+     */
+    warn: (...args: any[]) => void;
+  };
+  /**
+   * Enable debug for specific namespaces
+   * @param namespaces - Comma-separated list of namespaces to enable
+   */
+  enable(namespaces: string): void;
+  /**
+   * Disable all debug output
+   */
+  disable(): void;
+  /**
+   * Check if a namespace is enabled
+   * @param namespace - The namespace to check
+   * @returns Whether the namespace is enabled
+   */
+  enabled(namespace: string): boolean;
+}
+/**
+ * Global debug logger instance
+ */
+declare const debugLogger: DebugLogger;
+/**
+ * Convenience function to create a debug logger for a specific category
+ * @param category - Main category (e.g., 'kernel', 'plugin', 'upload')
+ * @param subcategory - Optional subcategory
+ * @returns Logger object with debug methods
+ */
+declare function createDebugLogger(category: string, subcategory?: string): {
+  /**
+   * General debug logging
+   */
+  debug: createDebug.Debugger;
+  /**
+   * Error level logging - uses console.error for proper browser dev tool support
+   */
+  error: (...args: any[]) => void;
+  /**
+   * Info level logging
+   */
+  info: createDebug.Debugger;
+  /**
+   * Log function - alias for debug for compatibility
+   */
+  log: createDebug.Debugger;
+  /**
+   * Warning level logging - uses console.warn for proper browser dev tool support
+   */
+  warn: (...args: any[]) => void;
+};
+/**
+ * Pre-configured debug loggers for common categories
+ */
+declare const debugLoggers: {
+  demo: {
+    /**
+     * General debug logging
+     */
+    debug: createDebug.Debugger;
+    /**
+     * Error level logging - uses console.error for proper browser dev tool support
+     */
+    error: (...args: any[]) => void;
+    /**
+     * Info level logging
+     */
+    info: createDebug.Debugger;
+    /**
+     * Log function - alias for debug for compatibility
+     */
+    log: createDebug.Debugger;
+    /**
+     * Warning level logging - uses console.warn for proper browser dev tool support
+     */
+    warn: (...args: any[]) => void;
+  };
+  file: {
+    /**
+     * General debug logging
+     */
+    debug: createDebug.Debugger;
+    /**
+     * Error level logging - uses console.error for proper browser dev tool support
+     */
+    error: (...args: any[]) => void;
+    /**
+     * Info level logging
+     */
+    info: createDebug.Debugger;
+    /**
+     * Log function - alias for debug for compatibility
+     */
+    log: createDebug.Debugger;
+    /**
+     * Warning level logging - uses console.warn for proper browser dev tool support
+     */
+    warn: (...args: any[]) => void;
+  };
+  image: {
+    /**
+     * General debug logging
+     */
+    debug: createDebug.Debugger;
+    /**
+     * Error level logging - uses console.error for proper browser dev tool support
+     */
+    error: (...args: any[]) => void;
+    /**
+     * Info level logging
+     */
+    info: createDebug.Debugger;
+    /**
+     * Log function - alias for debug for compatibility
+     */
+    log: createDebug.Debugger;
+    /**
+     * Warning level logging - uses console.warn for proper browser dev tool support
+     */
+    warn: (...args: any[]) => void;
+  };
+  kernel: {
+    /**
+     * General debug logging
+     */
+    debug: createDebug.Debugger;
+    /**
+     * Error level logging - uses console.error for proper browser dev tool support
+     */
+    error: (...args: any[]) => void;
+    /**
+     * Info level logging
+     */
+    info: createDebug.Debugger;
+    /**
+     * Log function - alias for debug for compatibility
+     */
+    log: createDebug.Debugger;
+    /**
+     * Warning level logging - uses console.warn for proper browser dev tool support
+     */
+    warn: (...args: any[]) => void;
+  };
+  markdown: {
+    /**
+     * General debug logging
+     */
+    debug: createDebug.Debugger;
+    /**
+     * Error level logging - uses console.error for proper browser dev tool support
+     */
+    error: (...args: any[]) => void;
+    /**
+     * Info level logging
+     */
+    info: createDebug.Debugger;
+    /**
+     * Log function - alias for debug for compatibility
+     */
+    log: createDebug.Debugger;
+    /**
+     * Warning level logging - uses console.warn for proper browser dev tool support
+     */
+    warn: (...args: any[]) => void;
+  };
+  math: {
+    /**
+     * General debug logging
+     */
+    debug: createDebug.Debugger;
+    /**
+     * Error level logging - uses console.error for proper browser dev tool support
+     */
+    error: (...args: any[]) => void;
+    /**
+     * Info level logging
+     */
+    info: createDebug.Debugger;
+    /**
+     * Log function - alias for debug for compatibility
+     */
+    log: createDebug.Debugger;
+    /**
+     * Warning level logging - uses console.warn for proper browser dev tool support
+     */
+    warn: (...args: any[]) => void;
+  };
+  mention: {
+    /**
+     * General debug logging
+     */
+    debug: createDebug.Debugger;
+    /**
+     * Error level logging - uses console.error for proper browser dev tool support
+     */
+    error: (...args: any[]) => void;
+    /**
+     * Info level logging
+     */
+    info: createDebug.Debugger;
+    /**
+     * Log function - alias for debug for compatibility
+     */
+    log: createDebug.Debugger;
+    /**
+     * Warning level logging - uses console.warn for proper browser dev tool support
+     */
+    warn: (...args: any[]) => void;
+  };
+  plugin: {
+    /**
+     * General debug logging
+     */
+    debug: createDebug.Debugger;
+    /**
+     * Error level logging - uses console.error for proper browser dev tool support
+     */
+    error: (...args: any[]) => void;
+    /**
+     * Info level logging
+     */
+    info: createDebug.Debugger;
+    /**
+     * Log function - alias for debug for compatibility
+     */
+    log: createDebug.Debugger;
+    /**
+     * Warning level logging - uses console.warn for proper browser dev tool support
+     */
+    warn: (...args: any[]) => void;
+  };
+  react: {
+    /**
+     * General debug logging
+     */
+    debug: createDebug.Debugger;
+    /**
+     * Error level logging - uses console.error for proper browser dev tool support
+     */
+    error: (...args: any[]) => void;
+    /**
+     * Info level logging
+     */
+    info: createDebug.Debugger;
+    /**
+     * Log function - alias for debug for compatibility
+     */
+    log: createDebug.Debugger;
+    /**
+     * Warning level logging - uses console.warn for proper browser dev tool support
+     */
+    warn: (...args: any[]) => void;
+  };
+  service: {
+    /**
+     * General debug logging
+     */
+    debug: createDebug.Debugger;
+    /**
+     * Error level logging - uses console.error for proper browser dev tool support
+     */
+    error: (...args: any[]) => void;
+    /**
+     * Info level logging
+     */
+    info: createDebug.Debugger;
+    /**
+     * Log function - alias for debug for compatibility
+     */
+    log: createDebug.Debugger;
+    /**
+     * Warning level logging - uses console.warn for proper browser dev tool support
+     */
+    warn: (...args: any[]) => void;
+  };
+  slash: {
+    /**
+     * General debug logging
+     */
+    debug: createDebug.Debugger;
+    /**
+     * Error level logging - uses console.error for proper browser dev tool support
+     */
+    error: (...args: any[]) => void;
+    /**
+     * Info level logging
+     */
+    info: createDebug.Debugger;
+    /**
+     * Log function - alias for debug for compatibility
+     */
+    log: createDebug.Debugger;
+    /**
+     * Warning level logging - uses console.warn for proper browser dev tool support
+     */
+    warn: (...args: any[]) => void;
+  };
+  upload: {
+    /**
+     * General debug logging
+     */
+    debug: createDebug.Debugger;
+    /**
+     * Error level logging - uses console.error for proper browser dev tool support
+     */
+    error: (...args: any[]) => void;
+    /**
+     * Info level logging
+     */
+    info: createDebug.Debugger;
+    /**
+     * Log function - alias for debug for compatibility
+     */
+    log: createDebug.Debugger;
+    /**
+     * Warning level logging - uses console.warn for proper browser dev tool support
+     */
+    warn: (...args: any[]) => void;
+  };
+};
+/**
+ * Conditional console logging - only logs in development mode
+ * Use this for demo files and development-only logging
+ */
+declare const devConsole: {
+  error: (...args: any[]) => void;
+  info: (...args: any[]) => void;
+  log: (...args: any[]) => void;
+  warn: (...args: any[]) => void;
+};
+/**
+ * Production-safe error logging
+ * Always logs errors and warnings regardless of environment using native console methods
+ * for proper browser dev tool support. Debug/info uses debug package.
+ */
+declare const prodSafeLogger: {
+  /**
+   * Debug info - only shown when debug is enabled
+   */
+  debug: createDebug.Debugger;
+  /**
+   * Log critical errors that should always be visible (uses console.error)
+   */
+  error: (...args: any[]) => void;
+  /**
+   * Info logging - only shown when debug is enabled
+   */
+  info: createDebug.Debugger;
+  /**
+   * Log warnings that should always be visible (uses console.warn)
+   */
+  warn: (...args: any[]) => void;
+};
+/**
+ * Browser debug utilities for Next.js and other client-side frameworks
+ */
+declare const browserDebug: {
+  /**
+   * Disable debug logging in browser environment
+   */
+  disable: () => void;
+  /**
+   * Enable debug logging in browser environment
+   * @param namespaces - Debug namespaces to enable (e.g., 'lobe-editor:*')
+   */
+  enable: (namespaces?: string) => void;
+  /**
+   * Get current debug configuration
+   */
+  getConfig: () => {
+    enabled: string | boolean;
+    source: string;
+  };
+  /**
+   * Show available debug categories
+   */
+  showCategories: () => void;
+  /**
+   * Show current debug status and configuration
+   */
+  showStatus: () => void;
+};
+//#endregion
+export { browserDebug, createDebugLogger, debugLogger, debugLoggers, devConsole, prodSafeLogger };

package/es/{debug-CIvbNHJu.js → utils/debug.js}

@@ -1,38 +1,5 @@
+import { __esmMin, __exportAll } from "../_virtual/_rolldown/runtime.js";
 import createDebug from "debug";
-//#region \0rolldown/runtime.js
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	return target;
-};
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-//#endregion
 //#region src/utils/debug.ts
 var debug_exports = /* @__PURE__ */ __exportAll({
 	DebugLogger: () => DebugLogger,
@@ -267,4 +234,5 @@ var init_debug = __esmMin((() => {
 	};
 }));
 //#endregion
-export { debug_exports as a, prodSafeLogger as c, __exportAll as d, __toCommonJS as f, debugLoggers as i, __commonJSMin as l, createDebugLogger as n, devConsole as o, __toESM as p, debugLogger as r, init_debug as s, browserDebug as t, __esmMin as u };
+init_debug();
+export { browserDebug, createDebugLogger, debugLogger, debugLoggers, debug_exports, devConsole, init_debug, prodSafeLogger };

package/es/utils/hotkey/isHotkeyMatch.js

@@ -0,0 +1,17 @@
+import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
+import { init_parseHotkeys, mapCode, parseHotkey } from "./parseHotkeys.js";
+import { isModifierMatch } from "lexical";
+//#region src/utils/hotkey/isHotkeyMatch.ts
+var isHotkeyMatch;
+var init_isHotkeyMatch = __esmMin((() => {
+	init_parseHotkeys();
+	isHotkeyMatch = (event, hotkey) => {
+		const keys = parseHotkey(hotkey);
+		if (!isModifierMatch(event, keys.modifiers)) return false;
+		if (mapCode(event.code) !== keys.key) return false;
+		return true;
+	};
+}));
+//#endregion
+init_isHotkeyMatch();
+export { init_isHotkeyMatch, isHotkeyMatch };

package/es/utils/hotkey/parseHotkeys.js

@@ -0,0 +1,53 @@
+import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
+import { init_sys, isApple } from "../../common/sys.js";
+//#region src/utils/hotkey/parseHotkeys.ts
+function mapCode(key) {
+	return (mappedKeys[key.trim()] || key.trim()).toLowerCase().replace(/key|digit|numpad/, "");
+}
+function parseHotkey(hotkey) {
+	let keys = [];
+	keys = hotkey.toLocaleLowerCase().split("+").map((k) => mapCode(k));
+	const modifiers = {
+		altKey: keys.includes("alt"),
+		ctrlKey: keys.includes("ctrl") || keys.includes("control") || (!isApple ? keys.includes("mod") : false),
+		metaKey: keys.includes("meta") || (isApple ? keys.includes("mod") : false),
+		shiftKey: keys.includes("shift")
+	};
+	return {
+		key: keys.find((k) => !reservedModifierKeywords.has(k)),
+		modifiers
+	};
+}
+var reservedModifierKeywords, mappedKeys;
+var init_parseHotkeys = __esmMin((() => {
+	init_sys();
+	reservedModifierKeywords = new Set([
+		"shift",
+		"alt",
+		"meta",
+		"mod",
+		"ctrl",
+		"control"
+	]);
+	mappedKeys = {
+		AltLeft: "alt",
+		AltRight: "alt",
+		ControlLeft: "ctrl",
+		ControlRight: "ctrl",
+		MetaLeft: "meta",
+		MetaRight: "meta",
+		OSLeft: "meta",
+		OSRight: "meta",
+		ShiftLeft: "shift",
+		ShiftRight: "shift",
+		down: "arrowdown",
+		esc: "escape",
+		left: "arrowleft",
+		return: "enter",
+		right: "arrowright",
+		up: "arrowup"
+	};
+}));
+//#endregion
+init_parseHotkeys();
+export { init_parseHotkeys, mapCode, parseHotkey };

package/es/utils/hotkey/registerHotkey.d.ts

@@ -0,0 +1,18 @@
+import { HotkeyId, HotkeyItem, ModifierCombination } from "../../types/hotkey.js";
+
+//#region src/utils/hotkey/registerHotkey.d.ts
+type HotkeysEvent = {
+  key?: string;
+  keys: string;
+  modifiers: ModifierCombination;
+  scopes?: string[];
+};
+type HotkeyOptions = {
+  enabled?: boolean;
+  preventDefault?: boolean;
+  stopImmediatePropagation?: boolean;
+  stopPropagation?: boolean;
+};
+declare const getHotkeyById: (id: HotkeyId) => HotkeyItem;
+//#endregion
+export { HotkeyOptions, HotkeysEvent, getHotkeyById };

package/es/utils/hotkey/registerHotkey.js

@@ -0,0 +1,35 @@
+import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
+import { createDebugLogger, init_debug } from "../debug.js";
+import { HOTKEYS_REGISTRATION, init_hotkey } from "../../const/hotkey.js";
+import { init_parseHotkeys, parseHotkey } from "./parseHotkeys.js";
+import { init_isHotkeyMatch, isHotkeyMatch } from "./isHotkeyMatch.js";
+//#region src/utils/hotkey/registerHotkey.ts
+var logger, registerHotkey, getHotkeyById;
+var init_registerHotkey = __esmMin((() => {
+	init_hotkey();
+	init_debug();
+	init_parseHotkeys();
+	init_isHotkeyMatch();
+	logger = createDebugLogger("hotkey");
+	registerHotkey = (hotkey, callback, options = {}) => {
+		return (e) => {
+			if (!isHotkeyMatch(e, hotkey.keys)) return false;
+			const keys = parseHotkey(hotkey.keys);
+			if (options.preventDefault) e.preventDefault();
+			if (options.stopPropagation) e.stopPropagation();
+			callback(e, {
+				keys: hotkey.keys,
+				...keys,
+				scopes: hotkey.scopes
+			});
+			logger.debug(`⌨️ Hotkey matched: ${hotkey.id} [${hotkey.keys}]`, hotkey);
+			return true;
+		};
+	};
+	getHotkeyById = (id) => {
+		return HOTKEYS_REGISTRATION.find((hotkey) => hotkey.id === id);
+	};
+}));
+//#endregion
+init_registerHotkey();
+export { getHotkeyById, init_registerHotkey, registerHotkey };

package/es/utils/scrollIntoView.d.ts

@@ -0,0 +1,8 @@
+//#region src/utils/scrollIntoView.d.ts
+/**
+ * Scroll the current selection into view, centered vertically in the viewport
+ * @param offsetY Optional vertical offset from center (default: 0)
+ */
+declare function scrollIntoView(offsetY?: number): void;
+//#endregion
+export { scrollIntoView };

package/es/utils/scrollIntoView.js

@@ -0,0 +1,29 @@
+//#region src/utils/scrollIntoView.ts
+/**
+* Scroll the current selection into view, centered vertically in the viewport
+* @param offsetY Optional vertical offset from center (default: 0)
+*/
+function scrollIntoView(offsetY = 0) {
+	if (typeof window === "undefined" || typeof document === "undefined") return;
+	const selection = window.getSelection();
+	if (!selection || selection.rangeCount === 0) return;
+	const rect = selection.getRangeAt(0).getBoundingClientRect();
+	if (rect.height === 0 && rect.width === 0) {
+		const focusNode = selection.focusNode;
+		if (focusNode) {
+			const element = focusNode.nodeType === Node.ELEMENT_NODE ? focusNode : focusNode.parentElement;
+			if (element) element.scrollIntoView({
+				behavior: "smooth",
+				block: "center"
+			});
+		}
+		return;
+	}
+	const scrollAmount = rect.top + rect.height / 2 - window.innerHeight / 2 + offsetY;
+	window.scrollBy({
+		behavior: "smooth",
+		top: scrollAmount
+	});
+}
+//#endregion
+export { scrollIntoView };

package/es/utils/updatePosition.js

@@ -0,0 +1,26 @@
+import { computePosition, flip, offset, shift } from "@floating-ui/dom";
+//#region src/utils/updatePosition.ts
+const updatePosition = ({ floating, placement = "bottom-start", reference, offset: offsetNumber = 8, callback }) => {
+	if (!reference || !floating) return;
+	return computePosition(reference, floating, {
+		middleware: [
+			offset(offsetNumber),
+			flip(),
+			shift()
+		],
+		placement
+	}).then((props) => {
+		if (!floating) return false;
+		const { x, y } = props;
+		floating.style.left = `${x}px`;
+		floating.style.top = `${y}px`;
+		callback?.(props);
+	});
+};
+const cleanPosition = (floating) => {
+	if (!floating) return false;
+	floating.style.left = "-9999px";
+	floating.style.top = "-9999px";
+};
+//#endregion
+export { cleanPosition, updatePosition };

package/es/utils/url.d.ts

@@ -0,0 +1,18 @@
+//#region src/utils/url.d.ts
+/**
+ * Shared URL validation utilities
+ */
+/**
+ * Validates if a string is a valid URL
+ * @param url - The URL to validate
+ * @returns true if the URL is valid, false otherwise
+ */
+declare function isValidUrl(url: string): boolean;
+/**
+ * Checks if text is a pure URL (single URL without other text)
+ * @param text - The text to check
+ * @returns true if text is a pure URL, false otherwise
+ */
+declare function isPureUrl(text: string): boolean;
+//#endregion
+export { isPureUrl, isValidUrl };