@payloadcms/richtext-lexical 3.0.0-beta.5 → 3.0.0-beta.50

package/dist/field/features/horizontalRule/feature.client.js

@@ -0,0 +1,77 @@
+'use client';
+import { $isNodeSelection } from 'lexical';
+import { HorizontalRuleIcon } from '../../lexical/ui/icons/HorizontalRule/index.js';
+import { createClientComponent } from '../createClientComponent.js';
+import { slashMenuBasicGroupWithItems } from '../shared/slashMenu/basicGroup.js';
+import { toolbarAddDropdownGroupWithItems } from '../shared/toolbar/addDropdownGroup.js';
+import { MarkdownTransformer } from './markdownTransformer.js';
+import { $isHorizontalRuleNode, HorizontalRuleNode, INSERT_HORIZONTAL_RULE_COMMAND } from './nodes/HorizontalRuleNode.js';
+import { HorizontalRulePlugin } from './plugin/index.js';
+const HorizontalRuleFeatureClient = (props)=>{
+    return {
+        clientFeatureProps: props,
+        feature: ()=>({
+                clientFeatureProps: props,
+                markdownTransformers: [
+                    MarkdownTransformer
+                ],
+                nodes: [
+                    HorizontalRuleNode
+                ],
+                plugins: [
+                    {
+                        Component: HorizontalRulePlugin,
+                        position: 'normal'
+                    }
+                ],
+                slashMenu: {
+                    groups: [
+                        slashMenuBasicGroupWithItems([
+                            {
+                                Icon: HorizontalRuleIcon,
+                                key: 'horizontalRule',
+                                keywords: [
+                                    'hr',
+                                    'horizontal rule',
+                                    'line',
+                                    'separator'
+                                ],
+                                label: ({ i18n })=>{
+                                    return i18n.t('lexical:horizontalRule:label');
+                                },
+                                onSelect: ({ editor })=>{
+                                    editor.dispatchCommand(INSERT_HORIZONTAL_RULE_COMMAND, undefined);
+                                }
+                            }
+                        ])
+                    ]
+                },
+                toolbarFixed: {
+                    groups: [
+                        toolbarAddDropdownGroupWithItems([
+                            {
+                                ChildComponent: HorizontalRuleIcon,
+                                isActive: ({ selection })=>{
+                                    if (!$isNodeSelection(selection) || !selection.getNodes().length) {
+                                        return false;
+                                    }
+                                    const firstNode = selection.getNodes()[0];
+                                    return $isHorizontalRuleNode(firstNode);
+                                },
+                                key: 'horizontalRule',
+                                label: ({ i18n })=>{
+                                    return i18n.t('lexical:horizontalRule:label');
+                                },
+                                onSelect: ({ editor })=>{
+                                    editor.dispatchCommand(INSERT_HORIZONTAL_RULE_COMMAND, undefined);
+                                }
+                            }
+                        ])
+                    ]
+                }
+            })
+    };
+};
+export const HorizontalRuleFeatureClientComponent = createClientComponent(HorizontalRuleFeatureClient);
+
+//# sourceMappingURL=feature.client.js.map

package/dist/field/features/horizontalRule/feature.client.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/field/features/horizontalRule/feature.client.tsx"],"sourcesContent":["'use client'\n\nimport type { ClientTranslationKeys } from '@payloadcms/translations'\n\nimport { $isNodeSelection } from 'lexical'\n\nimport type { FeatureProviderProviderClient } from '../types.js'\n\nimport { HorizontalRuleIcon } from '../../lexical/ui/icons/HorizontalRule/index.js'\nimport { createClientComponent } from '../createClientComponent.js'\nimport { slashMenuBasicGroupWithItems } from '../shared/slashMenu/basicGroup.js'\nimport { toolbarAddDropdownGroupWithItems } from '../shared/toolbar/addDropdownGroup.js'\nimport { MarkdownTransformer } from './markdownTransformer.js'\nimport {\n  $isHorizontalRuleNode,\n  HorizontalRuleNode,\n  INSERT_HORIZONTAL_RULE_COMMAND,\n} from './nodes/HorizontalRuleNode.js'\nimport { HorizontalRulePlugin } from './plugin/index.js'\n\nconst HorizontalRuleFeatureClient: FeatureProviderProviderClient<undefined> = (props) => {\n  return {\n    clientFeatureProps: props,\n    feature: () => ({\n      clientFeatureProps: props,\n      markdownTransformers: [MarkdownTransformer],\n      nodes: [HorizontalRuleNode],\n      plugins: [\n        {\n          Component: HorizontalRulePlugin,\n          position: 'normal',\n        },\n      ],\n      slashMenu: {\n        groups: [\n          slashMenuBasicGroupWithItems([\n            {\n              Icon: HorizontalRuleIcon,\n              key: 'horizontalRule',\n              keywords: ['hr', 'horizontal rule', 'line', 'separator'],\n              label: ({ i18n }) => {\n                return i18n.t('lexical:horizontalRule:label')\n              },\n\n              onSelect: ({ editor }) => {\n                editor.dispatchCommand(INSERT_HORIZONTAL_RULE_COMMAND, undefined)\n              },\n            },\n          ]),\n        ],\n      },\n\n      toolbarFixed: {\n        groups: [\n          toolbarAddDropdownGroupWithItems([\n            {\n              ChildComponent: HorizontalRuleIcon,\n              isActive: ({ selection }) => {\n                if (!$isNodeSelection(selection) || !selection.getNodes().length) {\n                  return false\n                }\n\n                const firstNode = selection.getNodes()[0]\n                return $isHorizontalRuleNode(firstNode)\n              },\n              key: 'horizontalRule',\n              label: ({ i18n }) => {\n                return i18n.t('lexical:horizontalRule:label')\n              },\n              onSelect: ({ editor }) => {\n                editor.dispatchCommand(INSERT_HORIZONTAL_RULE_COMMAND, undefined)\n              },\n            },\n          ]),\n        ],\n      },\n    }),\n  }\n}\n\nexport const HorizontalRuleFeatureClientComponent = createClientComponent(\n  HorizontalRuleFeatureClient,\n)\n"],"names":["$isNodeSelection","HorizontalRuleIcon","createClientComponent","slashMenuBasicGroupWithItems","toolbarAddDropdownGroupWithItems","MarkdownTransformer","$isHorizontalRuleNode","HorizontalRuleNode","INSERT_HORIZONTAL_RULE_COMMAND","HorizontalRulePlugin","HorizontalRuleFeatureClient","props","clientFeatureProps","feature","markdownTransformers","nodes","plugins","Component","position","slashMenu","groups","Icon","key","keywords","label","i18n","t","onSelect","editor","dispatchCommand","undefined","toolbarFixed","ChildComponent","isActive","selection","getNodes","length","firstNode","HorizontalRuleFeatureClientComponent"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;AAIA,SAASA,gBAAgB,QAAQ,UAAS;AAI1C,SAASC,kBAAkB,QAAQ,iDAAgD;AACnF,SAASC,qBAAqB,QAAQ,8BAA6B;AACnE,SAASC,4BAA4B,QAAQ,oCAAmC;AAChF,SAASC,gCAAgC,QAAQ,wCAAuC;AACxF,SAASC,mBAAmB,QAAQ,2BAA0B;AAC9D,SACEC,qBAAqB,EACrBC,kBAAkB,EAClBC,8BAA8B,QACzB,gCAA+B;AACtC,SAASC,oBAAoB,QAAQ,oBAAmB;AAExD,MAAMC,8BAAwE,CAACC;IAC7E,OAAO;QACLC,oBAAoBD;QACpBE,SAAS,IAAO,CAAA;gBACdD,oBAAoBD;gBACpBG,sBAAsB;oBAACT;iBAAoB;gBAC3CU,OAAO;oBAACR;iBAAmB;gBAC3BS,SAAS;oBACP;wBACEC,WAAWR;wBACXS,UAAU;oBACZ;iBACD;gBACDC,WAAW;oBACTC,QAAQ;wBACNjB,6BAA6B;4BAC3B;gCACEkB,MAAMpB;gCACNqB,KAAK;gCACLC,UAAU;oCAAC;oCAAM;oCAAmB;oCAAQ;iCAAY;gCACxDC,OAAO,CAAC,EAAEC,IAAI,EAAE;oCACd,OAAOA,KAAKC,CAAC,CAAC;gCAChB;gCAEAC,UAAU,CAAC,EAAEC,MAAM,EAAE;oCACnBA,OAAOC,eAAe,CAACrB,gCAAgCsB;gCACzD;4BACF;yBACD;qBACF;gBACH;gBAEAC,cAAc;oBACZX,QAAQ;wBACNhB,iCAAiC;4BAC/B;gCACE4B,gBAAgB/B;gCAChBgC,UAAU,CAAC,EAAEC,SAAS,EAAE;oCACtB,IAAI,CAAClC,iBAAiBkC,cAAc,CAACA,UAAUC,QAAQ,GAAGC,MAAM,EAAE;wCAChE,OAAO;oCACT;oCAEA,MAAMC,YAAYH,UAAUC,QAAQ,EAAE,CAAC,EAAE;oCACzC,OAAO7B,sBAAsB+B;gCAC/B;gCACAf,KAAK;gCACLE,OAAO,CAAC,EAAEC,IAAI,EAAE;oCACd,OAAOA,KAAKC,CAAC,CAAC;gCAChB;gCACAC,UAAU,CAAC,EAAEC,MAAM,EAAE;oCACnBA,OAAOC,eAAe,CAACrB,gCAAgCsB;gCACzD;4BACF;yBACD;qBACF;gBACH;YACF,CAAA;IACF;AACF;AAEA,OAAO,MAAMQ,uCAAuCpC,sBAClDQ,6BACD"}

package/dist/field/features/horizontalRule/feature.server.d.ts

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

package/dist/field/features/horizontalRule/feature.server.d.ts.map

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

package/dist/field/features/horizontalRule/feature.server.js

@@ -0,0 +1,39 @@
+// eslint-disable-next-line payload/no-imports-from-exports-dir
+import { HorizontalRuleFeatureClientComponent } from '../../../exports/client/index.js';
+import { createNode } from '../typeUtilities.js';
+import { i18n } from './i18n.js';
+import { MarkdownTransformer } from './markdownTransformer.js';
+import { HorizontalRuleNode } from './nodes/HorizontalRuleNode.js';
+export const HorizontalRuleFeature = (props)=>{
+    return {
+        feature: ()=>{
+            return {
+                ClientComponent: HorizontalRuleFeatureClientComponent,
+                i18n,
+                markdownTransformers: [
+                    MarkdownTransformer
+                ],
+                nodes: [
+                    createNode({
+                        converters: {
+                            html: {
+                                converter: ()=>{
+                                    return `<hr/>`;
+                                },
+                                nodeTypes: [
+                                    HorizontalRuleNode.getType()
+                                ]
+                            }
+                        },
+                        node: HorizontalRuleNode
+                    })
+                ],
+                serverFeatureProps: props
+            };
+        },
+        key: 'horizontalRule',
+        serverFeatureProps: props
+    };
+};
+
+//# sourceMappingURL=feature.server.js.map

package/dist/field/features/horizontalRule/feature.server.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/field/features/horizontalRule/feature.server.ts"],"sourcesContent":["import type { FeatureProviderProviderServer } from '../types.js'\n\n// eslint-disable-next-line payload/no-imports-from-exports-dir\nimport { HorizontalRuleFeatureClientComponent } from '../../../exports/client/index.js'\nimport { createNode } from '../typeUtilities.js'\nimport { i18n } from './i18n.js'\nimport { MarkdownTransformer } from './markdownTransformer.js'\nimport { HorizontalRuleNode } from './nodes/HorizontalRuleNode.js'\n\nexport const HorizontalRuleFeature: FeatureProviderProviderServer<undefined, undefined> = (\n  props,\n) => {\n  return {\n    feature: () => {\n      return {\n        ClientComponent: HorizontalRuleFeatureClientComponent,\n        i18n,\n        markdownTransformers: [MarkdownTransformer],\n        nodes: [\n          createNode({\n            converters: {\n              html: {\n                converter: () => {\n                  return `<hr/>`\n                },\n                nodeTypes: [HorizontalRuleNode.getType()],\n              },\n            },\n            node: HorizontalRuleNode,\n          }),\n        ],\n        serverFeatureProps: props,\n      }\n    },\n    key: 'horizontalRule',\n    serverFeatureProps: props,\n  }\n}\n"],"names":["HorizontalRuleFeatureClientComponent","createNode","i18n","MarkdownTransformer","HorizontalRuleNode","HorizontalRuleFeature","props","feature","ClientComponent","markdownTransformers","nodes","converters","html","converter","nodeTypes","getType","node","serverFeatureProps","key"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAEA,+DAA+D;AAC/D,SAASA,oCAAoC,QAAQ,mCAAkC;AACvF,SAASC,UAAU,QAAQ,sBAAqB;AAChD,SAASC,IAAI,QAAQ,YAAW;AAChC,SAASC,mBAAmB,QAAQ,2BAA0B;AAC9D,SAASC,kBAAkB,QAAQ,gCAA+B;AAElE,OAAO,MAAMC,wBAA6E,CACxFC;IAEA,OAAO;QACLC,SAAS;YACP,OAAO;gBACLC,iBAAiBR;gBACjBE;gBACAO,sBAAsB;oBAACN;iBAAoB;gBAC3CO,OAAO;oBACLT,WAAW;wBACTU,YAAY;4BACVC,MAAM;gCACJC,WAAW;oCACT,OAAO,CAAC,KAAK,CAAC;gCAChB;gCACAC,WAAW;oCAACV,mBAAmBW,OAAO;iCAAG;4BAC3C;wBACF;wBACAC,MAAMZ;oBACR;iBACD;gBACDa,oBAAoBX;YACtB;QACF;QACAY,KAAK;QACLD,oBAAoBX;IACtB;AACF,EAAC"}

package/dist/field/features/horizontalRule/i18n.d.ts

@@ -0,0 +1,3 @@
+import type { GenericLanguages } from '@payloadcms/translations';
+export declare const i18n: Partial<GenericLanguages>;
+//# sourceMappingURL=i18n.d.ts.map

package/dist/field/features/horizontalRule/i18n.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i18n.d.ts","sourceRoot":"","sources":["../../../../src/field/features/horizontalRule/i18n.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAA;AAEhE,eAAO,MAAM,IAAI,EAAE,OAAO,CAAC,gBAAgB,CAiG1C,CAAA"}

package/dist/field/features/horizontalRule/i18n.js

@@ -0,0 +1,100 @@
+export const i18n = {
+    ar: {
+        label: 'القاعدة الأفقية'
+    },
+    az: {
+        label: 'Üfüqi Xətt'
+    },
+    bg: {
+        label: 'Хоризонтална линия'
+    },
+    cs: {
+        label: 'Vodorovný pravítko'
+    },
+    de: {
+        label: 'Trennlinie'
+    },
+    en: {
+        label: 'Horizontal Rule'
+    },
+    es: {
+        label: 'Regla Horizontal'
+    },
+    fa: {
+        label: 'قاعده افقی'
+    },
+    fr: {
+        label: 'Règle horizontale'
+    },
+    he: {
+        label: 'קו אופקי'
+    },
+    hr: {
+        label: 'Vodoravna linija'
+    },
+    hu: {
+        label: 'Vízszintes vonal'
+    },
+    it: {
+        label: 'Regola Orizzontale'
+    },
+    ja: {
+        label: '水平線'
+    },
+    ko: {
+        label: '수평 규칙'
+    },
+    my: {
+        label: 'Peraturan Mendatar'
+    },
+    nb: {
+        label: 'Horisontal Regel'
+    },
+    nl: {
+        label: 'Horizontale Regel'
+    },
+    pl: {
+        label: 'Pozioma Linia'
+    },
+    pt: {
+        label: 'Regra Horizontal'
+    },
+    ro: {
+        label: 'Linie orizontală'
+    },
+    rs: {
+        label: 'Horizontalna linija'
+    },
+    'rs-latin': {
+        label: 'Horizontalna linija'
+    },
+    ru: {
+        label: 'Горизонтальная линия'
+    },
+    sk: {
+        label: 'Vodorovná čiara'
+    },
+    sv: {
+        label: 'Horisontell linje'
+    },
+    th: {
+        label: 'กฎขีดตรง'
+    },
+    tr: {
+        label: 'Yatay Çizgi'
+    },
+    uk: {
+        label: 'Горизонтальна лінія'
+    },
+    vi: {
+        label: 'Quy tắc ngang'
+    },
+    zh: {
+        label: '水平线'
+    },
+    'zh-TW': {
+        label: '水平線'
+    }
+};
+
+//# sourceMappingURL=i18n.js.map

package/dist/field/features/horizontalRule/i18n.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/field/features/horizontalRule/i18n.ts"],"sourcesContent":["import type { GenericLanguages } from '@payloadcms/translations'\n\nexport const i18n: Partial<GenericLanguages> = {\n  ar: {\n    label: 'القاعدة الأفقية',\n  },\n  az: {\n    label: 'Üfüqi Xətt',\n  },\n  bg: {\n    label: 'Хоризонтална линия',\n  },\n  cs: {\n    label: 'Vodorovný pravítko',\n  },\n  de: {\n    label: 'Trennlinie',\n  },\n  en: {\n    label: 'Horizontal Rule',\n  },\n  es: {\n    label: 'Regla Horizontal',\n  },\n  fa: {\n    label: 'قاعده افقی',\n  },\n  fr: {\n    label: 'Règle horizontale',\n  },\n  he: {\n    label: 'קו אופקי',\n  },\n  hr: {\n    label: 'Vodoravna linija',\n  },\n  hu: {\n    label: 'Vízszintes vonal',\n  },\n  it: {\n    label: 'Regola Orizzontale',\n  },\n  ja: {\n    label: '水平線',\n  },\n  ko: {\n    label: '수평 규칙',\n  },\n  my: {\n    label: 'Peraturan Mendatar',\n  },\n  nb: {\n    label: 'Horisontal Regel',\n  },\n  nl: {\n    label: 'Horizontale Regel',\n  },\n  pl: {\n    label: 'Pozioma Linia',\n  },\n  pt: {\n    label: 'Regra Horizontal',\n  },\n  ro: {\n    label: 'Linie orizontală',\n  },\n  rs: {\n    label: 'Horizontalna linija',\n  },\n  'rs-latin': {\n    label: 'Horizontalna linija',\n  },\n  ru: {\n    label: 'Горизонтальная линия',\n  },\n  sk: {\n    label: 'Vodorovná čiara',\n  },\n  sv: {\n    label: 'Horisontell linje',\n  },\n  th: {\n    label: 'กฎขีดตรง',\n  },\n  tr: {\n    label: 'Yatay Çizgi',\n  },\n  uk: {\n    label: 'Горизонтальна лінія',\n  },\n  vi: {\n    label: 'Quy tắc ngang',\n  },\n  zh: {\n    label: '水平线',\n  },\n  'zh-TW': {\n    label: '水平線',\n  },\n}\n"],"names":["i18n","ar","label","az","bg","cs","de","en","es","fa","fr","he","hr","hu","it","ja","ko","my","nb","nl","pl","pt","ro","rs","ru","sk","sv","th","tr","uk","vi","zh"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAEA,OAAO,MAAMA,OAAkC;IAC7CC,IAAI;QACFC,OAAO;IACT;IACAC,IAAI;QACFD,OAAO;IACT;IACAE,IAAI;QACFF,OAAO;IACT;IACAG,IAAI;QACFH,OAAO;IACT;IACAI,IAAI;QACFJ,OAAO;IACT;IACAK,IAAI;QACFL,OAAO;IACT;IACAM,IAAI;QACFN,OAAO;IACT;IACAO,IAAI;QACFP,OAAO;IACT;IACAQ,IAAI;QACFR,OAAO;IACT;IACAS,IAAI;QACFT,OAAO;IACT;IACAU,IAAI;QACFV,OAAO;IACT;IACAW,IAAI;QACFX,OAAO;IACT;IACAY,IAAI;QACFZ,OAAO;IACT;IACAa,IAAI;QACFb,OAAO;IACT;IACAc,IAAI;QACFd,OAAO;IACT;IACAe,IAAI;QACFf,OAAO;IACT;IACAgB,IAAI;QACFhB,OAAO;IACT;IACAiB,IAAI;QACFjB,OAAO;IACT;IACAkB,IAAI;QACFlB,OAAO;IACT;IACAmB,IAAI;QACFnB,OAAO;IACT;IACAoB,IAAI;QACFpB,OAAO;IACT;IACAqB,IAAI;QACFrB,OAAO;IACT;IACA,YAAY;QACVA,OAAO;IACT;IACAsB,IAAI;QACFtB,OAAO;IACT;IACAuB,IAAI;QACFvB,OAAO;IACT;IACAwB,IAAI;QACFxB,OAAO;IACT;IACAyB,IAAI;QACFzB,OAAO;IACT;IACA0B,IAAI;QACF1B,OAAO;IACT;IACA2B,IAAI;QACF3B,OAAO;IACT;IACA4B,IAAI;QACF5B,OAAO;IACT;IACA6B,IAAI;QACF7B,OAAO;IACT;IACA,SAAS;QACPA,OAAO;IACT;AACF,EAAC"}

package/dist/field/features/horizontalRule/markdownTransformer.d.ts

@@ -0,0 +1,3 @@
+import type { ElementTransformer } from '@lexical/markdown';
+export declare const MarkdownTransformer: ElementTransformer;
+//# sourceMappingURL=markdownTransformer.d.ts.map

package/dist/field/features/horizontalRule/markdownTransformer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdownTransformer.d.ts","sourceRoot":"","sources":["../../../../src/field/features/horizontalRule/markdownTransformer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AAQ3D,eAAO,MAAM,mBAAmB,EAAE,kBAiBjC,CAAA"}

package/dist/field/features/horizontalRule/markdownTransformer.js

@@ -0,0 +1,23 @@
+import { $createHorizontalRuleNode, $isHorizontalRuleNode, HorizontalRuleNode } from './nodes/HorizontalRuleNode.js';
+export const MarkdownTransformer = {
+    type: 'element',
+    dependencies: [
+        HorizontalRuleNode
+    ],
+    export: (node, exportChildren)=>{
+        if (!$isHorizontalRuleNode(node)) {
+            return null;
+        }
+        return '---';
+    },
+    // match ---
+    regExp: /^---\s*$/,
+    replace: (parentNode)=>{
+        const node = $createHorizontalRuleNode();
+        if (node) {
+            parentNode.replace(node);
+        }
+    }
+};
+
+//# sourceMappingURL=markdownTransformer.js.map

package/dist/field/features/horizontalRule/markdownTransformer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/field/features/horizontalRule/markdownTransformer.ts"],"sourcesContent":["import type { ElementTransformer } from '@lexical/markdown'\n\nimport {\n  $createHorizontalRuleNode,\n  $isHorizontalRuleNode,\n  HorizontalRuleNode,\n} from './nodes/HorizontalRuleNode.js'\n\nexport const MarkdownTransformer: ElementTransformer = {\n  type: 'element',\n  dependencies: [HorizontalRuleNode],\n  export: (node, exportChildren) => {\n    if (!$isHorizontalRuleNode(node)) {\n      return null\n    }\n    return '---'\n  },\n  // match ---\n  regExp: /^---\\s*$/,\n  replace: (parentNode) => {\n    const node = $createHorizontalRuleNode()\n    if (node) {\n      parentNode.replace(node)\n    }\n  },\n}\n"],"names":["$createHorizontalRuleNode","$isHorizontalRuleNode","HorizontalRuleNode","MarkdownTransformer","type","dependencies","export","node","exportChildren","regExp","replace","parentNode"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;","mappings":"AAEA,SACEA,yBAAyB,EACzBC,qBAAqB,EACrBC,kBAAkB,QACb,gCAA+B;AAEtC,OAAO,MAAMC,sBAA0C;IACrDC,MAAM;IACNC,cAAc;QAACH;KAAmB;IAClCI,QAAQ,CAACC,MAAMC;QACb,IAAI,CAACP,sBAAsBM,OAAO;YAChC,OAAO;QACT;QACA,OAAO;IACT;IACA,YAAY;IACZE,QAAQ;IACRC,SAAS,CAACC;QACR,MAAMJ,OAAOP;QACb,IAAIO,MAAM;YACRI,WAAWD,OAAO,CAACH;QACrB;IACF;AACF,EAAC"}

package/dist/field/features/horizontalRule/nodes/HorizontalRuleNode.d.ts

@@ -0,0 +1,53 @@
+import type { DOMConversionMap, DOMExportOutput, EditorConfig, LexicalCommand, LexicalNode, SerializedLexicalNode } from 'lexical';
+import { DecoratorNode } from 'lexical';
+import * as React from 'react';
+/**
+ * Serialized representation of a horizontal rule node. Serialized = converted to JSON. This is what is stored in the database / in the lexical editor state.
+ */
+export type SerializedHorizontalRuleNode = SerializedLexicalNode;
+export declare const INSERT_HORIZONTAL_RULE_COMMAND: LexicalCommand<void>;
+/**
+ * This node is a DecoratorNode. DecoratorNodes allow you to render React components in the editor.
+ *
+ * They need both createDom and decorate functions. createDom => outside of the html. decorate => React Component inside of the html.
+ *
+ * If we used DecoratorBlockNode instead, we would only need a decorate method
+ */
+export declare class HorizontalRuleNode extends DecoratorNode<React.ReactElement> {
+    static clone(node: HorizontalRuleNode): HorizontalRuleNode;
+    static getType(): string;
+    /**
+     * Defines what happens if you copy an hr element from another page and paste it into the lexical editor
+     *
+     * This also determines the behavior of lexical's internal HTML -> Lexical converter
+     */
+    static importDOM(): DOMConversionMap | null;
+    /**
+     * The data for this node is stored serialized as JSON. This is the "load function" of that node: it takes the saved data and converts it into a node.
+     */
+    static importJSON(serializedNode: SerializedHorizontalRuleNode): HorizontalRuleNode;
+    /**
+     * Determines how the hr element is rendered in the lexical editor. This is only the "initial" / "outer" HTML element.
+     */
+    createDOM(config: EditorConfig): HTMLElement;
+    /**
+     * Allows you to render a React component within whatever createDOM returns.
+     */
+    decorate(): React.ReactElement;
+    /**
+     * Opposite of importDOM, this function defines what happens when you copy an hr element from the lexical editor and paste it into another page.
+     *
+     * This also determines the behavior of lexical's internal Lexical -> HTML converter
+     */
+    exportDOM(): DOMExportOutput;
+    /**
+     * Opposite of importJSON. This determines what data is saved in the database / in the lexical editor state.
+     */
+    exportJSON(): SerializedLexicalNode;
+    getTextContent(): string;
+    isInline(): false;
+    updateDOM(): boolean;
+}
+export declare function $createHorizontalRuleNode(): HorizontalRuleNode;
+export declare function $isHorizontalRuleNode(node: LexicalNode | null | undefined): node is HorizontalRuleNode;
+//# sourceMappingURL=HorizontalRuleNode.d.ts.map

package/dist/field/features/horizontalRule/nodes/HorizontalRuleNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HorizontalRuleNode.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/horizontalRule/nodes/HorizontalRuleNode.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAEhB,eAAe,EACf,YAAY,EACZ,cAAc,EACd,WAAW,EACX,qBAAqB,EACtB,MAAM,SAAS,CAAA;AAGhB,OAAO,EAAyB,aAAa,EAAiB,MAAM,SAAS,CAAA;AAC7E,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAQ9B;;GAEG;AACH,MAAM,MAAM,4BAA4B,GAAG,qBAAqB,CAAA;AAEhE,eAAO,MAAM,8BAA8B,EAAE,cAAc,CAAC,IAAI,CAE/D,CAAA;AAED;;;;;;GAMG;AACH,qBAAa,kBAAmB,SAAQ,aAAa,CAAC,KAAK,CAAC,YAAY,CAAC;IACvE,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,kBAAkB,GAAG,kBAAkB;IAI1D,MAAM,CAAC,OAAO,IAAI,MAAM;IAIxB;;;;OAIG;IACH,MAAM,CAAC,SAAS,IAAI,gBAAgB,GAAG,IAAI;IAS3C;;OAEG;IACH,MAAM,CAAC,UAAU,CAAC,cAAc,EAAE,4BAA4B,GAAG,kBAAkB;IAInF;;OAEG;IACH,SAAS,CAAC,MAAM,EAAE,YAAY,GAAG,WAAW;IAM5C;;OAEG;IACH,QAAQ,IAAI,KAAK,CAAC,YAAY;IAI9B;;;;OAIG;IACH,SAAS,IAAI,eAAe;IAG5B;;OAEG;IACH,UAAU,IAAI,qBAAqB;IAOnC,cAAc,IAAI,MAAM;IAIxB,QAAQ,IAAI,KAAK;IAIjB,SAAS,IAAI,OAAO;CAGrB;AAMD,wBAAgB,yBAAyB,IAAI,kBAAkB,CAE9D;AAED,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GACnC,IAAI,IAAI,kBAAkB,CAE5B"}

package/dist/field/features/horizontalRule/nodes/HorizontalRuleNode.js

@@ -0,0 +1,92 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { addClassNamesToElement } from '@lexical/utils';
+import { $applyNodeReplacement, DecoratorNode, createCommand } from 'lexical';
+import * as React from 'react';
+const HorizontalRuleComponent = /*#__PURE__*/ React.lazy(()=>import('../component/index.js').then((module)=>({
+            default: module.HorizontalRuleComponent
+        })));
+export const INSERT_HORIZONTAL_RULE_COMMAND = createCommand('INSERT_HORIZONTAL_RULE_COMMAND');
+/**
+ * This node is a DecoratorNode. DecoratorNodes allow you to render React components in the editor.
+ *
+ * They need both createDom and decorate functions. createDom => outside of the html. decorate => React Component inside of the html.
+ *
+ * If we used DecoratorBlockNode instead, we would only need a decorate method
+ */ export class HorizontalRuleNode extends DecoratorNode {
+    static clone(node) {
+        return new HorizontalRuleNode(node.__key);
+    }
+    static getType() {
+        return 'horizontalrule';
+    }
+    /**
+   * Defines what happens if you copy an hr element from another page and paste it into the lexical editor
+   *
+   * This also determines the behavior of lexical's internal HTML -> Lexical converter
+   */ static importDOM() {
+        return {
+            hr: ()=>({
+                    conversion: $convertHorizontalRuleElement,
+                    priority: 0
+                })
+        };
+    }
+    /**
+   * The data for this node is stored serialized as JSON. This is the "load function" of that node: it takes the saved data and converts it into a node.
+   */ static importJSON(serializedNode) {
+        return $createHorizontalRuleNode();
+    }
+    /**
+   * Determines how the hr element is rendered in the lexical editor. This is only the "initial" / "outer" HTML element.
+   */ createDOM(config) {
+        const element = document.createElement('hr');
+        addClassNamesToElement(element, config.theme.hr);
+        return element;
+    }
+    /**
+   * Allows you to render a React component within whatever createDOM returns.
+   */ decorate() {
+        return /*#__PURE__*/ _jsx(HorizontalRuleComponent, {
+            nodeKey: this.__key
+        });
+    }
+    /**
+   * Opposite of importDOM, this function defines what happens when you copy an hr element from the lexical editor and paste it into another page.
+   *
+   * This also determines the behavior of lexical's internal Lexical -> HTML converter
+   */ exportDOM() {
+        return {
+            element: document.createElement('hr')
+        };
+    }
+    /**
+   * Opposite of importJSON. This determines what data is saved in the database / in the lexical editor state.
+   */ exportJSON() {
+        return {
+            type: 'horizontalrule',
+            version: 1
+        };
+    }
+    getTextContent() {
+        return '\n';
+    }
+    isInline() {
+        return false;
+    }
+    updateDOM() {
+        return false;
+    }
+}
+function $convertHorizontalRuleElement() {
+    return {
+        node: $createHorizontalRuleNode()
+    };
+}
+export function $createHorizontalRuleNode() {
+    return $applyNodeReplacement(new HorizontalRuleNode());
+}
+export function $isHorizontalRuleNode(node) {
+    return node instanceof HorizontalRuleNode;
+}
+
+//# sourceMappingURL=HorizontalRuleNode.js.map

package/dist/field/features/horizontalRule/nodes/HorizontalRuleNode.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/field/features/horizontalRule/nodes/HorizontalRuleNode.tsx"],"sourcesContent":["import type {\n  DOMConversionMap,\n  DOMConversionOutput,\n  DOMExportOutput,\n  EditorConfig,\n  LexicalCommand,\n  LexicalNode,\n  SerializedLexicalNode,\n} from 'lexical'\n\nimport { addClassNamesToElement } from '@lexical/utils'\nimport { $applyNodeReplacement, DecoratorNode, createCommand } from 'lexical'\nimport * as React from 'react'\n\nconst HorizontalRuleComponent = React.lazy(() =>\n  import('../component/index.js').then((module) => ({\n    default: module.HorizontalRuleComponent,\n  })),\n)\n\n/**\n * Serialized representation of a horizontal rule node. Serialized = converted to JSON. This is what is stored in the database / in the lexical editor state.\n */\nexport type SerializedHorizontalRuleNode = SerializedLexicalNode\n\nexport const INSERT_HORIZONTAL_RULE_COMMAND: LexicalCommand<void> = createCommand(\n  'INSERT_HORIZONTAL_RULE_COMMAND',\n)\n\n/**\n * This node is a DecoratorNode. DecoratorNodes allow you to render React components in the editor.\n *\n * They need both createDom and decorate functions. createDom => outside of the html. decorate => React Component inside of the html.\n *\n * If we used DecoratorBlockNode instead, we would only need a decorate method\n */\nexport class HorizontalRuleNode extends DecoratorNode<React.ReactElement> {\n  static clone(node: HorizontalRuleNode): HorizontalRuleNode {\n    return new HorizontalRuleNode(node.__key)\n  }\n\n  static getType(): string {\n    return 'horizontalrule'\n  }\n\n  /**\n   * Defines what happens if you copy an hr element from another page and paste it into the lexical editor\n   *\n   * This also determines the behavior of lexical's internal HTML -> Lexical converter\n   */\n  static importDOM(): DOMConversionMap | null {\n    return {\n      hr: () => ({\n        conversion: $convertHorizontalRuleElement,\n        priority: 0,\n      }),\n    }\n  }\n\n  /**\n   * The data for this node is stored serialized as JSON. This is the \"load function\" of that node: it takes the saved data and converts it into a node.\n   */\n  static importJSON(serializedNode: SerializedHorizontalRuleNode): HorizontalRuleNode {\n    return $createHorizontalRuleNode()\n  }\n\n  /**\n   * Determines how the hr element is rendered in the lexical editor. This is only the \"initial\" / \"outer\" HTML element.\n   */\n  createDOM(config: EditorConfig): HTMLElement {\n    const element = document.createElement('hr')\n    addClassNamesToElement(element, config.theme.hr)\n    return element\n  }\n\n  /**\n   * Allows you to render a React component within whatever createDOM returns.\n   */\n  decorate(): React.ReactElement {\n    return <HorizontalRuleComponent nodeKey={this.__key} />\n  }\n\n  /**\n   * Opposite of importDOM, this function defines what happens when you copy an hr element from the lexical editor and paste it into another page.\n   *\n   * This also determines the behavior of lexical's internal Lexical -> HTML converter\n   */\n  exportDOM(): DOMExportOutput {\n    return { element: document.createElement('hr') }\n  }\n  /**\n   * Opposite of importJSON. This determines what data is saved in the database / in the lexical editor state.\n   */\n  exportJSON(): SerializedLexicalNode {\n    return {\n      type: 'horizontalrule',\n      version: 1,\n    }\n  }\n\n  getTextContent(): string {\n    return '\\n'\n  }\n\n  isInline(): false {\n    return false\n  }\n\n  updateDOM(): boolean {\n    return false\n  }\n}\n\nfunction $convertHorizontalRuleElement(): DOMConversionOutput {\n  return { node: $createHorizontalRuleNode() }\n}\n\nexport function $createHorizontalRuleNode(): HorizontalRuleNode {\n  return $applyNodeReplacement(new HorizontalRuleNode())\n}\n\nexport function $isHorizontalRuleNode(\n  node: LexicalNode | null | undefined,\n): node is HorizontalRuleNode {\n  return node instanceof HorizontalRuleNode\n}\n"],"names":["addClassNamesToElement","$applyNodeReplacement","DecoratorNode","createCommand","React","HorizontalRuleComponent","lazy","then","module","default","INSERT_HORIZONTAL_RULE_COMMAND","HorizontalRuleNode","clone","node","__key","getType","importDOM","hr","conversion","$convertHorizontalRuleElement","priority","importJSON","serializedNode","$createHorizontalRuleNode","createDOM","config","element","document","createElement","theme","decorate","nodeKey","exportDOM","exportJSON","type","version","getTextContent","isInline","updateDOM","$isHorizontalRuleNode"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";AAUA,SAASA,sBAAsB,QAAQ,iBAAgB;AACvD,SAASC,qBAAqB,EAAEC,aAAa,EAAEC,aAAa,QAAQ,UAAS;AAC7E,YAAYC,WAAW,QAAO;AAE9B,MAAMC,wCAA0BD,MAAME,IAAI,CAAC,IACzC,MAAM,CAAC,yBAAyBC,IAAI,CAAC,CAACC,SAAY,CAAA;YAChDC,SAASD,OAAOH,uBAAuB;QACzC,CAAA;AAQF,OAAO,MAAMK,iCAAuDP,cAClE,kCACD;AAED;;;;;;CAMC,GACD,OAAO,MAAMQ,2BAA2BT;IACtC,OAAOU,MAAMC,IAAwB,EAAsB;QACzD,OAAO,IAAIF,mBAAmBE,KAAKC,KAAK;IAC1C;IAEA,OAAOC,UAAkB;QACvB,OAAO;IACT;IAEA;;;;GAIC,GACD,OAAOC,YAAqC;QAC1C,OAAO;YACLC,IAAI,IAAO,CAAA;oBACTC,YAAYC;oBACZC,UAAU;gBACZ,CAAA;QACF;IACF;IAEA;;GAEC,GACD,OAAOC,WAAWC,cAA4C,EAAsB;QAClF,OAAOC;IACT;IAEA;;GAEC,GACDC,UAAUC,MAAoB,EAAe;QAC3C,MAAMC,UAAUC,SAASC,aAAa,CAAC;QACvC5B,uBAAuB0B,SAASD,OAAOI,KAAK,CAACZ,EAAE;QAC/C,OAAOS;IACT;IAEA;;GAEC,GACDI,WAA+B;QAC7B,qBAAO,KAACzB;YAAwB0B,SAAS,IAAI,CAACjB,KAAK;;IACrD;IAEA;;;;GAIC,GACDkB,YAA6B;QAC3B,OAAO;YAAEN,SAASC,SAASC,aAAa,CAAC;QAAM;IACjD;IACA;;GAEC,GACDK,aAAoC;QAClC,OAAO;YACLC,MAAM;YACNC,SAAS;QACX;IACF;IAEAC,iBAAyB;QACvB,OAAO;IACT;IAEAC,WAAkB;QAChB,OAAO;IACT;IAEAC,YAAqB;QACnB,OAAO;IACT;AACF;AAEA,SAASnB;IACP,OAAO;QAAEN,MAAMU;IAA4B;AAC7C;AAEA,OAAO,SAASA;IACd,OAAOtB,sBAAsB,IAAIU;AACnC;AAEA,OAAO,SAAS4B,sBACd1B,IAAoC;IAEpC,OAAOA,gBAAgBF;AACzB"}

package/dist/field/features/horizontalRule/plugin/index.d.ts

@@ -0,0 +1,7 @@
+import type { PluginComponent } from '../../types.js';
+import './index.scss';
+/**
+ * Registers the INSERT_HORIZONTAL_RULE_COMMAND lexical command and defines the behavior for when it is called.
+ */
+export declare const HorizontalRulePlugin: PluginComponent<undefined>;
+//# sourceMappingURL=index.d.ts.map

package/dist/field/features/horizontalRule/plugin/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/horizontalRule/plugin/index.tsx"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAMrD,OAAO,cAAc,CAAA;AAErB;;GAEG;AACH,eAAO,MAAM,oBAAoB,EAAE,eAAe,CAAC,SAAS,CA2B3D,CAAA"}

package/dist/field/features/horizontalRule/plugin/index.js

@@ -0,0 +1,30 @@
+'use client';
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js';
+import { $insertNodeToNearestRoot } from '@lexical/utils';
+import { $getSelection, $isRangeSelection, COMMAND_PRIORITY_EDITOR } from 'lexical';
+import { useEffect } from 'react';
+import { $createHorizontalRuleNode, INSERT_HORIZONTAL_RULE_COMMAND } from '../nodes/HorizontalRuleNode.js';
+/**
+ * Registers the INSERT_HORIZONTAL_RULE_COMMAND lexical command and defines the behavior for when it is called.
+ */ export const HorizontalRulePlugin = ()=>{
+    const [editor] = useLexicalComposerContext();
+    useEffect(()=>{
+        return editor.registerCommand(INSERT_HORIZONTAL_RULE_COMMAND, (type)=>{
+            const selection = $getSelection();
+            if (!$isRangeSelection(selection)) {
+                return false;
+            }
+            const focusNode = selection.focus.getNode();
+            if (focusNode !== null) {
+                const horizontalRuleNode = $createHorizontalRuleNode();
+                $insertNodeToNearestRoot(horizontalRuleNode);
+            }
+            return true;
+        }, COMMAND_PRIORITY_EDITOR);
+    }, [
+        editor
+    ]);
+    return null;
+};
+
+//# sourceMappingURL=index.js.map

package/dist/field/features/horizontalRule/plugin/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/field/features/horizontalRule/plugin/index.tsx"],"sourcesContent":["'use client'\n\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js'\nimport { $insertNodeToNearestRoot } from '@lexical/utils'\nimport { $getSelection, $isRangeSelection, COMMAND_PRIORITY_EDITOR } from 'lexical'\nimport { useEffect } from 'react'\n\nimport type { PluginComponent } from '../../types.js'\n\nimport {\n  $createHorizontalRuleNode,\n  INSERT_HORIZONTAL_RULE_COMMAND,\n} from '../nodes/HorizontalRuleNode.js'\nimport './index.scss'\n\n/**\n * Registers the INSERT_HORIZONTAL_RULE_COMMAND lexical command and defines the behavior for when it is called.\n */\nexport const HorizontalRulePlugin: PluginComponent<undefined> = () => {\n  const [editor] = useLexicalComposerContext()\n\n  useEffect(() => {\n    return editor.registerCommand(\n      INSERT_HORIZONTAL_RULE_COMMAND,\n      (type) => {\n        const selection = $getSelection()\n\n        if (!$isRangeSelection(selection)) {\n          return false\n        }\n\n        const focusNode = selection.focus.getNode()\n\n        if (focusNode !== null) {\n          const horizontalRuleNode = $createHorizontalRuleNode()\n          $insertNodeToNearestRoot(horizontalRuleNode)\n        }\n\n        return true\n      },\n      COMMAND_PRIORITY_EDITOR,\n    )\n  }, [editor])\n\n  return null\n}\n"],"names":["useLexicalComposerContext","$insertNodeToNearestRoot","$getSelection","$isRangeSelection","COMMAND_PRIORITY_EDITOR","useEffect","$createHorizontalRuleNode","INSERT_HORIZONTAL_RULE_COMMAND","HorizontalRulePlugin","editor","registerCommand","type","selection","focusNode","focus","getNode","horizontalRuleNode"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;AAEA,SAASA,yBAAyB,QAAQ,2CAA0C;AACpF,SAASC,wBAAwB,QAAQ,iBAAgB;AACzD,SAASC,aAAa,EAAEC,iBAAiB,EAAEC,uBAAuB,QAAQ,UAAS;AACnF,SAASC,SAAS,QAAQ,QAAO;AAIjC,SACEC,yBAAyB,EACzBC,8BAA8B,QACzB,iCAAgC;AAGvC;;CAEC,GACD,OAAO,MAAMC,uBAAmD;IAC9D,MAAM,CAACC,OAAO,GAAGT;IAEjBK,UAAU;QACR,OAAOI,OAAOC,eAAe,CAC3BH,gCACA,CAACI;YACC,MAAMC,YAAYV;YAElB,IAAI,CAACC,kBAAkBS,YAAY;gBACjC,OAAO;YACT;YAEA,MAAMC,YAAYD,UAAUE,KAAK,CAACC,OAAO;YAEzC,IAAIF,cAAc,MAAM;gBACtB,MAAMG,qBAAqBV;gBAC3BL,yBAAyBe;YAC3B;YAEA,OAAO;QACT,GACAZ;IAEJ,GAAG;QAACK;KAAO;IAEX,OAAO;AACT,EAAC"}

package/dist/field/features/indent/feature.client.d.ts

@@ -1,3 +1,6 @@
 /// <reference types="react" resolution-mode="require"/>
-export declare const IndentFeatureClientComponent: import("react").FC<undefined>;
+export declare const IndentFeatureClientComponent: import("react").FC<{
+    featureKey: string;
+    order: number;
+}>;
 //# sourceMappingURL=feature.client.d.ts.map

package/dist/field/features/indent/feature.client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"feature.client.d.ts","sourceRoot":"","sources":["../../../../src/field/features/indent/feature.client.tsx"],"names":[],"mappings":";AAkEA,eAAO,MAAM,4BAA4B,+BAA6C,CAAA"}
+{"version":3,"file":"feature.client.d.ts","sourceRoot":"","sources":["../../../../src/field/features/indent/feature.client.tsx"],"names":[],"mappings":";AAuEA,eAAO,MAAM,4BAA4B;;;EAA6C,CAAA"}

package/dist/field/features/indent/feature.client.js

@@ -1,54 +1,59 @@
 'use client';
-import lexicalImport from 'lexical';
-const { INDENT_CONTENT_COMMAND, OUTDENT_CONTENT_COMMAND } = lexicalImport;
+import { INDENT_CONTENT_COMMAND, OUTDENT_CONTENT_COMMAND } from 'lexical';
 import { IndentDecreaseIcon } from '../../lexical/ui/icons/IndentDecrease/index.js';
 import { IndentIncreaseIcon } from '../../lexical/ui/icons/IndentIncrease/index.js';
 import { createClientComponent } from '../createClientComponent.js';
-import { IndentSectionWithEntries } from './floatingSelectToolbarIndentSection.js';
+import { toolbarIndentGroupWithItems } from './toolbarIndentGroup.js';
+const toolbarGroups = [
+    toolbarIndentGroupWithItems([
+        {
+            ChildComponent: IndentDecreaseIcon,
+            isActive: ()=>false,
+            isEnabled: ({ selection })=>{
+                if (!selection || !selection?.getNodes()?.length) {
+                    return false;
+                }
+                for (const node of selection.getNodes()){
+                    // If at least one node is indented, this should be active
+                    if ('__indent' in node && node.__indent > 0 || node.getParent() && '__indent' in node.getParent() && node.getParent().__indent > 0) {
+                        return true;
+                    }
+                }
+                return false;
+            },
+            key: 'indentDecrease',
+            label: ({ i18n })=>{
+                return i18n.t('lexical:indent:decreaseLabel');
+            },
+            onSelect: ({ editor })=>{
+                editor.dispatchCommand(OUTDENT_CONTENT_COMMAND, undefined);
+            },
+            order: 1
+        },
+        {
+            ChildComponent: IndentIncreaseIcon,
+            isActive: ()=>false,
+            key: 'indentIncrease',
+            label: ({ i18n })=>{
+                return i18n.t('lexical:indent:increaseLabel');
+            },
+            onSelect: ({ editor })=>{
+                editor.dispatchCommand(INDENT_CONTENT_COMMAND, undefined);
+            },
+            order: 2
+        }
+    ])
+];
 const IndentFeatureClient = (props)=>{
     return {
         clientFeatureProps: props,
         feature: ()=>({
                 clientFeatureProps: props,
-                floatingSelectToolbar: {
-                    sections: [
-                        IndentSectionWithEntries([
-                            {
-                                ChildComponent: IndentDecreaseIcon,
-                                isActive: ()=>false,
-                                isEnabled: ({ selection })=>{
-                                    if (!selection || !selection?.getNodes()?.length) {
-                                        return false;
-                                    }
-                                    for (const node of selection.getNodes()){
-                                        // If at least one node is indented, this should be active
-                                        if ('__indent' in node && node.__indent > 0 || node.getParent() && '__indent' in node.getParent() && node.getParent().__indent > 0) {
-                                            return true;
-                                        }
-                                    }
-                                    return false;
-                                },
-                                key: 'indent-decrease',
-                                label: `Decrease Indent`,
-                                onClick: ({ editor })=>{
-                                    editor.dispatchCommand(OUTDENT_CONTENT_COMMAND, undefined);
-                                },
-                                order: 1
-                            }
-                        ]),
-                        IndentSectionWithEntries([
-                            {
-                                ChildComponent: IndentIncreaseIcon,
-                                isActive: ()=>false,
-                                key: 'indent-increase',
-                                label: `Increase Indent`,
-                                onClick: ({ editor })=>{
-                                    editor.dispatchCommand(INDENT_CONTENT_COMMAND, undefined);
-                                },
-                                order: 2
-                            }
-                        ])
-                    ]
+                toolbarFixed: {
+                    groups: toolbarGroups
+                },
+                toolbarInline: {
+                    groups: toolbarGroups
                 }
             })
     };