@payloadcms/richtext-lexical 0.7.0 → 3.0.0-alpha.18

package/dist/field/features/debug/testrecorder/plugin/index.js

@@ -0,0 +1,504 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    TestRecorderPlugin: function() {
+        return TestRecorderPlugin;
+    },
+    isSelectAll: function() {
+        return isSelectAll;
+    }
+});
+const _LexicalComposerContext = require("@lexical/react/LexicalComposerContext");
+const _lexical = require("lexical");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _environment = require("../../../../lexical/utils/environment");
+require("./index.scss");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const copy = (text)=>{
+    const textArea = document.createElement('textarea');
+    textArea.value = text || '';
+    textArea.style.position = 'absolute';
+    textArea.style.opacity = '0';
+    document.body?.appendChild(textArea);
+    textArea.focus();
+    textArea.select();
+    try {
+        const result = document.execCommand('copy');
+        // eslint-disable-next-line no-console
+        console.log(result);
+    } catch (error) {
+        console.error(error);
+    }
+    document.body?.removeChild(textArea);
+};
+const download = (filename, text)=>{
+    const a = document.createElement('a');
+    a.setAttribute('href', 'data:text/plain;charset=utf-8,' + encodeURIComponent(text || ''));
+    a.setAttribute('download', filename);
+    a.style.display = 'none';
+    document.body?.appendChild(a);
+    a.click();
+    document.body?.removeChild(a);
+};
+const formatStep = (step)=>{
+    const formatOneStep = (name, value)=>{
+        switch(name){
+            case 'click':
+                {
+                    return `      await page.mouse.click(${value.x}, ${value.y});`;
+                }
+            case 'press':
+                {
+                    return `      await page.keyboard.press('${value}');`;
+                }
+            case 'keydown':
+                {
+                    return `      await page.keyboard.keydown('${value}');`;
+                }
+            case 'keyup':
+                {
+                    return `      await page.keyboard.keyup('${value}');`;
+                }
+            case 'type':
+                {
+                    return `      await page.keyboard.type('${value}');`;
+                }
+            case 'selectAll':
+                {
+                    return `      await selectAll(page);`;
+                }
+            case 'snapshot':
+                {
+                    return `      await assertHTMLSnapshot(page);
+      await assertSelection(page, {
+        anchorPath: [${value.anchorPath.toString()}],
+        anchorOffset: ${value.anchorOffset},
+        focusPath: [${value.focusPath.toString()}],
+        focusOffset: ${value.focusOffset},
+      });
+`;
+                }
+            default:
+                return ``;
+        }
+    };
+    const formattedStep = formatOneStep(step.name, step.value);
+    switch(step.count){
+        case 1:
+            return formattedStep;
+        case 2:
+            return [
+                formattedStep,
+                formattedStep
+            ].join(`\n`);
+        default:
+            return `      await repeat(${step.count}, async () => {
+  ${formattedStep}
+      );`;
+    }
+};
+function isSelectAll(event) {
+    return event.keyCode === 65 && (_environment.IS_APPLE ? event.metaKey : event.ctrlKey);
+}
+// stolen from LexicalSelection-test
+function sanitizeSelection(selection) {
+    const { anchorNode, focusNode } = selection;
+    let { anchorOffset, focusOffset } = selection;
+    if (anchorOffset !== 0) {
+        anchorOffset--;
+    }
+    if (focusOffset !== 0) {
+        focusOffset--;
+    }
+    return {
+        anchorNode,
+        anchorOffset,
+        focusNode,
+        focusOffset
+    };
+}
+function getPathFromNodeToEditor(node, rootElement) {
+    let currentNode = node;
+    const path = [];
+    while(currentNode !== rootElement){
+        if (currentNode !== null && currentNode !== undefined) {
+            path.unshift(Array.from(currentNode?.parentNode?.childNodes ?? []).indexOf(currentNode));
+        }
+        currentNode = currentNode?.parentNode;
+    }
+    return path;
+}
+const keyPresses = new Set([
+    'Enter',
+    'Backspace',
+    'Delete',
+    'Escape',
+    'ArrowLeft',
+    'ArrowRight',
+    'ArrowUp',
+    'ArrowDown'
+]);
+function useTestRecorder(editor) {
+    const [steps, setSteps] = (0, _react.useState)([]);
+    const [isRecording, setIsRecording] = (0, _react.useState)(false);
+    const [, setCurrentInnerHTML] = (0, _react.useState)('');
+    const [templatedTest, setTemplatedTest] = (0, _react.useState)('');
+    const previousSelectionRef = (0, _react.useRef)(null);
+    const skipNextSelectionChangeRef = (0, _react.useRef)(false);
+    const preRef = (0, _react.useRef)(null);
+    const getCurrentEditor = (0, _react.useCallback)(()=>{
+        return editor;
+    }, [
+        editor
+    ]);
+    const generateTestContent = (0, _react.useCallback)(()=>{
+        const rootElement = editor.getRootElement();
+        const browserSelection = window.getSelection();
+        if (rootElement == null || browserSelection == null || browserSelection.anchorNode == null || browserSelection.focusNode == null || !rootElement.contains(browserSelection.anchorNode) || !rootElement.contains(browserSelection.focusNode)) {
+            return null;
+        }
+        return `
+import {
+  initializeE2E,
+  assertHTMLSnapshot,
+  assertSelection,
+  repeat,
+} from '../utils';
+import {selectAll} from '../keyboardShortcuts';
+import { RangeSelection } from 'lexical';
+import { NodeSelection } from 'lexical';
+
+describe('Test case', () => {
+  initializeE2E((e2e) => {
+    it('Should pass this test', async () => {
+      const {page} = e2e;
+
+      await page.focus('div[contenteditable="true"]');
+${steps.map(formatStep).join(`\n`)}
+    });
+});
+    `;
+    }, [
+        editor,
+        steps
+    ]);
+    // just a wrapper around inserting new actions so that we can
+    // coalesce some actions like insertText/moveNativeSelection
+    const pushStep = (0, _react.useCallback)((name, value)=>{
+        setSteps((currentSteps)=>{
+            // trying to group steps
+            const currentIndex = steps.length - 1;
+            const lastStep = steps[currentIndex];
+            if (lastStep) {
+                if (lastStep.name === name) {
+                    if (name === 'type') {
+                        // for typing events we just append the text
+                        return [
+                            ...steps.slice(0, currentIndex),
+                            {
+                                ...lastStep,
+                                value: lastStep.value + value
+                            }
+                        ];
+                    } else {
+                        // for other events we bump the counter if their values are the same
+                        if (lastStep.value === value) {
+                            return [
+                                ...steps.slice(0, currentIndex),
+                                {
+                                    ...lastStep,
+                                    count: lastStep.count + 1
+                                }
+                            ];
+                        }
+                    }
+                }
+            }
+            // could not group, just append a new one
+            return [
+                ...currentSteps,
+                {
+                    name,
+                    count: 1,
+                    value
+                }
+            ];
+        });
+    }, [
+        steps,
+        setSteps
+    ]);
+    (0, _react.useLayoutEffect)(()=>{
+        const onKeyDown = (event)=>{
+            if (!isRecording) {
+                return;
+            }
+            const key = event.key;
+            if (isSelectAll(event)) {
+                pushStep('selectAll', '');
+            } else if (keyPresses.has(key)) {
+                pushStep('press', event.key);
+            } else if ([
+                ...key
+            ].length > 1) {
+                pushStep('keydown', event.key);
+            } else {
+                pushStep('type', event.key);
+            }
+        };
+        const onKeyUp = (event)=>{
+            if (!isRecording) {
+                return;
+            }
+            const key = event.key;
+            if (!keyPresses.has(key) && [
+                ...key
+            ].length > 1) {
+                pushStep('keyup', event.key);
+            }
+        };
+        return editor.registerRootListener((rootElement, prevRootElement)=>{
+            if (prevRootElement !== null) {
+                prevRootElement.removeEventListener('keydown', onKeyDown);
+                prevRootElement.removeEventListener('keyup', onKeyUp);
+            }
+            if (rootElement !== null) {
+                rootElement.addEventListener('keydown', onKeyDown);
+                rootElement.addEventListener('keyup', onKeyUp);
+            }
+        });
+    }, [
+        editor,
+        isRecording,
+        pushStep
+    ]);
+    (0, _react.useLayoutEffect)(()=>{
+        if (preRef.current) {
+            preRef.current.scrollTo(0, preRef.current.scrollHeight);
+        }
+    }, [
+        generateTestContent
+    ]);
+    (0, _react.useEffect)(()=>{
+        if (steps) {
+            const testContent = generateTestContent();
+            if (testContent !== null) {
+                setTemplatedTest(testContent);
+            }
+            if (preRef.current) {
+                preRef.current.scrollTo(0, preRef.current.scrollHeight);
+            }
+        }
+    }, [
+        generateTestContent,
+        steps
+    ]);
+    (0, _react.useEffect)(()=>{
+        const removeUpdateListener = editor.registerUpdateListener(({ dirtyElements, dirtyLeaves, editorState })=>{
+            if (!isRecording) {
+                return;
+            }
+            const currentSelection = editorState._selection;
+            const previousSelection = previousSelectionRef.current;
+            const skipNextSelectionChange = skipNextSelectionChangeRef.current;
+            if (previousSelection !== currentSelection) {
+                if (dirtyLeaves.size === 0 && dirtyElements.size === 0 && !skipNextSelectionChange) {
+                    const browserSelection = window.getSelection();
+                    if (browserSelection && (browserSelection.anchorNode == null || browserSelection.focusNode == null)) {
+                        return;
+                    }
+                }
+                previousSelectionRef.current = currentSelection;
+            }
+            skipNextSelectionChangeRef.current = false;
+            const testContent = generateTestContent();
+            if (testContent !== null) {
+                setTemplatedTest(testContent);
+            }
+        });
+        return removeUpdateListener;
+    }, [
+        editor,
+        generateTestContent,
+        isRecording,
+        pushStep
+    ]);
+    // save innerHTML
+    (0, _react.useEffect)(()=>{
+        if (!isRecording) {
+            return;
+        }
+        const removeUpdateListener = editor.registerUpdateListener(()=>{
+            const rootElement = editor.getRootElement();
+            if (rootElement !== null) {
+                setCurrentInnerHTML(rootElement?.innerHTML);
+            }
+        });
+        return removeUpdateListener;
+    }, [
+        editor,
+        isRecording
+    ]);
+    // clear editor and start recording
+    const toggleEditorSelection = (0, _react.useCallback)((currentEditor)=>{
+        if (!isRecording) {
+            currentEditor.update(()=>{
+                const root = (0, _lexical.$getRoot)();
+                root.clear();
+                const text = (0, _lexical.$createTextNode)();
+                root.append((0, _lexical.$createParagraphNode)().append(text));
+                text.select();
+            });
+            setSteps([]);
+        }
+        setIsRecording((currentIsRecording)=>!currentIsRecording);
+    }, [
+        isRecording
+    ]);
+    const onSnapshotClick = (0, _react.useCallback)(()=>{
+        if (!isRecording) {
+            return;
+        }
+        const browserSelection = window.getSelection();
+        if (browserSelection === null || browserSelection.anchorNode == null || browserSelection.focusNode == null) {
+            return;
+        }
+        const { anchorNode, anchorOffset, focusNode, focusOffset } = sanitizeSelection(browserSelection);
+        const rootElement = getCurrentEditor().getRootElement();
+        let anchorPath;
+        if (anchorNode !== null) {
+            anchorPath = getPathFromNodeToEditor(anchorNode, rootElement);
+        }
+        let focusPath;
+        if (focusNode !== null) {
+            focusPath = getPathFromNodeToEditor(focusNode, rootElement);
+        }
+        pushStep('snapshot', {
+            anchorNode,
+            anchorOffset,
+            anchorPath,
+            focusNode,
+            focusOffset,
+            focusPath
+        });
+    }, [
+        pushStep,
+        isRecording,
+        getCurrentEditor
+    ]);
+    const onCopyClick = (0, _react.useCallback)(()=>{
+        copy(generateTestContent());
+    }, [
+        generateTestContent
+    ]);
+    const onDownloadClick = (0, _react.useCallback)(()=>{
+        download('test.js', generateTestContent());
+    }, [
+        generateTestContent
+    ]);
+    const button = /*#__PURE__*/ _react.createElement("button", {
+        className: `editor-dev-button ${isRecording ? 'active' : ''}`,
+        id: "test-recorder-button",
+        onClick: (e)=>{
+            toggleEditorSelection(getCurrentEditor());
+            e.preventDefault();
+        },
+        title: isRecording ? 'Disable test recorder' : 'Enable test recorder',
+        type: "button"
+    }, isRecording ? 'Disable test recorder' : 'Enable test recorder');
+    const output = isRecording ? /*#__PURE__*/ _react.createElement("div", {
+        className: "test-recorder-output"
+    }, /*#__PURE__*/ _react.createElement("div", {
+        className: "test-recorder-toolbar"
+    }, /*#__PURE__*/ _react.createElement("button", {
+        className: "test-recorder-button",
+        id: "test-recorder-button-snapshot",
+        onClick: (e)=>{
+            onSnapshotClick();
+            e.preventDefault();
+        },
+        title: "Insert snapshot",
+        type: "button"
+    }, "Insert Snapshot"), /*#__PURE__*/ _react.createElement("button", {
+        className: "test-recorder-button",
+        id: "test-recorder-button-copy",
+        onClick: (e)=>{
+            onCopyClick();
+            e.preventDefault();
+        },
+        title: "Copy to clipboard",
+        type: "button"
+    }, "Copy"), /*#__PURE__*/ _react.createElement("button", {
+        className: "test-recorder-button",
+        id: "test-recorder-button-download",
+        onClick: (e)=>{
+            onDownloadClick();
+            e.preventDefault();
+        },
+        title: "Download as a file",
+        type: "button"
+    }, "Download")), /*#__PURE__*/ _react.createElement("pre", {
+        id: "test-recorder",
+        ref: preRef
+    }, templatedTest)) : null;
+    return [
+        button,
+        output
+    ];
+}
+const TestRecorderPlugin = ()=>{
+    const [editor] = (0, _LexicalComposerContext.useLexicalComposerContext)();
+    const [testRecorderButton, testRecorderOutput] = useTestRecorder(editor);
+    return /*#__PURE__*/ _react.createElement(_react.Fragment, null, /*#__PURE__*/ _react.createElement("p", null, "HI"), testRecorderButton, testRecorderOutput, /*#__PURE__*/ _react.createElement("p", null, "DONE"));
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../../src/field/features/debug/testrecorder/plugin/index.tsx"],"sourcesContent":["'use client'\nimport type { BaseSelection, LexicalEditor } from 'lexical'\n\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext'\nimport { $createParagraphNode, $createTextNode, $getRoot } from 'lexical'\nimport * as React from 'react'\nimport { useCallback, useEffect, useLayoutEffect, useRef, useState } from 'react'\n\nimport { IS_APPLE } from '../../../../lexical/utils/environment'\nimport './index.scss'\n\nconst copy = (text: null | string) => {\n  const textArea = document.createElement('textarea')\n  textArea.value = text || ''\n  textArea.style.position = 'absolute'\n  textArea.style.opacity = '0'\n  document.body?.appendChild(textArea)\n  textArea.focus()\n  textArea.select()\n  try {\n    const result = document.execCommand('copy')\n    // eslint-disable-next-line no-console\n    console.log(result)\n  } catch (error) {\n    console.error(error)\n  }\n  document.body?.removeChild(textArea)\n}\n\nconst download = (filename: string, text: null | string) => {\n  const a = document.createElement('a')\n  a.setAttribute('href', 'data:text/plain;charset=utf-8,' + encodeURIComponent(text || ''))\n  a.setAttribute('download', filename)\n  a.style.display = 'none'\n  document.body?.appendChild(a)\n  a.click()\n  document.body?.removeChild(a)\n}\n\nconst formatStep = (step: Step) => {\n  const formatOneStep = (name: string, value: Step['value']) => {\n    switch (name) {\n      case 'click': {\n        return `      await page.mouse.click(${value.x}, ${value.y});`\n      }\n      case 'press': {\n        return `      await page.keyboard.press('${value}');`\n      }\n      case 'keydown': {\n        return `      await page.keyboard.keydown('${value}');`\n      }\n      case 'keyup': {\n        return `      await page.keyboard.keyup('${value}');`\n      }\n      case 'type': {\n        return `      await page.keyboard.type('${value}');`\n      }\n      case 'selectAll': {\n        return `      await selectAll(page);`\n      }\n      case 'snapshot': {\n        return `      await assertHTMLSnapshot(page);\n      await assertSelection(page, {\n        anchorPath: [${value.anchorPath.toString()}],\n        anchorOffset: ${value.anchorOffset},\n        focusPath: [${value.focusPath.toString()}],\n        focusOffset: ${value.focusOffset},\n      });\n`\n      }\n      default:\n        return ``\n    }\n  }\n  const formattedStep = formatOneStep(step.name, step.value)\n  switch (step.count) {\n    case 1:\n      return formattedStep\n    case 2:\n      return [formattedStep, formattedStep].join(`\\n`)\n    default:\n      return `      await repeat(${step.count}, async () => {\n  ${formattedStep}\n      );`\n  }\n}\n\nexport function isSelectAll(event: KeyboardEvent): boolean {\n  return event.keyCode === 65 && (IS_APPLE ? event.metaKey : event.ctrlKey)\n}\n\n// stolen from LexicalSelection-test\nfunction sanitizeSelection(selection: Selection) {\n  const { anchorNode, focusNode } = selection\n  let { anchorOffset, focusOffset } = selection\n  if (anchorOffset !== 0) {\n    anchorOffset--\n  }\n  if (focusOffset !== 0) {\n    focusOffset--\n  }\n  return { anchorNode, anchorOffset, focusNode, focusOffset }\n}\n\nfunction getPathFromNodeToEditor(node: Node, rootElement: HTMLElement | null) {\n  let currentNode: Node | null | undefined = node\n  const path = []\n  while (currentNode !== rootElement) {\n    if (currentNode !== null && currentNode !== undefined) {\n      path.unshift(\n        Array.from(currentNode?.parentNode?.childNodes ?? []).indexOf(currentNode as ChildNode),\n      )\n    }\n    currentNode = currentNode?.parentNode\n  }\n  return path\n}\n\nconst keyPresses = new Set([\n  'Enter',\n  'Backspace',\n  'Delete',\n  'Escape',\n  'ArrowLeft',\n  'ArrowRight',\n  'ArrowUp',\n  'ArrowDown',\n])\n\ntype Step = {\n  count: number\n  name: string\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  value: any\n}\n\ntype Steps = Step[]\n\nfunction useTestRecorder(editor: LexicalEditor): [JSX.Element, JSX.Element | null] {\n  const [steps, setSteps] = useState<Steps>([])\n  const [isRecording, setIsRecording] = useState(false)\n  const [, setCurrentInnerHTML] = useState('')\n  const [templatedTest, setTemplatedTest] = useState('')\n  const previousSelectionRef = useRef<BaseSelection | null>(null)\n  const skipNextSelectionChangeRef = useRef(false)\n  const preRef = useRef<HTMLPreElement>(null)\n\n  const getCurrentEditor = useCallback(() => {\n    return editor\n  }, [editor])\n\n  const generateTestContent = useCallback(() => {\n    const rootElement = editor.getRootElement()\n    const browserSelection = window.getSelection()\n\n    if (\n      rootElement == null ||\n      browserSelection == null ||\n      browserSelection.anchorNode == null ||\n      browserSelection.focusNode == null ||\n      !rootElement.contains(browserSelection.anchorNode) ||\n      !rootElement.contains(browserSelection.focusNode)\n    ) {\n      return null\n    }\n\n    return `\nimport {\n  initializeE2E,\n  assertHTMLSnapshot,\n  assertSelection,\n  repeat,\n} from '../utils';\nimport {selectAll} from '../keyboardShortcuts';\nimport { RangeSelection } from 'lexical';\nimport { NodeSelection } from 'lexical';\n\ndescribe('Test case', () => {\n  initializeE2E((e2e) => {\n    it('Should pass this test', async () => {\n      const {page} = e2e;\n\n      await page.focus('div[contenteditable=\"true\"]');\n${steps.map(formatStep).join(`\\n`)}\n    });\n});\n    `\n  }, [editor, steps])\n\n  // just a wrapper around inserting new actions so that we can\n  // coalesce some actions like insertText/moveNativeSelection\n  const pushStep = useCallback(\n    (name: string, value: Step['value']) => {\n      setSteps((currentSteps) => {\n        // trying to group steps\n        const currentIndex = steps.length - 1\n        const lastStep = steps[currentIndex]\n        if (lastStep) {\n          if (lastStep.name === name) {\n            if (name === 'type') {\n              // for typing events we just append the text\n              return [\n                ...steps.slice(0, currentIndex),\n                { ...lastStep, value: lastStep.value + value },\n              ]\n            } else {\n              // for other events we bump the counter if their values are the same\n              if (lastStep.value === value) {\n                return [...steps.slice(0, currentIndex), { ...lastStep, count: lastStep.count + 1 }]\n              }\n            }\n          }\n        }\n        // could not group, just append a new one\n        return [...currentSteps, { name, count: 1, value }]\n      })\n    },\n    [steps, setSteps],\n  )\n\n  useLayoutEffect(() => {\n    const onKeyDown = (event: KeyboardEvent) => {\n      if (!isRecording) {\n        return\n      }\n      const key = event.key\n      if (isSelectAll(event)) {\n        pushStep('selectAll', '')\n      } else if (keyPresses.has(key)) {\n        pushStep('press', event.key)\n      } else if ([...key].length > 1) {\n        pushStep('keydown', event.key)\n      } else {\n        pushStep('type', event.key)\n      }\n    }\n\n    const onKeyUp = (event: KeyboardEvent) => {\n      if (!isRecording) {\n        return\n      }\n      const key = event.key\n      if (!keyPresses.has(key) && [...key].length > 1) {\n        pushStep('keyup', event.key)\n      }\n    }\n\n    return editor.registerRootListener(\n      (rootElement: HTMLElement | null, prevRootElement: HTMLElement | null) => {\n        if (prevRootElement !== null) {\n          prevRootElement.removeEventListener('keydown', onKeyDown)\n          prevRootElement.removeEventListener('keyup', onKeyUp)\n        }\n        if (rootElement !== null) {\n          rootElement.addEventListener('keydown', onKeyDown)\n          rootElement.addEventListener('keyup', onKeyUp)\n        }\n      },\n    )\n  }, [editor, isRecording, pushStep])\n\n  useLayoutEffect(() => {\n    if (preRef.current) {\n      preRef.current.scrollTo(0, preRef.current.scrollHeight)\n    }\n  }, [generateTestContent])\n\n  useEffect(() => {\n    if (steps) {\n      const testContent = generateTestContent()\n      if (testContent !== null) {\n        setTemplatedTest(testContent)\n      }\n      if (preRef.current) {\n        preRef.current.scrollTo(0, preRef.current.scrollHeight)\n      }\n    }\n  }, [generateTestContent, steps])\n\n  useEffect(() => {\n    const removeUpdateListener = editor.registerUpdateListener(\n      ({ dirtyElements, dirtyLeaves, editorState }) => {\n        if (!isRecording) {\n          return\n        }\n        const currentSelection = editorState._selection\n        const previousSelection = previousSelectionRef.current\n        const skipNextSelectionChange = skipNextSelectionChangeRef.current\n        if (previousSelection !== currentSelection) {\n          if (dirtyLeaves.size === 0 && dirtyElements.size === 0 && !skipNextSelectionChange) {\n            const browserSelection = window.getSelection()\n            if (\n              browserSelection &&\n              (browserSelection.anchorNode == null || browserSelection.focusNode == null)\n            ) {\n              return\n            }\n          }\n          previousSelectionRef.current = currentSelection\n        }\n        skipNextSelectionChangeRef.current = false\n        const testContent = generateTestContent()\n        if (testContent !== null) {\n          setTemplatedTest(testContent)\n        }\n      },\n    )\n    return removeUpdateListener\n  }, [editor, generateTestContent, isRecording, pushStep])\n\n  // save innerHTML\n  useEffect(() => {\n    if (!isRecording) {\n      return\n    }\n    const removeUpdateListener = editor.registerUpdateListener(() => {\n      const rootElement = editor.getRootElement()\n      if (rootElement !== null) {\n        setCurrentInnerHTML(rootElement?.innerHTML)\n      }\n    })\n    return removeUpdateListener\n  }, [editor, isRecording])\n\n  // clear editor and start recording\n  const toggleEditorSelection = useCallback(\n    (currentEditor: LexicalEditor) => {\n      if (!isRecording) {\n        currentEditor.update(() => {\n          const root = $getRoot()\n          root.clear()\n          const text = $createTextNode()\n          root.append($createParagraphNode().append(text))\n          text.select()\n        })\n        setSteps([])\n      }\n      setIsRecording((currentIsRecording) => !currentIsRecording)\n    },\n    [isRecording],\n  )\n\n  const onSnapshotClick = useCallback(() => {\n    if (!isRecording) {\n      return\n    }\n    const browserSelection = window.getSelection()\n    if (\n      browserSelection === null ||\n      browserSelection.anchorNode == null ||\n      browserSelection.focusNode == null\n    ) {\n      return\n    }\n    const { anchorNode, anchorOffset, focusNode, focusOffset } = sanitizeSelection(browserSelection)\n    const rootElement = getCurrentEditor().getRootElement()\n    let anchorPath\n    if (anchorNode !== null) {\n      anchorPath = getPathFromNodeToEditor(anchorNode, rootElement)\n    }\n    let focusPath\n    if (focusNode !== null) {\n      focusPath = getPathFromNodeToEditor(focusNode, rootElement)\n    }\n    pushStep('snapshot', {\n      anchorNode,\n      anchorOffset,\n      anchorPath,\n      focusNode,\n      focusOffset,\n      focusPath,\n    })\n  }, [pushStep, isRecording, getCurrentEditor])\n\n  const onCopyClick = useCallback(() => {\n    copy(generateTestContent())\n  }, [generateTestContent])\n\n  const onDownloadClick = useCallback(() => {\n    download('test.js', generateTestContent())\n  }, [generateTestContent])\n\n  const button = (\n    <button\n      className={`editor-dev-button ${isRecording ? 'active' : ''}`}\n      id=\"test-recorder-button\"\n      onClick={(e) => {\n        toggleEditorSelection(getCurrentEditor())\n        e.preventDefault()\n      }}\n      title={isRecording ? 'Disable test recorder' : 'Enable test recorder'}\n      type=\"button\"\n    >\n      {isRecording ? 'Disable test recorder' : 'Enable test recorder'}\n    </button>\n  )\n  const output = isRecording ? (\n    <div className=\"test-recorder-output\">\n      <div className=\"test-recorder-toolbar\">\n        <button\n          className=\"test-recorder-button\"\n          id=\"test-recorder-button-snapshot\"\n          onClick={(e) => {\n            onSnapshotClick()\n            e.preventDefault()\n          }}\n          title=\"Insert snapshot\"\n          type=\"button\"\n        >\n          Insert Snapshot\n        </button>\n        <button\n          className=\"test-recorder-button\"\n          id=\"test-recorder-button-copy\"\n          onClick={(e) => {\n            onCopyClick()\n            e.preventDefault()\n          }}\n          title=\"Copy to clipboard\"\n          type=\"button\"\n        >\n          Copy\n        </button>\n        <button\n          className=\"test-recorder-button\"\n          id=\"test-recorder-button-download\"\n          onClick={(e) => {\n            onDownloadClick()\n            e.preventDefault()\n          }}\n          title=\"Download as a file\"\n          type=\"button\"\n        >\n          Download\n        </button>\n      </div>\n      <pre id=\"test-recorder\" ref={preRef}>\n        {templatedTest}\n      </pre>\n    </div>\n  ) : null\n\n  return [button, output]\n}\nexport const TestRecorderPlugin: React.FC = () => {\n  const [editor] = useLexicalComposerContext()\n  const [testRecorderButton, testRecorderOutput] = useTestRecorder(editor)\n\n  return (\n    <React.Fragment>\n      <p>HI</p>\n      {testRecorderButton}\n      {testRecorderOutput}\n      <p>DONE</p>\n    </React.Fragment>\n  )\n}\n"],"names":["TestRecorderPlugin","isSelectAll","copy","text","textArea","document","createElement","value","style","position","opacity","body","appendChild","focus","select","result","execCommand","console","log","error","removeChild","download","filename","a","setAttribute","encodeURIComponent","display","click","formatStep","step","formatOneStep","name","x","y","anchorPath","toString","anchorOffset","focusPath","focusOffset","formattedStep","count","join","event","keyCode","IS_APPLE","metaKey","ctrlKey","sanitizeSelection","selection","anchorNode","focusNode","getPathFromNodeToEditor","node","rootElement","currentNode","path","undefined","unshift","Array","from","parentNode","childNodes","indexOf","keyPresses","Set","useTestRecorder","editor","steps","setSteps","useState","isRecording","setIsRecording","setCurrentInnerHTML","templatedTest","setTemplatedTest","previousSelectionRef","useRef","skipNextSelectionChangeRef","preRef","getCurrentEditor","useCallback","generateTestContent","getRootElement","browserSelection","window","getSelection","contains","map","pushStep","currentSteps","currentIndex","length","lastStep","slice","useLayoutEffect","onKeyDown","key","has","onKeyUp","registerRootListener","prevRootElement","removeEventListener","addEventListener","current","scrollTo","scrollHeight","useEffect","testContent","removeUpdateListener","registerUpdateListener","dirtyElements","dirtyLeaves","editorState","currentSelection","_selection","previousSelection","skipNextSelectionChange","size","innerHTML","toggleEditorSelection","currentEditor","update","root","$getRoot","clear","$createTextNode","append","$createParagraphNode","currentIsRecording","onSnapshotClick","onCopyClick","onDownloadClick","button","className","id","onClick","e","preventDefault","title","type","output","div","pre","ref","useLexicalComposerContext","testRecorderButton","testRecorderOutput","React","Fragment","p"],"mappings":"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"}

package/dist/field/features/debug/testrecorder/plugin/index.scss

@@ -0,0 +1,49 @@
+.test-recorder-output {
+  margin: 20px auto 20px auto;
+  width: 100%;
+}
+.test-recorder-toolbar {
+  display: flex;
+}
+
+.test-recorder-button {
+  position: relative;
+  display: block;
+  font-size: 10px;
+  padding: 6px 6px;
+  border-radius: 4px;
+  border: none;
+  cursor: pointer;
+  outline: none;
+  box-shadow: 1px 2px 2px rgba(0, 0, 0, 0.4);
+  background-color: #222;
+  color: white;
+  transition: box-shadow 50ms ease-out;
+}
+
+.test-recorder-button:active {
+  box-shadow: 1px 2px 4px rgba(0, 0, 0, 0.4);
+}
+
+.test-recorder-button + .test-recorder-button {
+  margin-left: 4px;
+}
+
+.test-recorder-button::after {
+  content: '';
+  position: absolute;
+  top: 8px;
+  right: 8px;
+  bottom: 8px;
+  left: 8px;
+  display: block;
+  background-size: contain;
+  filter: invert(1);
+}
+#test-recorder-button {
+  position: relative;
+}
+
+#test-recorder-button-snapshot {
+  margin-right: auto;
+}

package/dist/field/features/debug/treeview/feature.client.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+export declare const TreeViewFeatureClientComponent: import("react").FC<undefined>;
+//# sourceMappingURL=feature.client.d.ts.map

package/dist/field/features/debug/treeview/feature.client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature.client.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/debug/treeview/feature.client.tsx"],"names":[],"mappings":";AAqBA,eAAO,MAAM,8BAA8B,+BAA+C,CAAA"}

package/dist/field/features/debug/treeview/feature.client.js

@@ -0,0 +1,30 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TreeViewFeatureClientComponent", {
+    enumerable: true,
+    get: function() {
+        return TreeViewFeatureClientComponent;
+    }
+});
+const _createClientComponent = require("../../createClientComponent");
+const _plugin = require("./plugin");
+const TreeViewFeatureClient = (props)=>{
+    return {
+        clientFeatureProps: props,
+        feature: ()=>({
+                clientFeatureProps: props,
+                plugins: [
+                    {
+                        Component: _plugin.TreeViewPlugin,
+                        position: 'bottom'
+                    }
+                ]
+            })
+    };
+};
+const TreeViewFeatureClientComponent = (0, _createClientComponent.createClientComponent)(TreeViewFeatureClient);
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9kZWJ1Zy90cmVldmlldy9mZWF0dXJlLmNsaWVudC50c3giXSwic291cmNlc0NvbnRlbnQiOlsiJ3VzZSBjbGllbnQnXG5pbXBvcnQgdHlwZSB7IEZlYXR1cmVQcm92aWRlclByb3ZpZGVyQ2xpZW50IH0gZnJvbSAnLi4vLi4vdHlwZXMnXG5cbmltcG9ydCB7IGNyZWF0ZUNsaWVudENvbXBvbmVudCB9IGZyb20gJy4uLy4uL2NyZWF0ZUNsaWVudENvbXBvbmVudCdcbmltcG9ydCB7IFRyZWVWaWV3UGx1Z2luIH0gZnJvbSAnLi9wbHVnaW4nXG5cbmNvbnN0IFRyZWVWaWV3RmVhdHVyZUNsaWVudDogRmVhdHVyZVByb3ZpZGVyUHJvdmlkZXJDbGllbnQ8dW5kZWZpbmVkPiA9IChwcm9wcykgPT4ge1xuICByZXR1cm4ge1xuICAgIGNsaWVudEZlYXR1cmVQcm9wczogcHJvcHMsXG4gICAgZmVhdHVyZTogKCkgPT4gKHtcbiAgICAgIGNsaWVudEZlYXR1cmVQcm9wczogcHJvcHMsXG4gICAgICBwbHVnaW5zOiBbXG4gICAgICAgIHtcbiAgICAgICAgICBDb21wb25lbnQ6IFRyZWVWaWV3UGx1Z2luLFxuICAgICAgICAgIHBvc2l0aW9uOiAnYm90dG9tJyxcbiAgICAgICAgfSxcbiAgICAgIF0sXG4gICAgfSksXG4gIH1cbn1cblxuZXhwb3J0IGNvbnN0IFRyZWVWaWV3RmVhdHVyZUNsaWVudENvbXBvbmVudCA9IGNyZWF0ZUNsaWVudENvbXBvbmVudChUcmVlVmlld0ZlYXR1cmVDbGllbnQpXG4iXSwibmFtZXMiOlsiVHJlZVZpZXdGZWF0dXJlQ2xpZW50Q29tcG9uZW50IiwiVHJlZVZpZXdGZWF0dXJlQ2xpZW50IiwicHJvcHMiLCJjbGllbnRGZWF0dXJlUHJvcHMiLCJmZWF0dXJlIiwicGx1Z2lucyIsIkNvbXBvbmVudCIsIlRyZWVWaWV3UGx1Z2luIiwicG9zaXRpb24iLCJjcmVhdGVDbGllbnRDb21wb25lbnQiXSwibWFwcGluZ3MiOiJBQUFBOzs7OzsrQkFxQmFBOzs7ZUFBQUE7Ozt1Q0FsQnlCO3dCQUNQO0FBRS9CLE1BQU1DLHdCQUFrRSxDQUFDQztJQUN2RSxPQUFPO1FBQ0xDLG9CQUFvQkQ7UUFDcEJFLFNBQVMsSUFBTyxDQUFBO2dCQUNkRCxvQkFBb0JEO2dCQUNwQkcsU0FBUztvQkFDUDt3QkFDRUMsV0FBV0Msc0JBQWM7d0JBQ3pCQyxVQUFVO29CQUNaO2lCQUNEO1lBQ0gsQ0FBQTtJQUNGO0FBQ0Y7QUFFTyxNQUFNUixpQ0FBaUNTLElBQUFBLDRDQUFxQixFQUFDUiJ9

package/dist/field/features/debug/treeview/feature.server.d.ts

@@ -0,0 +1,3 @@
+import type { FeatureProviderProviderServer } from '../../types';
+export declare const TreeViewFeature: FeatureProviderProviderServer<undefined, undefined>;
+//# sourceMappingURL=feature.server.d.ts.map

package/dist/field/features/debug/treeview/feature.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature.server.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/debug/treeview/feature.server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,aAAa,CAAA;AAIhE,eAAO,MAAM,eAAe,EAAE,6BAA6B,CAAC,SAAS,EAAE,SAAS,CAW/E,CAAA"}