@fluentui-copilot/react-chat-input-plugins 0.0.0-nightly-20251010-0406-7df7c6d1.1 → 0.0.0-nightly-20251013-0406-7c7739c8.1

package/lib-commonjs/components/GhostText/index.js

@@ -0,0 +1,31 @@
+"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, {
+    GhostText: function() {
+        return _GhostText.GhostText;
+    },
+    ghostTextClassNames: function() {
+        return _useGhostTextStylesstyles.ghostTextClassNames;
+    },
+    renderGhostText_unstable: function() {
+        return _renderGhostText.renderGhostText_unstable;
+    },
+    useGhostTextStyles_unstable: function() {
+        return _useGhostTextStylesstyles.useGhostTextStyles_unstable;
+    },
+    useGhostText_unstable: function() {
+        return _useGhostText.useGhostText_unstable;
+    }
+});
+const _GhostText = require("./GhostText");
+const _renderGhostText = require("./renderGhostText");
+const _useGhostText = require("./useGhostText");
+const _useGhostTextStylesstyles = require("./useGhostTextStyles.styles");

package/lib-commonjs/components/GhostText/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["index.ts"],"sourcesContent":["export { GhostText } from './GhostText';\nexport type { GhostTextProps, GhostTextSlots, GhostTextState } from './GhostText.types';\nexport { renderGhostText_unstable } from './renderGhostText';\nexport { useGhostText_unstable } from './useGhostText';\nexport { ghostTextClassNames, useGhostTextStyles_unstable } from './useGhostTextStyles.styles';\n"],"names":["GhostText","ghostTextClassNames","renderGhostText_unstable","useGhostTextStyles_unstable","useGhostText_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAASA,SAAS;eAATA,oBAAS;;IAITC,mBAAmB;eAAnBA,6CAAmB;;IAFnBC,wBAAwB;eAAxBA,yCAAwB;;IAEHC,2BAA2B;eAA3BA,qDAA2B;;IADhDC,qBAAqB;eAArBA,mCAAqB;;;2BAHJ;iCAEe;8BACH;0CAC2B"}

package/lib-commonjs/components/GhostText/renderGhostText.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "renderGhostText_unstable", {
+    enumerable: true,
+    get: function() {
+        return renderGhostText_unstable;
+    }
+});
+const _jsxruntime = require("@fluentui/react-jsx-runtime/jsx-runtime");
+const _reactcomponents = require("@fluentui/react-components");
+const renderGhostText_unstable = (state)=>{
+    (0, _reactcomponents.assertSlots)(state);
+    return /*#__PURE__*/ (0, _jsxruntime.jsxs)(state.root, {
+        children: [
+            state.root.children,
+            state.indicator && /*#__PURE__*/ (0, _jsxruntime.jsx)(state.indicator, {})
+        ]
+    });
+};

package/lib-commonjs/components/GhostText/renderGhostText.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["renderGhostText.tsx"],"sourcesContent":["/** @jsxRuntime automatic */\n/** @jsxImportSource @fluentui/react-jsx-runtime */\n\nimport { assertSlots } from '@fluentui/react-components';\nimport type { JSXElement } from '@fluentui/react-components';\nimport type { GhostTextState, GhostTextSlots } from './GhostText.types';\n\n/**\n * Render the final JSX of GhostText\n */\nexport const renderGhostText_unstable = (state: GhostTextState): JSXElement => {\n  assertSlots<GhostTextSlots>(state);\n\n  return (\n    <state.root>\n      {state.root.children}\n      {state.indicator && <state.indicator />}\n    </state.root>\n  );\n};\n"],"names":["renderGhostText_unstable","state","assertSlots","_jsxs","root","children","indicator","_jsx"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAUaA;;;eAAAA;;;4BATb;iCAE4B;AAOrB,MAAMA,2BAA2B,CAACC;IACvCC,IAAAA,4BAAAA,EAA4BD;IAE5B,OAAA,WAAA,GACEE,IAAAA,gBAAA,EAACF,MAAMG,IAAI,EAAA;;YACRH,MAAMG,IAAI,CAACC,QAAQ;YACnBJ,MAAMK,SAAS,IAAA,WAAA,GAAIC,IAAAA,eAAA,EAACN,MAAMK,SAAS,EAAA,CAAA;;;AAG1C"}

package/lib-commonjs/components/GhostText/useGhostText.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useGhostText_unstable", {
+    enumerable: true,
+    get: function() {
+        return useGhostText_unstable;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _reactcomponents = require("@fluentui/react-components");
+const _reacttexteditor = require("@fluentui-copilot/react-text-editor");
+const useGhostText_unstable = (props, ref)=>{
+    const { nodeKey, onClick, ...rest } = props;
+    const [editor] = (0, _reacttexteditor.useLexicalComposerContext)();
+    const handleClick = _react.useCallback((_ev)=>{
+        if (!nodeKey) {
+            return;
+        }
+        editor.update(()=>{
+            var _node_getPreviousSibling;
+            const node = (0, _reacttexteditor.$getNodeByKey)(nodeKey);
+            node === null || node === void 0 ? void 0 : (_node_getPreviousSibling = node.getPreviousSibling()) === null || _node_getPreviousSibling === void 0 ? void 0 : _node_getPreviousSibling.selectEnd();
+        }, {
+            tag: 'historic'
+        });
+    }, [
+        editor,
+        nodeKey
+    ]);
+    const mergedOnClick = (0, _reactcomponents.mergeCallbacks)(handleClick, onClick);
+    const state = {
+        components: {
+            root: 'span',
+            indicator: 'span'
+        },
+        root: _reactcomponents.slot.always((0, _reactcomponents.getIntrinsicElementProps)('span', {
+            ref,
+            onClick: mergedOnClick,
+            ...rest
+        }), {
+            elementType: 'span'
+        }),
+        indicator: _reactcomponents.slot.optional(props.indicator, {
+            elementType: 'span'
+        })
+    };
+    return state;
+};

package/lib-commonjs/components/GhostText/useGhostText.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["useGhostText.ts"],"sourcesContent":["import * as React from 'react';\nimport { getIntrinsicElementProps, mergeCallbacks, slot } from '@fluentui/react-components';\nimport type { GhostTextProps, GhostTextState } from './GhostText.types';\nimport { $getNodeByKey, useLexicalComposerContext } from '@fluentui-copilot/react-text-editor';\n\n// If you add JSX to this file, be sure to change the file type to .tsx\n\n/**\n * Create the state required to render GhostText.\n *\n * The returned state can be modified with hooks such as useGhostTextStyles_unstable,\n * before being passed to renderGhostText_unstable.\n *\n * @param props - props from this instance of GhostText\n * @param ref - reference to root HTMLElement of GhostText\n */\nexport const useGhostText_unstable = (props: GhostTextProps, ref: React.Ref<HTMLSpanElement>): GhostTextState => {\n  const { nodeKey, onClick, ...rest } = props;\n  const [editor] = useLexicalComposerContext();\n\n  const handleClick = React.useCallback(\n    (_ev: React.MouseEvent<HTMLElement>) => {\n      if (!nodeKey) {\n        return;\n      }\n\n      editor.update(\n        () => {\n          const node = $getNodeByKey(nodeKey);\n          node?.getPreviousSibling()?.selectEnd();\n        },\n        { tag: 'historic' },\n      );\n    },\n    [editor, nodeKey],\n  );\n\n  const mergedOnClick = mergeCallbacks(handleClick, onClick);\n\n  const state: GhostTextState = {\n    components: {\n      root: 'span',\n      indicator: 'span',\n    },\n    root: slot.always(\n      getIntrinsicElementProps('span', {\n        ref,\n        onClick: mergedOnClick,\n        ...rest,\n      }),\n      { elementType: 'span' },\n    ),\n    indicator: slot.optional(props.indicator, { elementType: 'span' }),\n  };\n\n  return state;\n};\n"],"names":["useGhostText_unstable","props","ref","nodeKey","onClick","rest","editor","useLexicalComposerContext","handleClick","React","useCallback","_ev","update","node","$getNodeByKey","getPreviousSibling","selectEnd","tag","mergedOnClick","mergeCallbacks","state","components","root","indicator","slot","always","getIntrinsicElementProps","elementType","optional"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAgBaA;;;eAAAA;;;;iEAhBU;iCACwC;iCAEN;AAalD,MAAMA,wBAAwB,CAACC,OAAuBC;IAC3D,MAAM,EAAEC,OAAO,EAAEC,OAAO,EAAE,GAAGC,MAAM,GAAGJ;IACtC,MAAM,CAACK,OAAO,GAAGC,IAAAA,0CAAAA;IAEjB,MAAMC,cAAcC,OAAMC,WAAW,CACnC,CAACC;QACC,IAAI,CAACR,SAAS;YACZ;QACF;QAEAG,OAAOM,MAAM,CACX;gBAEEC;YADA,MAAMA,OAAOC,IAAAA,8BAAAA,EAAcX;YAC3BU,SAAAA,QAAAA,SAAAA,KAAAA,IAAAA,KAAAA,IAAAA,CAAAA,2BAAAA,KAAME,kBAAkB,EAAA,MAAA,QAAxBF,6BAAAA,KAAAA,IAAAA,KAAAA,IAAAA,yBAA4BG,SAAS;QACvC,GACA;YAAEC,KAAK;QAAW;IAEtB,GACA;QAACX;QAAQH;KAAQ;IAGnB,MAAMe,gBAAgBC,IAAAA,+BAAAA,EAAeX,aAAaJ;IAElD,MAAMgB,QAAwB;QAC5BC,YAAY;YACVC,MAAM;YACNC,WAAW;QACb;QACAD,MAAME,qBAAAA,CAAKC,MAAM,CACfC,IAAAA,yCAAAA,EAAyB,QAAQ;YAC/BxB;YACAE,SAASc;YACT,GAAGb,IAAI;QACT,IACA;YAAEsB,aAAa;QAAO;QAExBJ,WAAWC,qBAAAA,CAAKI,QAAQ,CAAC3B,MAAMsB,SAAS,EAAE;YAAEI,aAAa;QAAO;IAClE;IAEA,OAAOP;AACT"}

package/lib-commonjs/components/GhostText/useGhostTextStyles.styles.js

@@ -0,0 +1,98 @@
+"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, {
+    ghostTextClassNames: function() {
+        return ghostTextClassNames;
+    },
+    useGhostTextStyles_unstable: function() {
+        return useGhostTextStyles_unstable;
+    }
+});
+const _reactcomponents = require("@fluentui/react-components");
+const ghostTextClassNames = {
+    root: 'fai-GhostText',
+    indicator: 'fai-GhostText__indicator'
+};
+/**
+ * Styles for the root slot
+ */ const useStyles = (0, _reactcomponents.__styles)({
+    root: {
+        sj55zd: "fxc4j92",
+        Huce71: "fibxuh5",
+        i8kkvl: 0,
+        Belr9w4: 0,
+        rmohyg: "fkln5zr"
+    },
+    indicator: {
+        Bahqtrf: "fk6fouc",
+        Be2twd7: "f13mqy1h",
+        Bhrd7zp: "flh3ekv",
+        Bg96gwp: "fwrc4pm",
+        sj55zd: "f11d4kpn",
+        De3pzq: "f3vzo32",
+        Byoj8tv: 0,
+        uwmqm3: 0,
+        z189sj: 0,
+        z8tnut: 0,
+        B0ocmuz: "f1vo1c1k",
+        Beyfa6y: 0,
+        Bbmb7ep: 0,
+        Btl43ni: 0,
+        B7oj6ja: 0,
+        Dimara: "fq9zq91",
+        Frg6f3: [
+            "fbyavb5",
+            "fm0x6gh"
+        ],
+        Cd5d3v: "f1pc5kto"
+    }
+}, {
+    d: [
+        ".fxc4j92{color:var(--colorNeutralForeground4);}",
+        ".fibxuh5{white-space:pre-wrap;}",
+        [
+            ".fkln5zr{gap:var(--spacingHorizontalXS);}",
+            {
+                p: -1
+            }
+        ],
+        ".fk6fouc{font-family:var(--fontFamilyBase);}",
+        ".f13mqy1h{font-size:var(--fontSizeBase100);}",
+        ".flh3ekv{font-weight:var(--fontWeightBold);}",
+        ".fwrc4pm{line-height:var(--lineHeightBase200);}",
+        ".f11d4kpn{color:var(--colorNeutralForeground3);}",
+        ".f3vzo32{background-color:var(--colorNeutralBackground5);}",
+        [
+            ".f1vo1c1k{padding:var(--spacingVerticalNone) var(--spacingHorizontalSNudge);}",
+            {
+                p: -1
+            }
+        ],
+        [
+            ".fq9zq91{border-radius:var(--borderRadiusSmall);}",
+            {
+                p: -1
+            }
+        ],
+        ".fbyavb5{margin-left:var(--spacingHorizontalXS);}",
+        ".fm0x6gh{margin-right:var(--spacingHorizontalXS);}",
+        ".f1pc5kto{mergin-right:var(--spacingHorizontalXS);}"
+    ]
+});
+const useGhostTextStyles_unstable = (state)=>{
+    'use no memo';
+    const styles = useStyles();
+    state.root.className = (0, _reactcomponents.mergeClasses)(ghostTextClassNames.root, styles.root, state.root.className);
+    if (state.indicator) {
+        state.indicator.className = (0, _reactcomponents.mergeClasses)(ghostTextClassNames.indicator, styles.indicator, state.indicator.className);
+    }
+    return state;
+}; //# sourceMappingURL=useGhostTextStyles.styles.js.map

package/lib-commonjs/components/GhostText/useGhostTextStyles.styles.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["useGhostTextStyles.styles.ts"],"sourcesContent":["import { makeStyles, mergeClasses } from '@fluentui/react-components';\nimport { tokens, typographyStyles } from '@fluentui-copilot/tokens';\nimport type { GhostTextSlots, GhostTextState } from './GhostText.types';\nimport type { SlotClassNames } from '@fluentui/react-components';\n\nexport const ghostTextClassNames: SlotClassNames<GhostTextSlots> = {\n  root: 'fai-GhostText',\n  indicator: 'fai-GhostText__indicator',\n};\n\n/**\n * Styles for the root slot\n */\nconst useStyles = makeStyles({\n  root: {\n    color: tokens.colorNeutralForeground4,\n    whiteSpace: 'pre-wrap',\n    gap: tokens.spacingHorizontalXS,\n  },\n\n  indicator: {\n    ...typographyStyles.caption2Strong,\n    color: tokens.colorNeutralForeground3,\n    backgroundColor: tokens.colorNeutralBackground5,\n    padding: `${tokens.spacingVerticalNone} ${tokens.spacingHorizontalSNudge}`,\n    borderRadius: tokens.borderRadiusSmall,\n    marginLeft: tokens.spacingHorizontalXS,\n    merginRight: tokens.spacingHorizontalXS,\n  },\n});\n\n/**\n * Apply styling to the GhostText slots based on the state\n */\nexport const useGhostTextStyles_unstable = (state: GhostTextState): GhostTextState => {\n  'use no memo';\n\n  const styles = useStyles();\n  state.root.className = mergeClasses(ghostTextClassNames.root, styles.root, state.root.className);\n\n  if (state.indicator) {\n    state.indicator.className = mergeClasses(\n      ghostTextClassNames.indicator,\n      styles.indicator,\n      state.indicator.className,\n    );\n  }\n\n  return state;\n};\n"],"names":["ghostTextClassNames","root","indicator","__styles","color","whiteSpace","gap","i8kkvl","typographyStyles","backgroundColor","padding","borderRadius","marginLeft","merginRight","sj55zd","De3pzq","Byoj8tv","z189sj","z8tnut","B0ocmuz","styles","state","Bbmb7ep","B7oj6ja","Dimara","Frg6f3"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAKaA,mBAAAA;eAAAA;;;;;;iCALoB;AAK1B,MAAMA,sBAAsD;UACjEC;eACAC;AACF;AAEA;;CAEC,SAECD,YAAME,IAAAA,yBAAA,EAAA;UACJC;gBACAC;gBACAC;QACFC,QAAA;QAEAL,SAAAA;gBACKM;;eAEHC;iBACAC;iBACAC;iBACAC;iBACAC;QACFC,QAAA;QACFC,QAAA;QAEAC,SAAA;;QAGAC,QAAO;QACLC,QAAA;QAEAC,SAAMC;QACNC,SAAMpB;QAENqB,SAAID;iBACFA;QAKFE,SAAA;QAEAC,QAAOH;QACPI,QAAA;YAAA;YAAA;SAAA"}

package/lib-commonjs/components/GhostText/useGhostTextStyles.styles.raw.js

@@ -0,0 +1,51 @@
+"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, {
+    ghostTextClassNames: function() {
+        return ghostTextClassNames;
+    },
+    useGhostTextStyles_unstable: function() {
+        return useGhostTextStyles_unstable;
+    }
+});
+const _reactcomponents = require("@fluentui/react-components");
+const _tokens = require("@fluentui-copilot/tokens");
+const ghostTextClassNames = {
+    root: 'fai-GhostText',
+    indicator: 'fai-GhostText__indicator'
+};
+/**
+ * Styles for the root slot
+ */ const useStyles = (0, _reactcomponents.makeStyles)({
+    root: {
+        color: _tokens.tokens.colorNeutralForeground4,
+        whiteSpace: 'pre-wrap',
+        gap: _tokens.tokens.spacingHorizontalXS
+    },
+    indicator: {
+        ..._tokens.typographyStyles.caption2Strong,
+        color: _tokens.tokens.colorNeutralForeground3,
+        backgroundColor: _tokens.tokens.colorNeutralBackground5,
+        padding: `${_tokens.tokens.spacingVerticalNone} ${_tokens.tokens.spacingHorizontalSNudge}`,
+        borderRadius: _tokens.tokens.borderRadiusSmall,
+        marginLeft: _tokens.tokens.spacingHorizontalXS,
+        merginRight: _tokens.tokens.spacingHorizontalXS
+    }
+});
+const useGhostTextStyles_unstable = (state)=>{
+    'use no memo';
+    const styles = useStyles();
+    state.root.className = (0, _reactcomponents.mergeClasses)(ghostTextClassNames.root, styles.root, state.root.className);
+    if (state.indicator) {
+        state.indicator.className = (0, _reactcomponents.mergeClasses)(ghostTextClassNames.indicator, styles.indicator, state.indicator.className);
+    }
+    return state;
+};

package/lib-commonjs/components/GhostText/useGhostTextStyles.styles.raw.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["useGhostTextStyles.styles.ts"],"sourcesContent":["import { makeStyles, mergeClasses } from '@fluentui/react-components';\nimport { tokens, typographyStyles } from '@fluentui-copilot/tokens';\nimport type { GhostTextSlots, GhostTextState } from './GhostText.types';\nimport type { SlotClassNames } from '@fluentui/react-components';\n\nexport const ghostTextClassNames: SlotClassNames<GhostTextSlots> = {\n  root: 'fai-GhostText',\n  indicator: 'fai-GhostText__indicator',\n};\n\n/**\n * Styles for the root slot\n */\nconst useStyles = makeStyles({\n  root: {\n    color: tokens.colorNeutralForeground4,\n    whiteSpace: 'pre-wrap',\n    gap: tokens.spacingHorizontalXS,\n  },\n\n  indicator: {\n    ...typographyStyles.caption2Strong,\n    color: tokens.colorNeutralForeground3,\n    backgroundColor: tokens.colorNeutralBackground5,\n    padding: `${tokens.spacingVerticalNone} ${tokens.spacingHorizontalSNudge}`,\n    borderRadius: tokens.borderRadiusSmall,\n    marginLeft: tokens.spacingHorizontalXS,\n    merginRight: tokens.spacingHorizontalXS,\n  },\n});\n\n/**\n * Apply styling to the GhostText slots based on the state\n */\nexport const useGhostTextStyles_unstable = (state: GhostTextState): GhostTextState => {\n  'use no memo';\n\n  const styles = useStyles();\n  state.root.className = mergeClasses(ghostTextClassNames.root, styles.root, state.root.className);\n\n  if (state.indicator) {\n    state.indicator.className = mergeClasses(\n      ghostTextClassNames.indicator,\n      styles.indicator,\n      state.indicator.className,\n    );\n  }\n\n  return state;\n};\n"],"names":["ghostTextClassNames","useGhostTextStyles_unstable","root","indicator","useStyles","makeStyles","color","tokens","colorNeutralForeground4","whiteSpace","gap","spacingHorizontalXS","typographyStyles","caption2Strong","colorNeutralForeground3","backgroundColor","colorNeutralBackground5","padding","spacingVerticalNone","spacingHorizontalSNudge","borderRadius","borderRadiusSmall","marginLeft","merginRight","state","styles","className","mergeClasses"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAKaA,mBAAAA;eAAAA;;IA6BAC,2BAAAA;eAAAA;;;iCAlC4B;wBACA;AAIlC,MAAMD,sBAAsD;IACjEE,MAAM;IACNC,WAAW;AACb;AAEA;;CAEC,GACD,MAAMC,YAAYC,IAAAA,2BAAAA,EAAW;IAC3BH,MAAM;QACJI,OAAOC,cAAAA,CAAOC,uBAAuB;QACrCC,YAAY;QACZC,KAAKH,cAAAA,CAAOI,mBAAmB;IACjC;IAEAR,WAAW;QACT,GAAGS,wBAAAA,CAAiBC,cAAc;QAClCP,OAAOC,cAAAA,CAAOO,uBAAuB;QACrCC,iBAAiBR,cAAAA,CAAOS,uBAAuB;QAC/CC,SAAS,CAAC,EAAEV,cAAAA,CAAOW,mBAAmB,CAAC,CAAC,EAAEX,cAAAA,CAAOY,uBAAuB,CAAC,CAAC;QAC1EC,cAAcb,cAAAA,CAAOc,iBAAiB;QACtCC,YAAYf,cAAAA,CAAOI,mBAAmB;QACtCY,aAAahB,cAAAA,CAAOI,mBAAmB;IACzC;AACF;AAKO,MAAMV,8BAA8B,CAACuB;IAC1C;IAEA,MAAMC,SAASrB;IACfoB,MAAMtB,IAAI,CAACwB,SAAS,GAAGC,IAAAA,6BAAAA,EAAa3B,oBAAoBE,IAAI,EAAEuB,OAAOvB,IAAI,EAAEsB,MAAMtB,IAAI,CAACwB,SAAS;IAE/F,IAAIF,MAAMrB,SAAS,EAAE;QACnBqB,MAAMrB,SAAS,CAACuB,SAAS,GAAGC,IAAAA,6BAAAA,EAC1B3B,oBAAoBG,SAAS,EAC7BsB,OAAOtB,SAAS,EAChBqB,MAAMrB,SAAS,CAACuB,SAAS;IAE7B;IAEA,OAAOF;AACT"}

package/lib-commonjs/index.js

@@ -0,0 +1,108 @@
+"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, {
+    $createChatInputEntityNode: function() {
+        return _ChatInputEntity.$createChatInputEntityNode;
+    },
+    $createChatInputTokenNode: function() {
+        return _ChatInputToken.$createChatInputTokenNode;
+    },
+    $createGhostTextNode: function() {
+        return _GhostText.$createGhostTextNode;
+    },
+    $isChatInputEntityNode: function() {
+        return _ChatInputEntity.$isChatInputEntityNode;
+    },
+    $isChatInputTokenNode: function() {
+        return _ChatInputToken.$isChatInputTokenNode;
+    },
+    $isGhostTextNode: function() {
+        return _GhostText.$isGhostTextNode;
+    },
+    BasicFunctionalityPlugin: function() {
+        return _BasicFunctionality.BasicFunctionalityPlugin;
+    },
+    ChatInputEntity: function() {
+        return _ChatInputEntity.ChatInputEntity;
+    },
+    ChatInputEntityNode: function() {
+        return _ChatInputEntity.ChatInputEntityNode;
+    },
+    ChatInputEntityPlugin: function() {
+        return _ChatInputEntity.ChatInputEntityPlugin;
+    },
+    ChatInputToken: function() {
+        return _ChatInputToken.ChatInputToken;
+    },
+    ChatInputTokenNode: function() {
+        return _ChatInputToken.ChatInputTokenNode;
+    },
+    GhostText: function() {
+        return _GhostText.GhostText;
+    },
+    GhostTextNode: function() {
+        return _GhostText.GhostTextNode;
+    },
+    GhostTextPlugin: function() {
+        return _GhostText.GhostTextPlugin;
+    },
+    ImperativeControlPlugin: function() {
+        return _ImperativeControl.ImperativeControlPlugin;
+    },
+    ManualGhostTextPlugin: function() {
+        return _GhostText.ManualGhostTextPlugin;
+    },
+    PasteUnfurlingPlugin: function() {
+        return _PasteUnfurling.PasteUnfurlingPlugin;
+    },
+    chatInputEntityClassNames: function() {
+        return _ChatInputEntity.chatInputEntityClassNames;
+    },
+    chatInputTokenClassNames: function() {
+        return _ChatInputToken.chatInputTokenClassNames;
+    },
+    ghostTextClassNames: function() {
+        return _GhostText.ghostTextClassNames;
+    },
+    renderChatInputEntity_unstable: function() {
+        return _ChatInputEntity.renderChatInputEntity_unstable;
+    },
+    renderChatInputToken_unstable: function() {
+        return _ChatInputToken.renderChatInputToken_unstable;
+    },
+    renderGhostText_unstable: function() {
+        return _GhostText.renderGhostText_unstable;
+    },
+    useChatInputEntityStyles_unstable: function() {
+        return _ChatInputEntity.useChatInputEntityStyles_unstable;
+    },
+    useChatInputEntity_unstable: function() {
+        return _ChatInputEntity.useChatInputEntity_unstable;
+    },
+    useChatInputTokenStyles_unstable: function() {
+        return _ChatInputToken.useChatInputTokenStyles_unstable;
+    },
+    useChatInputToken_unstable: function() {
+        return _ChatInputToken.useChatInputToken_unstable;
+    },
+    useGhostTextStyles_unstable: function() {
+        return _GhostText.useGhostTextStyles_unstable;
+    },
+    useGhostText_unstable: function() {
+        return _GhostText.useGhostText_unstable;
+    }
+});
+const _ChatInputEntity = require("./ChatInputEntity");
+const _GhostText = require("./GhostText");
+const _ChatInputToken = require("./ChatInputToken");
+const _BasicFunctionality = require("./BasicFunctionality");
+const _ImperativeControl = require("./ImperativeControl");
+const _PasteUnfurling = require("./PasteUnfurling");

package/lib-commonjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["index.ts"],"sourcesContent":["export type {\n  ChatInputEntityProps,\n  ChatInputEntitySlots,\n  ChatInputEntityState,\n  ChatInputEntityPluginRef,\n  SerializedChatInputEntityNode,\n} from './ChatInputEntity';\nexport {\n  ChatInputEntity,\n  chatInputEntityClassNames,\n  renderChatInputEntity_unstable,\n  useChatInputEntityStyles_unstable,\n  useChatInputEntity_unstable,\n  ChatInputEntityNode,\n  ChatInputEntityPlugin,\n  $isChatInputEntityNode,\n  $createChatInputEntityNode,\n} from './ChatInputEntity';\n\nexport type {\n  GhostTextProps,\n  GhostTextSlots,\n  GhostTextState,\n  GhostTextPluginProps,\n  SerializedGhostTextNode,\n  ManualGhostTextRef,\n  ManualGhostTextProps,\n} from './GhostText';\nexport {\n  GhostText,\n  ghostTextClassNames,\n  renderGhostText_unstable,\n  useGhostTextStyles_unstable,\n  useGhostText_unstable,\n  GhostTextNode,\n  GhostTextPlugin,\n  $isGhostTextNode,\n  $createGhostTextNode,\n  ManualGhostTextPlugin,\n} from './GhostText';\n\nexport type {\n  ChatInputTokenProps,\n  ChatInputTokenSlots,\n  ChatInputTokenState,\n  SerializedChatInputTokenNode,\n} from './ChatInputToken';\nexport {\n  ChatInputToken,\n  ChatInputTokenNode,\n  chatInputTokenClassNames,\n  renderChatInputToken_unstable,\n  useChatInputTokenStyles_unstable,\n  useChatInputToken_unstable,\n  $createChatInputTokenNode,\n  $isChatInputTokenNode,\n} from './ChatInputToken';\n\nexport type { BasicFunctionalityPluginProps, BasicFunctionalityPluginRef } from './BasicFunctionality';\nexport { BasicFunctionalityPlugin } from './BasicFunctionality';\n\nexport type { ImperativeControlPluginProps, ImperativeControlPluginRef } from './ImperativeControl';\nexport { ImperativeControlPlugin } from './ImperativeControl';\n\nexport type { PasteUnfurlingPluginProps } from './PasteUnfurling';\nexport { PasteUnfurlingPlugin } from './PasteUnfurling';\n"],"names":["$createChatInputEntityNode","$createChatInputTokenNode","$createGhostTextNode","$isChatInputEntityNode","$isChatInputTokenNode","$isGhostTextNode","BasicFunctionalityPlugin","ChatInputEntity","ChatInputEntityNode","ChatInputEntityPlugin","ChatInputToken","ChatInputTokenNode","GhostText","GhostTextNode","GhostTextPlugin","ImperativeControlPlugin","ManualGhostTextPlugin","PasteUnfurlingPlugin","chatInputEntityClassNames","chatInputTokenClassNames","ghostTextClassNames","renderChatInputEntity_unstable","renderChatInputToken_unstable","renderGhostText_unstable","useChatInputEntityStyles_unstable","useChatInputEntity_unstable","useChatInputTokenStyles_unstable","useChatInputToken_unstable","useGhostTextStyles_unstable","useGhostText_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAgBEA,0BAA0B;eAA1BA,2CAA0B;;IAsC1BC,yBAAyB;eAAzBA,yCAAyB;;IAjBzBC,oBAAoB;eAApBA,+BAAoB;;IAtBpBC,sBAAsB;eAAtBA,uCAAsB;;IAwCtBC,qBAAqB;eAArBA,qCAAqB;;IAnBrBC,gBAAgB;eAAhBA,2BAAgB;;IAuBTC,wBAAwB;eAAxBA,4CAAwB;;IAnD/BC,eAAe;eAAfA,gCAAe;;IAKfC,mBAAmB;eAAnBA,oCAAmB;;IACnBC,qBAAqB;eAArBA,sCAAqB;;IAkCrBC,cAAc;eAAdA,8BAAc;;IACdC,kBAAkB;eAAlBA,kCAAkB;;IApBlBC,SAAS;eAATA,oBAAS;;IAKTC,aAAa;eAAbA,wBAAa;;IACbC,eAAe;eAAfA,0BAAe;;IA2BRC,uBAAuB;eAAvBA,0CAAuB;;IAxB9BC,qBAAqB;eAArBA,gCAAqB;;IA2BdC,oBAAoB;eAApBA,oCAAoB;;IAxD3BC,yBAAyB;eAAzBA,0CAAyB;;IAyCzBC,wBAAwB;eAAxBA,wCAAwB;;IApBxBC,mBAAmB;eAAnBA,8BAAmB;;IApBnBC,8BAA8B;eAA9BA,+CAA8B;;IAyC9BC,6BAA6B;eAA7BA,6CAA6B;;IApB7BC,wBAAwB;eAAxBA,mCAAwB;;IApBxBC,iCAAiC;eAAjCA,kDAAiC;;IACjCC,2BAA2B;eAA3BA,4CAA2B;;IAwC3BC,gCAAgC;eAAhCA,gDAAgC;;IAChCC,0BAA0B;eAA1BA,0CAA0B;;IArB1BC,2BAA2B;eAA3BA,sCAA2B;;IAC3BC,qBAAqB;eAArBA,gCAAqB;;;iCAhBhB;2BAsBA;gCAiBA;oCAGkC;mCAGD;gCAGH"}

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

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "BasicFunctionalityPlugin", {
+    enumerable: true,
+    get: function() {
+        return BasicFunctionalityPlugin;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _reacttexteditor = require("@fluentui-copilot/react-text-editor");
+const _reactcomponents = require("@fluentui/react-components");
+const _chatinputplugins = require("@fluentui-copilot/chat-input-plugins");
+const BasicFunctionalityPlugin = /*#__PURE__*/ _react.forwardRef((props, ref)=>{
+    const { trimWhitespace, onCountChanged, onContentChange, onPaste, isSentinelNodeEnabled } = props;
+    const [editor] = (0, _reacttexteditor.useLexicalComposerContext)();
+    const [basicFunctionalityImpl, setBasicFunctionalityImpl] = _react.useState(null);
+    (0, _reactcomponents.useIsomorphicLayoutEffect)(()=>{
+        setBasicFunctionalityImpl(new _chatinputplugins.BasicFunctionalityBase(editor, isSentinelNodeEnabled));
+        return ()=>{
+            setBasicFunctionalityImpl((prev)=>{
+                prev === null || prev === void 0 ? void 0 : prev.cleanup();
+                return null;
+            });
+        };
+    }, [
+        editor,
+        isSentinelNodeEnabled
+    ]);
+    _react.useImperativeHandle(ref, ()=>({
+            setIsDisabled (isDisabled) {
+                basicFunctionalityImpl === null || basicFunctionalityImpl === void 0 ? void 0 : basicFunctionalityImpl.setIsDisabled(isDisabled);
+            }
+        }), [
+        basicFunctionalityImpl
+    ]);
+    _react.useEffect(()=>{
+        basicFunctionalityImpl === null || basicFunctionalityImpl === void 0 ? void 0 : basicFunctionalityImpl.activateContentCallbacks(onContentChange, onCountChanged);
+        return ()=>basicFunctionalityImpl === null || basicFunctionalityImpl === void 0 ? void 0 : basicFunctionalityImpl.deactivateContentCallbacks();
+    }, [
+        basicFunctionalityImpl,
+        editor,
+        onContentChange,
+        onCountChanged
+    ]);
+    _react.useEffect(()=>{
+        if (onPaste) {
+            basicFunctionalityImpl === null || basicFunctionalityImpl === void 0 ? void 0 : basicFunctionalityImpl.activatePasteCallback(onPaste);
+        }
+        return ()=>basicFunctionalityImpl === null || basicFunctionalityImpl === void 0 ? void 0 : basicFunctionalityImpl.deactivatePasteCallback();
+    }, [
+        basicFunctionalityImpl,
+        editor,
+        onPaste
+    ]);
+    _react.useEffect(()=>{
+        if (trimWhitespace) {
+            basicFunctionalityImpl === null || basicFunctionalityImpl === void 0 ? void 0 : basicFunctionalityImpl.activateTrimWhitespace();
+        }
+        return ()=>basicFunctionalityImpl === null || basicFunctionalityImpl === void 0 ? void 0 : basicFunctionalityImpl.deactivateTrimWhitespace();
+    }, [
+        basicFunctionalityImpl,
+        editor,
+        trimWhitespace
+    ]);
+    return null;
+});

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

@@ -0,0 +1 @@
+{"version":3,"sources":["BasicFunctionality.ts"],"sourcesContent":["import * as React from 'react';\nimport { useLexicalComposerContext } from '@fluentui-copilot/react-text-editor';\nimport { useIsomorphicLayoutEffect } from '@fluentui/react-components';\nimport type { IBasicFunctionalityBase } from '@fluentui-copilot/chat-input-plugins';\nimport { BasicFunctionalityBase } from '@fluentui-copilot/chat-input-plugins';\n\nexport type BasicFunctionalityPluginProps = {\n  // Whether or not to clear the input when only whitespace is remaining\n  trimWhitespace?: boolean;\n  onCountChanged?: (count: number) => void;\n  onContentChange?: (value: string) => void;\n  onPaste?: (event: ClipboardEvent) => void;\n  isSentinelNodeEnabled?: boolean;\n};\n\nexport type BasicFunctionalityPluginRef = {\n  setIsDisabled: (isDisabled: boolean) => void;\n};\n\nexport const BasicFunctionalityPlugin = React.forwardRef<BasicFunctionalityPluginRef, BasicFunctionalityPluginProps>(\n  (props, ref) => {\n    const { trimWhitespace, onCountChanged, onContentChange, onPaste, isSentinelNodeEnabled } = props;\n\n    const [editor] = useLexicalComposerContext();\n\n    const [basicFunctionalityImpl, setBasicFunctionalityImpl] = React.useState<IBasicFunctionalityBase | null>(null);\n\n    useIsomorphicLayoutEffect(() => {\n      setBasicFunctionalityImpl(new BasicFunctionalityBase(editor, isSentinelNodeEnabled));\n\n      return () => {\n        setBasicFunctionalityImpl(prev => {\n          prev?.cleanup();\n          return null;\n        });\n      };\n    }, [editor, isSentinelNodeEnabled]);\n\n    React.useImperativeHandle<BasicFunctionalityPluginRef, BasicFunctionalityPluginRef>(\n      ref,\n      () => ({\n        setIsDisabled(isDisabled: boolean) {\n          basicFunctionalityImpl?.setIsDisabled(isDisabled);\n        },\n      }),\n      [basicFunctionalityImpl],\n    );\n\n    React.useEffect(() => {\n      basicFunctionalityImpl?.activateContentCallbacks(onContentChange, onCountChanged);\n      return () => basicFunctionalityImpl?.deactivateContentCallbacks();\n    }, [basicFunctionalityImpl, editor, onContentChange, onCountChanged]);\n\n    React.useEffect(() => {\n      if (onPaste) {\n        basicFunctionalityImpl?.activatePasteCallback(onPaste);\n      }\n      return () => basicFunctionalityImpl?.deactivatePasteCallback();\n    }, [basicFunctionalityImpl, editor, onPaste]);\n\n    React.useEffect(() => {\n      if (trimWhitespace) {\n        basicFunctionalityImpl?.activateTrimWhitespace();\n      }\n      return () => basicFunctionalityImpl?.deactivateTrimWhitespace();\n    }, [basicFunctionalityImpl, editor, trimWhitespace]);\n\n    return null;\n  },\n);\n"],"names":["BasicFunctionalityPlugin","React","forwardRef","props","ref","trimWhitespace","onCountChanged","onContentChange","onPaste","isSentinelNodeEnabled","editor","useLexicalComposerContext","basicFunctionalityImpl","setBasicFunctionalityImpl","useState","useIsomorphicLayoutEffect","BasicFunctionalityBase","prev","cleanup","useImperativeHandle","setIsDisabled","isDisabled","useEffect","activateContentCallbacks","deactivateContentCallbacks","activatePasteCallback","deactivatePasteCallback","activateTrimWhitespace","deactivateTrimWhitespace"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAmBaA;;;eAAAA;;;;iEAnBU;iCACmB;iCACA;kCAEH;AAehC,MAAMA,yCAA2BC,OAAMC,UAAU,CACtD,CAACC,OAAOC;IACN,MAAM,EAAEC,cAAc,EAAEC,cAAc,EAAEC,eAAe,EAAEC,OAAO,EAAEC,qBAAqB,EAAE,GAAGN;IAE5F,MAAM,CAACO,OAAO,GAAGC,IAAAA,0CAAAA;IAEjB,MAAM,CAACC,wBAAwBC,0BAA0B,GAAGZ,OAAMa,QAAQ,CAAiC;IAE3GC,IAAAA,0CAAAA,EAA0B;QACxBF,0BAA0B,IAAIG,wCAAAA,CAAuBN,QAAQD;QAE7D,OAAO;YACLI,0BAA0BI,CAAAA;gBACxBA,SAAAA,QAAAA,SAAAA,KAAAA,IAAAA,KAAAA,IAAAA,KAAMC,OAAO;gBACb,OAAO;YACT;QACF;IACF,GAAG;QAACR;QAAQD;KAAsB;IAElCR,OAAMkB,mBAAmB,CACvBf,KACA,IAAO,CAAA;YACLgB,eAAcC,UAAmB;gBAC/BT,2BAAAA,QAAAA,2BAAAA,KAAAA,IAAAA,KAAAA,IAAAA,uBAAwBQ,aAAa,CAACC;YACxC;QACF,CAAA,GACA;QAACT;KAAuB;IAG1BX,OAAMqB,SAAS,CAAC;QACdV,2BAAAA,QAAAA,2BAAAA,KAAAA,IAAAA,KAAAA,IAAAA,uBAAwBW,wBAAwB,CAAChB,iBAAiBD;QAClE,OAAO,IAAMM,2BAAAA,QAAAA,2BAAAA,KAAAA,IAAAA,KAAAA,IAAAA,uBAAwBY,0BAA0B;IACjE,GAAG;QAACZ;QAAwBF;QAAQH;QAAiBD;KAAe;IAEpEL,OAAMqB,SAAS,CAAC;QACd,IAAId,SAAS;YACXI,2BAAAA,QAAAA,2BAAAA,KAAAA,IAAAA,KAAAA,IAAAA,uBAAwBa,qBAAqB,CAACjB;QAChD;QACA,OAAO,IAAMI,2BAAAA,QAAAA,2BAAAA,KAAAA,IAAAA,KAAAA,IAAAA,uBAAwBc,uBAAuB;IAC9D,GAAG;QAACd;QAAwBF;QAAQF;KAAQ;IAE5CP,OAAMqB,SAAS,CAAC;QACd,IAAIjB,gBAAgB;YAClBO,2BAAAA,QAAAA,2BAAAA,KAAAA,IAAAA,KAAAA,IAAAA,uBAAwBe,sBAAsB;QAChD;QACA,OAAO,IAAMf,2BAAAA,QAAAA,2BAAAA,KAAAA,IAAAA,KAAAA,IAAAA,uBAAwBgB,wBAAwB;IAC/D,GAAG;QAAChB;QAAwBF;QAAQL;KAAe;IAEnD,OAAO;AACT"}

package/lib-commonjs/plugins/BasicFunctionality/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "BasicFunctionalityPlugin", {
+    enumerable: true,
+    get: function() {
+        return _BasicFunctionality.BasicFunctionalityPlugin;
+    }
+});
+const _BasicFunctionality = require("./BasicFunctionality");

package/lib-commonjs/plugins/BasicFunctionality/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["index.ts"],"sourcesContent":["export type { BasicFunctionalityPluginProps, BasicFunctionalityPluginRef } from './BasicFunctionality';\nexport { BasicFunctionalityPlugin } from './BasicFunctionality';\n"],"names":["BasicFunctionalityPlugin"],"rangeMappings":";;;;;;;;;;","mappings":";;;;+BACSA;;;eAAAA,4CAAwB;;;oCAAQ"}

package/lib-commonjs/plugins/ChatInputEntity/ChatInputEntity.node.js

@@ -0,0 +1,100 @@
+"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, {
+    $createChatInputEntityNode: function() {
+        return $createChatInputEntityNode;
+    },
+    $isChatInputEntityNode: function() {
+        return $isChatInputEntityNode;
+    },
+    ChatInputEntityNode: function() {
+        return ChatInputEntityNode;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _define_property = require("@swc/helpers/_/_define_property");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _texteditor = require("@fluentui-copilot/text-editor");
+const _ChatInputEntity = require("../../ChatInputEntity");
+class ChatInputEntityNode extends _texteditor.DecoratorNode {
+    static getType() {
+        return 'entity';
+    }
+    static clone(node) {
+        return new ChatInputEntityNode(node.__pluginId, node.__text, node.__data, node.__entityProps, node.__key);
+    }
+    static importJSON(serializedNode) {
+        return $createChatInputEntityNode(serializedNode.pluginId, serializedNode.text, serializedNode.data, serializedNode.entityProps);
+    }
+    isIsolated() {
+        return true;
+    }
+    isInline() {
+        return true;
+    }
+    getTextContent() {
+        return this.__text;
+    }
+    exportJSON() {
+        return {
+            pluginId: this.__pluginId,
+            text: this.__text,
+            data: this.__data,
+            entityProps: this.__entityProps,
+            type: ChatInputEntityNode.getType(),
+            version: 1
+        };
+    }
+    createDOM() {
+        // eslint-disable-next-line no-restricted-globals
+        return document.createElement('span');
+    }
+    updateDOM() {
+        return false;
+    }
+    decorate(_editor, config) {
+        var _this___entityProps;
+        if ((_this___entityProps = this.__entityProps) === null || _this___entityProps === void 0 ? void 0 : _this___entityProps.children) {
+            return /*#__PURE__*/ _react.createElement(_ChatInputEntity.ChatInputEntity, this.__entityProps);
+        }
+        return /*#__PURE__*/ _react.createElement(_ChatInputEntity.ChatInputEntity, this.__entityProps, this.__text);
+    }
+    getEntityData() {
+        return {
+            text: this.__text,
+            data: this.__data,
+            entityProps: this.__entityProps
+        };
+    }
+    updateEntityData(data) {
+        const writable = this.getWritable();
+        writable.__text = data.text;
+        writable.__data = data.data;
+        writable.__entityProps = data.entityProps;
+    }
+    constructor(pluginId, text, data, entityProps, key){
+        super(key);
+        (0, _define_property._)(this, "__pluginId", void 0);
+        (0, _define_property._)(this, "__text", void 0);
+        (0, _define_property._)(this, "__entityProps", void 0);
+        (0, _define_property._)(this, "__data", void 0);
+        this.__pluginId = pluginId;
+        this.__text = text;
+        this.__data = data;
+        this.__entityProps = entityProps;
+    }
+}
+function $createChatInputEntityNode(pluginId, text, data, entityProps, key) {
+    return new ChatInputEntityNode(pluginId, text, data, entityProps, key);
+}
+function $isChatInputEntityNode(node) {
+    return node instanceof ChatInputEntityNode;
+}

package/lib-commonjs/plugins/ChatInputEntity/ChatInputEntity.node.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["ChatInputEntity.node.tsx"],"sourcesContent":["import * as React from 'react';\n\nimport { DecoratorNode } from '@fluentui-copilot/text-editor';\nimport type {\n  EditorConfig,\n  LexicalEditor,\n  LexicalNode,\n  NodeKey,\n  SerializedLexicalNode,\n  Spread,\n} from '@fluentui-copilot/text-editor';\nimport type { JSXElement } from '@fluentui/react-components';\nimport type { ChatInputEntityProps } from '../../ChatInputEntity';\nimport { ChatInputEntity } from '../../ChatInputEntity';\nimport type { ChatInputEntityData } from '@fluentui-copilot/chat-input-plugins';\n\nexport type SerializedChatInputEntityNode<T> = Spread<\n  { pluginId: string; text: string; data?: T; entityProps?: ChatInputEntityProps },\n  SerializedLexicalNode\n>;\n\nexport class ChatInputEntityNode<T> extends DecoratorNode<JSXElement | null> {\n  __pluginId: string;\n  __text: string;\n  __entityProps?: ChatInputEntityProps;\n  __data?: T;\n\n  static getType(): string {\n    return 'entity';\n  }\n  static clone<T>(node: ChatInputEntityNode<T>): ChatInputEntityNode<T> {\n    return new ChatInputEntityNode(node.__pluginId, node.__text, node.__data, node.__entityProps, node.__key);\n  }\n\n  static importJSON<T>(serializedNode: SerializedChatInputEntityNode<T>): ChatInputEntityNode<T> {\n    return $createChatInputEntityNode(\n      serializedNode.pluginId,\n      serializedNode.text,\n      serializedNode.data,\n      serializedNode.entityProps,\n    );\n  }\n\n  isIsolated(): boolean {\n    return true;\n  }\n  isInline(): boolean {\n    return true;\n  }\n\n  getTextContent(): string {\n    return this.__text;\n  }\n\n  exportJSON(): SerializedChatInputEntityNode<T> {\n    return {\n      pluginId: this.__pluginId,\n      text: this.__text,\n      data: this.__data,\n      entityProps: this.__entityProps,\n      type: ChatInputEntityNode.getType(),\n      version: 1,\n    };\n  }\n\n  constructor(pluginId: string, text: string, data?: T, entityProps?: ChatInputEntityProps, key?: NodeKey) {\n    super(key);\n    this.__pluginId = pluginId;\n    this.__text = text;\n    this.__data = data;\n    this.__entityProps = entityProps;\n  }\n\n  createDOM(): HTMLElement {\n    // eslint-disable-next-line no-restricted-globals\n    return document.createElement('span');\n  }\n\n  updateDOM(): boolean {\n    return false;\n  }\n\n  decorate(_editor: LexicalEditor, config: EditorConfig): JSXElement | null {\n    if (this.__entityProps?.children) {\n      return <ChatInputEntity {...this.__entityProps} />;\n    }\n    return <ChatInputEntity {...this.__entityProps}>{this.__text}</ChatInputEntity>;\n  }\n\n  getEntityData(): ChatInputEntityData<T, ChatInputEntityProps> {\n    return {\n      text: this.__text,\n      data: this.__data,\n      entityProps: this.__entityProps,\n    };\n  }\n\n  updateEntityData(data: ChatInputEntityData<T, ChatInputEntityProps>): void {\n    const writable = this.getWritable();\n    writable.__text = data.text;\n    writable.__data = data.data;\n    writable.__entityProps = data.entityProps;\n  }\n}\n\nexport function $createChatInputEntityNode<T>(\n  pluginId: string,\n  text: string,\n  data?: T,\n  entityProps?: ChatInputEntityProps,\n  key?: NodeKey,\n): ChatInputEntityNode<T> {\n  return new ChatInputEntityNode(pluginId, text, data, entityProps, key);\n}\n\nexport function $isChatInputEntityNode<T>(node: LexicalNode | null | undefined): node is ChatInputEntityNode<T> {\n  return node instanceof ChatInputEntityNode;\n}\n"],"names":["$createChatInputEntityNode","$isChatInputEntityNode","ChatInputEntityNode","DecoratorNode","getType","clone","node","__pluginId","__text","__data","__entityProps","__key","importJSON","serializedNode","pluginId","text","data","entityProps","isIsolated","isInline","getTextContent","exportJSON","type","version","createDOM","document","createElement","updateDOM","decorate","_editor","config","_this___entityProps","children","React","ChatInputEntity","getEntityData","updateEntityData","writable","getWritable","constructor","key"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAyGgBA,0BAAAA;eAAAA;;IAUAC,sBAAAA;eAAAA;;IA9FHC,mBAAAA;eAAAA;;;;;iEArBU;4BAEO;iCAWE;AAQzB,MAAMA,4BAA+BC,yBAAAA;IAM1C,OAAOC,UAAkB;QACvB,OAAO;IACT;IACA,OAAOC,MAASC,IAA4B,EAA0B;QACpE,OAAO,IAAIJ,oBAAoBI,KAAKC,UAAU,EAAED,KAAKE,MAAM,EAAEF,KAAKG,MAAM,EAAEH,KAAKI,aAAa,EAAEJ,KAAKK,KAAK;IAC1G;IAEA,OAAOC,WAAcC,cAAgD,EAA0B;QAC7F,OAAOb,2BACLa,eAAeC,QAAQ,EACvBD,eAAeE,IAAI,EACnBF,eAAeG,IAAI,EACnBH,eAAeI,WAAW;IAE9B;IAEAC,aAAsB;QACpB,OAAO;IACT;IACAC,WAAoB;QAClB,OAAO;IACT;IAEAC,iBAAyB;QACvB,OAAO,IAAI,CAACZ,MAAM;IACpB;IAEAa,aAA+C;QAC7C,OAAO;YACLP,UAAU,IAAI,CAACP,UAAU;YACzBQ,MAAM,IAAI,CAACP,MAAM;YACjBQ,MAAM,IAAI,CAACP,MAAM;YACjBQ,aAAa,IAAI,CAACP,aAAa;YAC/BY,MAAMpB,oBAAoBE,OAAO;YACjCmB,SAAS;QACX;IACF;IAUAC,YAAyB;QACvB,iDAAiD;QACjD,OAAOC,SAASC,aAAa,CAAC;IAChC;IAEAC,YAAqB;QACnB,OAAO;IACT;IAEAC,SAASC,OAAsB,EAAEC,MAAoB,EAAqB;YACpEC;QAAJ,IAAA,AAAIA,CAAAA,sBAAA,IAAI,CAACrB,aAAa,AAAbA,MAAa,QAAlBqB,wBAAA,KAAA,IAAA,KAAA,IAAAA,oBAAoBC,QAAQ,EAAE;YAChC,OAAA,WAAA,GAAOC,OAAAP,aAAA,CAACQ,gCAAAA,EAAoB,IAAI,CAACxB,aAAa;QAChD;QACA,OAAA,WAAA,GAAOuB,OAAAP,aAAA,CAACQ,gCAAAA,EAAoB,IAAI,CAACxB,aAAa,EAAG,IAAI,CAACF,MAAM;IAC9D;IAEA2B,gBAA8D;QAC5D,OAAO;YACLpB,MAAM,IAAI,CAACP,MAAM;YACjBQ,MAAM,IAAI,CAACP,MAAM;YACjBQ,aAAa,IAAI,CAACP,aAAa;QACjC;IACF;IAEA0B,iBAAiBpB,IAAkD,EAAQ;QACzE,MAAMqB,WAAW,IAAI,CAACC,WAAW;QACjCD,SAAS7B,MAAM,GAAGQ,KAAKD,IAAI;QAC3BsB,SAAS5B,MAAM,GAAGO,KAAKA,IAAI;QAC3BqB,SAAS3B,aAAa,GAAGM,KAAKC,WAAW;IAC3C;IArCAsB,YAAYzB,QAAgB,EAAEC,IAAY,EAAEC,IAAQ,EAAEC,WAAkC,EAAEuB,GAAa,CAAE;QACvG,KAAK,CAACA;QA5CRjC,IAAAA,kBAAAA,EAAAA,IAAAA,EAAAA,cAAAA,KAAAA;QACAC,IAAAA,kBAAAA,EAAAA,IAAAA,EAAAA,UAAAA,KAAAA;QACAE,IAAAA,kBAAAA,EAAAA,IAAAA,EAAAA,iBAAAA,KAAAA;QACAD,IAAAA,kBAAAA,EAAAA,IAAAA,EAAAA,UAAAA,KAAAA;QA0CE,IAAI,CAACF,UAAU,GAAGO;QAClB,IAAI,CAACN,MAAM,GAAGO;QACd,IAAI,CAACN,MAAM,GAAGO;QACd,IAAI,CAACN,aAAa,GAAGO;IACvB;AAgCF;AAEO,SAASjB,2BACdc,QAAgB,EAChBC,IAAY,EACZC,IAAQ,EACRC,WAAkC,EAClCuB,GAAa;IAEb,OAAO,IAAItC,oBAAoBY,UAAUC,MAAMC,MAAMC,aAAauB;AACpE;AAEO,SAASvC,uBAA0BK,IAAoC;IAC5E,OAAOA,gBAAgBJ;AACzB"}