@lvce-editor/preview-sandbox-worker 3.2.0 → 3.4.0

package/dist/previewSandBoxWorkerMain.js

@@ -1607,12 +1607,137 @@ const handleInput = (uid, hdId, value) => {
   return handleInputLocal(uid, hdId, value);
 };
 
+const numericCodeMap = {
+  13: 'Enter',
+  27: 'Escape',
+  32: 'Space',
+  37: 'ArrowLeft',
+  38: 'ArrowUp',
+  39: 'ArrowRight',
+  40: 'ArrowDown',
+  8: 'Backspace',
+  9: 'Tab'
+};
+
+// cspell:ignore Spacebar
+
+const invalidCodeValues = new Set(['code', 'event.code', 'e.code', 'key', 'event.key', 'e.key']);
+const getNumericCode = code => {
+  if (typeof code === 'number' && Number.isFinite(code)) {
+    return code;
+  }
+  if (typeof code === 'string' && /^\d+$/.test(code)) {
+    return Number(code);
+  }
+  return undefined;
+};
+const getCodeFromNumericCode = numericCode => {
+  if (numericCodeMap[numericCode]) {
+    return numericCodeMap[numericCode];
+  }
+  if (numericCode >= 48 && numericCode <= 57) {
+    return `Digit${String.fromCodePoint(numericCode)}`;
+  }
+  if (numericCode >= 65 && numericCode <= 90) {
+    return `Key${String.fromCodePoint(numericCode)}`;
+  }
+  return String(numericCode);
+};
+const getCodeFromKey = key => {
+  if (key === ' ' || key === 'Space' || key === 'Spacebar') {
+    return 'Space';
+  }
+  if (key === 'Enter' || key.startsWith('Arrow')) {
+    return key;
+  }
+  if (/^[a-z]$/i.test(key)) {
+    return `Key${key.toUpperCase()}`;
+  }
+  if (/^\d$/.test(key)) {
+    return `Digit${key}`;
+  }
+  return key;
+};
+const isInvalidCodeString = code => {
+  const trimmedCode = code.trim();
+  if (!trimmedCode) {
+    return true;
+  }
+  return invalidCodeValues.has(trimmedCode);
+};
+const getNormalizedCode = (key, code) => {
+  const numericCode = getNumericCode(code);
+  if (numericCode !== undefined) {
+    return getCodeFromNumericCode(numericCode);
+  }
+  if (typeof code === 'string' && !isInvalidCodeString(code)) {
+    return code.trim();
+  }
+  return getCodeFromKey(key);
+};
+const getNormalizedKey = (key, normalizedCode) => {
+  if (key === 'Space' || key === 'Spacebar') {
+    return ' ';
+  }
+  if (key) {
+    return key;
+  }
+  if (normalizedCode === 'Space') {
+    return ' ';
+  }
+  if (/^Key[A-Z]$/.test(normalizedCode)) {
+    return normalizedCode.slice(3).toLowerCase();
+  }
+  if (/^Digit\d$/.test(normalizedCode)) {
+    return normalizedCode.slice(5);
+  }
+  return normalizedCode;
+};
+const getLegacyKeyCode = (normalizedCode, code) => {
+  const numericCode = getNumericCode(code);
+  if (numericCode !== undefined) {
+    return numericCode;
+  }
+  for (const [key, value] of Object.entries(numericCodeMap)) {
+    if (value === normalizedCode) {
+      return Number(key);
+    }
+  }
+  if (/^Key[A-Z]$/.test(normalizedCode)) {
+    return normalizedCode.codePointAt(3) ?? 0;
+  }
+  if (/^Digit\d$/.test(normalizedCode)) {
+    return normalizedCode.codePointAt(5) ?? 0;
+  }
+  return 0;
+};
+const getKeyboardEventInit = (key, code) => {
+  const normalizedCode = getNormalizedCode(key, code);
+  const normalizedKey = getNormalizedKey(key, normalizedCode);
+  const keyCode = getLegacyKeyCode(normalizedCode, code);
+  return {
+    code: normalizedCode,
+    key: normalizedKey,
+    keyCode
+  };
+};
+
+const setLegacyKeyCode$1 = (event, keyCode) => {
+  Object.defineProperty(event, 'keyCode', {
+    value: keyCode
+  });
+  Object.defineProperty(event, 'which', {
+    value: keyCode
+  });
+};
 const dispatchKeydownEvent = (element, window, key, code) => {
+  const keyboardEventInit = getKeyboardEventInit(key, code);
   const keydownEvent = new window.KeyboardEvent('keydown', {
     bubbles: true,
-    code,
-    key
+    code: keyboardEventInit.code,
+    key: keyboardEventInit.key
   });
+  setLegacyKeyCode$1(keydownEvent, keyboardEventInit.keyCode);
   dispatchEvent(element, keydownEvent);
 };
 
@@ -1621,28 +1746,43 @@ const handleKeydownLocal = (uid, hdId, key, code) => {
   if (!happyDomInstance) {
     return;
   }
-  const element = hdId ? happyDomInstance.elementMap[hdId] : happyDomInstance.document;
+  const {
+    document,
+    elementMap,
+    window
+  } = happyDomInstance;
+  const element = hdId ? elementMap[hdId] : document;
   if (!element) {
     return;
   }
-  dispatchKeydownEvent(element, happyDomInstance.window, key, code);
-  const elementMap = Object.create(null);
+  dispatchKeydownEvent(element, window, key, code);
+  const newElementMap = Object.create(null);
   set$1(uid, {
-    document: happyDomInstance.document,
-    elementMap,
-    window: happyDomInstance.window
+    document,
+    elementMap: newElementMap,
+    window
   });
 };
 const handleKeydown = (uid, hdId, key, code) => {
   return handleKeydownLocal(uid, hdId, key, code);
 };
 
+const setLegacyKeyCode = (event, keyCode) => {
+  Object.defineProperty(event, 'keyCode', {
+    value: keyCode
+  });
+  Object.defineProperty(event, 'which', {
+    value: keyCode
+  });
+};
 const dispatchKeyupEvent = (element, window, key, code) => {
+  const keyboardEventInit = getKeyboardEventInit(key, code);
   const keyupEvent = new window.KeyboardEvent('keyup', {
     bubbles: true,
-    code,
-    key
+    code: keyboardEventInit.code,
+    key: keyboardEventInit.key
   });
+  setLegacyKeyCode(keyupEvent, keyboardEventInit.keyCode);
   dispatchEvent(element, keyupEvent);
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/preview-sandbox-worker",
-  "version": "3.2.0",
+  "version": "3.4.0",
   "description": "Preview SandBox Worker",
   "repository": {
     "type": "git",