@payloadcms/richtext-lexical 3.0.0-beta.3 → 3.0.0-beta.30

package/dist/field/features/lists/checklist/markdownTransformers.js

@@ -1,6 +1,5 @@
-import lexicalListImport from '@lexical/list';
-const { $isListNode, ListItemNode, ListNode } = lexicalListImport;
-import { listExport, listReplace } from '../common/markdown.js';
+import { $isListNode, ListItemNode, ListNode } from '@lexical/list';
+import { listExport, listReplace } from '../shared/markdown.js';
 export const CHECK_LIST = {
     type: 'element',
     dependencies: [

package/dist/field/features/lists/checklist/markdownTransformers.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/field/features/lists/checklist/markdownTransformers.ts"],"sourcesContent":["import type { ElementTransformer } from '@lexical/markdown'\n\nimport lexicalListImport from '@lexical/list'\nconst { $isListNode, ListItemNode, ListNode } = lexicalListImport\n\nimport { listExport, listReplace } from '../common/markdown.js'\n\nexport const CHECK_LIST: ElementTransformer = {\n  type: 'element',\n  dependencies: [ListNode, ListItemNode],\n  export: (node, exportChildren) => {\n    return $isListNode(node) ? listExport(node, exportChildren, 0) : null\n  },\n  regExp: /^(\\s*)(?:-\\s)?\\s?(\\[(\\s|x)?\\])\\s/i,\n  replace: listReplace('check'),\n}\n"],"names":["lexicalListImport","$isListNode","ListItemNode","ListNode","listExport","listReplace","CHECK_LIST","type","dependencies","export","node","exportChildren","regExp","replace"],"rangeMappings":";;;;;;;;;;;;;;","mappings":"AAEA,OAAOA,uBAAuB,gBAAe;AAC7C,MAAM,EAAEC,WAAW,EAAEC,YAAY,EAAEC,QAAQ,EAAE,GAAGH;AAEhD,SAASI,UAAU,EAAEC,WAAW,QAAQ,wBAAuB;AAE/D,OAAO,MAAMC,aAAiC;IAC5CC,MAAM;IACNC,cAAc;QAACL;QAAUD;KAAa;IACtCO,QAAQ,CAACC,MAAMC;QACb,OAAOV,YAAYS,QAAQN,WAAWM,MAAMC,gBAAgB,KAAK;IACnE;IACAC,QAAQ;IACRC,SAASR,YAAY;AACvB,EAAC"}
+{"version":3,"sources":["../../../../../src/field/features/lists/checklist/markdownTransformers.ts"],"sourcesContent":["import type { ElementTransformer } from '@lexical/markdown'\n\nimport { $isListNode, ListItemNode, ListNode } from '@lexical/list'\n\nimport { listExport, listReplace } from '../shared/markdown.js'\n\nexport const CHECK_LIST: ElementTransformer = {\n  type: 'element',\n  dependencies: [ListNode, ListItemNode],\n  export: (node, exportChildren) => {\n    return $isListNode(node) ? listExport(node, exportChildren, 0) : null\n  },\n  regExp: /^(\\s*)(?:-\\s)?\\s?(\\[(\\s|x)?\\])\\s/i,\n  replace: listReplace('check'),\n}\n"],"names":["$isListNode","ListItemNode","ListNode","listExport","listReplace","CHECK_LIST","type","dependencies","export","node","exportChildren","regExp","replace"],"rangeMappings":";;;;;;;;;;;;;","mappings":"AAEA,SAASA,WAAW,EAAEC,YAAY,EAAEC,QAAQ,QAAQ,gBAAe;AAEnE,SAASC,UAAU,EAAEC,WAAW,QAAQ,wBAAuB;AAE/D,OAAO,MAAMC,aAAiC;IAC5CC,MAAM;IACNC,cAAc;QAACL;QAAUD;KAAa;IACtCO,QAAQ,CAACC,MAAMC;QACb,OAAOV,YAAYS,QAAQN,WAAWM,MAAMC,gBAAgB,KAAK;IACnE;IACAC,QAAQ;IACRC,SAASR,YAAY;AACvB,EAAC"}

package/dist/field/features/lists/checklist/plugin/index.d.ts

@@ -1,3 +1,3 @@
-import React from 'react';
-export declare function LexicalCheckListPlugin(): React.JSX.Element;
+import type { PluginComponent } from '../../../types.js';
+export declare const LexicalCheckListPlugin: PluginComponent<undefined>;
 //# sourceMappingURL=index.d.ts.map

package/dist/field/features/lists/checklist/plugin/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/field/features/lists/checklist/plugin/index.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,OAAO,CAAA;AAEzB,wBAAgB,sBAAsB,sBAErC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/field/features/lists/checklist/plugin/index.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAExD,eAAO,MAAM,sBAAsB,EAAE,eAAe,CAAC,SAAS,CAE7D,CAAA"}

package/dist/field/features/lists/checklist/plugin/index.js

@@ -1,9 +1,8 @@
 'use client';
-import lexicalCheckListPluginImport from '@lexical/react/LexicalCheckListPlugin.js';
-const { CheckListPlugin } = lexicalCheckListPluginImport;
+import { CheckListPlugin } from '@lexical/react/LexicalCheckListPlugin.js';
 import React from 'react';
-export function LexicalCheckListPlugin() {
+export const LexicalCheckListPlugin = ()=>{
     return /*#__PURE__*/ React.createElement(CheckListPlugin, null);
-}
+};
 
 //# sourceMappingURL=index.js.map

package/dist/field/features/lists/checklist/plugin/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../src/field/features/lists/checklist/plugin/index.tsx"],"sourcesContent":["'use client'\nimport lexicalCheckListPluginImport from '@lexical/react/LexicalCheckListPlugin.js'\nconst { CheckListPlugin } = lexicalCheckListPluginImport\n\nimport React from 'react'\n\nexport function LexicalCheckListPlugin() {\n  return <CheckListPlugin />\n}\n"],"names":["lexicalCheckListPluginImport","CheckListPlugin","React","LexicalCheckListPlugin"],"rangeMappings":";;;;;;","mappings":"AAAA;AACA,OAAOA,kCAAkC,2CAA0C;AACnF,MAAM,EAAEC,eAAe,EAAE,GAAGD;AAE5B,OAAOE,WAAW,QAAO;AAEzB,OAAO,SAASC;IACd,qBAAO,oBAACF;AACV"}
+{"version":3,"sources":["../../../../../../src/field/features/lists/checklist/plugin/index.tsx"],"sourcesContent":["'use client'\nimport { CheckListPlugin } from '@lexical/react/LexicalCheckListPlugin.js'\nimport React from 'react'\n\nimport type { PluginComponent } from '../../../types.js'\n\nexport const LexicalCheckListPlugin: PluginComponent<undefined> = () => {\n  return <CheckListPlugin />\n}\n"],"names":["CheckListPlugin","React","LexicalCheckListPlugin"],"rangeMappings":";;;;;","mappings":"AAAA;AACA,SAASA,eAAe,QAAQ,2CAA0C;AAC1E,OAAOC,WAAW,QAAO;AAIzB,OAAO,MAAMC,yBAAqD;IAChE,qBAAO,oBAACF;AACV,EAAC"}

package/dist/field/features/lists/htmlConverter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"htmlConverter.d.ts","sourceRoot":"","sources":["../../../../src/field/features/lists/htmlConverter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAA;AAK/E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uCAAuC,CAAA;AAI1E,eAAO,MAAM,iBAAiB,EAAE,aAAa,CAAC,kBAAkB,CAe/D,CAAA;AAED,eAAO,MAAM,qBAAqB,EAAE,aAAa,CAAC,sBAAsB,CA6BvE,CAAA"}
+{"version":3,"file":"htmlConverter.d.ts","sourceRoot":"","sources":["../../../../src/field/features/lists/htmlConverter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAA;AAK/E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uCAAuC,CAAA;AAI1E,eAAO,MAAM,iBAAiB,EAAE,aAAa,CAAC,kBAAkB,CAe/D,CAAA;AAED,eAAO,MAAM,qBAAqB,EAAE,aAAa,CAAC,sBAAsB,CA0CvE,CAAA"}

package/dist/field/features/lists/htmlConverter.js

@@ -1,5 +1,5 @@
-import lexicalListImport from '@lexical/list';
-const { ListItemNode, ListNode } = lexicalListImport;
+import { ListItemNode, ListNode } from '@lexical/list';
+import { v4 as uuidv4 } from 'uuid';
 import { convertLexicalNodesToHTML } from '../converters/html/converter/index.js';
 export const ListHTMLConverter = {
     converter: async ({ converters, node, parent, payload })=>{
@@ -12,7 +12,7 @@ export const ListHTMLConverter = {
             },
             payload
         });
-        return `<${node?.tag} class="${node?.listType}">${childrenText}</${node?.tag}>`;
+        return `<${node?.tag} class="list-${node?.listType}">${childrenText}</${node?.tag}>`;
     },
     nodeTypes: [
         ListNode.getType()
@@ -20,6 +20,7 @@ export const ListHTMLConverter = {
 };
 export const ListItemHTMLConverter = {
     converter: async ({ converters, node, parent, payload })=>{
+        const hasSubLists = node.children.some((child)=>child.type === 'list');
         const childrenText = await convertLexicalNodesToHTML({
             converters,
             lexicalNodes: node.children,
@@ -30,15 +31,21 @@ export const ListItemHTMLConverter = {
             payload
         });
         if ('listType' in parent && parent?.listType === 'check') {
-            return `<li aria-checked=${node.checked ? 'true' : 'false'} class="${'list-item-checkbox' + node.checked ? 'list-item-checkbox-checked' : 'list-item-checkbox-unchecked'}"
+            const uuid = uuidv4();
+            return `<li aria-checked=${node.checked ? 'true' : 'false'} class="${'list-item-checkbox' + (node.checked ? ' list-item-checkbox-checked' : ' list-item-checkbox-unchecked') + (hasSubLists ? ' nestedListItem' : '')}"
           role="checkbox"
           tabIndex=${-1}
           value=${node?.value}
       >
-          ${childrenText}
+      ${hasSubLists ? childrenText : `
+        <input type="checkbox" id="${uuid}"${node.checked ? ' checked' : ''}>
+        <label for="${uuid}">${childrenText}</label><br>
+      `}
+
+
           </li>`;
         } else {
-            return `<li value=${node?.value}>${childrenText}</li>`;
+            return `<li ${hasSubLists ? `class="nestedListItem" ` : ''}value=${node?.value}>${childrenText}</li>`;
         }
     },
     nodeTypes: [

package/dist/field/features/lists/htmlConverter.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/field/features/lists/htmlConverter.ts"],"sourcesContent":["import type { SerializedListItemNode, SerializedListNode } from '@lexical/list'\n\nimport lexicalListImport from '@lexical/list'\nconst { ListItemNode, ListNode } = lexicalListImport\n\nimport type { HTMLConverter } from '../converters/html/converter/types.js'\n\nimport { convertLexicalNodesToHTML } from '../converters/html/converter/index.js'\n\nexport const ListHTMLConverter: HTMLConverter<SerializedListNode> = {\n  converter: async ({ converters, node, parent, payload }) => {\n    const childrenText = await convertLexicalNodesToHTML({\n      converters,\n      lexicalNodes: node.children,\n      parent: {\n        ...node,\n        parent,\n      },\n      payload,\n    })\n\n    return `<${node?.tag} class=\"${node?.listType}\">${childrenText}</${node?.tag}>`\n  },\n  nodeTypes: [ListNode.getType()],\n}\n\nexport const ListItemHTMLConverter: HTMLConverter<SerializedListItemNode> = {\n  converter: async ({ converters, node, parent, payload }) => {\n    const childrenText = await convertLexicalNodesToHTML({\n      converters,\n      lexicalNodes: node.children,\n      parent: {\n        ...node,\n        parent,\n      },\n      payload,\n    })\n\n    if ('listType' in parent && parent?.listType === 'check') {\n      return `<li aria-checked=${node.checked ? 'true' : 'false'} class=\"${\n        'list-item-checkbox' + node.checked\n          ? 'list-item-checkbox-checked'\n          : 'list-item-checkbox-unchecked'\n      }\"\n          role=\"checkbox\"\n          tabIndex=${-1}\n          value=${node?.value}\n      >\n          ${childrenText}\n          </li>`\n    } else {\n      return `<li value=${node?.value}>${childrenText}</li>`\n    }\n  },\n  nodeTypes: [ListItemNode.getType()],\n}\n"],"names":["lexicalListImport","ListItemNode","ListNode","convertLexicalNodesToHTML","ListHTMLConverter","converter","converters","node","parent","payload","childrenText","lexicalNodes","children","tag","listType","nodeTypes","getType","ListItemHTMLConverter","checked","value"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAEA,OAAOA,uBAAuB,gBAAe;AAC7C,MAAM,EAAEC,YAAY,EAAEC,QAAQ,EAAE,GAAGF;AAInC,SAASG,yBAAyB,QAAQ,wCAAuC;AAEjF,OAAO,MAAMC,oBAAuD;IAClEC,WAAW,OAAO,EAAEC,UAAU,EAAEC,IAAI,EAAEC,MAAM,EAAEC,OAAO,EAAE;QACrD,MAAMC,eAAe,MAAMP,0BAA0B;YACnDG;YACAK,cAAcJ,KAAKK,QAAQ;YAC3BJ,QAAQ;gBACN,GAAGD,IAAI;gBACPC;YACF;YACAC;QACF;QAEA,OAAO,CAAC,CAAC,EAAEF,MAAMM,IAAI,QAAQ,EAAEN,MAAMO,SAAS,EAAE,EAAEJ,aAAa,EAAE,EAAEH,MAAMM,IAAI,CAAC,CAAC;IACjF;IACAE,WAAW;QAACb,SAASc,OAAO;KAAG;AACjC,EAAC;AAED,OAAO,MAAMC,wBAA+D;IAC1EZ,WAAW,OAAO,EAAEC,UAAU,EAAEC,IAAI,EAAEC,MAAM,EAAEC,OAAO,EAAE;QACrD,MAAMC,eAAe,MAAMP,0BAA0B;YACnDG;YACAK,cAAcJ,KAAKK,QAAQ;YAC3BJ,QAAQ;gBACN,GAAGD,IAAI;gBACPC;YACF;YACAC;QACF;QAEA,IAAI,cAAcD,UAAUA,QAAQM,aAAa,SAAS;YACxD,OAAO,CAAC,iBAAiB,EAAEP,KAAKW,OAAO,GAAG,SAAS,QAAQ,QAAQ,EACjE,uBAAuBX,KAAKW,OAAO,GAC/B,+BACA,+BACL;;mBAEY,EAAE,CAAC,EAAE;gBACR,EAAEX,MAAMY,MAAM;;UAEpB,EAAET,aAAa;eACV,CAAC;QACZ,OAAO;YACL,OAAO,CAAC,UAAU,EAAEH,MAAMY,MAAM,CAAC,EAAET,aAAa,KAAK,CAAC;QACxD;IACF;IACAK,WAAW;QAACd,aAAae,OAAO;KAAG;AACrC,EAAC"}
+{"version":3,"sources":["../../../../src/field/features/lists/htmlConverter.ts"],"sourcesContent":["import type { SerializedListItemNode, SerializedListNode } from '@lexical/list'\n\nimport { ListItemNode, ListNode } from '@lexical/list'\nimport { v4 as uuidv4 } from 'uuid'\n\nimport type { HTMLConverter } from '../converters/html/converter/types.js'\n\nimport { convertLexicalNodesToHTML } from '../converters/html/converter/index.js'\n\nexport const ListHTMLConverter: HTMLConverter<SerializedListNode> = {\n  converter: async ({ converters, node, parent, payload }) => {\n    const childrenText = await convertLexicalNodesToHTML({\n      converters,\n      lexicalNodes: node.children,\n      parent: {\n        ...node,\n        parent,\n      },\n      payload,\n    })\n\n    return `<${node?.tag} class=\"list-${node?.listType}\">${childrenText}</${node?.tag}>`\n  },\n  nodeTypes: [ListNode.getType()],\n}\n\nexport const ListItemHTMLConverter: HTMLConverter<SerializedListItemNode> = {\n  converter: async ({ converters, node, parent, payload }) => {\n    const hasSubLists = node.children.some((child) => child.type === 'list')\n\n    const childrenText = await convertLexicalNodesToHTML({\n      converters,\n      lexicalNodes: node.children,\n      parent: {\n        ...node,\n        parent,\n      },\n      payload,\n    })\n\n    if ('listType' in parent && parent?.listType === 'check') {\n      const uuid = uuidv4()\n\n      return `<li aria-checked=${node.checked ? 'true' : 'false'} class=\"${\n        'list-item-checkbox' +\n        (node.checked ? ' list-item-checkbox-checked' : ' list-item-checkbox-unchecked') +\n        (hasSubLists ? ' nestedListItem' : '')\n      }\"\n          role=\"checkbox\"\n          tabIndex=${-1}\n          value=${node?.value}\n      >\n      ${\n        hasSubLists\n          ? childrenText\n          : `\n        <input type=\"checkbox\" id=\"${uuid}\"${node.checked ? ' checked' : ''}>\n        <label for=\"${uuid}\">${childrenText}</label><br>\n      `\n      }\n\n\n          </li>`\n    } else {\n      return `<li ${hasSubLists ? `class=\"nestedListItem\" ` : ''}value=${node?.value}>${childrenText}</li>`\n    }\n  },\n  nodeTypes: [ListItemNode.getType()],\n}\n"],"names":["ListItemNode","ListNode","v4","uuidv4","convertLexicalNodesToHTML","ListHTMLConverter","converter","converters","node","parent","payload","childrenText","lexicalNodes","children","tag","listType","nodeTypes","getType","ListItemHTMLConverter","hasSubLists","some","child","type","uuid","checked","value"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAEA,SAASA,YAAY,EAAEC,QAAQ,QAAQ,gBAAe;AACtD,SAASC,MAAMC,MAAM,QAAQ,OAAM;AAInC,SAASC,yBAAyB,QAAQ,wCAAuC;AAEjF,OAAO,MAAMC,oBAAuD;IAClEC,WAAW,OAAO,EAAEC,UAAU,EAAEC,IAAI,EAAEC,MAAM,EAAEC,OAAO,EAAE;QACrD,MAAMC,eAAe,MAAMP,0BAA0B;YACnDG;YACAK,cAAcJ,KAAKK,QAAQ;YAC3BJ,QAAQ;gBACN,GAAGD,IAAI;gBACPC;YACF;YACAC;QACF;QAEA,OAAO,CAAC,CAAC,EAAEF,MAAMM,IAAI,aAAa,EAAEN,MAAMO,SAAS,EAAE,EAAEJ,aAAa,EAAE,EAAEH,MAAMM,IAAI,CAAC,CAAC;IACtF;IACAE,WAAW;QAACf,SAASgB,OAAO;KAAG;AACjC,EAAC;AAED,OAAO,MAAMC,wBAA+D;IAC1EZ,WAAW,OAAO,EAAEC,UAAU,EAAEC,IAAI,EAAEC,MAAM,EAAEC,OAAO,EAAE;QACrD,MAAMS,cAAcX,KAAKK,QAAQ,CAACO,IAAI,CAAC,CAACC,QAAUA,MAAMC,IAAI,KAAK;QAEjE,MAAMX,eAAe,MAAMP,0BAA0B;YACnDG;YACAK,cAAcJ,KAAKK,QAAQ;YAC3BJ,QAAQ;gBACN,GAAGD,IAAI;gBACPC;YACF;YACAC;QACF;QAEA,IAAI,cAAcD,UAAUA,QAAQM,aAAa,SAAS;YACxD,MAAMQ,OAAOpB;YAEb,OAAO,CAAC,iBAAiB,EAAEK,KAAKgB,OAAO,GAAG,SAAS,QAAQ,QAAQ,EACjE,uBACChB,CAAAA,KAAKgB,OAAO,GAAG,gCAAgC,+BAA8B,IAC7EL,CAAAA,cAAc,oBAAoB,EAAC,EACrC;;mBAEY,EAAE,CAAC,EAAE;gBACR,EAAEX,MAAMiB,MAAM;;MAExB,EACEN,cACIR,eACA,CAAC;mCACsB,EAAEY,KAAK,CAAC,EAAEf,KAAKgB,OAAO,GAAG,aAAa,GAAG;oBACxD,EAAED,KAAK,EAAE,EAAEZ,aAAa;MACtC,CAAC,CACA;;;eAGQ,CAAC;QACZ,OAAO;YACL,OAAO,CAAC,IAAI,EAAEQ,cAAc,CAAC,uBAAuB,CAAC,GAAG,GAAG,MAAM,EAAEX,MAAMiB,MAAM,CAAC,EAAEd,aAAa,KAAK,CAAC;QACvG;IACF;IACAK,WAAW;QAAChB,aAAaiB,OAAO;KAAG;AACrC,EAAC"}

package/dist/field/features/lists/orderedList/feature.client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature.client.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/lists/orderedList/feature.client.tsx"],"names":[],"mappings":";AAkGA,eAAO,MAAM,iCAAiC,+BAAkD,CAAA"}

package/dist/field/features/lists/orderedList/feature.client.js

@@ -0,0 +1,96 @@
+'use client';
+import { $isListNode, INSERT_ORDERED_LIST_COMMAND, ListItemNode, ListNode } from '@lexical/list';
+import { $isRangeSelection } from 'lexical';
+import { OrderedListIcon } from '../../../lexical/ui/icons/OrderedList/index.js';
+import { createClientComponent } from '../../createClientComponent.js';
+import { toolbarTextDropdownGroupWithItems } from '../../shared/toolbar/textDropdownGroup.js';
+import { LexicalListPlugin } from '../plugin/index.js';
+import { ORDERED_LIST } from './markdownTransformer.js';
+const toolbarGroups = [
+    toolbarTextDropdownGroupWithItems([
+        {
+            ChildComponent: OrderedListIcon,
+            isActive: ({ selection })=>{
+                if (!$isRangeSelection(selection)) {
+                    return false;
+                }
+                for (const node of selection.getNodes()){
+                    if ($isListNode(node) && node.getListType() === 'number') {
+                        continue;
+                    }
+                    const parent = node.getParent();
+                    if ($isListNode(parent) && parent.getListType() === 'number') {
+                        continue;
+                    }
+                    const parentParent = parent?.getParent();
+                    // Example scenario: Node = textNode, parent = listItemNode, parentParent = listNode
+                    if ($isListNode(parentParent) && parentParent.getListType() === 'number') {
+                        continue;
+                    }
+                    return false;
+                }
+                return true;
+            },
+            key: 'orderedList',
+            label: `Ordered List`,
+            onSelect: ({ editor })=>{
+                editor.dispatchCommand(INSERT_ORDERED_LIST_COMMAND, undefined);
+            },
+            order: 10
+        }
+    ])
+];
+const OrderedListFeatureClient = (props)=>{
+    return {
+        clientFeatureProps: props,
+        feature: ({ featureProviderMap })=>{
+            return {
+                clientFeatureProps: props,
+                markdownTransformers: [
+                    ORDERED_LIST
+                ],
+                nodes: featureProviderMap.has('orderedList') ? [] : [
+                    ListNode,
+                    ListItemNode
+                ],
+                plugins: featureProviderMap.has('orderedList') ? [] : [
+                    {
+                        Component: LexicalListPlugin,
+                        position: 'normal'
+                    }
+                ],
+                slashMenu: {
+                    groups: [
+                        {
+                            items: [
+                                {
+                                    Icon: OrderedListIcon,
+                                    key: 'orderedList',
+                                    keywords: [
+                                        'ordered list',
+                                        'ol'
+                                    ],
+                                    label: 'Ordered List',
+                                    onSelect: ({ editor })=>{
+                                        editor.dispatchCommand(INSERT_ORDERED_LIST_COMMAND, undefined);
+                                    }
+                                }
+                            ],
+                            key: 'lists',
+                            label: 'Lists'
+                        }
+                    ]
+                },
+                toolbarFixed: {
+                    groups: toolbarGroups
+                },
+                toolbarInline: {
+                    groups: toolbarGroups
+                }
+            };
+        }
+    };
+};
+export const OrderedListFeatureClientComponent = createClientComponent(OrderedListFeatureClient);
+
+//# sourceMappingURL=feature.client.js.map

package/dist/field/features/lists/orderedList/feature.client.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/field/features/lists/orderedList/feature.client.tsx"],"sourcesContent":["'use client'\nimport { $isListNode, INSERT_ORDERED_LIST_COMMAND, ListItemNode, ListNode } from '@lexical/list'\nimport { $isRangeSelection } from 'lexical'\n\nimport type { ToolbarGroup } from '../../toolbars/types.js'\nimport type { FeatureProviderProviderClient } from '../../types.js'\n\nimport { OrderedListIcon } from '../../../lexical/ui/icons/OrderedList/index.js'\nimport { createClientComponent } from '../../createClientComponent.js'\nimport { toolbarTextDropdownGroupWithItems } from '../../shared/toolbar/textDropdownGroup.js'\nimport { LexicalListPlugin } from '../plugin/index.js'\nimport { ORDERED_LIST } from './markdownTransformer.js'\n\nconst toolbarGroups: ToolbarGroup[] = [\n  toolbarTextDropdownGroupWithItems([\n    {\n      ChildComponent: OrderedListIcon,\n      isActive: ({ selection }) => {\n        if (!$isRangeSelection(selection)) {\n          return false\n        }\n        for (const node of selection.getNodes()) {\n          if ($isListNode(node) && node.getListType() === 'number') {\n            continue\n          }\n\n          const parent = node.getParent()\n\n          if ($isListNode(parent) && parent.getListType() === 'number') {\n            continue\n          }\n\n          const parentParent = parent?.getParent()\n          // Example scenario: Node = textNode, parent = listItemNode, parentParent = listNode\n          if ($isListNode(parentParent) && parentParent.getListType() === 'number') {\n            continue\n          }\n\n          return false\n        }\n        return true\n      },\n      key: 'orderedList',\n      label: `Ordered List`,\n      onSelect: ({ editor }) => {\n        editor.dispatchCommand(INSERT_ORDERED_LIST_COMMAND, undefined)\n      },\n      order: 10,\n    },\n  ]),\n]\n\nconst OrderedListFeatureClient: FeatureProviderProviderClient<undefined> = (props) => {\n  return {\n    clientFeatureProps: props,\n    feature: ({ featureProviderMap }) => {\n      return {\n        clientFeatureProps: props,\n        markdownTransformers: [ORDERED_LIST],\n        nodes: featureProviderMap.has('orderedList') ? [] : [ListNode, ListItemNode],\n        plugins: featureProviderMap.has('orderedList')\n          ? []\n          : [\n              {\n                Component: LexicalListPlugin,\n                position: 'normal',\n              },\n            ],\n        slashMenu: {\n          groups: [\n            {\n              items: [\n                {\n                  Icon: OrderedListIcon,\n                  key: 'orderedList',\n                  keywords: ['ordered list', 'ol'],\n                  label: 'Ordered List',\n                  onSelect: ({ editor }) => {\n                    editor.dispatchCommand(INSERT_ORDERED_LIST_COMMAND, undefined)\n                  },\n                },\n              ],\n              key: 'lists',\n              label: 'Lists',\n            },\n          ],\n        },\n        toolbarFixed: {\n          groups: toolbarGroups,\n        },\n        toolbarInline: {\n          groups: toolbarGroups,\n        },\n      }\n    },\n  }\n}\n\nexport const OrderedListFeatureClientComponent = createClientComponent(OrderedListFeatureClient)\n"],"names":["$isListNode","INSERT_ORDERED_LIST_COMMAND","ListItemNode","ListNode","$isRangeSelection","OrderedListIcon","createClientComponent","toolbarTextDropdownGroupWithItems","LexicalListPlugin","ORDERED_LIST","toolbarGroups","ChildComponent","isActive","selection","node","getNodes","getListType","parent","getParent","parentParent","key","label","onSelect","editor","dispatchCommand","undefined","order","OrderedListFeatureClient","props","clientFeatureProps","feature","featureProviderMap","markdownTransformers","nodes","has","plugins","Component","position","slashMenu","groups","items","Icon","keywords","toolbarFixed","toolbarInline","OrderedListFeatureClientComponent"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;AACA,SAASA,WAAW,EAAEC,2BAA2B,EAAEC,YAAY,EAAEC,QAAQ,QAAQ,gBAAe;AAChG,SAASC,iBAAiB,QAAQ,UAAS;AAK3C,SAASC,eAAe,QAAQ,iDAAgD;AAChF,SAASC,qBAAqB,QAAQ,iCAAgC;AACtE,SAASC,iCAAiC,QAAQ,4CAA2C;AAC7F,SAASC,iBAAiB,QAAQ,qBAAoB;AACtD,SAASC,YAAY,QAAQ,2BAA0B;AAEvD,MAAMC,gBAAgC;IACpCH,kCAAkC;QAChC;YACEI,gBAAgBN;YAChBO,UAAU,CAAC,EAAEC,SAAS,EAAE;gBACtB,IAAI,CAACT,kBAAkBS,YAAY;oBACjC,OAAO;gBACT;gBACA,KAAK,MAAMC,QAAQD,UAAUE,QAAQ,GAAI;oBACvC,IAAIf,YAAYc,SAASA,KAAKE,WAAW,OAAO,UAAU;wBACxD;oBACF;oBAEA,MAAMC,SAASH,KAAKI,SAAS;oBAE7B,IAAIlB,YAAYiB,WAAWA,OAAOD,WAAW,OAAO,UAAU;wBAC5D;oBACF;oBAEA,MAAMG,eAAeF,QAAQC;oBAC7B,oFAAoF;oBACpF,IAAIlB,YAAYmB,iBAAiBA,aAAaH,WAAW,OAAO,UAAU;wBACxE;oBACF;oBAEA,OAAO;gBACT;gBACA,OAAO;YACT;YACAI,KAAK;YACLC,OAAO,CAAC,YAAY,CAAC;YACrBC,UAAU,CAAC,EAAEC,MAAM,EAAE;gBACnBA,OAAOC,eAAe,CAACvB,6BAA6BwB;YACtD;YACAC,OAAO;QACT;KACD;CACF;AAED,MAAMC,2BAAqE,CAACC;IAC1E,OAAO;QACLC,oBAAoBD;QACpBE,SAAS,CAAC,EAAEC,kBAAkB,EAAE;YAC9B,OAAO;gBACLF,oBAAoBD;gBACpBI,sBAAsB;oBAACvB;iBAAa;gBACpCwB,OAAOF,mBAAmBG,GAAG,CAAC,iBAAiB,EAAE,GAAG;oBAAC/B;oBAAUD;iBAAa;gBAC5EiC,SAASJ,mBAAmBG,GAAG,CAAC,iBAC5B,EAAE,GACF;oBACE;wBACEE,WAAW5B;wBACX6B,UAAU;oBACZ;iBACD;gBACLC,WAAW;oBACTC,QAAQ;wBACN;4BACEC,OAAO;gCACL;oCACEC,MAAMpC;oCACNe,KAAK;oCACLsB,UAAU;wCAAC;wCAAgB;qCAAK;oCAChCrB,OAAO;oCACPC,UAAU,CAAC,EAAEC,MAAM,EAAE;wCACnBA,OAAOC,eAAe,CAACvB,6BAA6BwB;oCACtD;gCACF;6BACD;4BACDL,KAAK;4BACLC,OAAO;wBACT;qBACD;gBACH;gBACAsB,cAAc;oBACZJ,QAAQ7B;gBACV;gBACAkC,eAAe;oBACbL,QAAQ7B;gBACV;YACF;QACF;IACF;AACF;AAEA,OAAO,MAAMmC,oCAAoCvC,sBAAsBqB,0BAAyB"}

package/dist/field/features/lists/orderedList/feature.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature.server.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/lists/orderedList/feature.server.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,gBAAgB,CAAA;AAOnE,eAAO,MAAM,kBAAkB,EAAE,6BAA6B,CAAC,SAAS,EAAE,SAAS,CA4BlF,CAAA"}

package/dist/field/features/lists/{orderedlist → orderedList}/feature.server.js

@@ -1,5 +1,5 @@
-import lexicalListImport from '@lexical/list';
-const { ListItemNode, ListNode } = lexicalListImport;
+import { ListItemNode, ListNode } from '@lexical/list';
+import { createNode } from '../../typeUtilities.js';
 import { ListHTMLConverter, ListItemHTMLConverter } from '../htmlConverter.js';
 import { OrderedListFeatureClientComponent } from './feature.client.js';
 import { ORDERED_LIST } from './markdownTransformer.js';
@@ -12,23 +12,23 @@ export const OrderedListFeature = (props)=>{
                     ORDERED_LIST
                 ],
                 nodes: featureProviderMap.has('unorderedlist') ? [] : [
-                    {
+                    createNode({
                         converters: {
                             html: ListHTMLConverter
                         },
                         node: ListNode
-                    },
-                    {
+                    }),
+                    createNode({
                         converters: {
                             html: ListItemHTMLConverter
                         },
                         node: ListItemNode
-                    }
+                    })
                 ],
                 serverFeatureProps: props
             };
         },
-        key: 'orderedlist',
+        key: 'orderedList',
         serverFeatureProps: props
     };
 };

package/dist/field/features/lists/orderedList/feature.server.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/field/features/lists/orderedList/feature.server.ts"],"sourcesContent":["import { ListItemNode, ListNode } from '@lexical/list'\n\nimport type { FeatureProviderProviderServer } from '../../types.js'\n\nimport { createNode } from '../../typeUtilities.js'\nimport { ListHTMLConverter, ListItemHTMLConverter } from '../htmlConverter.js'\nimport { OrderedListFeatureClientComponent } from './feature.client.js'\nimport { ORDERED_LIST } from './markdownTransformer.js'\n\nexport const OrderedListFeature: FeatureProviderProviderServer<undefined, undefined> = (props) => {\n  return {\n    feature: ({ featureProviderMap }) => {\n      return {\n        ClientComponent: OrderedListFeatureClientComponent,\n        markdownTransformers: [ORDERED_LIST],\n        nodes: featureProviderMap.has('unorderedlist')\n          ? []\n          : [\n              createNode({\n                converters: {\n                  html: ListHTMLConverter,\n                },\n                node: ListNode,\n              }),\n              createNode({\n                converters: {\n                  html: ListItemHTMLConverter,\n                },\n                node: ListItemNode,\n              }),\n            ],\n        serverFeatureProps: props,\n      }\n    },\n    key: 'orderedList',\n    serverFeatureProps: props,\n  }\n}\n"],"names":["ListItemNode","ListNode","createNode","ListHTMLConverter","ListItemHTMLConverter","OrderedListFeatureClientComponent","ORDERED_LIST","OrderedListFeature","props","feature","featureProviderMap","ClientComponent","markdownTransformers","nodes","has","converters","html","node","serverFeatureProps","key"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,YAAY,EAAEC,QAAQ,QAAQ,gBAAe;AAItD,SAASC,UAAU,QAAQ,yBAAwB;AACnD,SAASC,iBAAiB,EAAEC,qBAAqB,QAAQ,sBAAqB;AAC9E,SAASC,iCAAiC,QAAQ,sBAAqB;AACvE,SAASC,YAAY,QAAQ,2BAA0B;AAEvD,OAAO,MAAMC,qBAA0E,CAACC;IACtF,OAAO;QACLC,SAAS,CAAC,EAAEC,kBAAkB,EAAE;YAC9B,OAAO;gBACLC,iBAAiBN;gBACjBO,sBAAsB;oBAACN;iBAAa;gBACpCO,OAAOH,mBAAmBI,GAAG,CAAC,mBAC1B,EAAE,GACF;oBACEZ,WAAW;wBACTa,YAAY;4BACVC,MAAMb;wBACR;wBACAc,MAAMhB;oBACR;oBACAC,WAAW;wBACTa,YAAY;4BACVC,MAAMZ;wBACR;wBACAa,MAAMjB;oBACR;iBACD;gBACLkB,oBAAoBV;YACtB;QACF;QACAW,KAAK;QACLD,oBAAoBV;IACtB;AACF,EAAC"}

package/dist/field/features/lists/orderedList/markdownTransformer.d.ts.map

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

package/dist/field/features/lists/{orderedlist → orderedList}/markdownTransformer.js

@@ -1,6 +1,5 @@
-import lexicalListImport from '@lexical/list';
-const { $isListNode, ListItemNode, ListNode } = lexicalListImport;
-import { listExport, listReplace } from '../common/markdown.js';
+import { $isListNode, ListItemNode, ListNode } from '@lexical/list';
+import { listExport, listReplace } from '../shared/markdown.js';
 export const ORDERED_LIST = {
     type: 'element',
     dependencies: [

package/dist/field/features/lists/orderedList/markdownTransformer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/field/features/lists/orderedList/markdownTransformer.ts"],"sourcesContent":["import type { ElementTransformer } from '@lexical/markdown'\n\nimport { $isListNode, ListItemNode, ListNode } from '@lexical/list'\n\nimport { listExport, listReplace } from '../shared/markdown.js'\n\nexport const ORDERED_LIST: ElementTransformer = {\n  type: 'element',\n  dependencies: [ListNode, ListItemNode],\n  export: (node, exportChildren) => {\n    return $isListNode(node) ? listExport(node, exportChildren, 0) : null\n  },\n  regExp: /^(\\s*)(\\d+)\\.\\s/,\n  replace: listReplace('number'),\n}\n"],"names":["$isListNode","ListItemNode","ListNode","listExport","listReplace","ORDERED_LIST","type","dependencies","export","node","exportChildren","regExp","replace"],"rangeMappings":";;;;;;;;;;;;;","mappings":"AAEA,SAASA,WAAW,EAAEC,YAAY,EAAEC,QAAQ,QAAQ,gBAAe;AAEnE,SAASC,UAAU,EAAEC,WAAW,QAAQ,wBAAuB;AAE/D,OAAO,MAAMC,eAAmC;IAC9CC,MAAM;IACNC,cAAc;QAACL;QAAUD;KAAa;IACtCO,QAAQ,CAACC,MAAMC;QACb,OAAOV,YAAYS,QAAQN,WAAWM,MAAMC,gBAAgB,KAAK;IACnE;IACAC,QAAQ;IACRC,SAASR,YAAY;AACvB,EAAC"}

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

@@ -1,3 +1,3 @@
-import React from 'react';
-export declare function LexicalListPlugin(): React.JSX.Element;
+import type { PluginComponent } from '../../types.js';
+export declare const LexicalListPlugin: PluginComponent<undefined>;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/lists/plugin/index.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,MAAM,OAAO,CAAA;AAEzB,wBAAgB,iBAAiB,sBAEhC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/lists/plugin/index.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAErD,eAAO,MAAM,iBAAiB,EAAE,eAAe,CAAC,SAAS,CAExD,CAAA"}

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

@@ -1,9 +1,8 @@
 'use client';
-import lexicalListPluginImport from '@lexical/react/LexicalListPlugin.js';
-const { ListPlugin } = lexicalListPluginImport;
+import { ListPlugin } from '@lexical/react/LexicalListPlugin.js';
 import React from 'react';
-export function LexicalListPlugin() {
+export const LexicalListPlugin = ()=>{
     return /*#__PURE__*/ React.createElement(ListPlugin, null);
-}
+};
 
 //# sourceMappingURL=index.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/field/features/lists/plugin/index.tsx"],"sourcesContent":["'use client'\nimport lexicalListPluginImport from '@lexical/react/LexicalListPlugin.js'\nconst { ListPlugin } = lexicalListPluginImport\nimport React from 'react'\n\nexport function LexicalListPlugin() {\n  return <ListPlugin />\n}\n"],"names":["lexicalListPluginImport","ListPlugin","React","LexicalListPlugin"],"rangeMappings":";;;;;;","mappings":"AAAA;AACA,OAAOA,6BAA6B,sCAAqC;AACzE,MAAM,EAAEC,UAAU,EAAE,GAAGD;AACvB,OAAOE,WAAW,QAAO;AAEzB,OAAO,SAASC;IACd,qBAAO,oBAACF;AACV"}
+{"version":3,"sources":["../../../../../src/field/features/lists/plugin/index.tsx"],"sourcesContent":["'use client'\nimport { ListPlugin } from '@lexical/react/LexicalListPlugin.js'\nimport React from 'react'\n\nimport type { PluginComponent } from '../../types.js'\n\nexport const LexicalListPlugin: PluginComponent<undefined> = () => {\n  return <ListPlugin />\n}\n"],"names":["ListPlugin","React","LexicalListPlugin"],"rangeMappings":";;;;;","mappings":"AAAA;AACA,SAASA,UAAU,QAAQ,sCAAqC;AAChE,OAAOC,WAAW,QAAO;AAIzB,OAAO,MAAMC,oBAAgD;IAC3D,qBAAO,oBAACF;AACV,EAAC"}

package/dist/field/features/lists/{common → shared}/markdown.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/lists/common/markdown.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AACvD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AAC3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAQ1C,eAAO,MAAM,WAAW,aAAc,QAAQ,KAAG,kBAAkB,CAAC,SAAS,CA6B5E,CAAA;AAED,eAAO,MAAM,UAAU,aACX,QAAQ,kBACF,CAAC,IAAI,EAAE,WAAW,KAAK,MAAM,SACtC,MAAM,KACZ,MA2BF,CAAA"}
+{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/lists/shared/markdown.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AACvD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AAC3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAO1C,eAAO,MAAM,WAAW,aAAc,QAAQ,KAAG,kBAAkB,CAAC,SAAS,CA6B5E,CAAA;AAED,eAAO,MAAM,UAAU,aACX,QAAQ,kBACF,CAAC,IAAI,EAAE,WAAW,KAAK,MAAM,SACtC,MAAM,KACZ,MA2BF,CAAA"}

package/dist/field/features/lists/{common → shared}/markdown.js

@@ -1,6 +1,5 @@
 // Copied from https://github.com/facebook/lexical/blob/176b8cf16ecb332ee5efe2c75219e223b7b019f2/packages/lexical-markdown/src/MarkdownTransformers.ts#L97C1-L172C1
-import lexicalListImport from '@lexical/list';
-const { $createListItemNode, $createListNode, $isListItemNode, $isListNode } = lexicalListImport;
+import { $createListItemNode, $createListNode, $isListItemNode, $isListNode } from '@lexical/list';
 // Amount of spaces that define indentation level
 const LIST_INDENT_SIZE = 4;
 export const listReplace = (listType)=>{

package/dist/field/features/lists/shared/markdown.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/field/features/lists/shared/markdown.ts"],"sourcesContent":["// Copied from https://github.com/facebook/lexical/blob/176b8cf16ecb332ee5efe2c75219e223b7b019f2/packages/lexical-markdown/src/MarkdownTransformers.ts#L97C1-L172C1\n\nimport type { ListNode, ListType } from '@lexical/list'\nimport type { ElementTransformer } from '@lexical/markdown'\nimport type { ElementNode } from 'lexical'\n\nimport { $createListItemNode, $createListNode, $isListItemNode, $isListNode } from '@lexical/list'\n\n// Amount of spaces that define indentation level\nconst LIST_INDENT_SIZE = 4\n\nexport const listReplace = (listType: ListType): ElementTransformer['replace'] => {\n  return (parentNode, children, match) => {\n    const previousNode = parentNode.getPreviousSibling()\n    const nextNode = parentNode.getNextSibling()\n    const listItem = $createListItemNode(listType === 'check' ? match[3] === 'x' : undefined)\n    if ($isListNode(nextNode) && nextNode.getListType() === listType) {\n      const firstChild = nextNode.getFirstChild()\n      if (firstChild !== null) {\n        firstChild.insertBefore(listItem)\n      } else {\n        // should never happen, but let's handle gracefully, just in case.\n        nextNode.append(listItem)\n      }\n      parentNode.remove()\n    } else if ($isListNode(previousNode) && previousNode.getListType() === listType) {\n      previousNode.append(listItem)\n      parentNode.remove()\n    } else {\n      const list = $createListNode(listType, listType === 'number' ? Number(match[2]) : undefined)\n      list.append(listItem)\n      parentNode.replace(list)\n    }\n    listItem.append(...children)\n    listItem.select(0, 0)\n    const indent = Math.floor(match[1].length / LIST_INDENT_SIZE)\n    if (indent) {\n      listItem.setIndent(indent)\n    }\n  }\n}\n\nexport const listExport = (\n  listNode: ListNode,\n  exportChildren: (node: ElementNode) => string,\n  depth: number,\n): string => {\n  const output = []\n  const children = listNode.getChildren()\n  let index = 0\n  for (const listItemNode of children) {\n    if ($isListItemNode(listItemNode)) {\n      if (listItemNode.getChildrenSize() === 1) {\n        const firstChild = listItemNode.getFirstChild()\n        if ($isListNode(firstChild)) {\n          output.push(listExport(firstChild, exportChildren, depth + 1))\n          continue\n        }\n      }\n      const indent = ' '.repeat(depth * LIST_INDENT_SIZE)\n      const listType = listNode.getListType()\n      const prefix =\n        listType === 'number'\n          ? `${listNode.getStart() + index}. `\n          : listType === 'check'\n            ? `- [${listItemNode.getChecked() ? 'x' : ' '}] `\n            : '- '\n      output.push(indent + prefix + exportChildren(listItemNode))\n      index++\n    }\n  }\n\n  return output.join('\\n')\n}\n"],"names":["$createListItemNode","$createListNode","$isListItemNode","$isListNode","LIST_INDENT_SIZE","listReplace","listType","parentNode","children","match","previousNode","getPreviousSibling","nextNode","getNextSibling","listItem","undefined","getListType","firstChild","getFirstChild","insertBefore","append","remove","list","Number","replace","select","indent","Math","floor","length","setIndent","listExport","listNode","exportChildren","depth","output","getChildren","index","listItemNode","getChildrenSize","push","repeat","prefix","getStart","getChecked","join"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,mKAAmK;AAMnK,SAASA,mBAAmB,EAAEC,eAAe,EAAEC,eAAe,EAAEC,WAAW,QAAQ,gBAAe;AAElG,iDAAiD;AACjD,MAAMC,mBAAmB;AAEzB,OAAO,MAAMC,cAAc,CAACC;IAC1B,OAAO,CAACC,YAAYC,UAAUC;QAC5B,MAAMC,eAAeH,WAAWI,kBAAkB;QAClD,MAAMC,WAAWL,WAAWM,cAAc;QAC1C,MAAMC,WAAWd,oBAAoBM,aAAa,UAAUG,KAAK,CAAC,EAAE,KAAK,MAAMM;QAC/E,IAAIZ,YAAYS,aAAaA,SAASI,WAAW,OAAOV,UAAU;YAChE,MAAMW,aAAaL,SAASM,aAAa;YACzC,IAAID,eAAe,MAAM;gBACvBA,WAAWE,YAAY,CAACL;YAC1B,OAAO;gBACL,kEAAkE;gBAClEF,SAASQ,MAAM,CAACN;YAClB;YACAP,WAAWc,MAAM;QACnB,OAAO,IAAIlB,YAAYO,iBAAiBA,aAAaM,WAAW,OAAOV,UAAU;YAC/EI,aAAaU,MAAM,CAACN;YACpBP,WAAWc,MAAM;QACnB,OAAO;YACL,MAAMC,OAAOrB,gBAAgBK,UAAUA,aAAa,WAAWiB,OAAOd,KAAK,CAAC,EAAE,IAAIM;YAClFO,KAAKF,MAAM,CAACN;YACZP,WAAWiB,OAAO,CAACF;QACrB;QACAR,SAASM,MAAM,IAAIZ;QACnBM,SAASW,MAAM,CAAC,GAAG;QACnB,MAAMC,SAASC,KAAKC,KAAK,CAACnB,KAAK,CAAC,EAAE,CAACoB,MAAM,GAAGzB;QAC5C,IAAIsB,QAAQ;YACVZ,SAASgB,SAAS,CAACJ;QACrB;IACF;AACF,EAAC;AAED,OAAO,MAAMK,aAAa,CACxBC,UACAC,gBACAC;IAEA,MAAMC,SAAS,EAAE;IACjB,MAAM3B,WAAWwB,SAASI,WAAW;IACrC,IAAIC,QAAQ;IACZ,KAAK,MAAMC,gBAAgB9B,SAAU;QACnC,IAAIN,gBAAgBoC,eAAe;YACjC,IAAIA,aAAaC,eAAe,OAAO,GAAG;gBACxC,MAAMtB,aAAaqB,aAAapB,aAAa;gBAC7C,IAAIf,YAAYc,aAAa;oBAC3BkB,OAAOK,IAAI,CAACT,WAAWd,YAAYgB,gBAAgBC,QAAQ;oBAC3D;gBACF;YACF;YACA,MAAMR,SAAS,IAAIe,MAAM,CAACP,QAAQ9B;YAClC,MAAME,WAAW0B,SAAShB,WAAW;YACrC,MAAM0B,SACJpC,aAAa,WACT,CAAC,EAAE0B,SAASW,QAAQ,KAAKN,MAAM,EAAE,CAAC,GAClC/B,aAAa,UACX,CAAC,GAAG,EAAEgC,aAAaM,UAAU,KAAK,MAAM,IAAI,EAAE,CAAC,GAC/C;YACRT,OAAOK,IAAI,CAACd,SAASgB,SAAST,eAAeK;YAC7CD;QACF;IACF;IAEA,OAAOF,OAAOU,IAAI,CAAC;AACrB,EAAC"}

package/dist/field/features/lists/unorderedList/feature.client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature.client.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/lists/unorderedList/feature.client.tsx"],"names":[],"mappings":";AAiGA,eAAO,MAAM,mCAAmC,+BAAoD,CAAA"}

package/dist/field/features/lists/unorderedList/feature.client.js

@@ -0,0 +1,96 @@
+'use client';
+import { $isListNode, INSERT_UNORDERED_LIST_COMMAND, ListItemNode, ListNode } from '@lexical/list';
+import { $isRangeSelection } from 'lexical';
+import { UnorderedListIcon } from '../../../lexical/ui/icons/UnorderedList/index.js';
+import { createClientComponent } from '../../createClientComponent.js';
+import { toolbarTextDropdownGroupWithItems } from '../../shared/toolbar/textDropdownGroup.js';
+import { LexicalListPlugin } from '../plugin/index.js';
+import { UNORDERED_LIST } from './markdownTransformer.js';
+const toolbarGroups = [
+    toolbarTextDropdownGroupWithItems([
+        {
+            ChildComponent: UnorderedListIcon,
+            isActive: ({ selection })=>{
+                if (!$isRangeSelection(selection)) {
+                    return false;
+                }
+                for (const node of selection.getNodes()){
+                    if ($isListNode(node) && node.getListType() === 'bullet') {
+                        continue;
+                    }
+                    const parent = node.getParent();
+                    if ($isListNode(parent) && parent.getListType() === 'bullet') {
+                        continue;
+                    }
+                    const parentParent = parent?.getParent();
+                    // Example scenario: Node = textNode, parent = listItemNode, parentParent = listNode
+                    if ($isListNode(parentParent) && parentParent.getListType() === 'bullet') {
+                        continue;
+                    }
+                    return false;
+                }
+                return true;
+            },
+            key: 'unorderedList',
+            label: `Unordered List`,
+            onSelect: ({ editor })=>{
+                editor.dispatchCommand(INSERT_UNORDERED_LIST_COMMAND, undefined);
+            },
+            order: 11
+        }
+    ])
+];
+const UnorderedListFeatureClient = (props)=>{
+    return {
+        clientFeatureProps: props,
+        feature: ()=>{
+            return {
+                clientFeatureProps: props,
+                markdownTransformers: [
+                    UNORDERED_LIST
+                ],
+                nodes: [
+                    ListNode,
+                    ListItemNode
+                ],
+                plugins: [
+                    {
+                        Component: LexicalListPlugin,
+                        position: 'normal'
+                    }
+                ],
+                slashMenu: {
+                    groups: [
+                        {
+                            items: [
+                                {
+                                    Icon: UnorderedListIcon,
+                                    key: 'unorderedList',
+                                    keywords: [
+                                        'unordered list',
+                                        'ul'
+                                    ],
+                                    label: 'Unordered List',
+                                    onSelect: ({ editor })=>{
+                                        editor.dispatchCommand(INSERT_UNORDERED_LIST_COMMAND, undefined);
+                                    }
+                                }
+                            ],
+                            key: 'lists',
+                            label: 'Lists'
+                        }
+                    ]
+                },
+                toolbarFixed: {
+                    groups: toolbarGroups
+                },
+                toolbarInline: {
+                    groups: toolbarGroups
+                }
+            };
+        }
+    };
+};
+export const UnorderedListFeatureClientComponent = createClientComponent(UnorderedListFeatureClient);
+
+//# sourceMappingURL=feature.client.js.map

package/dist/field/features/lists/unorderedList/feature.client.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/field/features/lists/unorderedList/feature.client.tsx"],"sourcesContent":["'use client'\n\nimport { $isListNode, INSERT_UNORDERED_LIST_COMMAND, ListItemNode, ListNode } from '@lexical/list'\nimport { $isRangeSelection } from 'lexical'\n\nimport type { ToolbarGroup } from '../../toolbars/types.js'\nimport type { FeatureProviderProviderClient } from '../../types.js'\n\nimport { UnorderedListIcon } from '../../../lexical/ui/icons/UnorderedList/index.js'\nimport { createClientComponent } from '../../createClientComponent.js'\nimport { toolbarTextDropdownGroupWithItems } from '../../shared/toolbar/textDropdownGroup.js'\nimport { LexicalListPlugin } from '../plugin/index.js'\nimport { UNORDERED_LIST } from './markdownTransformer.js'\n\nconst toolbarGroups: ToolbarGroup[] = [\n  toolbarTextDropdownGroupWithItems([\n    {\n      ChildComponent: UnorderedListIcon,\n      isActive: ({ selection }) => {\n        if (!$isRangeSelection(selection)) {\n          return false\n        }\n        for (const node of selection.getNodes()) {\n          if ($isListNode(node) && node.getListType() === 'bullet') {\n            continue\n          }\n\n          const parent = node.getParent()\n\n          if ($isListNode(parent) && parent.getListType() === 'bullet') {\n            continue\n          }\n\n          const parentParent = parent?.getParent()\n          // Example scenario: Node = textNode, parent = listItemNode, parentParent = listNode\n          if ($isListNode(parentParent) && parentParent.getListType() === 'bullet') {\n            continue\n          }\n\n          return false\n        }\n        return true\n      },\n      key: 'unorderedList',\n      label: `Unordered List`,\n      onSelect: ({ editor }) => {\n        editor.dispatchCommand(INSERT_UNORDERED_LIST_COMMAND, undefined)\n      },\n      order: 11,\n    },\n  ]),\n]\n\nconst UnorderedListFeatureClient: FeatureProviderProviderClient<undefined> = (props) => {\n  return {\n    clientFeatureProps: props,\n    feature: () => {\n      return {\n        clientFeatureProps: props,\n        markdownTransformers: [UNORDERED_LIST],\n        nodes: [ListNode, ListItemNode],\n        plugins: [\n          {\n            Component: LexicalListPlugin,\n            position: 'normal',\n          },\n        ],\n        slashMenu: {\n          groups: [\n            {\n              items: [\n                {\n                  Icon: UnorderedListIcon,\n                  key: 'unorderedList',\n                  keywords: ['unordered list', 'ul'],\n                  label: 'Unordered List',\n                  onSelect: ({ editor }) => {\n                    editor.dispatchCommand(INSERT_UNORDERED_LIST_COMMAND, undefined)\n                  },\n                },\n              ],\n              key: 'lists',\n              label: 'Lists',\n            },\n          ],\n        },\n        toolbarFixed: {\n          groups: toolbarGroups,\n        },\n        toolbarInline: {\n          groups: toolbarGroups,\n        },\n      }\n    },\n  }\n}\n\nexport const UnorderedListFeatureClientComponent = createClientComponent(UnorderedListFeatureClient)\n"],"names":["$isListNode","INSERT_UNORDERED_LIST_COMMAND","ListItemNode","ListNode","$isRangeSelection","UnorderedListIcon","createClientComponent","toolbarTextDropdownGroupWithItems","LexicalListPlugin","UNORDERED_LIST","toolbarGroups","ChildComponent","isActive","selection","node","getNodes","getListType","parent","getParent","parentParent","key","label","onSelect","editor","dispatchCommand","undefined","order","UnorderedListFeatureClient","props","clientFeatureProps","feature","markdownTransformers","nodes","plugins","Component","position","slashMenu","groups","items","Icon","keywords","toolbarFixed","toolbarInline","UnorderedListFeatureClientComponent"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;AAEA,SAASA,WAAW,EAAEC,6BAA6B,EAAEC,YAAY,EAAEC,QAAQ,QAAQ,gBAAe;AAClG,SAASC,iBAAiB,QAAQ,UAAS;AAK3C,SAASC,iBAAiB,QAAQ,mDAAkD;AACpF,SAASC,qBAAqB,QAAQ,iCAAgC;AACtE,SAASC,iCAAiC,QAAQ,4CAA2C;AAC7F,SAASC,iBAAiB,QAAQ,qBAAoB;AACtD,SAASC,cAAc,QAAQ,2BAA0B;AAEzD,MAAMC,gBAAgC;IACpCH,kCAAkC;QAChC;YACEI,gBAAgBN;YAChBO,UAAU,CAAC,EAAEC,SAAS,EAAE;gBACtB,IAAI,CAACT,kBAAkBS,YAAY;oBACjC,OAAO;gBACT;gBACA,KAAK,MAAMC,QAAQD,UAAUE,QAAQ,GAAI;oBACvC,IAAIf,YAAYc,SAASA,KAAKE,WAAW,OAAO,UAAU;wBACxD;oBACF;oBAEA,MAAMC,SAASH,KAAKI,SAAS;oBAE7B,IAAIlB,YAAYiB,WAAWA,OAAOD,WAAW,OAAO,UAAU;wBAC5D;oBACF;oBAEA,MAAMG,eAAeF,QAAQC;oBAC7B,oFAAoF;oBACpF,IAAIlB,YAAYmB,iBAAiBA,aAAaH,WAAW,OAAO,UAAU;wBACxE;oBACF;oBAEA,OAAO;gBACT;gBACA,OAAO;YACT;YACAI,KAAK;YACLC,OAAO,CAAC,cAAc,CAAC;YACvBC,UAAU,CAAC,EAAEC,MAAM,EAAE;gBACnBA,OAAOC,eAAe,CAACvB,+BAA+BwB;YACxD;YACAC,OAAO;QACT;KACD;CACF;AAED,MAAMC,6BAAuE,CAACC;IAC5E,OAAO;QACLC,oBAAoBD;QACpBE,SAAS;YACP,OAAO;gBACLD,oBAAoBD;gBACpBG,sBAAsB;oBAACtB;iBAAe;gBACtCuB,OAAO;oBAAC7B;oBAAUD;iBAAa;gBAC/B+B,SAAS;oBACP;wBACEC,WAAW1B;wBACX2B,UAAU;oBACZ;iBACD;gBACDC,WAAW;oBACTC,QAAQ;wBACN;4BACEC,OAAO;gCACL;oCACEC,MAAMlC;oCACNe,KAAK;oCACLoB,UAAU;wCAAC;wCAAkB;qCAAK;oCAClCnB,OAAO;oCACPC,UAAU,CAAC,EAAEC,MAAM,EAAE;wCACnBA,OAAOC,eAAe,CAACvB,+BAA+BwB;oCACxD;gCACF;6BACD;4BACDL,KAAK;4BACLC,OAAO;wBACT;qBACD;gBACH;gBACAoB,cAAc;oBACZJ,QAAQ3B;gBACV;gBACAgC,eAAe;oBACbL,QAAQ3B;gBACV;YACF;QACF;IACF;AACF;AAEA,OAAO,MAAMiC,sCAAsCrC,sBAAsBqB,4BAA2B"}

package/dist/field/features/lists/unorderedList/feature.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature.server.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/lists/unorderedList/feature.server.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,gBAAgB,CAAA;AAOnE,eAAO,MAAM,oBAAoB,EAAE,6BAA6B,CAAC,SAAS,EAAE,SAAS,CA4BpF,CAAA"}

package/dist/field/features/lists/{unorderedlist → unorderedList}/feature.server.js

@@ -1,5 +1,5 @@
-import lexicalListImport from '@lexical/list';
-const { ListItemNode, ListNode } = lexicalListImport;
+import { ListItemNode, ListNode } from '@lexical/list';
+import { createNode } from '../../typeUtilities.js';
 import { ListHTMLConverter, ListItemHTMLConverter } from '../htmlConverter.js';
 import { UnorderedListFeatureClientComponent } from './feature.client.js';
 import { UNORDERED_LIST } from './markdownTransformer.js';
@@ -12,23 +12,23 @@ export const UnorderedListFeature = (props)=>{
                     UNORDERED_LIST
                 ],
                 nodes: [
-                    {
+                    createNode({
                         converters: {
                             html: ListHTMLConverter
                         },
                         node: ListNode
-                    },
-                    {
+                    }),
+                    createNode({
                         converters: {
                             html: ListItemHTMLConverter
                         },
                         node: ListItemNode
-                    }
+                    })
                 ],
                 serverFeatureProps: props
             };
         },
-        key: 'unorderedlist',
+        key: 'unorderedList',
         serverFeatureProps: props
     };
 };

package/dist/field/features/lists/unorderedList/feature.server.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/field/features/lists/unorderedList/feature.server.ts"],"sourcesContent":["import { ListItemNode, ListNode } from '@lexical/list'\n\nimport type { FeatureProviderProviderServer } from '../../types.js'\n\nimport { createNode } from '../../typeUtilities.js'\nimport { ListHTMLConverter, ListItemHTMLConverter } from '../htmlConverter.js'\nimport { UnorderedListFeatureClientComponent } from './feature.client.js'\nimport { UNORDERED_LIST } from './markdownTransformer.js'\n\nexport const UnorderedListFeature: FeatureProviderProviderServer<undefined, undefined> = (\n  props,\n) => {\n  return {\n    feature: () => {\n      return {\n        ClientComponent: UnorderedListFeatureClientComponent,\n        markdownTransformers: [UNORDERED_LIST],\n        nodes: [\n          createNode({\n            converters: {\n              html: ListHTMLConverter,\n            },\n            node: ListNode,\n          }),\n          createNode({\n            converters: {\n              html: ListItemHTMLConverter,\n            },\n            node: ListItemNode,\n          }),\n        ],\n        serverFeatureProps: props,\n      }\n    },\n    key: 'unorderedList',\n    serverFeatureProps: props,\n  }\n}\n"],"names":["ListItemNode","ListNode","createNode","ListHTMLConverter","ListItemHTMLConverter","UnorderedListFeatureClientComponent","UNORDERED_LIST","UnorderedListFeature","props","feature","ClientComponent","markdownTransformers","nodes","converters","html","node","serverFeatureProps","key"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,YAAY,EAAEC,QAAQ,QAAQ,gBAAe;AAItD,SAASC,UAAU,QAAQ,yBAAwB;AACnD,SAASC,iBAAiB,EAAEC,qBAAqB,QAAQ,sBAAqB;AAC9E,SAASC,mCAAmC,QAAQ,sBAAqB;AACzE,SAASC,cAAc,QAAQ,2BAA0B;AAEzD,OAAO,MAAMC,uBAA4E,CACvFC;IAEA,OAAO;QACLC,SAAS;YACP,OAAO;gBACLC,iBAAiBL;gBACjBM,sBAAsB;oBAACL;iBAAe;gBACtCM,OAAO;oBACLV,WAAW;wBACTW,YAAY;4BACVC,MAAMX;wBACR;wBACAY,MAAMd;oBACR;oBACAC,WAAW;wBACTW,YAAY;4BACVC,MAAMV;wBACR;wBACAW,MAAMf;oBACR;iBACD;gBACDgB,oBAAoBR;YACtB;QACF;QACAS,KAAK;QACLD,oBAAoBR;IACtB;AACF,EAAC"}

package/dist/field/features/lists/unorderedList/markdownTransformer.d.ts.map

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

package/dist/field/features/lists/{unorderedlist → unorderedList}/markdownTransformer.js

@@ -1,6 +1,5 @@
-import lexicalListImport from '@lexical/list';
-const { $isListNode, ListItemNode, ListNode } = lexicalListImport;
-import { listExport, listReplace } from '../common/markdown.js';
+import { $isListNode, ListItemNode, ListNode } from '@lexical/list';
+import { listExport, listReplace } from '../shared/markdown.js';
 export const UNORDERED_LIST = {
     type: 'element',
     dependencies: [

package/dist/field/features/lists/unorderedList/markdownTransformer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/field/features/lists/unorderedList/markdownTransformer.ts"],"sourcesContent":["import type { ElementTransformer } from '@lexical/markdown'\n\nimport { $isListNode, ListItemNode, ListNode } from '@lexical/list'\n\nimport { listExport, listReplace } from '../shared/markdown.js'\n\nexport const UNORDERED_LIST: ElementTransformer = {\n  type: 'element',\n  dependencies: [ListNode, ListItemNode],\n  export: (node, exportChildren) => {\n    return $isListNode(node) ? listExport(node, exportChildren, 0) : null\n  },\n  regExp: /^(\\s*)[-*+]\\s/,\n  replace: listReplace('bullet'),\n}\n"],"names":["$isListNode","ListItemNode","ListNode","listExport","listReplace","UNORDERED_LIST","type","dependencies","export","node","exportChildren","regExp","replace"],"rangeMappings":";;;;;;;;;;;;;","mappings":"AAEA,SAASA,WAAW,EAAEC,YAAY,EAAEC,QAAQ,QAAQ,gBAAe;AAEnE,SAASC,UAAU,EAAEC,WAAW,QAAQ,wBAAuB;AAE/D,OAAO,MAAMC,iBAAqC;IAChDC,MAAM;IACNC,cAAc;QAACL;QAAUD;KAAa;IACtCO,QAAQ,CAACC,MAAMC;QACb,OAAOV,YAAYS,QAAQN,WAAWM,MAAMC,gBAAgB,KAAK;IACnE;IACAC,QAAQ;IACRC,SAASR,YAAY;AACvB,EAAC"}

package/dist/field/features/migrations/lexicalPluginToLexical/converter/converters/upload/converter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/upload/converter.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAA;AAEhE,eAAO,MAAM,gBAAgB,EAAE,0BAoB9B,CAAA"}
+{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/upload/converter.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAA;AAEhE,eAAO,MAAM,gBAAgB,EAAE,0BAkB9B,CAAA"}

package/dist/field/features/migrations/lexicalPluginToLexical/converter/converters/upload/converter.js

@@ -11,10 +11,8 @@
             fields,
             format: lexicalPluginNode?.format || '',
             relationTo: lexicalPluginNode?.rawImagePayload?.relationTo,
-            value: {
-                id: lexicalPluginNode?.rawImagePayload?.value?.id || ''
-            },
-            version: 1
+            value: lexicalPluginNode?.rawImagePayload?.value?.id || '',
+            version: 2
         };
     },
     nodeTypes: [

package/dist/field/features/migrations/lexicalPluginToLexical/converter/converters/upload/converter.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/upload/converter.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport type { SerializedUploadNode } from '../../../../../upload/nodes/UploadNode.js'\nimport type { LexicalPluginNodeConverter } from '../../types.js'\n\nexport const _UploadConverter: LexicalPluginNodeConverter = {\n  converter({ lexicalPluginNode }) {\n    let fields = {}\n    if ((lexicalPluginNode as any)?.caption?.editorState) {\n      fields = {\n        caption: (lexicalPluginNode as any)?.caption,\n      }\n    }\n    return {\n      type: 'upload',\n      fields,\n      format: (lexicalPluginNode as any)?.format || '',\n      relationTo: (lexicalPluginNode as any)?.rawImagePayload?.relationTo,\n      value: {\n        id: (lexicalPluginNode as any)?.rawImagePayload?.value?.id || '',\n      },\n      version: 1,\n    } as const as SerializedUploadNode\n  },\n  nodeTypes: ['upload'],\n}\n"],"names":["_UploadConverter","converter","lexicalPluginNode","fields","caption","editorState","type","format","relationTo","rawImagePayload","value","id","version","nodeTypes"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,qDAAqD,GAKrD,OAAO,MAAMA,mBAA+C;IAC1DC,WAAU,EAAEC,iBAAiB,EAAE;QAC7B,IAAIC,SAAS,CAAC;QACd,IAAKD,mBAA2BE,SAASC,aAAa;YACpDF,SAAS;gBACPC,SAAUF,mBAA2BE;YACvC;QACF;QACA,OAAO;YACLE,MAAM;YACNH;YACAI,QAAQ,AAACL,mBAA2BK,UAAU;YAC9CC,YAAaN,mBAA2BO,iBAAiBD;YACzDE,OAAO;gBACLC,IAAI,AAACT,mBAA2BO,iBAAiBC,OAAOC,MAAM;YAChE;YACAC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAS;AACvB,EAAC"}
+{"version":3,"sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/upload/converter.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport type { SerializedUploadNode } from '../../../../../upload/nodes/UploadNode.js'\nimport type { LexicalPluginNodeConverter } from '../../types.js'\n\nexport const _UploadConverter: LexicalPluginNodeConverter = {\n  converter({ lexicalPluginNode }) {\n    let fields = {}\n    if ((lexicalPluginNode as any)?.caption?.editorState) {\n      fields = {\n        caption: (lexicalPluginNode as any)?.caption,\n      }\n    }\n    return {\n      type: 'upload',\n      fields,\n      format: (lexicalPluginNode as any)?.format || '',\n      relationTo: (lexicalPluginNode as any)?.rawImagePayload?.relationTo,\n      value: (lexicalPluginNode as any)?.rawImagePayload?.value?.id || '',\n      version: 2,\n    } as const as SerializedUploadNode\n  },\n  nodeTypes: ['upload'],\n}\n"],"names":["_UploadConverter","converter","lexicalPluginNode","fields","caption","editorState","type","format","relationTo","rawImagePayload","value","id","version","nodeTypes"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,qDAAqD,GAKrD,OAAO,MAAMA,mBAA+C;IAC1DC,WAAU,EAAEC,iBAAiB,EAAE;QAC7B,IAAIC,SAAS,CAAC;QACd,IAAKD,mBAA2BE,SAASC,aAAa;YACpDF,SAAS;gBACPC,SAAUF,mBAA2BE;YACvC;QACF;QACA,OAAO;YACLE,MAAM;YACNH;YACAI,QAAQ,AAACL,mBAA2BK,UAAU;YAC9CC,YAAaN,mBAA2BO,iBAAiBD;YACzDE,OAAO,AAACR,mBAA2BO,iBAAiBC,OAAOC,MAAM;YACjEC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAS;AACvB,EAAC"}