@fluentui-copilot/chat-input-plugins 0.4.2 → 0.5.1

package/lib/PasteUnfurling/PasteUnfurlingTestUtils.js

@@ -1,163 +1,162 @@
 import { _ as _define_property } from "@swc/helpers/_/_define_property";
 import { TextNode } from '@fluentui-copilot/text-editor';
 export class MockClipboardEvent extends Event {
-  constructor(...args) {
-    super(...args);
-    _define_property(this, "clipboardData", null);
-  }
+    constructor(...args){
+        super(...args);
+        _define_property(this, "clipboardData", null);
+    }
 }
 export function createPasteEvent(data) {
-  const event = new MockClipboardEvent('paste');
-  event.clipboardData = {
-    types: [data.map(({
-      mimeType
-    }) => mimeType)],
-    getData: format => {
-      const item = data.find(({
-        mimeType
-      }) => mimeType === format);
-      if (item) {
-        return item.value;
-      }
-      return '';
-    }
-  };
-  return event;
+    const event = new MockClipboardEvent('paste');
+    event.clipboardData = {
+        types: [
+            data.map(({ mimeType })=>mimeType)
+        ],
+        getData: (format)=>{
+            const item = data.find(({ mimeType })=>mimeType === format);
+            if (item) {
+                return item.value;
+            }
+            return '';
+        }
+    };
+    return event;
 }
 export class MockEntityNode extends TextNode {
-  static getType() {
-    return 'mockEntity';
-  }
-  constructor(text, url) {
-    super(text);
-    _define_property(this, "url", void 0);
-    this.url = url;
-  }
+    static getType() {
+        return 'mockEntity';
+    }
+    constructor(text, url){
+        super(text);
+        _define_property(this, "url", void 0);
+        this.url = url;
+    }
 }
 export function $createMockEntityNode(text, url) {
-  return new MockEntityNode(text, url);
+    return new MockEntityNode(text, url);
 }
 export function $isMockEntityNode(node) {
-  return node instanceof MockEntityNode;
+    return node instanceof MockEntityNode;
 }
-export const parseLinkPreview = event => {
-  let previewData;
-  try {
-    var _event_clipboardData;
-    const previewDataString = (_event_clipboardData = event.clipboardData) === null || _event_clipboardData === void 0 ? void 0 : _event_clipboardData.getData('text/link-preview');
-    if (previewDataString === undefined || previewDataString === '') {
-      return {
-        handled: false
-      };
+export const parseLinkPreview = (event)=>{
+    let previewData;
+    try {
+        var _event_clipboardData;
+        const previewDataString = (_event_clipboardData = event.clipboardData) === null || _event_clipboardData === void 0 ? void 0 : _event_clipboardData.getData('text/link-preview');
+        if (previewDataString === undefined || previewDataString === '') {
+            return {
+                handled: false
+            };
+        }
+        previewData = JSON.parse(previewDataString);
+    } catch (e) {
+        return {
+            handled: false
+        };
+    }
+    const title = previewData.title;
+    const url = previewData.url;
+    if (!title || !url) {
+        return {
+            handled: false
+        };
     }
-    previewData = JSON.parse(previewDataString);
-  } catch (e) {
-    return {
-      handled: false
-    };
-  }
-  const title = previewData.title;
-  const url = previewData.url;
-  if (!title || !url) {
     return {
-      handled: false
+        handled: true,
+        transformedParts: [
+            {
+                type: 'entity',
+                value: {
+                    text: title,
+                    data: {
+                        url
+                    }
+                }
+            }
+        ]
     };
-  }
-  return {
-    handled: true,
-    transformedParts: [{
-      type: 'entity',
-      value: {
-        text: title,
-        data: {
-          url
-        }
-      }
-    }]
-  };
 };
 const urlRegex = /(\b(?:https?):\/\/[^\s]+)/gi;
-export const parseLink = event => {
-  var _event_clipboardData;
-  const text = (_event_clipboardData = event.clipboardData) === null || _event_clipboardData === void 0 ? void 0 : _event_clipboardData.getData('text/plain');
-  if (!text) {
-    return {
-      handled: false
-    };
-  }
-  const parts = text.split(urlRegex);
-  // If an entity was found, parts will be at least 3 elements long
-  if (parts.length < 3) {
+export const parseLink = (event)=>{
+    var _event_clipboardData;
+    const text = (_event_clipboardData = event.clipboardData) === null || _event_clipboardData === void 0 ? void 0 : _event_clipboardData.getData('text/plain');
+    if (!text) {
+        return {
+            handled: false
+        };
+    }
+    const parts = text.split(urlRegex);
+    // If an entity was found, parts will be at least 3 elements long
+    if (parts.length < 3) {
+        return {
+            handled: false
+        };
+    }
+    const transformedParts = parts.map((str, i)=>{
+        if (i % 2 === 0) {
+            return {
+                type: 'text',
+                value: str
+            };
+        } else {
+            return {
+                type: 'entity',
+                value: {
+                    text: str,
+                    data: {
+                        url: str
+                    }
+                }
+            };
+        }
+    })// Filter out all the nulls for empty strings
+    .filter((node)=>node !== null);
     return {
-      handled: false
+        handled: true,
+        transformedParts
     };
-  }
-  const transformedParts = parts.map((str, i) => {
-    if (i % 2 === 0) {
-      return {
-        type: 'text',
-        value: str
-      };
-    } else {
-      return {
-        type: 'entity',
-        value: {
-          text: str,
-          data: {
-            url: str
-          }
-        }
-      };
-    }
-  }) // Filter out all the nulls for empty strings
-  .filter(node => node !== null);
-  return {
-    handled: true,
-    transformedParts
-  };
 };
 // A transform can be async in case it needs to fetch data from a server.
-export const parseEntity = async event => {
-  var _event_clipboardData;
-  const text = (_event_clipboardData = event.clipboardData) === null || _event_clipboardData === void 0 ? void 0 : _event_clipboardData.getData('text/plain');
-  if (!text) {
-    return {
-      handled: false
-    };
-  }
-  // Assume entities come in the syntax <entity>title</entity>
-  const re = /<entity[^>]*>([^<]*)<\/entity>/g;
-  const parts = text.split(re);
-  // If an entity was found, parts will be at least 3 elements long
-  if (parts.length < 3) {
+export const parseEntity = async (event)=>{
+    var _event_clipboardData;
+    const text = (_event_clipboardData = event.clipboardData) === null || _event_clipboardData === void 0 ? void 0 : _event_clipboardData.getData('text/plain');
+    if (!text) {
+        return {
+            handled: false
+        };
+    }
+    // Assume entities come in the syntax <entity>title</entity>
+    const re = /<entity[^>]*>([^<]*)<\/entity>/g;
+    const parts = text.split(re);
+    // If an entity was found, parts will be at least 3 elements long
+    if (parts.length < 3) {
+        return {
+            handled: false
+        };
+    }
+    // Even elements are text, odd elements are entities
+    // ["", entity, "", entity, "", ...]
+    const transformedParts = parts.map((str, i)=>{
+        if (i % 2 === 0) {
+            return {
+                type: 'text',
+                value: str
+            };
+        } else {
+            return {
+                type: 'entity',
+                value: {
+                    text: str,
+                    data: {
+                        url: str
+                    }
+                }
+            };
+        }
+    })// Filter out all the nulls for empty strings
+    .filter((node)=>node !== null);
     return {
-      handled: false
+        handled: true,
+        transformedParts
     };
-  }
-  // Even elements are text, odd elements are entities
-  // ["", entity, "", entity, "", ...]
-  const transformedParts = parts.map((str, i) => {
-    if (i % 2 === 0) {
-      return {
-        type: 'text',
-        value: str
-      };
-    } else {
-      return {
-        type: 'entity',
-        value: {
-          text: str,
-          data: {
-            url: str
-          }
-        }
-      };
-    }
-  }) // Filter out all the nulls for empty strings
-  .filter(node => node !== null);
-  return {
-    handled: true,
-    transformedParts
-  };
 };
-//# sourceMappingURL=PasteUnfurlingTestUtils.js.map

package/lib/PasteUnfurling/index.js

@@ -1,2 +1 @@
 export { registerPasteUnfurlingPlugin } from './PasteUnfurling.base';
-//# sourceMappingURL=index.js.map

package/lib/index.js

@@ -4,4 +4,3 @@ export { GhostTextPluginBase } from './GhostText';
 export { ImperativeControlBase } from './ImperativeControl';
 export { ManualGhostTextBase } from './ManualGhostText';
 export { registerPasteUnfurlingPlugin } from './PasteUnfurling';
-//# sourceMappingURL=index.js.map

package/lib-commonjs/BasicFunctionality/BasicFunctionality.base.js

@@ -15,6 +15,10 @@ const _SentinelNodeHandlers = require("./SentinelNodeHandlers");
 function isClipboardEvent(event) {
     return event.type === 'paste';
 }
+function getTextFromEditorState(state) {
+    // Remove the sentinel node whenever getting the text
+    return state.read(()=>(0, _texteditor.$getRoot)().getTextContent()).replace(_SentinelNode.SENTINEL_VALUE, '');
+}
 class BasicFunctionalityBase {
     __enterHandler(event) {
         const selection = (0, _texteditor.$getSelection)();
@@ -31,22 +35,17 @@ class BasicFunctionalityBase {
         // Mark event handled to override default behavior
         return true;
     }
-    insertDefaultValue(defaultValue) {
-        if (defaultValue) {
-            this.__editor.update(()=>{
-                (0, _texteditor.$insertNodes)([
-                    (0, _texteditor.$createTextNode)(defaultValue)
-                ]);
-            });
-        }
-    }
     activateContentCallbacks(onContentChange, onCountChanged) {
         this.deactivateContentCallbacks();
-        this.__contentChangeCleanup = this.__editor.registerTextContentListener((text)=>{
-            // Remove the sentinel node
-            const processed = text.replace(_SentinelNode.SENTINEL_VALUE, '');
-            onContentChange === null || onContentChange === void 0 ? void 0 : onContentChange(processed);
-            onCountChanged === null || onCountChanged === void 0 ? void 0 : onCountChanged(processed.length);
+        this.__contentChangeCleanup = this.__editor.registerUpdateListener(({ editorState, prevEditorState, tags })=>{
+            const prevText = getTextFromEditorState(prevEditorState);
+            const newText = getTextFromEditorState(editorState);
+            // If the text has not changed, don't trigger callbacks
+            if (prevText === newText) {
+                return;
+            }
+            onContentChange === null || onContentChange === void 0 ? void 0 : onContentChange(newText);
+            onCountChanged === null || onCountChanged === void 0 ? void 0 : onCountChanged(newText.length);
         });
     }
     deactivateContentCallbacks() {
@@ -79,8 +78,7 @@ class BasicFunctionalityBase {
                     (0, _texteditor.$getRoot)().getAllTextNodes().forEach((node)=>{
                         node.remove();
                     });
-                }, // Don't allow undoing this action
-                {
+                }, {
                     tag: 'historic'
                 });
             }
@@ -114,4 +112,4 @@ class BasicFunctionalityBase {
 }
 function noop() {
     return;
-} //# sourceMappingURL=BasicFunctionality.base.js.map
+}

package/lib-commonjs/BasicFunctionality/BasicFunctionality.base.js.map

@@ -1 +1 @@
-{"version":3,"sources":["BasicFunctionality.base.ts"],"sourcesContent":["import type { LexicalEditor } from '@fluentui-copilot/text-editor';\nimport { COMMAND_PRIORITY_HIGH } from '@fluentui-copilot/text-editor';\nimport {\n  $createTextNode,\n  $getRoot,\n  $getSelection,\n  $insertNodes,\n  $isRangeSelection,\n  INSERT_PARAGRAPH_COMMAND,\n  KEY_ENTER_COMMAND,\n  PASTE_COMMAND,\n  mergeRegister,\n} from '@fluentui-copilot/text-editor';\nimport { SENTINEL_VALUE } from './SentinelNode';\nimport { registerSentinelNodeHandlers } from './SentinelNodeHandlers';\n\nfunction isClipboardEvent(event: ClipboardEvent | KeyboardEvent | InputEvent): event is ClipboardEvent {\n  return event.type === 'paste';\n}\n\nexport interface IBasicFunctionalityBase {\n  insertDefaultValue: (defaultValue: string) => void;\n  setIsDisabled: (isDisabled: boolean) => void;\n  activateContentCallbacks(onContentChange?: (value: string) => void, onCountChanged?: (count: number) => void): void;\n  deactivateContentCallbacks(): void;\n  activateTrimWhitespace(): void;\n  deactivateTrimWhitespace(): void;\n  activatePasteCallback(onPaste: (event: ClipboardEvent) => void): void;\n  deactivatePasteCallback(): void;\n  cleanup(): void;\n}\n\nexport class BasicFunctionalityBase implements IBasicFunctionalityBase {\n  private __editor: LexicalEditor;\n  private __contentChangeCleanup?: () => void;\n  private __trimWhitespaceCleanup?: () => void;\n  private __baseHandlersCleanup?: () => void;\n  private __pasteHandlerCleanup?: () => void;\n\n  private __enterHandler(event: KeyboardEvent) {\n    const selection = $getSelection();\n    if (!$isRangeSelection(selection)) {\n      return false;\n    }\n\n    if (event === null) {\n      return false;\n    }\n\n    event.preventDefault();\n\n    if (event.shiftKey) {\n      return this.__editor.dispatchCommand(INSERT_PARAGRAPH_COMMAND, undefined);\n    }\n\n    // Mark event handled to override default behavior\n    return true;\n  }\n\n  constructor(editor: LexicalEditor, isSentinelNodeEnabled = true) {\n    this.__editor = editor;\n\n    this.__baseHandlersCleanup = mergeRegister(\n      this.__editor.registerCommand(KEY_ENTER_COMMAND, this.__enterHandler.bind(this), COMMAND_PRIORITY_HIGH),\n      isSentinelNodeEnabled ? registerSentinelNodeHandlers(editor) : noop,\n    );\n  }\n\n  insertDefaultValue(defaultValue: string) {\n    if (defaultValue) {\n      this.__editor.update(() => {\n        $insertNodes([$createTextNode(defaultValue)]);\n      });\n    }\n  }\n\n  activateContentCallbacks(\n    onContentChange?: ((value: string) => void) | undefined,\n    onCountChanged?: ((count: number) => void) | undefined,\n  ) {\n    this.deactivateContentCallbacks();\n    this.__contentChangeCleanup = this.__editor.registerTextContentListener(text => {\n      // Remove the sentinel node\n      const processed = text.replace(SENTINEL_VALUE, '');\n      onContentChange?.(processed);\n      onCountChanged?.(processed.length);\n    });\n  }\n\n  deactivateContentCallbacks() {\n    this.__contentChangeCleanup?.();\n    this.__contentChangeCleanup = undefined;\n  }\n\n  activatePasteCallback(onPaste: (event: ClipboardEvent) => void) {\n    this.__pasteHandlerCleanup = this.__editor.registerCommand(\n      PASTE_COMMAND,\n      (event: ClipboardEvent | KeyboardEvent | InputEvent) => {\n        if (!isClipboardEvent(event)) {\n          return false;\n        }\n\n        onPaste(event);\n\n        if (event.defaultPrevented) {\n          return true;\n        }\n\n        return false;\n      },\n      COMMAND_PRIORITY_HIGH,\n    );\n  }\n\n  deactivatePasteCallback() {\n    this.__pasteHandlerCleanup?.();\n    this.__pasteHandlerCleanup = undefined;\n  }\n\n  activateTrimWhitespace() {\n    this.deactivateTrimWhitespace();\n    this.__trimWhitespaceCleanup = this.__editor.registerTextContentListener(text => {\n      if (text.trim() === '') {\n        this.__editor.update(\n          () => {\n            $getRoot()\n              .getAllTextNodes()\n              .forEach(node => {\n                node.remove();\n              });\n          },\n          // Don't allow undoing this action\n          { tag: 'historic' },\n        );\n      }\n    });\n  }\n\n  deactivateTrimWhitespace() {\n    this.__trimWhitespaceCleanup?.();\n    this.__trimWhitespaceCleanup = undefined;\n  }\n\n  setIsDisabled(isDisabled: boolean) {\n    this.__editor.setEditable(!isDisabled);\n  }\n\n  cleanup() {\n    this.deactivateContentCallbacks();\n    this.deactivateTrimWhitespace();\n    this.deactivatePasteCallback();\n    this.__baseHandlersCleanup?.();\n    this.__baseHandlersCleanup = undefined;\n  }\n}\n\nfunction noop() {\n  return;\n}\n"],"names":["BasicFunctionalityBase","isClipboardEvent","event","type","__enterHandler","selection","$getSelection","$isRangeSelection","preventDefault","shiftKey","__editor","dispatchCommand","INSERT_PARAGRAPH_COMMAND","insertDefaultValue","defaultValue","update","$insertNodes","onContentChange","onCountChanged","deactivateContentCallbacks","activateContentCallbacks","text","processed","__contentChangeCleanup","SENTINEL_VALUE","registerTextContentListener","length","_this___contentChangeCleanup","_this","call","undefined","__pasteHandlerCleanup","registerCommand","PASTE_COMMAND","activatePasteCallback","onPaste","defaultPrevented","COMMAND_PRIORITY_HIGH","_this___pasteHandlerCleanup","deactivatePasteCallback","deactivateTrimWhitespace","activateTrimWhitespace","__trimWhitespaceCleanup","trim","forEach","node","remove","_this___trimWhitespaceCleanup","isDisabled","setIsDisabled","cleanup","__baseHandlersCleanup","_this___baseHandlersCleanup","editor","isSentinelNodeEnabled","constructor","noop"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}
+{"version":3,"sources":["BasicFunctionality.base.ts"],"sourcesContent":["import type { EditorState, LexicalEditor } from '@fluentui-copilot/text-editor';\nimport { COMMAND_PRIORITY_HIGH } from '@fluentui-copilot/text-editor';\nimport {\n  $getRoot,\n  $getSelection,\n  $isRangeSelection,\n  INSERT_PARAGRAPH_COMMAND,\n  KEY_ENTER_COMMAND,\n  PASTE_COMMAND,\n  mergeRegister,\n} from '@fluentui-copilot/text-editor';\nimport { SENTINEL_VALUE } from './SentinelNode';\nimport { registerSentinelNodeHandlers } from './SentinelNodeHandlers';\n\nfunction isClipboardEvent(event: ClipboardEvent | KeyboardEvent | InputEvent): event is ClipboardEvent {\n  return event.type === 'paste';\n}\n\nexport interface IBasicFunctionalityBase {\n  setIsDisabled: (isDisabled: boolean) => void;\n  activateContentCallbacks(onContentChange?: (value: string) => void, onCountChanged?: (count: number) => void): void;\n  deactivateContentCallbacks(): void;\n  activateTrimWhitespace(): void;\n  deactivateTrimWhitespace(): void;\n  activatePasteCallback(onPaste: (event: ClipboardEvent) => void): void;\n  deactivatePasteCallback(): void;\n  cleanup(): void;\n}\n\nfunction getTextFromEditorState(state: EditorState): string {\n  // Remove the sentinel node whenever getting the text\n  return state.read(() => $getRoot().getTextContent()).replace(SENTINEL_VALUE, '');\n}\n\nexport class BasicFunctionalityBase implements IBasicFunctionalityBase {\n  private __editor: LexicalEditor;\n  private __contentChangeCleanup?: () => void;\n  private __trimWhitespaceCleanup?: () => void;\n  private __baseHandlersCleanup?: () => void;\n  private __pasteHandlerCleanup?: () => void;\n\n  private __enterHandler(event: KeyboardEvent) {\n    const selection = $getSelection();\n    if (!$isRangeSelection(selection)) {\n      return false;\n    }\n\n    if (event === null) {\n      return false;\n    }\n\n    event.preventDefault();\n\n    if (event.shiftKey) {\n      return this.__editor.dispatchCommand(INSERT_PARAGRAPH_COMMAND, undefined);\n    }\n\n    // Mark event handled to override default behavior\n    return true;\n  }\n\n  constructor(editor: LexicalEditor, isSentinelNodeEnabled = true) {\n    this.__editor = editor;\n\n    this.__baseHandlersCleanup = mergeRegister(\n      this.__editor.registerCommand(KEY_ENTER_COMMAND, this.__enterHandler.bind(this), COMMAND_PRIORITY_HIGH),\n      isSentinelNodeEnabled ? registerSentinelNodeHandlers(editor) : noop,\n    );\n  }\n\n  activateContentCallbacks(\n    onContentChange?: ((value: string) => void) | undefined,\n    onCountChanged?: ((count: number) => void) | undefined,\n  ) {\n    this.deactivateContentCallbacks();\n    this.__contentChangeCleanup = this.__editor.registerUpdateListener(({ editorState, prevEditorState, tags }) => {\n      const prevText = getTextFromEditorState(prevEditorState);\n      const newText = getTextFromEditorState(editorState);\n\n      // If the text has not changed, don't trigger callbacks\n      if (prevText === newText) {\n        return;\n      }\n\n      onContentChange?.(newText);\n      onCountChanged?.(newText.length);\n    });\n  }\n\n  deactivateContentCallbacks() {\n    this.__contentChangeCleanup?.();\n    this.__contentChangeCleanup = undefined;\n  }\n\n  activatePasteCallback(onPaste: (event: ClipboardEvent) => void) {\n    this.__pasteHandlerCleanup = this.__editor.registerCommand(\n      PASTE_COMMAND,\n      (event: ClipboardEvent | KeyboardEvent | InputEvent) => {\n        if (!isClipboardEvent(event)) {\n          return false;\n        }\n\n        onPaste(event);\n\n        if (event.defaultPrevented) {\n          return true;\n        }\n\n        return false;\n      },\n      COMMAND_PRIORITY_HIGH,\n    );\n  }\n\n  deactivatePasteCallback() {\n    this.__pasteHandlerCleanup?.();\n    this.__pasteHandlerCleanup = undefined;\n  }\n\n  activateTrimWhitespace() {\n    this.deactivateTrimWhitespace();\n    this.__trimWhitespaceCleanup = this.__editor.registerTextContentListener(text => {\n      if (text.trim() === '') {\n        this.__editor.update(\n          () => {\n            $getRoot()\n              .getAllTextNodes()\n              .forEach(node => {\n                node.remove();\n              });\n          },\n          // Don't allow undoing this action\n          { tag: 'historic' },\n        );\n      }\n    });\n  }\n\n  deactivateTrimWhitespace() {\n    this.__trimWhitespaceCleanup?.();\n    this.__trimWhitespaceCleanup = undefined;\n  }\n\n  setIsDisabled(isDisabled: boolean) {\n    this.__editor.setEditable(!isDisabled);\n  }\n\n  cleanup() {\n    this.deactivateContentCallbacks();\n    this.deactivateTrimWhitespace();\n    this.deactivatePasteCallback();\n    this.__baseHandlersCleanup?.();\n    this.__baseHandlersCleanup = undefined;\n  }\n}\n\nfunction noop() {\n  return;\n}\n"],"names":["BasicFunctionalityBase","isClipboardEvent","event","type","getTextFromEditorState","state","read","$getRoot","getTextContent","replace","SENTINEL_VALUE","__enterHandler","selection","$getSelection","$isRangeSelection","preventDefault","shiftKey","__editor","dispatchCommand","INSERT_PARAGRAPH_COMMAND","undefined","activateContentCallbacks","onContentChange","onCountChanged","deactivateContentCallbacks","__contentChangeCleanup","registerUpdateListener","editorState","prevEditorState","tags","prevText","newText","length","_this___contentChangeCleanup","_this","call","activatePasteCallback","onPaste","__pasteHandlerCleanup","registerCommand","PASTE_COMMAND","defaultPrevented","COMMAND_PRIORITY_HIGH","deactivatePasteCallback","_this___pasteHandlerCleanup","activateTrimWhitespace","deactivateTrimWhitespace","__trimWhitespaceCleanup","registerTextContentListener","text","trim","update","getAllTextNodes","forEach","node","remove","tag","_this___trimWhitespaceCleanup","setIsDisabled","isDisabled","setEditable","cleanup","_this___baseHandlersCleanup","__baseHandlersCleanup","constructor","editor","isSentinelNodeEnabled","_define_property","mergeRegister","KEY_ENTER_COMMAND","bind","registerSentinelNodeHandlers","noop"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/lib-commonjs/BasicFunctionality/SentinelNode.js

@@ -58,4 +58,4 @@ function $createSentinelNode(key) {
 }
 function $isSentinelNode(node) {
     return node instanceof SentinelNode;
-} //# sourceMappingURL=SentinelNode.js.map
+}

package/lib-commonjs/BasicFunctionality/SentinelNode.js.map

@@ -1 +1 @@
-{"version":3,"sources":["SentinelNode.ts"],"sourcesContent":["import type { EditorConfig, LexicalNode, NodeKey, SerializedTextNode } from '@fluentui-copilot/text-editor';\nimport { TextNode } from '@fluentui-copilot/text-editor';\n\n// 2 zero width characters will not be visible in the editor.\n// \\u200b is the zero width space character which can allow line wrapping in a word\n// \\u200c is the zero width non-joiner character which prevents ligatures from connecting the two surrounding characters\n// These two characters together are a no-op and should not be present together in any legitimate user input.\nexport const SENTINEL_VALUE = '\\u200b\\u200c';\n\nexport class SentinelNode extends TextNode {\n  constructor(key?: NodeKey) {\n    super(SENTINEL_VALUE, key);\n  }\n\n  static getType() {\n    return 'sentinel';\n  }\n  static clone(node: SentinelNode) {\n    return new SentinelNode(node.__key);\n  }\n\n  createDOM(config: EditorConfig): HTMLElement {\n    const element = super.createDOM(config);\n    element.ariaHidden = 'true';\n    return element;\n  }\n\n  isToken() {\n    return true;\n  }\n\n  exportJSON(): SerializedTextNode {\n    return {\n      ...super.exportJSON(),\n      type: 'sentinel',\n      version: 1,\n    };\n  }\n\n  static importJSON(serializedNode: SerializedTextNode): SentinelNode {\n    return $createSentinelNode();\n  }\n}\n\nexport function $createSentinelNode(key?: NodeKey) {\n  return new SentinelNode(key);\n}\n\nexport function $isSentinelNode(node: LexicalNode | null): node is SentinelNode {\n  return node instanceof SentinelNode;\n}\n"],"names":["$createSentinelNode","$isSentinelNode","SENTINEL_VALUE","SentinelNode","TextNode","getType","clone","node","__key","createDOM","config","element","ariaHidden","isToken","exportJSON","type","version","importJSON","serializedNode","constructor","key"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IA4CgBA,mBAAAA;eAAAA;;IAIAC,eAAAA;eAAAA;;IAzCHC,cAAAA;eAAAA;;IAEAC,YAAAA;eAAAA;;;4BARY;AAMlB,MAAMD,iBAAiB;AAEvB,MAAMC,qBAAqBC,oBAAAA;WAKhCC,UAAOA;eACL;;WAEFC,MAAOA,IAAMC,EAAkB;eAC7B,IAAOJ,aAAIA,KAAaI,KAAKC;;cAG/BC,MAAUC,EAAoB;cAC5BC,UAAMA,KAAU,CAAAF,UAAMA;gBACtBE,UAAQC,GAAAA;eACRD;;cAGFE;eACE;;iBAGFC;eACE;oBACE,CAAGA,YAAMA;kBACTC;qBACAC;;;WAIJC,WAAOA,cAAWC,EAAkC;eAClDlB;;gBA9BFmB,GAAYC,CAAa;aACvB,CAAAlB,gBAAMA;;AA+BV;AAEO,SAASF,oBAAoBoB,GAAa;WAC/C,IAAOjB,aAAIA;AACb;AAEO,SAASF,gBAAgBM,IAAwB;WACtDA,gBAAOA;AACT"}
+{"version":3,"sources":["SentinelNode.ts"],"sourcesContent":["import type { EditorConfig, LexicalNode, NodeKey, SerializedTextNode } from '@fluentui-copilot/text-editor';\nimport { TextNode } from '@fluentui-copilot/text-editor';\n\n// 2 zero width characters will not be visible in the editor.\n// \\u200b is the zero width space character which can allow line wrapping in a word\n// \\u200c is the zero width non-joiner character which prevents ligatures from connecting the two surrounding characters\n// These two characters together are a no-op and should not be present together in any legitimate user input.\nexport const SENTINEL_VALUE = '\\u200b\\u200c';\n\nexport class SentinelNode extends TextNode {\n  constructor(key?: NodeKey) {\n    super(SENTINEL_VALUE, key);\n  }\n\n  static getType() {\n    return 'sentinel';\n  }\n  static clone(node: SentinelNode) {\n    return new SentinelNode(node.__key);\n  }\n\n  createDOM(config: EditorConfig): HTMLElement {\n    const element = super.createDOM(config);\n    element.ariaHidden = 'true';\n    return element;\n  }\n\n  isToken() {\n    return true;\n  }\n\n  exportJSON(): SerializedTextNode {\n    return {\n      ...super.exportJSON(),\n      type: 'sentinel',\n      version: 1,\n    };\n  }\n\n  static importJSON(serializedNode: SerializedTextNode): SentinelNode {\n    return $createSentinelNode();\n  }\n}\n\nexport function $createSentinelNode(key?: NodeKey) {\n  return new SentinelNode(key);\n}\n\nexport function $isSentinelNode(node: LexicalNode | null): node is SentinelNode {\n  return node instanceof SentinelNode;\n}\n"],"names":["$createSentinelNode","$isSentinelNode","SENTINEL_VALUE","SentinelNode","TextNode","getType","clone","node","__key","createDOM","config","element","ariaHidden","isToken","exportJSON","type","version","importJSON","serializedNode","constructor","key"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IA4CgBA,mBAAAA;eAAAA;;IAIAC,eAAAA;eAAAA;;IAzCHC,cAAAA;eAAAA;;IAEAC,YAAAA;eAAAA;;;4BARY;AAMlB,MAAMD,iBAAiB;AAEvB,MAAMC,qBAAqBC,oBAAAA;IAKhC,OAAOC,UAAU;QACf,OAAO;IACT;IACA,OAAOC,MAAMC,IAAkB,EAAE;QAC/B,OAAO,IAAIJ,aAAaI,KAAKC,KAAK;IACpC;IAEAC,UAAUC,MAAoB,EAAe;QAC3C,MAAMC,UAAU,KAAK,CAACF,UAAUC;QAChCC,QAAQC,UAAU,GAAG;QACrB,OAAOD;IACT;IAEAE,UAAU;QACR,OAAO;IACT;IAEAC,aAAiC;QAC/B,OAAO;YACL,GAAG,KAAK,CAACA,YAAY;YACrBC,MAAM;YACNC,SAAS;QACX;IACF;IAEA,OAAOC,WAAWC,cAAkC,EAAgB;QAClE,OAAOlB;IACT;IA/BAmB,YAAYC,GAAa,CAAE;QACzB,KAAK,CAAClB,gBAAgBkB;IACxB;AA8BF;AAEO,SAASpB,oBAAoBoB,GAAa;IAC/C,OAAO,IAAIjB,aAAaiB;AAC1B;AAEO,SAASnB,gBAAgBM,IAAwB;IACtD,OAAOA,gBAAgBJ;AACzB"}

package/lib-commonjs/BasicFunctionality/SentinelNodeHandlers.js

@@ -29,11 +29,9 @@ function registerSentinelNodeHandlers(editor) {
             // If the last node isn't a sentinel, add one
             if (!(0, _SentinelNode.$isSentinelNode)(lastNode)) {
                 editor.update(()=>{
-                    var // We find the node by its key again in case the node was removed before this update runs
-                    _$getNodeByKey;
+                    var _$getNodeByKey;
                     (_$getNodeByKey = (0, _texteditor.$getNodeByKey)(lastNodeKey)) === null || _$getNodeByKey === void 0 ? void 0 : _$getNodeByKey.insertAfter((0, _SentinelNode.$createSentinelNode)());
-                }, // historic tag prevents every sentinel node addition from being added to LexicalHistoryPlugin undo stack
-                {
+                }, {
                     discrete: true,
                     tag: 'historic'
                 });
@@ -86,4 +84,4 @@ function registerSentinelNodeHandlers(editor) {
             return;
         }
     }));
-} //# sourceMappingURL=SentinelNodeHandlers.js.map
+}

package/lib-commonjs/BasicFunctionality/SentinelNodeHandlers.js.map

@@ -1 +1 @@
-{"version":3,"sources":["SentinelNodeHandlers.ts"],"sourcesContent":["import type {\n  LexicalEditor,\n  UpdateListener} from '@fluentui-copilot/text-editor';\nimport {\n  $getLeafNodes,\n  $getNodeByKey,\n  $getRoot,\n  $getSelection,\n  $isRangeSelection,\n  $normalizeSelection__EXPERIMENTAL,\n  $setSelection,\n  mergeRegister\n} from '@fluentui-copilot/text-editor';\nimport { $isSentinelNode, $createSentinelNode, SentinelNode } from './SentinelNode';\n\nexport function registerSentinelNodeHandlers(editor: LexicalEditor) {\n  // Add a sentinel node at the end of the input when there is content.\n  // This sentinel node fixes a number of issues.\n  // In Safari, Lexical's behaviour of adding <br /> tags to the end of the input when it ends\n  // in a decorator node causes cursor location issues: https://github.com/facebook/lexical/issues/4487\n  // Otherwise, when a decorator node is the last node in the input, the cursor can't move past it.\n  // Adding an invisible text node that doesn't contribute to the content and can't be selected to the end of the input\n  // mitigates these issues.\n  const sentinelNodeUpdateHandler: UpdateListener = ({ editorState }) => {\n    editorState.read(() => {\n      const leaves = $getLeafNodes($getRoot());\n      if (leaves.length === 0) {\n        return;\n      }\n\n      const lastNode = leaves[leaves.length - 1];\n      const lastNodeKey = lastNode.getKey();\n\n      // If the last node isn't a sentinel, add one\n      if (!$isSentinelNode(lastNode)) {\n        editor.update(\n          () => {\n            // We find the node by its key again in case the node was removed before this update runs\n            $getNodeByKey(lastNodeKey)?.insertAfter($createSentinelNode());\n          },\n          // historic tag prevents every sentinel node addition from being added to LexicalHistoryPlugin undo stack\n          { discrete: true, tag: 'historic' },\n        );\n        return;\n      }\n\n      // If the sentinel node is not selected, we're done\n      const previous = lastNode.getPreviousSibling();\n      if (!previous || !lastNode.isSelected()) {\n        return;\n      }\n\n      const selection = $getSelection();\n      if (!$isRangeSelection(selection)) {\n        return;\n      }\n\n      // If the cursor is inside the sentinel node, move it out (next to the beginning)\n      // We allow selection on the boundary of the sentinel in case the adjacent node is a decorator node\n      // where selection is ill-defined.\n      if (selection.isCollapsed() && selection.anchor.offset > 0) {\n        editor.update(() => {\n          $getNodeByKey(lastNodeKey)?.selectStart();\n        });\n        return;\n      }\n\n      // If the selection is a range which includes the sentinel, modify the range to exclude it\n      if (!selection.isCollapsed()) {\n        let selectionChanged = false;\n        const newSelection = selection.clone();\n\n        if (newSelection.anchor.getNode() === lastNode && newSelection.anchor.offset > 0) {\n          newSelection.anchor.set(lastNodeKey, 0, 'text');\n          selectionChanged = true;\n        }\n        if (newSelection.focus.getNode() === lastNode && newSelection.focus.offset > 0) {\n          newSelection.focus.set(lastNodeKey, 0, 'text');\n          selectionChanged = true;\n        }\n\n        if (selectionChanged) {\n          editor.update(() => {\n            if ($getNodeByKey(lastNodeKey) !== null) {\n              $setSelection($normalizeSelection__EXPERIMENTAL(newSelection));\n            }\n          });\n        }\n      }\n    });\n  };\n\n  return mergeRegister(\n    editor.registerUpdateListener(sentinelNodeUpdateHandler),\n    editor.registerNodeTransform(SentinelNode, node => {\n      if (!node.getPreviousSibling() || node.getNextSibling()) {\n        node.remove();\n        return;\n      }\n    }),\n  );\n}\n"],"names":["registerSentinelNodeHandlers","editor","sentinelNodeUpdateHandler","editorState","leaves","$getLeafNodes","$getRoot","length","lastNode","lastNodeKey","$isSentinelNode","$getNodeByKey","discrete","_$getNodeByKey","insertAfter","$createSentinelNode","previous","selection","$getSelection","$isRangeSelection","isCollapsed","anchor","offset","selectStart","newSelection","selectionChanged","clone","getNode","focus","update","$setSelection","$normalizeSelection__EXPERIMENTAL","mergeRegister","registerUpdateListener","registerNodeTransform","SentinelNode","node","getPreviousSibling","getNextSibling","remove"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAegBA;;;eAAAA;;;4BAHT;8BAC4D;AAE5D,SAASA,6BAA6BC,MAAqB;yEAChE;mDACA;gGACA;yGACA;qGACA;yHACA;8BACA;UACAC,4BAAMA,CAAAA,aACJC;oBAEMC,IAAAA,CAAAA;2BACFC,IAAAA,yBAAA,EAAAC,IAAAA,oBAAA;uBACFC,MAAA,KAAA,GAAA;;;kBAKAC,WAAAJ,MAAA,CAAAA,OAAAG,MAAA,GAAA,EAAA;kBACAE,cAAKC,SAAgBF,MAAAA;yDAEjB;kDACE,EAAAA,WAAA;6BACAG,CAAAA;iHAEF;;sCACEC,IAAAA,yBAAU,EAAAH,YAAA,MAAA,QAAAI,mBAAA,KAAA,IAAA,KAAA,IAAAA,eAAAC,WAAA,CAAAC,IAAAA,iCAAA;4HAAsB;;8BAGtC;yBAEA;;;;+DAIA;kBAEAC,WAAMC,SAAYC,kBAAAA;6BACbC,CAAAA,SAAAA,UAAkBF,IAAY;;;kBAInCA,YAAAC,IAAAA,yBAAA;kDACA,EAAAD,YAAA;;;6FAGgB;+GACZN;8CAAAA;0BACFS,WAAA,MAAAH,UAAAI,MAAA,CAAAC,MAAA,GAAA,GAAA;6BACA,CAAA;wBACFT;sCAEAF,IAAAA,yBAAA,EAAAF,YAAA,MAAA,QAAAI,mBAAA,KAAA,IAAA,KAAA,IAA0FA,eAAAU,WAAA;;;;sGAKT;2BAC7EC,WAAAA,IAAaH;uCACbI;qCACFR,UAAAS,KAAA;iCACIF,MAAAA,CAAAA,OAAmBG,OAAOnB,YAAOA,aAAYgB,MAAAA,CAAaI,MAAMN,GAAAA,GAAM;iCACxEE,MAAAA,CAAAA,GAAaI,CAAAA,aAAUnB,GAAAA;uCACvBgB;;iCAGEA,KAAAA,CAAAA,OAAkB,OAAAjB,YAAAgB,aAAAI,KAAA,CAAAN,MAAA,GAAA,GAAA;iCACpBrB,KAAO4B,CAAAA,GAAAA,CAAMpB,aAAC,GAAA;uCACRE;;sCAEJ;iCACF,CAAA;4BACFA,IAAAA,yBAAA,EAAAF,iBAAA,MAAA;4BACFqB,IAAAA,yBAAA,EAAAC,IAAAA,6CAAA,EAAAP;wBACF;oBACF;gBAEA;;;;WAMIQ,IAAAA,yBAAA,EAAA/B,OAAAgC,sBAAA,CAAA/B,4BAAAD,OAAAiC,qBAAA,CAAAC,0BAAA,EAAAC,CAAAA;QACF,IAAA,CAAAA,KAAAC,kBAAA,MAAAD,KAAAE,cAAA,IAAA;YAEJF,KAAAG,MAAA"}
+{"version":3,"sources":["SentinelNodeHandlers.ts"],"sourcesContent":["import type {\n  LexicalEditor,\n  UpdateListener} from '@fluentui-copilot/text-editor';\nimport {\n  $getLeafNodes,\n  $getNodeByKey,\n  $getRoot,\n  $getSelection,\n  $isRangeSelection,\n  $normalizeSelection__EXPERIMENTAL,\n  $setSelection,\n  mergeRegister\n} from '@fluentui-copilot/text-editor';\nimport { $isSentinelNode, $createSentinelNode, SentinelNode } from './SentinelNode';\n\nexport function registerSentinelNodeHandlers(editor: LexicalEditor) {\n  // Add a sentinel node at the end of the input when there is content.\n  // This sentinel node fixes a number of issues.\n  // In Safari, Lexical's behaviour of adding <br /> tags to the end of the input when it ends\n  // in a decorator node causes cursor location issues: https://github.com/facebook/lexical/issues/4487\n  // Otherwise, when a decorator node is the last node in the input, the cursor can't move past it.\n  // Adding an invisible text node that doesn't contribute to the content and can't be selected to the end of the input\n  // mitigates these issues.\n  const sentinelNodeUpdateHandler: UpdateListener = ({ editorState }) => {\n    editorState.read(() => {\n      const leaves = $getLeafNodes($getRoot());\n      if (leaves.length === 0) {\n        return;\n      }\n\n      const lastNode = leaves[leaves.length - 1];\n      const lastNodeKey = lastNode.getKey();\n\n      // If the last node isn't a sentinel, add one\n      if (!$isSentinelNode(lastNode)) {\n        editor.update(\n          () => {\n            // We find the node by its key again in case the node was removed before this update runs\n            $getNodeByKey(lastNodeKey)?.insertAfter($createSentinelNode());\n          },\n          // historic tag prevents every sentinel node addition from being added to LexicalHistoryPlugin undo stack\n          { discrete: true, tag: 'historic' },\n        );\n        return;\n      }\n\n      // If the sentinel node is not selected, we're done\n      const previous = lastNode.getPreviousSibling();\n      if (!previous || !lastNode.isSelected()) {\n        return;\n      }\n\n      const selection = $getSelection();\n      if (!$isRangeSelection(selection)) {\n        return;\n      }\n\n      // If the cursor is inside the sentinel node, move it out (next to the beginning)\n      // We allow selection on the boundary of the sentinel in case the adjacent node is a decorator node\n      // where selection is ill-defined.\n      if (selection.isCollapsed() && selection.anchor.offset > 0) {\n        editor.update(() => {\n          $getNodeByKey(lastNodeKey)?.selectStart();\n        });\n        return;\n      }\n\n      // If the selection is a range which includes the sentinel, modify the range to exclude it\n      if (!selection.isCollapsed()) {\n        let selectionChanged = false;\n        const newSelection = selection.clone();\n\n        if (newSelection.anchor.getNode() === lastNode && newSelection.anchor.offset > 0) {\n          newSelection.anchor.set(lastNodeKey, 0, 'text');\n          selectionChanged = true;\n        }\n        if (newSelection.focus.getNode() === lastNode && newSelection.focus.offset > 0) {\n          newSelection.focus.set(lastNodeKey, 0, 'text');\n          selectionChanged = true;\n        }\n\n        if (selectionChanged) {\n          editor.update(() => {\n            if ($getNodeByKey(lastNodeKey) !== null) {\n              $setSelection($normalizeSelection__EXPERIMENTAL(newSelection));\n            }\n          });\n        }\n      }\n    });\n  };\n\n  return mergeRegister(\n    editor.registerUpdateListener(sentinelNodeUpdateHandler),\n    editor.registerNodeTransform(SentinelNode, node => {\n      if (!node.getPreviousSibling() || node.getNextSibling()) {\n        node.remove();\n        return;\n      }\n    }),\n  );\n}\n"],"names":["registerSentinelNodeHandlers","editor","sentinelNodeUpdateHandler","editorState","read","leaves","$getLeafNodes","$getRoot","length","lastNode","lastNodeKey","getKey","$isSentinelNode","update","$getNodeByKey","insertAfter","$createSentinelNode","discrete","tag","previous","getPreviousSibling","isSelected","selection","$getSelection","$isRangeSelection","isCollapsed","anchor","offset","selectStart","selectionChanged","newSelection","clone","getNode","set","focus","$setSelection","$normalizeSelection__EXPERIMENTAL","mergeRegister","registerUpdateListener","registerNodeTransform","SentinelNode","node","getNextSibling","remove"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAegBA;;;eAAAA;;;4BAHT;8BAC4D;AAE5D,SAASA,6BAA6BC,MAAqB;IAChE,qEAAqE;IACrE,+CAA+C;IAC/C,4FAA4F;IAC5F,qGAAqG;IACrG,iGAAiG;IACjG,qHAAqH;IACrH,0BAA0B;IAC1B,MAAMC,4BAA4C,CAAC,EAAEC,WAAW,EAAE;QAChEA,YAAYC,IAAI,CAAC;YACf,MAAMC,SAASC,IAAAA,yBAAAA,EAAcC,IAAAA,oBAAAA;YAC7B,IAAIF,OAAOG,MAAM,KAAK,GAAG;gBACvB;YACF;YAEA,MAAMC,WAAWJ,MAAM,CAACA,OAAOG,MAAM,GAAG,EAAE;YAC1C,MAAME,cAAcD,SAASE,MAAM;YAEnC,6CAA6C;YAC7C,IAAI,CAACC,IAAAA,6BAAAA,EAAgBH,WAAW;gBAC9BR,OAAOY,MAAM,CACX;wBAEEC;oBAAAA,CAAAA,iBAAAA,IAAAA,yBAAAA,EAAcJ,YAAAA,MAAAA,QAAdI,mBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,eAA4BC,WAAW,CAACC,IAAAA,iCAAAA;gBAC1C,GAEA;oBAAEC,UAAU;oBAAMC,KAAK;gBAAW;gBAEpC;YACF;YAEA,mDAAmD;YACnD,MAAMC,WAAWV,SAASW,kBAAkB;YAC5C,IAAI,CAACD,YAAY,CAACV,SAASY,UAAU,IAAI;gBACvC;YACF;YAEA,MAAMC,YAAYC,IAAAA,yBAAAA;YAClB,IAAI,CAACC,IAAAA,6BAAAA,EAAkBF,YAAY;gBACjC;YACF;YAEA,iFAAiF;YACjF,mGAAmG;YACnG,kCAAkC;YAClC,IAAIA,UAAUG,WAAW,MAAMH,UAAUI,MAAM,CAACC,MAAM,GAAG,GAAG;gBAC1D1B,OAAOY,MAAM,CAAC;wBACZC;oBAAAA,CAAAA,iBAAAA,IAAAA,yBAAAA,EAAcJ,YAAAA,MAAAA,QAAdI,mBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,eAA4Bc,WAAW;gBACzC;gBACA;YACF;YAEA,0FAA0F;YAC1F,IAAI,CAACN,UAAUG,WAAW,IAAI;gBAC5B,IAAII,mBAAmB;gBACvB,MAAMC,eAAeR,UAAUS,KAAK;gBAEpC,IAAID,aAAaJ,MAAM,CAACM,OAAO,OAAOvB,YAAYqB,aAAaJ,MAAM,CAACC,MAAM,GAAG,GAAG;oBAChFG,aAAaJ,MAAM,CAACO,GAAG,CAACvB,aAAa,GAAG;oBACxCmB,mBAAmB;gBACrB;gBACA,IAAIC,aAAaI,KAAK,CAACF,OAAO,OAAOvB,YAAYqB,aAAaI,KAAK,CAACP,MAAM,GAAG,GAAG;oBAC9EG,aAAaI,KAAK,CAACD,GAAG,CAACvB,aAAa,GAAG;oBACvCmB,mBAAmB;gBACrB;gBAEA,IAAIA,kBAAkB;oBACpB5B,OAAOY,MAAM,CAAC;wBACZ,IAAIC,IAAAA,yBAAAA,EAAcJ,iBAAiB,MAAM;4BACvCyB,IAAAA,yBAAAA,EAAcC,IAAAA,6CAAAA,EAAkCN;wBAClD;oBACF;gBACF;YACF;QACF;IACF;IAEA,OAAOO,IAAAA,yBAAAA,EACLpC,OAAOqC,sBAAsB,CAACpC,4BAC9BD,OAAOsC,qBAAqB,CAACC,0BAAAA,EAAcC,CAAAA;QACzC,IAAI,CAACA,KAAKrB,kBAAkB,MAAMqB,KAAKC,cAAc,IAAI;YACvDD,KAAKE,MAAM;YACX;QACF;IACF;AAEJ"}

package/lib-commonjs/BasicFunctionality/index.js

@@ -27,4 +27,3 @@ _export(exports, {
 });
 const _BasicFunctionalitybase = require("./BasicFunctionality.base");
 const _SentinelNode = require("./SentinelNode");
- //# sourceMappingURL=index.js.map

package/lib-commonjs/ChatInputEntity/ChatInputEntityPlugin.base.js

@@ -72,12 +72,10 @@ class ChatInputEntityPluginBase {
         this.__editor = editor;
         this.__id = id;
         this.__nodeClass = nodeClass;
-        this._cleanup = (0, _texteditor.mergeRegister)(// Keep track of delete direction so we know where to put the selection after adding back a space
-        editor.registerCommand(_texteditor.DELETE_CHARACTER_COMMAND, (isBackward)=>{
+        this._cleanup = (0, _texteditor.mergeRegister)(editor.registerCommand(_texteditor.DELETE_CHARACTER_COMMAND, (isBackward)=>{
             this.__deleteDirection = isBackward ? 'backward' : 'forward';
             return false;
-        }, _texteditor.COMMAND_PRIORITY_CRITICAL), // Always maintain a space before, after, and between entities in order for selection to work properly
-        editor.registerNodeTransform(this.__nodeClass, (node)=>{
+        }, _texteditor.COMMAND_PRIORITY_CRITICAL), editor.registerNodeTransform(this.__nodeClass, (node)=>{
             const nextSibling = node.getNextSibling();
             if (!nextSibling || (0, _texteditor.$isDecoratorNode)(nextSibling)) {
                 const selection = (0, _texteditor.$getSelection)();
@@ -124,4 +122,4 @@ class ChatInputEntityPluginBase {
 }
 function noop() {
     return;
-} //# sourceMappingURL=ChatInputEntityPlugin.base.js.map
+}

package/lib-commonjs/ChatInputEntity/ChatInputEntityPlugin.base.js.map

@@ -1 +1 @@
-{"version":3,"sources":["ChatInputEntityPlugin.base.ts"],"sourcesContent":["import type { LexicalEditor, LexicalNode, NodeKey, Klass } from '@fluentui-copilot/text-editor';\nimport {\n  $createParagraphNode,\n  $createTextNode,\n  $getNodeByKey,\n  $getSelection,\n  $insertNodes,\n  $isDecoratorNode,\n  $isRangeSelection,\n  $isRootOrShadowRoot,\n  $nodesOfType,\n  $wrapNodeInElement,\n  COMMAND_PRIORITY_CRITICAL,\n  DELETE_CHARACTER_COMMAND,\n  mergeRegister,\n} from '@fluentui-copilot/text-editor';\nimport type {\n  ChatInputEntityData,\n  ChatInputEntityPluginProps,\n  IChatInputEntityPluginBase,\n  IEntityNode,\n} from './ChatInputEntityPlugin.types';\n\nexport class ChatInputEntityPluginBase<\n  ExtraDataType,\n  NodePropsType,\n  NodeType extends IEntityNode<ExtraDataType, NodePropsType>,\n> implements IChatInputEntityPluginBase<ExtraDataType, NodePropsType>\n{\n  private __nodeClass: Klass<NodeType>;\n  private __editor: LexicalEditor;\n  private __id: string;\n\n  private __deleteDirection: 'forward' | 'backward' | null = null;\n  private __$createNode: (\n    pluginId: string,\n    text: string,\n    data?: ExtraDataType,\n    entityProps?: NodePropsType,\n    key?: NodeKey,\n  ) => NodeType;\n\n  private _cleanup: () => void;\n\n  cleanup() {\n    this._cleanup();\n  }\n\n  constructor(\n    editor: LexicalEditor,\n    id: string,\n    nodeClass: Klass<NodeType>,\n    $createNode: (\n      pluginId: string,\n      text: string,\n      data?: ExtraDataType,\n      entityProps?: NodePropsType,\n      key?: NodeKey,\n    ) => NodeType,\n    $isChatInputEntityNode: (node: LexicalNode | null) => node is NodeType,\n    onChatInputEntityAdded?: ChatInputEntityPluginProps<ExtraDataType, NodePropsType>['onChatInputEntityAdded'],\n    onChatInputEntityDeleted?: ChatInputEntityPluginProps<ExtraDataType, NodePropsType>['onChatInputEntityDeleted'],\n  ) {\n    this.__$createNode = $createNode;\n    this.__editor = editor;\n    this.__id = id;\n    this.__nodeClass = nodeClass;\n\n    this._cleanup = mergeRegister(\n      // Keep track of delete direction so we know where to put the selection after adding back a space\n      editor.registerCommand(\n        DELETE_CHARACTER_COMMAND,\n        isBackward => {\n          this.__deleteDirection = isBackward ? 'backward' : 'forward';\n          return false;\n        },\n        COMMAND_PRIORITY_CRITICAL,\n      ),\n      // Always maintain a space before, after, and between entities in order for selection to work properly\n      editor.registerNodeTransform(this.__nodeClass, node => {\n        const nextSibling = node.getNextSibling();\n        if (!nextSibling || $isDecoratorNode(nextSibling)) {\n          const selection = $getSelection();\n\n          // If selection is between the two nodes, that means the user is trying to delete the space\n          // If they deleted to the left, we should move the cursor to the end of the entity\n          // If they delete to the right, we should move the cursor to the end of the newly added space\n          // This mimics changing the delete into a cursor move action\n          const shouldMoveSelection =\n            selection &&\n            $isRangeSelection(selection) &&\n            selection.isCollapsed() &&\n            selection.anchor.offset === node.getIndexWithinParent() + 1;\n          const text = $createTextNode(' ');\n          node.insertAfter(text);\n          if (shouldMoveSelection) {\n            if (this.__deleteDirection === 'forward') {\n              text.selectEnd();\n            } else {\n              node.selectEnd();\n            }\n          }\n        }\n\n        // In the case the entity is the first node, we need a space before it.\n        if (!node.getPreviousSibling()) {\n          const text = $createTextNode(' ');\n          node.insertBefore(text);\n        }\n      }),\n      onChatInputEntityAdded || onChatInputEntityDeleted\n        ? editor.registerMutationListener(this.__nodeClass, (nodes, payload) => {\n            for (const [nodeKey, mutation] of nodes) {\n              if (onChatInputEntityDeleted && mutation === 'destroyed') {\n                payload.prevEditorState.read(() => {\n                  const node = $getNodeByKey(nodeKey);\n                  if ($isChatInputEntityNode(node) && node.__pluginId === id) {\n                    onChatInputEntityDeleted(node.getEntityData(), nodeKey);\n                  }\n                });\n              } else if (onChatInputEntityAdded && mutation === 'created') {\n                editor.getEditorState().read(() => {\n                  const node = $getNodeByKey(nodeKey);\n                  if ($isChatInputEntityNode(node) && node.__pluginId === id) {\n                    onChatInputEntityAdded(node.getEntityData(), nodeKey);\n                  }\n                });\n              }\n            }\n          })\n        : noop,\n    );\n  }\n  insertChatInputEntity(props: ChatInputEntityData<ExtraDataType, NodePropsType>): string | undefined {\n    let key: string | undefined = undefined;\n    this.__editor.update(() => {\n      const { text, data, entityProps } = props;\n\n      const entityNode = this.__$createNode(this.__id, text, data, entityProps);\n\n      $insertNodes([entityNode]);\n      entityNode.selectEnd();\n      if ($isRootOrShadowRoot(entityNode.getParentOrThrow())) {\n        $wrapNodeInElement(entityNode, $createParagraphNode).selectEnd();\n      }\n\n      key = entityNode.getKey();\n    });\n\n    return key;\n  }\n  removeChatInputEntity(\n    keyOrPredicate: string | ((entity: ChatInputEntityData<ExtraDataType, NodePropsType>, i: number) => boolean),\n  ) {\n    this.__editor.update(() => {\n      if (typeof keyOrPredicate === 'function') {\n        $nodesOfType(this.__nodeClass)\n          .filter((node, i) => node.__pluginId === this.__id && keyOrPredicate(node.getEntityData(), i))\n          .forEach(node => node.remove());\n      } else {\n        $getNodeByKey(keyOrPredicate)?.remove();\n      }\n    });\n  }\n  updateChatInputEntityProps(\n    keyOrPredicate: string | ((entity: ChatInputEntityData<ExtraDataType, NodePropsType>, i: number) => boolean),\n    props:\n      | ChatInputEntityData<ExtraDataType, NodePropsType>\n      | ((\n          oldProps: ChatInputEntityData<ExtraDataType, NodePropsType>,\n        ) => ChatInputEntityData<ExtraDataType, NodePropsType>),\n  ) {\n    const updateNode = (node: NodeType) => {\n      const newProps = typeof props === 'function' ? props(node.getEntityData()) : props;\n      node.updateEntityData(newProps);\n    };\n\n    this.__editor.update(\n      () => {\n        if (typeof keyOrPredicate === 'function') {\n          $nodesOfType(this.__nodeClass)\n            .filter((node, i) => node.__pluginId === this.__id && keyOrPredicate(node.getEntityData(), i))\n            .forEach(updateNode);\n        } else {\n          const node = $getNodeByKey<NodeType>(keyOrPredicate);\n          if (node) {\n            updateNode(node);\n          }\n        }\n      },\n      { tag: 'historic' },\n    );\n  }\n\n  getActiveEntities(): ChatInputEntityData<ExtraDataType, NodePropsType>[] {\n    return this.__editor.getEditorState().read(() =>\n      $nodesOfType(this.__nodeClass)\n        .filter(node => node.__pluginId === this.__id)\n        .map(node => node.getEntityData()),\n    );\n  }\n}\n\nfunction noop() {\n  return;\n}\n"],"names":["ChatInputEntityPluginBase","cleanup","_cleanup","insertChatInputEntity","props","key","__editor","update","$insertNodes","entityNode","selectEnd","__id","text","data","entityProps","$isRootOrShadowRoot","$wrapNodeInElement","getParentOrThrow","$createParagraphNode","removeChatInputEntity","keyOrPredicate","$nodesOfType","$getNodeByKey","_$getNodeByKey","remove","updateChatInputEntityProps","updateEntityData","newProps","node","getEntityData","updateNode","tag","getActiveEntities","constructor","editor","id","$createNode","$isChatInputEntityNode","onChatInputEntityAdded","onChatInputEntityDeleted","map","nodeClass","__deleteDirection","__$createNode","__nodeClass","registerCommand","COMMAND_PRIORITY_CRITICAL","isBackward","registerNodeTransform","$isDecoratorNode","$getSelection","getNextSibling","nextSibling","isCollapsed","$isRangeSelection","selection","anchor","offset","getIndexWithinParent","$createTextNode","mutation","nodeKey","read","getEditorState","__pluginId","noop"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}
+{"version":3,"sources":["ChatInputEntityPlugin.base.ts"],"sourcesContent":["import type { LexicalEditor, LexicalNode, NodeKey, Klass } from '@fluentui-copilot/text-editor';\nimport {\n  $createParagraphNode,\n  $createTextNode,\n  $getNodeByKey,\n  $getSelection,\n  $insertNodes,\n  $isDecoratorNode,\n  $isRangeSelection,\n  $isRootOrShadowRoot,\n  $nodesOfType,\n  $wrapNodeInElement,\n  COMMAND_PRIORITY_CRITICAL,\n  DELETE_CHARACTER_COMMAND,\n  mergeRegister,\n} from '@fluentui-copilot/text-editor';\nimport type {\n  ChatInputEntityData,\n  ChatInputEntityPluginProps,\n  IChatInputEntityPluginBase,\n  IEntityNode,\n} from './ChatInputEntityPlugin.types';\n\nexport class ChatInputEntityPluginBase<\n  ExtraDataType,\n  NodePropsType,\n  NodeType extends IEntityNode<ExtraDataType, NodePropsType>,\n> implements IChatInputEntityPluginBase<ExtraDataType, NodePropsType>\n{\n  private __nodeClass: Klass<NodeType>;\n  private __editor: LexicalEditor;\n  private __id: string;\n\n  private __deleteDirection: 'forward' | 'backward' | null = null;\n  private __$createNode: (\n    pluginId: string,\n    text: string,\n    data?: ExtraDataType,\n    entityProps?: NodePropsType,\n    key?: NodeKey,\n  ) => NodeType;\n\n  private _cleanup: () => void;\n\n  cleanup() {\n    this._cleanup();\n  }\n\n  constructor(\n    editor: LexicalEditor,\n    id: string,\n    nodeClass: Klass<NodeType>,\n    $createNode: (\n      pluginId: string,\n      text: string,\n      data?: ExtraDataType,\n      entityProps?: NodePropsType,\n      key?: NodeKey,\n    ) => NodeType,\n    $isChatInputEntityNode: (node: LexicalNode | null) => node is NodeType,\n    onChatInputEntityAdded?: ChatInputEntityPluginProps<ExtraDataType, NodePropsType>['onChatInputEntityAdded'],\n    onChatInputEntityDeleted?: ChatInputEntityPluginProps<ExtraDataType, NodePropsType>['onChatInputEntityDeleted'],\n  ) {\n    this.__$createNode = $createNode;\n    this.__editor = editor;\n    this.__id = id;\n    this.__nodeClass = nodeClass;\n\n    this._cleanup = mergeRegister(\n      // Keep track of delete direction so we know where to put the selection after adding back a space\n      editor.registerCommand(\n        DELETE_CHARACTER_COMMAND,\n        isBackward => {\n          this.__deleteDirection = isBackward ? 'backward' : 'forward';\n          return false;\n        },\n        COMMAND_PRIORITY_CRITICAL,\n      ),\n      // Always maintain a space before, after, and between entities in order for selection to work properly\n      editor.registerNodeTransform(this.__nodeClass, node => {\n        const nextSibling = node.getNextSibling();\n        if (!nextSibling || $isDecoratorNode(nextSibling)) {\n          const selection = $getSelection();\n\n          // If selection is between the two nodes, that means the user is trying to delete the space\n          // If they deleted to the left, we should move the cursor to the end of the entity\n          // If they delete to the right, we should move the cursor to the end of the newly added space\n          // This mimics changing the delete into a cursor move action\n          const shouldMoveSelection =\n            selection &&\n            $isRangeSelection(selection) &&\n            selection.isCollapsed() &&\n            selection.anchor.offset === node.getIndexWithinParent() + 1;\n          const text = $createTextNode(' ');\n          node.insertAfter(text);\n          if (shouldMoveSelection) {\n            if (this.__deleteDirection === 'forward') {\n              text.selectEnd();\n            } else {\n              node.selectEnd();\n            }\n          }\n        }\n\n        // In the case the entity is the first node, we need a space before it.\n        if (!node.getPreviousSibling()) {\n          const text = $createTextNode(' ');\n          node.insertBefore(text);\n        }\n      }),\n      onChatInputEntityAdded || onChatInputEntityDeleted\n        ? editor.registerMutationListener(this.__nodeClass, (nodes, payload) => {\n            for (const [nodeKey, mutation] of nodes) {\n              if (onChatInputEntityDeleted && mutation === 'destroyed') {\n                payload.prevEditorState.read(() => {\n                  const node = $getNodeByKey(nodeKey);\n                  if ($isChatInputEntityNode(node) && node.__pluginId === id) {\n                    onChatInputEntityDeleted(node.getEntityData(), nodeKey);\n                  }\n                });\n              } else if (onChatInputEntityAdded && mutation === 'created') {\n                editor.getEditorState().read(() => {\n                  const node = $getNodeByKey(nodeKey);\n                  if ($isChatInputEntityNode(node) && node.__pluginId === id) {\n                    onChatInputEntityAdded(node.getEntityData(), nodeKey);\n                  }\n                });\n              }\n            }\n          })\n        : noop,\n    );\n  }\n  insertChatInputEntity(props: ChatInputEntityData<ExtraDataType, NodePropsType>): string | undefined {\n    let key: string | undefined = undefined;\n    this.__editor.update(() => {\n      const { text, data, entityProps } = props;\n\n      const entityNode = this.__$createNode(this.__id, text, data, entityProps);\n\n      $insertNodes([entityNode]);\n      entityNode.selectEnd();\n      if ($isRootOrShadowRoot(entityNode.getParentOrThrow())) {\n        $wrapNodeInElement(entityNode, $createParagraphNode).selectEnd();\n      }\n\n      key = entityNode.getKey();\n    });\n\n    return key;\n  }\n  removeChatInputEntity(\n    keyOrPredicate: string | ((entity: ChatInputEntityData<ExtraDataType, NodePropsType>, i: number) => boolean),\n  ) {\n    this.__editor.update(() => {\n      if (typeof keyOrPredicate === 'function') {\n        $nodesOfType(this.__nodeClass)\n          .filter((node, i) => node.__pluginId === this.__id && keyOrPredicate(node.getEntityData(), i))\n          .forEach(node => node.remove());\n      } else {\n        $getNodeByKey(keyOrPredicate)?.remove();\n      }\n    });\n  }\n  updateChatInputEntityProps(\n    keyOrPredicate: string | ((entity: ChatInputEntityData<ExtraDataType, NodePropsType>, i: number) => boolean),\n    props:\n      | ChatInputEntityData<ExtraDataType, NodePropsType>\n      | ((\n          oldProps: ChatInputEntityData<ExtraDataType, NodePropsType>,\n        ) => ChatInputEntityData<ExtraDataType, NodePropsType>),\n  ) {\n    const updateNode = (node: NodeType) => {\n      const newProps = typeof props === 'function' ? props(node.getEntityData()) : props;\n      node.updateEntityData(newProps);\n    };\n\n    this.__editor.update(\n      () => {\n        if (typeof keyOrPredicate === 'function') {\n          $nodesOfType(this.__nodeClass)\n            .filter((node, i) => node.__pluginId === this.__id && keyOrPredicate(node.getEntityData(), i))\n            .forEach(updateNode);\n        } else {\n          const node = $getNodeByKey<NodeType>(keyOrPredicate);\n          if (node) {\n            updateNode(node);\n          }\n        }\n      },\n      { tag: 'historic' },\n    );\n  }\n\n  getActiveEntities(): ChatInputEntityData<ExtraDataType, NodePropsType>[] {\n    return this.__editor.getEditorState().read(() =>\n      $nodesOfType(this.__nodeClass)\n        .filter(node => node.__pluginId === this.__id)\n        .map(node => node.getEntityData()),\n    );\n  }\n}\n\nfunction noop() {\n  return;\n}\n"],"names":["ChatInputEntityPluginBase","cleanup","_cleanup","insertChatInputEntity","props","key","undefined","__editor","update","text","data","entityProps","entityNode","__$createNode","__id","$insertNodes","selectEnd","$isRootOrShadowRoot","getParentOrThrow","$wrapNodeInElement","$createParagraphNode","getKey","removeChatInputEntity","keyOrPredicate","$nodesOfType","__nodeClass","filter","node","i","__pluginId","getEntityData","forEach","remove","$getNodeByKey","updateChatInputEntityProps","updateNode","newProps","updateEntityData","tag","getActiveEntities","getEditorState","read","map","constructor","editor","id","nodeClass","$createNode","$isChatInputEntityNode","onChatInputEntityAdded","onChatInputEntityDeleted","_define_property","__deleteDirection","mergeRegister","registerCommand","DELETE_CHARACTER_COMMAND","isBackward","COMMAND_PRIORITY_CRITICAL","registerNodeTransform","nextSibling","getNextSibling","$isDecoratorNode","selection","$getSelection","shouldMoveSelection","$isRangeSelection","isCollapsed","anchor","offset","getIndexWithinParent","$createTextNode","insertAfter","getPreviousSibling","insertBefore","registerMutationListener","nodes","payload","nodeKey","mutation","prevEditorState","noop"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/lib-commonjs/ChatInputEntity/ChatInputEntityPlugin.types.js

@@ -2,4 +2,3 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
- //# sourceMappingURL=ChatInputEntityPlugin.types.js.map

package/lib-commonjs/ChatInputEntity/index.js

@@ -9,4 +9,3 @@ Object.defineProperty(exports, "ChatInputEntityPluginBase", {
     }
 });
 const _ChatInputEntityPluginbase = require("./ChatInputEntityPlugin.base");
- //# sourceMappingURL=index.js.map