@lobehub/editor 1.5.10 → 1.6.1

package/es/types/kernel.d.ts

@@ -1,5 +1,7 @@
 import type { CommandListener, CommandListenerPriority, CommandPayloadType, DecoratorNode, LexicalCommand, LexicalEditor, LexicalNodeConfig } from 'lexical';
 import type DataSource from "../editor-kernel/data-source";
+import { HotkeyId } from "./hotkey";
+import { HotkeyOptions, HotkeysEvent } from "../utils/hotkey/registerHotkey";
 import { ILocaleKeys } from './locale';
 export type Commands = Map<LexicalCommand<unknown>, Array<Set<CommandListener<unknown>>>>;
 export type CommandsClean = Map<LexicalCommand<unknown>, () => void>;
@@ -120,6 +122,13 @@ export interface IEditor {
      * @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

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

@@ -0,0 +1 @@
+export declare const isHotkeyMatch: (event: KeyboardEvent, hotkey: string) => boolean;

package/es/utils/hotkey/isHotkeyMatch.js

@@ -0,0 +1,9 @@
+import { isModifierMatch } from 'lexical';
+import { mapCode, parseHotkey } from "./parseHotkeys";
+export var isHotkeyMatch = function isHotkeyMatch(event, hotkey) {
+  var keys = parseHotkey(hotkey);
+  var modifierMatch = isModifierMatch(event, keys.modifiers);
+  if (!modifierMatch) return false;
+  if (mapCode(event.code) !== keys.key) return false;
+  return true;
+};

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

@@ -0,0 +1,6 @@
+import type { ModifierCombination } from "../../types/hotkey";
+export declare function mapCode(key: string): string;
+export declare function parseHotkey(hotkey: string): {
+    key?: string;
+    modifiers: ModifierCombination;
+};

package/es/utils/hotkey/parseHotkeys.js

@@ -0,0 +1,42 @@
+import { isApple } from "../../common/sys";
+var reservedModifierKeywords = new Set(['shift', 'alt', 'meta', 'mod', 'ctrl', 'control']);
+var 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'
+};
+export function mapCode(key) {
+  return (mappedKeys[key.trim()] || key.trim()).toLowerCase().replace(/key|digit|numpad/, '');
+}
+export function parseHotkey(hotkey) {
+  var keys = [];
+  keys = hotkey.toLocaleLowerCase().split('+').map(function (k) {
+    return mapCode(k);
+  });
+  var 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')
+  };
+  var singleCharKeys = keys.find(function (k) {
+    return !reservedModifierKeywords.has(k);
+  });
+  return {
+    key: singleCharKeys,
+    modifiers: modifiers
+  };
+}

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

@@ -0,0 +1,15 @@
+import { HotkeyId, HotkeyItem, ModifierCombination } from "../../types/hotkey";
+export type HotkeysEvent = {
+    key?: string;
+    keys: string;
+    modifiers: ModifierCombination;
+    scopes?: string[];
+};
+export type HotkeyOptions = {
+    enabled?: boolean;
+    preventDefault?: boolean;
+    stopImmediatePropagation?: boolean;
+    stopPropagation?: boolean;
+};
+export declare const registerHotkey: (hotkey: HotkeyItem, callback: (event: KeyboardEvent, handler: HotkeysEvent) => void, options?: HotkeyOptions) => (e: KeyboardEvent) => boolean;
+export declare const getHotkeyById: (id: HotkeyId) => HotkeyItem;

package/es/utils/hotkey/registerHotkey.js

@@ -0,0 +1,32 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { HOTKEYS_REGISTRATION } from "../../const/hotkey";
+import { createDebugLogger } from "../debug";
+import { parseHotkey } from "./parseHotkeys";
+import { isHotkeyMatch } from "./isHotkeyMatch";
+var logger = createDebugLogger('hotkey');
+export var registerHotkey = function registerHotkey(hotkey, callback) {
+  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  return function (e) {
+    if (!isHotkeyMatch(e, hotkey.keys)) return false;
+    var keys = parseHotkey(hotkey.keys);
+    if (options.preventDefault) e.preventDefault();
+    if (options.stopPropagation) e.stopPropagation();
+    callback(e, _objectSpread(_objectSpread({
+      keys: hotkey.keys
+    }, keys), {}, {
+      scopes: hotkey.scopes
+    }));
+    logger.debug("\u2328\uFE0F Hotkey matched: ".concat(hotkey.id, " [").concat(hotkey.keys, "]"), hotkey);
+    return true;
+  };
+};
+export var getHotkeyById = function getHotkeyById(id) {
+  return HOTKEYS_REGISTRATION.find(function (hotkey) {
+    return hotkey.id === id;
+  });
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/editor",
-  "version": "1.5.10",
+  "version": "1.6.1",
   "description": "A powerful and extensible rich text editor built on Meta's Lexical framework, providing a modern editing experience with React integration.",
   "keywords": [
     "lobehub",
@@ -56,6 +56,7 @@
     "react-layout-kit": "^2.0.0",
     "react-merge-refs": "^3.0.2",
     "shiki": "^3.9.2",
+    "ts-key-enum": "^3.0.13",
     "use-merge-value": "^1.2.0"
   },
   "peerDependencies": {