@payloadcms/richtext-lexical 3.0.0-beta.7 → 3.0.0-canary.6041f49

package/dist/field/features/link/populationPromise.js

@@ -1,46 +1,31 @@
-import { populate } from '../../../populate/populate.js';
 import { recurseNestedFields } from '../../../populate/recurseNestedFields.js';
 export const linkPopulationPromiseHOC = (props)=>{
-    const linkPopulationPromise = ({ context, currentDepth, depth, editorPopulationPromises, field, findMany, flattenLocales, node, overrideAccess, populationPromises, req, showHiddenFields, siblingDoc })=>{
-        const promises = [];
-        if (node?.fields?.doc?.value && node?.fields?.doc?.relationTo) {
-            const collection = req.payload.collections[node?.fields?.doc?.relationTo];
-            if (collection) {
-                promises.push(populate({
-                    id: typeof node?.fields?.doc?.value === 'object' ? node?.fields?.doc?.value?.id : node?.fields?.doc?.value,
-                    collection,
-                    currentDepth,
-                    data: node?.fields?.doc,
-                    depth,
-                    field,
-                    key: 'value',
-                    overrideAccess,
-                    req,
-                    showHiddenFields
-                }));
-            }
+    return ({ context, currentDepth, depth, draft, editorPopulationPromises, fieldPromises, findMany, flattenLocales, node, overrideAccess, populationPromises, req, showHiddenFields })=>{
+        if (!props.fields?.length) {
+            return;
         }
-        if (Array.isArray(props.fields)) {
+        /**
+     * Should populate all fields, including the doc field (for internal links), as it's treated like a normal field
+     */ if (Array.isArray(props.fields)) {
             recurseNestedFields({
                 context,
                 currentDepth,
-                data: node.fields || {},
+                data: node.fields,
                 depth,
+                draft,
                 editorPopulationPromises,
+                fieldPromises,
                 fields: props.fields,
                 findMany,
                 flattenLocales,
                 overrideAccess,
                 populationPromises,
-                promises,
                 req,
                 showHiddenFields,
-                siblingDoc: node.fields || {}
+                siblingDoc: node.fields
             });
         }
-        return promises;
     };
-    return linkPopulationPromise;
 };
 
 //# sourceMappingURL=populationPromise.js.map

package/dist/field/features/link/populationPromise.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/field/features/link/populationPromise.ts"],"sourcesContent":["import type { PopulationPromise } from '../types.js'\nimport type { LinkFeatureServerProps } from './feature.server.js'\nimport type { SerializedLinkNode } from './nodes/types.js'\n\nimport { populate } from '../../../populate/populate.js'\nimport { recurseNestedFields } from '../../../populate/recurseNestedFields.js'\n\nexport const linkPopulationPromiseHOC = (\n  props: LinkFeatureServerProps,\n): PopulationPromise<SerializedLinkNode> => {\n  const linkPopulationPromise: PopulationPromise<SerializedLinkNode> = ({\n    context,\n    currentDepth,\n    depth,\n    editorPopulationPromises,\n    field,\n    findMany,\n    flattenLocales,\n    node,\n    overrideAccess,\n    populationPromises,\n    req,\n    showHiddenFields,\n    siblingDoc,\n  }) => {\n    const promises: Promise<void>[] = []\n\n    if (node?.fields?.doc?.value && node?.fields?.doc?.relationTo) {\n      const collection = req.payload.collections[node?.fields?.doc?.relationTo]\n\n      if (collection) {\n        promises.push(\n          populate({\n            id:\n              typeof node?.fields?.doc?.value === 'object'\n                ? node?.fields?.doc?.value?.id\n                : node?.fields?.doc?.value,\n            collection,\n            currentDepth,\n            data: node?.fields?.doc,\n            depth,\n            field,\n            key: 'value',\n            overrideAccess,\n            req,\n            showHiddenFields,\n          }),\n        )\n      }\n    }\n    if (Array.isArray(props.fields)) {\n      recurseNestedFields({\n        context,\n        currentDepth,\n        data: node.fields || {},\n        depth,\n        editorPopulationPromises,\n        fields: props.fields,\n        findMany,\n        flattenLocales,\n        overrideAccess,\n        populationPromises,\n        promises,\n        req,\n        showHiddenFields,\n        siblingDoc: node.fields || {},\n      })\n    }\n    return promises\n  }\n\n  return linkPopulationPromise\n}\n"],"names":["populate","recurseNestedFields","linkPopulationPromiseHOC","props","linkPopulationPromise","context","currentDepth","depth","editorPopulationPromises","field","findMany","flattenLocales","node","overrideAccess","populationPromises","req","showHiddenFields","siblingDoc","promises","fields","doc","value","relationTo","collection","payload","collections","push","id","data","key","Array","isArray"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAIA,SAASA,QAAQ,QAAQ,gCAA+B;AACxD,SAASC,mBAAmB,QAAQ,2CAA0C;AAE9E,OAAO,MAAMC,2BAA2B,CACtCC;IAEA,MAAMC,wBAA+D,CAAC,EACpEC,OAAO,EACPC,YAAY,EACZC,KAAK,EACLC,wBAAwB,EACxBC,KAAK,EACLC,QAAQ,EACRC,cAAc,EACdC,IAAI,EACJC,cAAc,EACdC,kBAAkB,EAClBC,GAAG,EACHC,gBAAgB,EAChBC,UAAU,EACX;QACC,MAAMC,WAA4B,EAAE;QAEpC,IAAIN,MAAMO,QAAQC,KAAKC,SAAST,MAAMO,QAAQC,KAAKE,YAAY;YAC7D,MAAMC,aAAaR,IAAIS,OAAO,CAACC,WAAW,CAACb,MAAMO,QAAQC,KAAKE,WAAW;YAEzE,IAAIC,YAAY;gBACdL,SAASQ,IAAI,CACX1B,SAAS;oBACP2B,IACE,OAAOf,MAAMO,QAAQC,KAAKC,UAAU,WAChCT,MAAMO,QAAQC,KAAKC,OAAOM,KAC1Bf,MAAMO,QAAQC,KAAKC;oBACzBE;oBACAjB;oBACAsB,MAAMhB,MAAMO,QAAQC;oBACpBb;oBACAE;oBACAoB,KAAK;oBACLhB;oBACAE;oBACAC;gBACF;YAEJ;QACF;QACA,IAAIc,MAAMC,OAAO,CAAC5B,MAAMgB,MAAM,GAAG;YAC/BlB,oBAAoB;gBAClBI;gBACAC;gBACAsB,MAAMhB,KAAKO,MAAM,IAAI,CAAC;gBACtBZ;gBACAC;gBACAW,QAAQhB,MAAMgB,MAAM;gBACpBT;gBACAC;gBACAE;gBACAC;gBACAI;gBACAH;gBACAC;gBACAC,YAAYL,KAAKO,MAAM,IAAI,CAAC;YAC9B;QACF;QACA,OAAOD;IACT;IAEA,OAAOd;AACT,EAAC"}
+{"version":3,"sources":["../../../../src/field/features/link/populationPromise.ts"],"sourcesContent":["import type { PopulationPromise } from '../types.js'\nimport type { LinkFeatureServerProps } from './feature.server.js'\nimport type { SerializedLinkNode } from './nodes/types.js'\n\nimport { recurseNestedFields } from '../../../populate/recurseNestedFields.js'\n\nexport const linkPopulationPromiseHOC = (\n  props: LinkFeatureServerProps,\n): PopulationPromise<SerializedLinkNode> => {\n  return ({\n    context,\n    currentDepth,\n    depth,\n    draft,\n    editorPopulationPromises,\n    fieldPromises,\n    findMany,\n    flattenLocales,\n    node,\n    overrideAccess,\n    populationPromises,\n    req,\n    showHiddenFields,\n  }) => {\n    if (!props.fields?.length) {\n      return\n    }\n\n    /**\n     * Should populate all fields, including the doc field (for internal links), as it's treated like a normal field\n     */\n    if (Array.isArray(props.fields)) {\n      recurseNestedFields({\n        context,\n        currentDepth,\n        data: node.fields,\n        depth,\n        draft,\n        editorPopulationPromises,\n        fieldPromises,\n        fields: props.fields,\n        findMany,\n        flattenLocales,\n        overrideAccess,\n        populationPromises,\n        req,\n        showHiddenFields,\n        siblingDoc: node.fields,\n      })\n    }\n  }\n}\n"],"names":["recurseNestedFields","linkPopulationPromiseHOC","props","context","currentDepth","depth","draft","editorPopulationPromises","fieldPromises","findMany","flattenLocales","node","overrideAccess","populationPromises","req","showHiddenFields","fields","length","Array","isArray","data","siblingDoc"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAIA,SAASA,mBAAmB,QAAQ,2CAA0C;AAE9E,OAAO,MAAMC,2BAA2B,CACtCC;IAEA,OAAO,CAAC,EACNC,OAAO,EACPC,YAAY,EACZC,KAAK,EACLC,KAAK,EACLC,wBAAwB,EACxBC,aAAa,EACbC,QAAQ,EACRC,cAAc,EACdC,IAAI,EACJC,cAAc,EACdC,kBAAkB,EAClBC,GAAG,EACHC,gBAAgB,EACjB;QACC,IAAI,CAACb,MAAMc,MAAM,EAAEC,QAAQ;YACzB;QACF;QAEA;;KAEC,GACD,IAAIC,MAAMC,OAAO,CAACjB,MAAMc,MAAM,GAAG;YAC/BhB,oBAAoB;gBAClBG;gBACAC;gBACAgB,MAAMT,KAAKK,MAAM;gBACjBX;gBACAC;gBACAC;gBACAC;gBACAQ,QAAQd,MAAMc,MAAM;gBACpBP;gBACAC;gBACAE;gBACAC;gBACAC;gBACAC;gBACAM,YAAYV,KAAKK,MAAM;YACzB;QACF;IACF;AACF,EAAC"}

package/dist/field/features/link/validate.d.ts

@@ -0,0 +1,5 @@
+import type { NodeValidation } from '../types.js';
+import type { LinkFeatureServerProps } from './feature.server.js';
+import type { SerializedAutoLinkNode, SerializedLinkNode } from './nodes/types.js';
+export declare const linkValidation: (props: LinkFeatureServerProps) => NodeValidation<SerializedAutoLinkNode | SerializedLinkNode>;
+//# sourceMappingURL=validate.d.ts.map

package/dist/field/features/link/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../../src/field/features/link/validate.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AACjD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAA;AACjE,OAAO,KAAK,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAElF,eAAO,MAAM,cAAc,UAClB,sBAAsB,KAE5B,eAAe,sBAAsB,GAAG,kBAAkB,CAuC5D,CAAA"}

package/dist/field/features/link/validate.js

@@ -0,0 +1,32 @@
+import { buildStateFromSchema } from '@payloadcms/ui/forms/buildStateFromSchema';
+export const linkValidation = (props)=>{
+    return async ({ node, validation: { options: { id, operation, preferences, req } } })=>{
+        /**
+     * Run buildStateFromSchema as that properly validates link fields and link sub-fields
+     */ const data = {
+            ...node.fields,
+            text: 'ignored'
+        };
+        const result = await buildStateFromSchema({
+            id,
+            data,
+            fieldSchema: props.fields,
+            operation: operation === 'create' || operation === 'update' ? operation : 'update',
+            preferences,
+            req,
+            siblingData: data
+        });
+        let errorPaths = [];
+        for(const fieldKey in result){
+            if (result[fieldKey].errorPaths) {
+                errorPaths = errorPaths.concat(result[fieldKey].errorPaths);
+            }
+        }
+        if (errorPaths.length) {
+            return 'Link fields validation failed: ' + errorPaths.join(', ');
+        }
+        return true;
+    };
+};
+
+//# sourceMappingURL=validate.js.map

package/dist/field/features/link/validate.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/field/features/link/validate.ts"],"sourcesContent":["import type { Field } from 'payload/types'\n\nimport { buildStateFromSchema } from '@payloadcms/ui/forms/buildStateFromSchema'\n\nimport type { NodeValidation } from '../types.js'\nimport type { LinkFeatureServerProps } from './feature.server.js'\nimport type { SerializedAutoLinkNode, SerializedLinkNode } from './nodes/types.js'\n\nexport const linkValidation = (\n  props: LinkFeatureServerProps,\n  // eslint-disable-next-line @typescript-eslint/no-duplicate-type-constituents\n): NodeValidation<SerializedAutoLinkNode | SerializedLinkNode> => {\n  return async ({\n    node,\n    validation: {\n      options: { id, operation, preferences, req },\n    },\n  }) => {\n    /**\n     * Run buildStateFromSchema as that properly validates link fields and link sub-fields\n     */\n\n    const data = {\n      ...node.fields,\n      text: 'ignored',\n    }\n\n    const result = await buildStateFromSchema({\n      id,\n      data,\n      fieldSchema: props.fields as Field[], // Sanitized in feature.server.ts\n      operation: operation === 'create' || operation === 'update' ? operation : 'update',\n      preferences,\n      req,\n      siblingData: data,\n    })\n\n    let errorPaths = []\n    for (const fieldKey in result) {\n      if (result[fieldKey].errorPaths) {\n        errorPaths = errorPaths.concat(result[fieldKey].errorPaths)\n      }\n    }\n\n    if (errorPaths.length) {\n      return 'Link fields validation failed: ' + errorPaths.join(', ')\n    }\n\n    return true\n  }\n}\n"],"names":["buildStateFromSchema","linkValidation","props","node","validation","options","id","operation","preferences","req","data","fields","text","result","fieldSchema","siblingData","errorPaths","fieldKey","concat","length","join"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAEA,SAASA,oBAAoB,QAAQ,4CAA2C;AAMhF,OAAO,MAAMC,iBAAiB,CAC5BC;IAGA,OAAO,OAAO,EACZC,IAAI,EACJC,YAAY,EACVC,SAAS,EAAEC,EAAE,EAAEC,SAAS,EAAEC,WAAW,EAAEC,GAAG,EAAE,EAC7C,EACF;QACC;;KAEC,GAED,MAAMC,OAAO;YACX,GAAGP,KAAKQ,MAAM;YACdC,MAAM;QACR;QAEA,MAAMC,SAAS,MAAMb,qBAAqB;YACxCM;YACAI;YACAI,aAAaZ,MAAMS,MAAM;YACzBJ,WAAWA,cAAc,YAAYA,cAAc,WAAWA,YAAY;YAC1EC;YACAC;YACAM,aAAaL;QACf;QAEA,IAAIM,aAAa,EAAE;QACnB,IAAK,MAAMC,YAAYJ,OAAQ;YAC7B,IAAIA,MAAM,CAACI,SAAS,CAACD,UAAU,EAAE;gBAC/BA,aAAaA,WAAWE,MAAM,CAACL,MAAM,CAACI,SAAS,CAACD,UAAU;YAC5D;QACF;QAEA,IAAIA,WAAWG,MAAM,EAAE;YACrB,OAAO,oCAAoCH,WAAWI,IAAI,CAAC;QAC7D;QAEA,OAAO;IACT;AACF,EAAC"}

package/dist/field/features/lists/checklist/feature.client.d.ts

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

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

@@ -1 +1 @@
-{"version":3,"file":"feature.client.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/lists/checklist/feature.client.tsx"],"names":[],"mappings":";AA+EA,eAAO,MAAM,+BAA+B,+BAAgD,CAAA"}
+{"version":3,"file":"feature.client.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/lists/checklist/feature.client.tsx"],"names":[],"mappings":";AA6GA,eAAO,MAAM,+BAA+B;;;EAAgD,CAAA"}

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

@@ -1,14 +1,47 @@
 'use client';
-import lexicalListImport from '@lexical/list';
-const { INSERT_CHECK_LIST_COMMAND, ListItemNode, ListNode } = lexicalListImport;
-import { SlashMenuOption } from '../../../lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/types.js';
+import { $isListNode, INSERT_CHECK_LIST_COMMAND, ListItemNode, ListNode } from '@lexical/list';
+import { $isRangeSelection } from 'lexical';
 import { ChecklistIcon } from '../../../lexical/ui/icons/Checklist/index.js';
-import { TextDropdownSectionWithEntries } from '../../common/floatingSelectToolbarTextDropdownSection/index.js';
 import { createClientComponent } from '../../createClientComponent.js';
+import { toolbarTextDropdownGroupWithItems } from '../../shared/toolbar/textDropdownGroup.js';
 import { LexicalListPlugin } from '../plugin/index.js';
 import { CHECK_LIST } from './markdownTransformers.js';
 import { LexicalCheckListPlugin } from './plugin/index.js';
-const CheckListFeatureClient = (props)=>{
+const toolbarGroups = [
+    toolbarTextDropdownGroupWithItems([
+        {
+            ChildComponent: ChecklistIcon,
+            isActive: ({ selection })=>{
+                if (!$isRangeSelection(selection)) {
+                    return false;
+                }
+                for (const node of selection.getNodes()){
+                    if ($isListNode(node) && node.getListType() === 'check') {
+                        continue;
+                    }
+                    const parent = node.getParent();
+                    if ($isListNode(parent) && parent.getListType() === 'check') {
+                        continue;
+                    }
+                    const parentParent = parent?.getParent();
+                    // Example scenario: Node = textNode, parent = listItemNode, parentParent = listNode
+                    if ($isListNode(parentParent) && parentParent.getListType() === 'check') {
+                        continue;
+                    }
+                    return false;
+                }
+                return true;
+            },
+            key: 'checklist',
+            label: `Check List`,
+            onSelect: ({ editor })=>{
+                editor.dispatchCommand(INSERT_CHECK_LIST_COMMAND, undefined);
+            },
+            order: 12
+        }
+    ])
+];
+const ChecklistFeatureClient = (props)=>{
     return {
         clientFeatureProps: props,
         feature: ({ featureProviderMap })=>{
@@ -18,7 +51,7 @@ const CheckListFeatureClient = (props)=>{
                     position: 'normal'
                 }
             ];
-            if (!featureProviderMap.has('unorderedlist') && !featureProviderMap.has('orderedlist')) {
+            if (!featureProviderMap.has('unorderedList') && !featureProviderMap.has('orderedList')) {
                 plugins.push({
                     Component: LexicalListPlugin,
                     position: 'normal'
@@ -26,57 +59,48 @@ const CheckListFeatureClient = (props)=>{
             }
             return {
                 clientFeatureProps: props,
-                floatingSelectToolbar: {
-                    sections: [
-                        TextDropdownSectionWithEntries([
-                            {
-                                ChildComponent: ChecklistIcon,
-                                isActive: ()=>false,
-                                key: 'checkList',
-                                label: `Check List`,
-                                onClick: ({ editor })=>{
-                                    editor.dispatchCommand(INSERT_CHECK_LIST_COMMAND, undefined);
-                                },
-                                order: 12
-                            }
-                        ])
-                    ]
-                },
                 markdownTransformers: [
                     CHECK_LIST
                 ],
-                nodes: featureProviderMap.has('unorderedlist') || featureProviderMap.has('orderedlist') ? [] : [
+                nodes: featureProviderMap.has('unorderedList') || featureProviderMap.has('orderedList') ? [] : [
                     ListNode,
                     ListItemNode
                 ],
                 plugins,
                 slashMenu: {
-                    options: [
+                    groups: [
                         {
-                            displayName: 'Lists',
-                            key: 'lists',
-                            options: [
-                                new SlashMenuOption('checklist', {
+                            items: [
+                                {
                                     Icon: ChecklistIcon,
-                                    displayName: 'Check List',
+                                    key: 'checklist',
                                     keywords: [
                                         'check list',
                                         'check',
                                         'checklist',
                                         'cl'
                                     ],
+                                    label: 'Check List',
                                     onSelect: ({ editor })=>{
                                         editor.dispatchCommand(INSERT_CHECK_LIST_COMMAND, undefined);
                                     }
-                                })
-                            ]
+                                }
+                            ],
+                            key: 'lists',
+                            label: 'Lists'
                         }
                     ]
+                },
+                toolbarFixed: {
+                    groups: toolbarGroups
+                },
+                toolbarInline: {
+                    groups: toolbarGroups
                 }
             };
         }
     };
 };
-export const CheckListFeatureClientComponent = createClientComponent(CheckListFeatureClient);
+export const ChecklistFeatureClientComponent = createClientComponent(ChecklistFeatureClient);
 
 //# sourceMappingURL=feature.client.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/field/features/lists/checklist/feature.client.tsx"],"sourcesContent":["'use client'\nimport lexicalListImport from '@lexical/list'\nconst { INSERT_CHECK_LIST_COMMAND, ListItemNode, ListNode } = lexicalListImport\n\nimport type { ClientFeature, FeatureProviderProviderClient } from '../../types.js'\n\nimport { SlashMenuOption } from '../../../lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/types.js'\nimport { ChecklistIcon } from '../../../lexical/ui/icons/Checklist/index.js'\nimport { TextDropdownSectionWithEntries } from '../../common/floatingSelectToolbarTextDropdownSection/index.js'\nimport { createClientComponent } from '../../createClientComponent.js'\nimport { LexicalListPlugin } from '../plugin/index.js'\nimport { CHECK_LIST } from './markdownTransformers.js'\nimport { LexicalCheckListPlugin } from './plugin/index.js'\n\nconst CheckListFeatureClient: FeatureProviderProviderClient<undefined> = (props) => {\n  return {\n    clientFeatureProps: props,\n    feature: ({ featureProviderMap }) => {\n      const plugins: ClientFeature<undefined>['plugins'] = [\n        {\n          Component: LexicalCheckListPlugin,\n          position: 'normal',\n        },\n      ]\n\n      if (!featureProviderMap.has('unorderedlist') && !featureProviderMap.has('orderedlist')) {\n        plugins.push({\n          Component: LexicalListPlugin,\n          position: 'normal',\n        })\n      }\n\n      return {\n        clientFeatureProps: props,\n        floatingSelectToolbar: {\n          sections: [\n            TextDropdownSectionWithEntries([\n              {\n                ChildComponent: ChecklistIcon,\n                isActive: () => false,\n                key: 'checkList',\n                label: `Check List`,\n                onClick: ({ editor }) => {\n                  editor.dispatchCommand(INSERT_CHECK_LIST_COMMAND, undefined)\n                },\n                order: 12,\n              },\n            ]),\n          ],\n        },\n        markdownTransformers: [CHECK_LIST],\n        nodes:\n          featureProviderMap.has('unorderedlist') || featureProviderMap.has('orderedlist')\n            ? []\n            : [ListNode, ListItemNode],\n        plugins,\n        slashMenu: {\n          options: [\n            {\n              displayName: 'Lists',\n              key: 'lists',\n              options: [\n                new SlashMenuOption('checklist', {\n                  Icon: ChecklistIcon,\n                  displayName: 'Check List',\n                  keywords: ['check list', 'check', 'checklist', 'cl'],\n                  onSelect: ({ editor }) => {\n                    editor.dispatchCommand(INSERT_CHECK_LIST_COMMAND, undefined)\n                  },\n                }),\n              ],\n            },\n          ],\n        },\n      }\n    },\n  }\n}\n\nexport const CheckListFeatureClientComponent = createClientComponent(CheckListFeatureClient)\n"],"names":["lexicalListImport","INSERT_CHECK_LIST_COMMAND","ListItemNode","ListNode","SlashMenuOption","ChecklistIcon","TextDropdownSectionWithEntries","createClientComponent","LexicalListPlugin","CHECK_LIST","LexicalCheckListPlugin","CheckListFeatureClient","props","clientFeatureProps","feature","featureProviderMap","plugins","Component","position","has","push","floatingSelectToolbar","sections","ChildComponent","isActive","key","label","onClick","editor","dispatchCommand","undefined","order","markdownTransformers","nodes","slashMenu","options","displayName","Icon","keywords","onSelect","CheckListFeatureClientComponent"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;AACA,OAAOA,uBAAuB,gBAAe;AAC7C,MAAM,EAAEC,yBAAyB,EAAEC,YAAY,EAAEC,QAAQ,EAAE,GAAGH;AAI9D,SAASI,eAAe,QAAQ,yEAAwE;AACxG,SAASC,aAAa,QAAQ,+CAA8C;AAC5E,SAASC,8BAA8B,QAAQ,iEAAgE;AAC/G,SAASC,qBAAqB,QAAQ,iCAAgC;AACtE,SAASC,iBAAiB,QAAQ,qBAAoB;AACtD,SAASC,UAAU,QAAQ,4BAA2B;AACtD,SAASC,sBAAsB,QAAQ,oBAAmB;AAE1D,MAAMC,yBAAmE,CAACC;IACxE,OAAO;QACLC,oBAAoBD;QACpBE,SAAS,CAAC,EAAEC,kBAAkB,EAAE;YAC9B,MAAMC,UAA+C;gBACnD;oBACEC,WAAWP;oBACXQ,UAAU;gBACZ;aACD;YAED,IAAI,CAACH,mBAAmBI,GAAG,CAAC,oBAAoB,CAACJ,mBAAmBI,GAAG,CAAC,gBAAgB;gBACtFH,QAAQI,IAAI,CAAC;oBACXH,WAAWT;oBACXU,UAAU;gBACZ;YACF;YAEA,OAAO;gBACLL,oBAAoBD;gBACpBS,uBAAuB;oBACrBC,UAAU;wBACRhB,+BAA+B;4BAC7B;gCACEiB,gBAAgBlB;gCAChBmB,UAAU,IAAM;gCAChBC,KAAK;gCACLC,OAAO,CAAC,UAAU,CAAC;gCACnBC,SAAS,CAAC,EAAEC,MAAM,EAAE;oCAClBA,OAAOC,eAAe,CAAC5B,2BAA2B6B;gCACpD;gCACAC,OAAO;4BACT;yBACD;qBACF;gBACH;gBACAC,sBAAsB;oBAACvB;iBAAW;gBAClCwB,OACElB,mBAAmBI,GAAG,CAAC,oBAAoBJ,mBAAmBI,GAAG,CAAC,iBAC9D,EAAE,GACF;oBAAChB;oBAAUD;iBAAa;gBAC9Bc;gBACAkB,WAAW;oBACTC,SAAS;wBACP;4BACEC,aAAa;4BACbX,KAAK;4BACLU,SAAS;gCACP,IAAI/B,gBAAgB,aAAa;oCAC/BiC,MAAMhC;oCACN+B,aAAa;oCACbE,UAAU;wCAAC;wCAAc;wCAAS;wCAAa;qCAAK;oCACpDC,UAAU,CAAC,EAAEX,MAAM,EAAE;wCACnBA,OAAOC,eAAe,CAAC5B,2BAA2B6B;oCACpD;gCACF;6BACD;wBACH;qBACD;gBACH;YACF;QACF;IACF;AACF;AAEA,OAAO,MAAMU,kCAAkCjC,sBAAsBI,wBAAuB"}
+{"version":3,"sources":["../../../../../src/field/features/lists/checklist/feature.client.tsx"],"sourcesContent":["'use client'\nimport { $isListNode, INSERT_CHECK_LIST_COMMAND, ListItemNode, ListNode } from '@lexical/list'\nimport { $isRangeSelection } from 'lexical'\n\nimport type { ToolbarGroup } from '../../toolbars/types.js'\nimport type { ClientFeature, FeatureProviderProviderClient } from '../../types.js'\n\nimport { ChecklistIcon } from '../../../lexical/ui/icons/Checklist/index.js'\nimport { createClientComponent } from '../../createClientComponent.js'\nimport { toolbarTextDropdownGroupWithItems } from '../../shared/toolbar/textDropdownGroup.js'\nimport { LexicalListPlugin } from '../plugin/index.js'\nimport { CHECK_LIST } from './markdownTransformers.js'\nimport { LexicalCheckListPlugin } from './plugin/index.js'\n\nconst toolbarGroups: ToolbarGroup[] = [\n  toolbarTextDropdownGroupWithItems([\n    {\n      ChildComponent: ChecklistIcon,\n      isActive: ({ selection }) => {\n        if (!$isRangeSelection(selection)) {\n          return false\n        }\n        for (const node of selection.getNodes()) {\n          if ($isListNode(node) && node.getListType() === 'check') {\n            continue\n          }\n\n          const parent = node.getParent()\n\n          if ($isListNode(parent) && parent.getListType() === 'check') {\n            continue\n          }\n\n          const parentParent = parent?.getParent()\n          // Example scenario: Node = textNode, parent = listItemNode, parentParent = listNode\n          if ($isListNode(parentParent) && parentParent.getListType() === 'check') {\n            continue\n          }\n\n          return false\n        }\n        return true\n      },\n      key: 'checklist',\n      label: `Check List`,\n      onSelect: ({ editor }) => {\n        editor.dispatchCommand(INSERT_CHECK_LIST_COMMAND, undefined)\n      },\n      order: 12,\n    },\n  ]),\n]\n\nconst ChecklistFeatureClient: FeatureProviderProviderClient<undefined> = (props) => {\n  return {\n    clientFeatureProps: props,\n    feature: ({ featureProviderMap }) => {\n      const plugins: ClientFeature<undefined>['plugins'] = [\n        {\n          Component: LexicalCheckListPlugin,\n          position: 'normal',\n        },\n      ]\n\n      if (!featureProviderMap.has('unorderedList') && !featureProviderMap.has('orderedList')) {\n        plugins.push({\n          Component: LexicalListPlugin,\n          position: 'normal',\n        })\n      }\n\n      return {\n        clientFeatureProps: props,\n        markdownTransformers: [CHECK_LIST],\n        nodes:\n          featureProviderMap.has('unorderedList') || featureProviderMap.has('orderedList')\n            ? []\n            : [ListNode, ListItemNode],\n        plugins,\n        slashMenu: {\n          groups: [\n            {\n              items: [\n                {\n                  Icon: ChecklistIcon,\n                  key: 'checklist',\n                  keywords: ['check list', 'check', 'checklist', 'cl'],\n                  label: 'Check List',\n                  onSelect: ({ editor }) => {\n                    editor.dispatchCommand(INSERT_CHECK_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 ChecklistFeatureClientComponent = createClientComponent(ChecklistFeatureClient)\n"],"names":["$isListNode","INSERT_CHECK_LIST_COMMAND","ListItemNode","ListNode","$isRangeSelection","ChecklistIcon","createClientComponent","toolbarTextDropdownGroupWithItems","LexicalListPlugin","CHECK_LIST","LexicalCheckListPlugin","toolbarGroups","ChildComponent","isActive","selection","node","getNodes","getListType","parent","getParent","parentParent","key","label","onSelect","editor","dispatchCommand","undefined","order","ChecklistFeatureClient","props","clientFeatureProps","feature","featureProviderMap","plugins","Component","position","has","push","markdownTransformers","nodes","slashMenu","groups","items","Icon","keywords","toolbarFixed","toolbarInline","ChecklistFeatureClientComponent"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;AACA,SAASA,WAAW,EAAEC,yBAAyB,EAAEC,YAAY,EAAEC,QAAQ,QAAQ,gBAAe;AAC9F,SAASC,iBAAiB,QAAQ,UAAS;AAK3C,SAASC,aAAa,QAAQ,+CAA8C;AAC5E,SAASC,qBAAqB,QAAQ,iCAAgC;AACtE,SAASC,iCAAiC,QAAQ,4CAA2C;AAC7F,SAASC,iBAAiB,QAAQ,qBAAoB;AACtD,SAASC,UAAU,QAAQ,4BAA2B;AACtD,SAASC,sBAAsB,QAAQ,oBAAmB;AAE1D,MAAMC,gBAAgC;IACpCJ,kCAAkC;QAChC;YACEK,gBAAgBP;YAChBQ,UAAU,CAAC,EAAEC,SAAS,EAAE;gBACtB,IAAI,CAACV,kBAAkBU,YAAY;oBACjC,OAAO;gBACT;gBACA,KAAK,MAAMC,QAAQD,UAAUE,QAAQ,GAAI;oBACvC,IAAIhB,YAAYe,SAASA,KAAKE,WAAW,OAAO,SAAS;wBACvD;oBACF;oBAEA,MAAMC,SAASH,KAAKI,SAAS;oBAE7B,IAAInB,YAAYkB,WAAWA,OAAOD,WAAW,OAAO,SAAS;wBAC3D;oBACF;oBAEA,MAAMG,eAAeF,QAAQC;oBAC7B,oFAAoF;oBACpF,IAAInB,YAAYoB,iBAAiBA,aAAaH,WAAW,OAAO,SAAS;wBACvE;oBACF;oBAEA,OAAO;gBACT;gBACA,OAAO;YACT;YACAI,KAAK;YACLC,OAAO,CAAC,UAAU,CAAC;YACnBC,UAAU,CAAC,EAAEC,MAAM,EAAE;gBACnBA,OAAOC,eAAe,CAACxB,2BAA2ByB;YACpD;YACAC,OAAO;QACT;KACD;CACF;AAED,MAAMC,yBAAmE,CAACC;IACxE,OAAO;QACLC,oBAAoBD;QACpBE,SAAS,CAAC,EAAEC,kBAAkB,EAAE;YAC9B,MAAMC,UAA+C;gBACnD;oBACEC,WAAWxB;oBACXyB,UAAU;gBACZ;aACD;YAED,IAAI,CAACH,mBAAmBI,GAAG,CAAC,oBAAoB,CAACJ,mBAAmBI,GAAG,CAAC,gBAAgB;gBACtFH,QAAQI,IAAI,CAAC;oBACXH,WAAW1B;oBACX2B,UAAU;gBACZ;YACF;YAEA,OAAO;gBACLL,oBAAoBD;gBACpBS,sBAAsB;oBAAC7B;iBAAW;gBAClC8B,OACEP,mBAAmBI,GAAG,CAAC,oBAAoBJ,mBAAmBI,GAAG,CAAC,iBAC9D,EAAE,GACF;oBAACjC;oBAAUD;iBAAa;gBAC9B+B;gBACAO,WAAW;oBACTC,QAAQ;wBACN;4BACEC,OAAO;gCACL;oCACEC,MAAMtC;oCACNgB,KAAK;oCACLuB,UAAU;wCAAC;wCAAc;wCAAS;wCAAa;qCAAK;oCACpDtB,OAAO;oCACPC,UAAU,CAAC,EAAEC,MAAM,EAAE;wCACnBA,OAAOC,eAAe,CAACxB,2BAA2ByB;oCACpD;gCACF;6BACD;4BACDL,KAAK;4BACLC,OAAO;wBACT;qBACD;gBACH;gBACAuB,cAAc;oBACZJ,QAAQ9B;gBACV;gBACAmC,eAAe;oBACbL,QAAQ9B;gBACV;YACF;QACF;IACF;AACF;AAEA,OAAO,MAAMoC,kCAAkCzC,sBAAsBsB,wBAAuB"}

package/dist/field/features/lists/checklist/feature.server.d.ts

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

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

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

package/dist/field/features/lists/checklist/feature.server.js

@@ -1,29 +1,29 @@
-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 { CheckListFeatureClientComponent } from './feature.client.js';
+import { ChecklistFeatureClientComponent } from './feature.client.js';
 import { CHECK_LIST } from './markdownTransformers.js';
-export const CheckListFeature = (props)=>{
+export const ChecklistFeature = (props)=>{
     return {
         feature: ({ featureProviderMap })=>{
             return {
-                ClientComponent: CheckListFeatureClientComponent,
+                ClientComponent: ChecklistFeatureClientComponent,
                 markdownTransformers: [
                     CHECK_LIST
                 ],
-                nodes: featureProviderMap.has('unorderedlist') || featureProviderMap.has('orderedlist') ? [] : [
-                    {
+                nodes: featureProviderMap.has('unorderedList') || featureProviderMap.has('orderedList') ? [] : [
+                    createNode({
                         converters: {
                             html: ListHTMLConverter
                         },
                         node: ListNode
-                    },
-                    {
+                    }),
+                    createNode({
                         converters: {
                             html: ListItemHTMLConverter
                         },
                         node: ListItemNode
-                    }
+                    })
                 ],
                 serverFeatureProps: props
             };

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/field/features/lists/checklist/feature.server.ts"],"sourcesContent":["import lexicalListImport from '@lexical/list'\nconst { ListItemNode, ListNode } = lexicalListImport\n\nimport type { FeatureProviderProviderServer } from '../../types.js'\n\nimport { ListHTMLConverter, ListItemHTMLConverter } from '../htmlConverter.js'\nimport { CheckListFeatureClientComponent } from './feature.client.js'\nimport { CHECK_LIST } from './markdownTransformers.js'\n\nexport const CheckListFeature: FeatureProviderProviderServer<undefined, undefined> = (props) => {\n  return {\n    feature: ({ featureProviderMap }) => {\n      return {\n        ClientComponent: CheckListFeatureClientComponent,\n        markdownTransformers: [CHECK_LIST],\n        nodes:\n          featureProviderMap.has('unorderedlist') || featureProviderMap.has('orderedlist')\n            ? []\n            : [\n                {\n                  converters: {\n                    html: ListHTMLConverter,\n                  },\n                  node: ListNode,\n                },\n                {\n                  converters: {\n                    html: ListItemHTMLConverter,\n                  },\n                  node: ListItemNode,\n                },\n              ],\n        serverFeatureProps: props,\n      }\n    },\n    key: 'checklist',\n    serverFeatureProps: props,\n  }\n}\n"],"names":["lexicalListImport","ListItemNode","ListNode","ListHTMLConverter","ListItemHTMLConverter","CheckListFeatureClientComponent","CHECK_LIST","CheckListFeature","props","feature","featureProviderMap","ClientComponent","markdownTransformers","nodes","has","converters","html","node","serverFeatureProps","key"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,OAAOA,uBAAuB,gBAAe;AAC7C,MAAM,EAAEC,YAAY,EAAEC,QAAQ,EAAE,GAAGF;AAInC,SAASG,iBAAiB,EAAEC,qBAAqB,QAAQ,sBAAqB;AAC9E,SAASC,+BAA+B,QAAQ,sBAAqB;AACrE,SAASC,UAAU,QAAQ,4BAA2B;AAEtD,OAAO,MAAMC,mBAAwE,CAACC;IACpF,OAAO;QACLC,SAAS,CAAC,EAAEC,kBAAkB,EAAE;YAC9B,OAAO;gBACLC,iBAAiBN;gBACjBO,sBAAsB;oBAACN;iBAAW;gBAClCO,OACEH,mBAAmBI,GAAG,CAAC,oBAAoBJ,mBAAmBI,GAAG,CAAC,iBAC9D,EAAE,GACF;oBACE;wBACEC,YAAY;4BACVC,MAAMb;wBACR;wBACAc,MAAMf;oBACR;oBACA;wBACEa,YAAY;4BACVC,MAAMZ;wBACR;wBACAa,MAAMhB;oBACR;iBACD;gBACPiB,oBAAoBV;YACtB;QACF;QACAW,KAAK;QACLD,oBAAoBV;IACtB;AACF,EAAC"}
+{"version":3,"sources":["../../../../../src/field/features/lists/checklist/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 { ChecklistFeatureClientComponent } from './feature.client.js'\nimport { CHECK_LIST } from './markdownTransformers.js'\n\nexport const ChecklistFeature: FeatureProviderProviderServer<undefined, undefined> = (props) => {\n  return {\n    feature: ({ featureProviderMap }) => {\n      return {\n        ClientComponent: ChecklistFeatureClientComponent,\n        markdownTransformers: [CHECK_LIST],\n        nodes:\n          featureProviderMap.has('unorderedList') || featureProviderMap.has('orderedList')\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: 'checklist',\n    serverFeatureProps: props,\n  }\n}\n"],"names":["ListItemNode","ListNode","createNode","ListHTMLConverter","ListItemHTMLConverter","ChecklistFeatureClientComponent","CHECK_LIST","ChecklistFeature","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,+BAA+B,QAAQ,sBAAqB;AACrE,SAASC,UAAU,QAAQ,4BAA2B;AAEtD,OAAO,MAAMC,mBAAwE,CAACC;IACpF,OAAO;QACLC,SAAS,CAAC,EAAEC,kBAAkB,EAAE;YAC9B,OAAO;gBACLC,iBAAiBN;gBACjBO,sBAAsB;oBAACN;iBAAW;gBAClCO,OACEH,mBAAmBI,GAAG,CAAC,oBAAoBJ,mBAAmBI,GAAG,CAAC,iBAC9D,EAAE,GACF;oBACEZ,WAAW;wBACTa,YAAY;4BACVC,MAAMb;wBACR;wBACAc,MAAMhB;oBACR;oBACAC,WAAW;wBACTa,YAAY;4BACVC,MAAMZ;wBACR;wBACAa,MAAMjB;oBACR;iBACD;gBACPkB,oBAAoBV;YACtB;QACF;QACAW,KAAK;QACLD,oBAAoBV;IACtB;AACF,EAAC"}

package/dist/field/features/lists/checklist/markdownTransformers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"markdownTransformers.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/lists/checklist/markdownTransformers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AAO3D,eAAO,MAAM,UAAU,EAAE,kBAQxB,CAAA"}
+{"version":3,"file":"markdownTransformers.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/lists/checklist/markdownTransformers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AAM3D,eAAO,MAAM,UAAU,EAAE,kBAQxB,CAAA"}

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 → orderedList}/feature.client.d.ts

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

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;;;EAAkD,CAAA"}