@lexical/react 0.1.7 → 0.1.8

package/DEPRECATED_useLexicalEditor.dev.js

@@ -0,0 +1,52 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var useLexicalCanShowPlaceholder = require('@lexical/react/DEPRECATED_useLexicalCanShowPlaceholder');
+var react = require('react');
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+const CAN_USE_DOM = typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined';
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+const useLayoutEffectImpl = CAN_USE_DOM ? react.useLayoutEffect : react.useEffect;
+var useLayoutEffect = useLayoutEffectImpl;
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+function useLexicalEditor(editor, onError) {
+  const showPlaceholder = useLexicalCanShowPlaceholder(editor);
+  const rootElementRef = react.useCallback(rootElement => {
+    editor.setRootElement(rootElement);
+  }, [editor]);
+  useLayoutEffect(() => {
+    return editor.addListener('error', onError);
+  }, [editor, onError]);
+  return [rootElementRef, showPlaceholder];
+}
+
+module.exports = useLexicalEditor;

package/DEPRECATED_useLexicalEditor.js

@@ -1 +1,9 @@
-'use strict';var b=require("react"),d=require("@lexical/react/DEPRECATED_useLexicalCanShowPlaceholder"),e="undefined"!==typeof window&&"undefined"!==typeof window.document&&"undefined"!==typeof window.document.createElement?b.useLayoutEffect:b.useEffect;module.exports=function(a,c){const f=d(a),h=b.useCallback(g=>{a.setRootElement(g)},[a]);e(()=>a.addListener("error",c),[a,c]);return[h,f]};
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict'
+const DEPRECATED_useLexicalEditor = process.env.NODE_ENV === 'development' ? require('./DEPRECATED_useLexicalEditor.dev.js') : require('./DEPRECATED_useLexicalEditor.prod.js')
+module.exports = DEPRECATED_useLexicalEditor;

package/DEPRECATED_useLexicalEditor.prod.js

@@ -0,0 +1,7 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';var b=require("@lexical/react/DEPRECATED_useLexicalCanShowPlaceholder"),d=require("react"),e="undefined"!==typeof window&&"undefined"!==typeof window.document&&"undefined"!==typeof window.document.createElement?d.useLayoutEffect:d.useEffect;module.exports=function(a,c){const f=b(a),h=d.useCallback(g=>{a.setRootElement(g)},[a]);e(()=>a.addListener("error",c),[a,c]);return[h,f]};

package/DEPRECATED_useLexicalEditorEvents.dev.js

@@ -0,0 +1,96 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var react = require('react');
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+const CAN_USE_DOM = typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined';
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+const useLayoutEffectImpl = CAN_USE_DOM ? react.useLayoutEffect : react.useEffect;
+var useLayoutEffect = useLayoutEffectImpl;
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+function getTarget(eventName, rootElement) {
+  return eventName === 'selectionchange' || eventName === 'keyup' || eventName === 'pointerup' || eventName === 'pointercancel' ? rootElement.ownerDocument : rootElement;
+}
+
+function isRootEditable(editor) {
+  const rootElement = editor.getRootElement();
+  return rootElement !== null && rootElement.contentEditable === 'true';
+}
+
+function useEditorEvents(events, editor) {
+  useLayoutEffect(() => {
+    const create = [];
+    const destroy = [];
+
+    for (let i = 0; i < events.length; i++) {
+      const [eventName, handler] = events[i];
+
+      const handlerWrapper = event => {
+        if (isRootEditable(editor)) {
+          handler(event, editor);
+        }
+      };
+
+      create.push(rootElement => {
+        getTarget(eventName, rootElement).addEventListener(eventName, handlerWrapper);
+      });
+      destroy.push(rootElement => {
+        getTarget(eventName, rootElement).removeEventListener(eventName, handlerWrapper);
+      });
+    }
+
+    return editor.addListener('root', (rootElement, prevRootElement) => {
+      if (prevRootElement !== null) {
+        destroy.forEach(fn => fn(prevRootElement));
+      }
+
+      if (rootElement !== null) {
+        create.forEach(fn => fn(rootElement));
+      }
+    });
+  }, [editor, events]);
+}
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+function useLexicalEditorEvents(events, editor) {
+  useEditorEvents(events, editor);
+}
+
+module.exports = useLexicalEditorEvents;

package/DEPRECATED_useLexicalEditorEvents.js

@@ -1,2 +1,9 @@
-'use strict';var g=require("react"),h="undefined"!==typeof window&&"undefined"!==typeof window.document&&"undefined"!==typeof window.document.createElement?g.useLayoutEffect:g.useEffect;function p(a,b){return"selectionchange"===a||"keyup"===a||"pointerup"===a||"pointercancel"===a?b.ownerDocument:b}
-function q(a,b){h(()=>{const k=[],l=[];for(let d=0;d<a.length;d++){const [c,e]=a[d],n=f=>{const m=b.getRootElement();null!==m&&"true"===m.contentEditable&&e(f,b)};k.push(f=>{p(c,f).addEventListener(c,n)});l.push(f=>{p(c,f).removeEventListener(c,n)})}return b.addListener("root",(d,c)=>{null!==c&&l.forEach(e=>e(c));null!==d&&k.forEach(e=>e(d))})},[b,a])}module.exports=function(a,b){q(a,b)};
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict'
+const DEPRECATED_useLexicalEditorEvents = process.env.NODE_ENV === 'development' ? require('./DEPRECATED_useLexicalEditorEvents.dev.js') : require('./DEPRECATED_useLexicalEditorEvents.prod.js')
+module.exports = DEPRECATED_useLexicalEditorEvents;

package/DEPRECATED_useLexicalEditorEvents.prod.js

@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';var g=require("react"),h="undefined"!==typeof window&&"undefined"!==typeof window.document&&"undefined"!==typeof window.document.createElement?g.useLayoutEffect:g.useEffect;function p(a,b){return"selectionchange"===a||"keyup"===a||"pointerup"===a||"pointercancel"===a?b.ownerDocument:b}
+function q(a,b){h(()=>{const k=[],l=[];for(let d=0;d<a.length;d++){const [c,e]=a[d],n=f=>{const m=b.getRootElement();null!==m&&"true"===m.contentEditable&&e(f,b)};k.push(f=>{p(c,f).addEventListener(c,n)});l.push(f=>{p(c,f).removeEventListener(c,n)})}return b.addListener("root",(d,c)=>{null!==c&&l.forEach(e=>e(c));null!==d&&k.forEach(e=>e(d))})},[b,a])}module.exports=function(a,b){q(a,b)};

package/DEPRECATED_useLexicalHistory.dev.js

@@ -0,0 +1,339 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var withSubscriptions = require('@lexical/react/withSubscriptions');
+var lexical = require('lexical');
+var react = require('react');
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+const MERGE = 0;
+const NO_MERGE = 1;
+const DISCARD = 2;
+const OTHER = 0;
+const COMPOSING_CHARACTER = 1;
+const INSERT_CHARACTER_AFTER_SELECTION = 2;
+const DELETE_CHARACTER_BEFORE_SELECTION = 3;
+const DELETE_CHARACTER_AFTER_SELECTION = 4;
+const EditorPriority = 0;
+
+function getDirtyNodes(editorState, dirtyLeavesSet, dirtyElementsSet) {
+  const dirtyLeaves = Array.from(dirtyLeavesSet);
+  const dirtyElements = Array.from(dirtyElementsSet);
+  const nodeMap = editorState._nodeMap;
+  const nodes = [];
+
+  for (let i = 0; i < dirtyLeaves.length; i++) {
+    const dirtyLeafKey = dirtyLeaves[i];
+    const dirtyLeaf = nodeMap.get(dirtyLeafKey);
+
+    if (dirtyLeaf !== undefined) {
+      nodes.push(dirtyLeaf);
+    }
+  }
+
+  for (let i = 0; i < dirtyElements.length; i++) {
+    const intentionallyMarkedAsDirty = dirtyElements[i][1];
+
+    if (!intentionallyMarkedAsDirty) {
+      continue;
+    }
+
+    const dirtyElementKey = dirtyElements[i][0];
+    const dirtyElement = nodeMap.get(dirtyElementKey);
+
+    if (dirtyElement !== undefined && !lexical.$isRootNode(dirtyElement)) {
+      nodes.push(dirtyElement);
+    }
+  }
+
+  return nodes;
+}
+
+function getChangeType(prevEditorState, nextEditorState, dirtyLeavesSet, dirtyElementsSet, isComposing) {
+  if (prevEditorState === null || dirtyLeavesSet.size === 0 && dirtyElementsSet.size === 0) {
+    return OTHER;
+  }
+
+  const nextSelection = nextEditorState._selection;
+  const prevSelection = prevEditorState._selection;
+
+  if (isComposing) {
+    return COMPOSING_CHARACTER;
+  }
+
+  if (nextSelection === null || prevSelection === null || !prevSelection.isCollapsed() || !nextSelection.isCollapsed()) {
+    return OTHER;
+  }
+
+  const dirtyNodes = getDirtyNodes(nextEditorState, dirtyLeavesSet, dirtyElementsSet);
+
+  if (dirtyNodes.length === 0) {
+    return OTHER;
+  } // Catching the case when inserting new text node into an element (e.g. first char in paragraph/list),
+  // or after existing node.
+
+
+  if (dirtyNodes.length > 1) {
+    const nextNodeMap = nextEditorState._nodeMap;
+    const nextAnchorNode = nextNodeMap.get(nextSelection.anchor.key);
+    const prevAnchorNode = nextNodeMap.get(prevSelection.anchor.key);
+
+    if (nextAnchorNode && prevAnchorNode && !prevEditorState._nodeMap.has(nextAnchorNode.__key) && lexical.$isTextNode(nextAnchorNode) && nextAnchorNode.__text.length === 1 && nextSelection.anchor.offset === 1) {
+      return INSERT_CHARACTER_AFTER_SELECTION;
+    }
+
+    return OTHER;
+  }
+
+  const nextDirtyNode = dirtyNodes[0];
+
+  const prevDirtyNode = prevEditorState._nodeMap.get(nextDirtyNode.__key);
+
+  if (!lexical.$isTextNode(prevDirtyNode) || !lexical.$isTextNode(nextDirtyNode) || prevDirtyNode.__mode !== nextDirtyNode.__mode) {
+    return OTHER;
+  }
+
+  const prevText = prevDirtyNode.__text;
+  const nextText = nextDirtyNode.__text;
+
+  if (prevText === nextText) {
+    return OTHER;
+  }
+
+  const nextAnchor = nextSelection.anchor;
+  const prevAnchor = prevSelection.anchor;
+
+  if (nextAnchor.key !== prevAnchor.key || nextAnchor.type !== 'text') {
+    return OTHER;
+  }
+
+  const nextAnchorOffset = nextAnchor.offset;
+  const prevAnchorOffset = prevAnchor.offset;
+  const textDiff = nextText.length - prevText.length;
+
+  if (textDiff === 1 && prevAnchorOffset === nextAnchorOffset - 1) {
+    return INSERT_CHARACTER_AFTER_SELECTION;
+  }
+
+  if (textDiff === -1 && prevAnchorOffset === nextAnchorOffset + 1) {
+    return DELETE_CHARACTER_BEFORE_SELECTION;
+  }
+
+  if (textDiff === -1 && prevAnchorOffset === nextAnchorOffset) {
+    return DELETE_CHARACTER_AFTER_SELECTION;
+  }
+
+  return OTHER;
+}
+
+function createMergeActionGetter(editor, delay) {
+  let prevChangeTime = Date.now();
+  let prevChangeType = OTHER;
+  return (prevEditorState, nextEditorState, currentHistoryEntry, dirtyLeaves, dirtyElements, tags) => {
+    const changeTime = Date.now(); // If applying changes from history stack there's no need
+    // to run history logic again, as history entries already calculated
+
+    if (tags.has('historic')) {
+      prevChangeType = OTHER;
+      prevChangeTime = changeTime;
+      return DISCARD;
+    }
+
+    const changeType = getChangeType(prevEditorState, nextEditorState, dirtyLeaves, dirtyElements, editor.isComposing());
+
+    const mergeAction = (() => {
+      if (tags.has('without-history')) {
+        return MERGE;
+      }
+
+      if (prevEditorState === null) {
+        return NO_MERGE;
+      }
+
+      const selection = nextEditorState._selection;
+      const prevSelection = prevEditorState._selection;
+      const hasDirtyNodes = dirtyLeaves.size > 0 || dirtyElements.size > 0;
+
+      if (!hasDirtyNodes) {
+        if (prevSelection === null && selection !== null) {
+          return MERGE;
+        }
+
+        return DISCARD;
+      }
+
+      const isSameEditor = currentHistoryEntry === null || currentHistoryEntry.editor === editor;
+
+      if (changeType !== OTHER && changeType === prevChangeType && changeTime < prevChangeTime + delay && isSameEditor) {
+        return MERGE;
+      }
+
+      return NO_MERGE;
+    })();
+
+    prevChangeTime = changeTime;
+    prevChangeType = changeType;
+    return mergeAction;
+  };
+}
+
+function useHistory(editor, externalHistoryState, delay = 1000) {
+  const historyState = react.useMemo(() => externalHistoryState || createEmptyHistoryState(), [externalHistoryState]);
+  const clearHistory = react.useCallback(() => {
+    historyState.undoStack = [];
+    historyState.redoStack = [];
+    historyState.current = null;
+  }, [historyState]);
+  react.useEffect(() => {
+    const getMergeAction = createMergeActionGetter(editor, delay);
+
+    const applyChange = ({
+      editorState,
+      prevEditorState,
+      dirtyLeaves,
+      dirtyElements,
+      tags
+    }) => {
+      const current = historyState.current;
+      const redoStack = historyState.redoStack;
+      const undoStack = historyState.undoStack;
+      const currentEditorState = current === null ? null : current.editorState;
+
+      if (current !== null && editorState === currentEditorState) {
+        return;
+      }
+
+      const mergeAction = getMergeAction(prevEditorState, editorState, current, dirtyLeaves, dirtyElements, tags);
+
+      if (mergeAction === NO_MERGE) {
+        if (redoStack.length !== 0) {
+          historyState.redoStack = [];
+        }
+
+        if (current !== null) {
+          undoStack.push({ ...current,
+            undoSelection: prevEditorState.read(lexical.$getSelection)
+          });
+          editor.execCommand('canUndo', true);
+        }
+      } else if (mergeAction === DISCARD) {
+        return;
+      } // Else we merge
+
+
+      historyState.current = {
+        editor,
+        editorState
+      };
+    };
+
+    const undo = () => {
+      const redoStack = historyState.redoStack;
+      const undoStack = historyState.undoStack;
+      const undoStackLength = undoStack.length;
+
+      if (undoStackLength !== 0) {
+        const current = historyState.current;
+        const historyStateEntry = undoStack.pop();
+
+        if (current !== null) {
+          redoStack.push(current);
+          editor.execCommand('canRedo', true);
+        }
+
+        if (undoStack.length === 0) {
+          editor.execCommand('canUndo', false);
+        }
+
+        historyState.current = historyStateEntry;
+        historyStateEntry.editor.setEditorState(historyStateEntry.editorState.clone(historyStateEntry.undoSelection), {
+          tag: 'historic'
+        });
+      }
+    };
+
+    const redo = () => {
+      const redoStack = historyState.redoStack;
+      const undoStack = historyState.undoStack;
+
+      if (redoStack.length !== 0) {
+        const current = historyState.current;
+
+        if (current !== null) {
+          undoStack.push(current);
+          editor.execCommand('canUndo', true);
+        }
+
+        const historyStateEntry = redoStack.pop();
+
+        if (redoStack.length === 0) {
+          editor.execCommand('canRedo', false);
+        }
+
+        historyState.current = historyStateEntry;
+        historyStateEntry.editor.setEditorState(historyStateEntry.editorState, {
+          tag: 'historic'
+        });
+      }
+    };
+
+    const applyCommand = type => {
+      switch (type) {
+        case 'undo':
+          undo();
+          return true;
+
+        case 'redo':
+          redo();
+          return true;
+
+        case 'clearEditor':
+          clearHistory();
+          return false;
+
+        case 'clearHistory':
+          clearHistory();
+          return true;
+
+        default:
+          return false;
+      }
+    };
+
+    return withSubscriptions(editor.addListener('command', applyCommand, EditorPriority), editor.addListener('update', applyChange));
+  }, [clearHistory, delay, editor, historyState]);
+}
+function createEmptyHistoryState() {
+  return {
+    current: null,
+    redoStack: [],
+    undoStack: []
+  };
+}
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+function useLexicalHistory(editor, externalHistoryState, delay = 1000) {
+  return useHistory(editor, externalHistoryState, delay);
+}
+
+exports.createEmptyHistoryState = createEmptyHistoryState;
+exports.useLexicalHistory = useLexicalHistory;

package/DEPRECATED_useLexicalHistory.js

@@ -1,7 +1,9 @@
-'use strict';var n=require("lexical"),r=require("react"),v=require("@lexical/react/withSubscriptions");
-function w(b,d,k,a,h){if(null===b||0===k.size&&0===a.size)return 0;var g=d._selection,c=b._selection;if(h)return 1;if(null===g||null===c||!c.isCollapsed()||!g.isCollapsed())return 0;var e=Array.from(k);a=Array.from(a);k=d._nodeMap;h=[];for(var f=0;f<e.length;f++){const l=k.get(e[f]);void 0!==l&&h.push(l)}for(e=0;e<a.length;e++)a[e][1]&&(f=k.get(a[e][0]),void 0===f||n.$isRootNode(f)||h.push(f));if(0===h.length)return 0;if(1<h.length)return a=d._nodeMap,d=a.get(g.anchor.key),c=a.get(c.anchor.key),d&&
-c&&!b._nodeMap.has(d.__key)&&n.$isTextNode(d)&&1===d.__text.length&&1===g.anchor.offset?2:0;d=h[0];b=b._nodeMap.get(d.__key);if(!n.$isTextNode(b)||!n.$isTextNode(d)||b.__mode!==d.__mode)return 0;b=b.__text;d=d.__text;if(b===d)return 0;g=g.anchor;c=c.anchor;if(g.key!==c.key||"text"!==g.type)return 0;g=g.offset;c=c.offset;b=d.length-b.length;return 1===b&&c===g-1?2:-1===b&&c===g+1?3:-1===b&&c===g?4:0}
-function x(b,d){let k=Date.now(),a=0;return(h,g,c,e,f,l)=>{const p=Date.now();if(l.has("historic"))return a=0,k=p,2;const m=w(h,g,e,f,b.isComposing()),u=(()=>{if(l.has("without-history"))return 0;if(null===h)return 1;var q=g._selection;const t=h._selection;if(!(0<e.size||0<f.size))return null===t&&null!==q?0:2;q=null===c||c.editor===b;return 0!==m&&m===a&&p<k+d&&q?0:1})();k=p;a=m;return u}}
-function y(b,d,k=1E3){const a=r.useMemo(()=>d||z(),[d]),h=r.useCallback(()=>{a.undoStack=[];a.redoStack=[];a.current=null},[a]);r.useEffect(()=>{const g=x(b,k);return v(b.addListener("command",c=>{switch(c){case "undo":c=a.redoStack;var e=a.undoStack;if(0!==e.length){var f=a.current;const l=e.pop();null!==f&&(c.push(f),b.execCommand("canRedo",!0));0===e.length&&b.execCommand("canUndo",!1);a.current=l;l.editor.setEditorState(l.editorState.clone(l.undoSelection),{tag:"historic"})}return!0;case "redo":return c=
-a.redoStack,e=a.undoStack,0!==c.length&&(f=a.current,null!==f&&(e.push(f),b.execCommand("canUndo",!0)),e=c.pop(),0===c.length&&b.execCommand("canRedo",!1),a.current=e,e.editor.setEditorState(e.editorState,{tag:"historic"})),!0;case "clearEditor":return h(),!1;case "clearHistory":return h(),!0;default:return!1}},0),b.addListener("update",({editorState:c,prevEditorState:e,dirtyLeaves:f,dirtyElements:l,tags:p})=>{const m=a.current,u=a.redoStack,q=a.undoStack,t=null===m?null:m.editorState;if(null===m||
-c!==t){f=g(e,c,m,f,l,p);if(1===f)0!==u.length&&(a.redoStack=[]),null!==m&&(q.push({...m,undoSelection:e.read(n.$getSelection)}),b.execCommand("canUndo",!0));else if(2===f)return;a.current={editor:b,editorState:c}}}))},[h,k,b,a])}function z(){return{current:null,redoStack:[],undoStack:[]}}exports.createEmptyHistoryState=z;exports.useLexicalHistory=function(b,d,k=1E3){return y(b,d,k)};
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict'
+const DEPRECATED_useLexicalHistory = process.env.NODE_ENV === 'development' ? require('./DEPRECATED_useLexicalHistory.dev.js') : require('./DEPRECATED_useLexicalHistory.prod.js')
+module.exports = DEPRECATED_useLexicalHistory;

package/DEPRECATED_useLexicalHistory.prod.js

@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';var n=require("@lexical/react/withSubscriptions"),r=require("lexical"),v=require("react");
+function w(b,d,k,a,h){if(null===b||0===k.size&&0===a.size)return 0;var g=d._selection,c=b._selection;if(h)return 1;if(null===g||null===c||!c.isCollapsed()||!g.isCollapsed())return 0;var e=Array.from(k);a=Array.from(a);k=d._nodeMap;h=[];for(var f=0;f<e.length;f++){const l=k.get(e[f]);void 0!==l&&h.push(l)}for(e=0;e<a.length;e++)a[e][1]&&(f=k.get(a[e][0]),void 0===f||r.$isRootNode(f)||h.push(f));if(0===h.length)return 0;if(1<h.length)return a=d._nodeMap,d=a.get(g.anchor.key),c=a.get(c.anchor.key),d&&
+c&&!b._nodeMap.has(d.__key)&&r.$isTextNode(d)&&1===d.__text.length&&1===g.anchor.offset?2:0;d=h[0];b=b._nodeMap.get(d.__key);if(!r.$isTextNode(b)||!r.$isTextNode(d)||b.__mode!==d.__mode)return 0;b=b.__text;d=d.__text;if(b===d)return 0;g=g.anchor;c=c.anchor;if(g.key!==c.key||"text"!==g.type)return 0;g=g.offset;c=c.offset;b=d.length-b.length;return 1===b&&c===g-1?2:-1===b&&c===g+1?3:-1===b&&c===g?4:0}
+function x(b,d){let k=Date.now(),a=0;return(h,g,c,e,f,l)=>{const p=Date.now();if(l.has("historic"))return a=0,k=p,2;const m=w(h,g,e,f,b.isComposing()),u=(()=>{if(l.has("without-history"))return 0;if(null===h)return 1;var q=g._selection;const t=h._selection;if(!(0<e.size||0<f.size))return null===t&&null!==q?0:2;q=null===c||c.editor===b;return 0!==m&&m===a&&p<k+d&&q?0:1})();k=p;a=m;return u}}
+function y(b,d,k=1E3){const a=v.useMemo(()=>d||z(),[d]),h=v.useCallback(()=>{a.undoStack=[];a.redoStack=[];a.current=null},[a]);v.useEffect(()=>{const g=x(b,k);return n(b.addListener("command",c=>{switch(c){case "undo":c=a.redoStack;var e=a.undoStack;if(0!==e.length){var f=a.current;const l=e.pop();null!==f&&(c.push(f),b.execCommand("canRedo",!0));0===e.length&&b.execCommand("canUndo",!1);a.current=l;l.editor.setEditorState(l.editorState.clone(l.undoSelection),{tag:"historic"})}return!0;case "redo":return c=
+a.redoStack,e=a.undoStack,0!==c.length&&(f=a.current,null!==f&&(e.push(f),b.execCommand("canUndo",!0)),e=c.pop(),0===c.length&&b.execCommand("canRedo",!1),a.current=e,e.editor.setEditorState(e.editorState,{tag:"historic"})),!0;case "clearEditor":return h(),!1;case "clearHistory":return h(),!0;default:return!1}},0),b.addListener("update",({editorState:c,prevEditorState:e,dirtyLeaves:f,dirtyElements:l,tags:p})=>{const m=a.current,u=a.redoStack,q=a.undoStack,t=null===m?null:m.editorState;if(null===m||
+c!==t){f=g(e,c,m,f,l,p);if(1===f)0!==u.length&&(a.redoStack=[]),null!==m&&(q.push({...m,undoSelection:e.read(r.$getSelection)}),b.execCommand("canUndo",!0));else if(2===f)return;a.current={editor:b,editorState:c}}}))},[h,k,b,a])}function z(){return{current:null,redoStack:[],undoStack:[]}}exports.createEmptyHistoryState=z;exports.useLexicalHistory=function(b,d,k=1E3){return y(b,d,k)};

package/DEPRECATED_useLexicalList.dev.js

@@ -0,0 +1,64 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var list = require('@lexical/list');
+var react = require('react');
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+const LowPriority = 1;
+function useList(editor) {
+  react.useEffect(() => {
+    return editor.addListener('command', type => {
+      if (type === 'indentContent') {
+        const hasHandledIndention = list.indentList();
+
+        if (hasHandledIndention) {
+          return true;
+        }
+      } else if (type === 'outdentContent') {
+        const hasHandledIndention = list.outdentList();
+
+        if (hasHandledIndention) {
+          return true;
+        }
+      } else if (type === 'insertOrderedList') {
+        list.insertList(editor, 'ol');
+        return true;
+      } else if (type === 'insertUnorderedList') {
+        list.insertList(editor, 'ul');
+        return true;
+      } else if (type === 'removeList') {
+        list.removeList(editor);
+        return true;
+      }
+
+      return false;
+    }, LowPriority);
+  }, [editor]);
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+function useLexicalList(editor) {
+  useList(editor);
+}
+
+module.exports = useLexicalList;

package/DEPRECATED_useLexicalList.js

@@ -1 +1,9 @@
-'use strict';var b=require("react"),d=require("@lexical/list");function e(a){b.useEffect(()=>a.addListener("command",c=>{if("indentContent"===c){if(d.indentList())return!0}else if("outdentContent"===c){if(d.outdentList())return!0}else{if("insertOrderedList"===c)return d.insertList(a,"ol"),!0;if("insertUnorderedList"===c)return d.insertList(a,"ul"),!0;if("removeList"===c)return d.removeList(a),!0}return!1},1),[a])}module.exports=function(a){e(a)};
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict'
+const DEPRECATED_useLexicalList = process.env.NODE_ENV === 'development' ? require('./DEPRECATED_useLexicalList.dev.js') : require('./DEPRECATED_useLexicalList.prod.js')
+module.exports = DEPRECATED_useLexicalList;

package/DEPRECATED_useLexicalList.prod.js

@@ -0,0 +1,7 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';var b=require("@lexical/list"),d=require("react");function e(a){d.useEffect(()=>a.addListener("command",c=>{if("indentContent"===c){if(b.indentList())return!0}else if("outdentContent"===c){if(b.outdentList())return!0}else{if("insertOrderedList"===c)return b.insertList(a,"ol"),!0;if("insertUnorderedList"===c)return b.insertList(a,"ul"),!0;if("removeList"===c)return b.removeList(a),!0}return!1},1),[a])}module.exports=function(a){e(a)};