@payloadcms/richtext-lexical 3.0.0-beta.4 → 3.0.0-beta.40

package/dist/field/features/link/plugins/floatingLinkEditor/utilities.js

@@ -1,36 +1,18 @@
 import { getBaseFields } from '../../drawer/baseFields.js';
 /**
  * This function is run to enrich the basefields which every link has with potential, custom user-added fields.
- */ // eslint-disable-next-line @typescript-eslint/require-await
-export function transformExtraFields(customFieldSchema, config, i18n, enabledCollections, disabledCollections) {
-    const baseFields = getBaseFields(config, enabledCollections, disabledCollections);
-    const fields = typeof customFieldSchema === 'function' ? customFieldSchema({
-        config,
-        defaultFields: baseFields,
-        i18n
-    }) : baseFields;
-    // Wrap fields which are not part of the base schema in a group named 'fields' - otherwise they will be rendered but not saved
-    const extraFields = [];
-    for(let i = fields.length - 1; i >= 0; i--){
-        const field = fields[i];
-        if ('name' in field) {
-            if (!baseFields.find((baseField)=>!('name' in baseField) || baseField.name === field.name)) {
-                if (field.name !== 'fields' && field.type !== 'group') {
-                    extraFields.push(field);
-                    // Remove from fields from now, as they need to be part of the fields group below
-                    fields.splice(fields.indexOf(field), 1);
-                }
-            }
-        }
-    }
-    if (Array.isArray(customFieldSchema) || fields.length > 0) {
-        // find field with name 'fields' and add the extra fields to it
-        const fieldsField = fields.find((field)=>field.type === 'group' && field.name === 'fields');
-        if (!fieldsField) {
-            throw new Error('Could not find field with name "fields". This is required to add fields to the link field.');
-        }
-        fieldsField.fields = Array.isArray(fieldsField.fields) ? fieldsField.fields : [];
-        fieldsField.fields.push(...Array.isArray(customFieldSchema) ? customFieldSchema.concat(extraFields) : extraFields);
+ */ export function transformExtraFields(customFieldSchema, config, enabledCollections, disabledCollections, maxDepth) {
+    const baseFields = getBaseFields(config, enabledCollections, disabledCollections, maxDepth);
+    let fields;
+    if (typeof customFieldSchema === 'function') {
+        fields = customFieldSchema({
+            config,
+            defaultFields: baseFields
+        });
+    } else if (Array.isArray(customFieldSchema)) {
+        fields = customFieldSchema;
+    } else {
+        fields = baseFields;
     }
     return fields;
 }

package/dist/field/features/link/plugins/floatingLinkEditor/utilities.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../src/field/features/link/plugins/floatingLinkEditor/utilities.ts"],"sourcesContent":["import type { I18n } from '@payloadcms/translations'\nimport type { SanitizedConfig } from 'payload/config'\nimport type { Field, GroupField } from 'payload/types'\n\nimport { getBaseFields } from '../../drawer/baseFields.js'\n\n/**\n * This function is run to enrich the basefields which every link has with potential, custom user-added fields.\n */\n// eslint-disable-next-line @typescript-eslint/require-await\nexport function transformExtraFields(\n  customFieldSchema:\n    | ((args: { config: SanitizedConfig; defaultFields: Field[]; i18n: I18n }) => Field[])\n    | Field[],\n  config: SanitizedConfig,\n  i18n: I18n,\n  enabledCollections?: false | string[],\n  disabledCollections?: false | string[],\n): Field[] {\n  const baseFields: Field[] = getBaseFields(config, enabledCollections, disabledCollections)\n\n  const fields =\n    typeof customFieldSchema === 'function'\n      ? customFieldSchema({ config, defaultFields: baseFields, i18n })\n      : baseFields\n\n  // Wrap fields which are not part of the base schema in a group named 'fields' - otherwise they will be rendered but not saved\n  const extraFields = []\n  for (let i = fields.length - 1; i >= 0; i--) {\n    const field = fields[i]\n\n    if ('name' in field) {\n      if (\n        !baseFields.find((baseField) => !('name' in baseField) || baseField.name === field.name)\n      ) {\n        if (field.name !== 'fields' && field.type !== 'group') {\n          extraFields.push(field)\n          // Remove from fields from now, as they need to be part of the fields group below\n          fields.splice(fields.indexOf(field), 1)\n        }\n      }\n    }\n  }\n\n  if (Array.isArray(customFieldSchema) || fields.length > 0) {\n    // find field with name 'fields' and add the extra fields to it\n    const fieldsField: GroupField = fields.find(\n      (field) => field.type === 'group' && field.name === 'fields',\n    ) as GroupField\n    if (!fieldsField) {\n      throw new Error(\n        'Could not find field with name \"fields\". This is required to add fields to the link field.',\n      )\n    }\n    fieldsField.fields = Array.isArray(fieldsField.fields) ? fieldsField.fields : []\n    fieldsField.fields.push(\n      ...(Array.isArray(customFieldSchema) ? customFieldSchema.concat(extraFields) : extraFields),\n    )\n  }\n  return fields\n}\n"],"names":["getBaseFields","transformExtraFields","customFieldSchema","config","i18n","enabledCollections","disabledCollections","baseFields","fields","defaultFields","extraFields","i","length","field","find","baseField","name","type","push","splice","indexOf","Array","isArray","fieldsField","Error","concat"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAIA,SAASA,aAAa,QAAQ,6BAA4B;AAE1D;;CAEC,GACD,4DAA4D;AAC5D,OAAO,SAASC,qBACdC,iBAEW,EACXC,MAAuB,EACvBC,IAAU,EACVC,kBAAqC,EACrCC,mBAAsC;IAEtC,MAAMC,aAAsBP,cAAcG,QAAQE,oBAAoBC;IAEtE,MAAME,SACJ,OAAON,sBAAsB,aACzBA,kBAAkB;QAAEC;QAAQM,eAAeF;QAAYH;IAAK,KAC5DG;IAEN,8HAA8H;IAC9H,MAAMG,cAAc,EAAE;IACtB,IAAK,IAAIC,IAAIH,OAAOI,MAAM,GAAG,GAAGD,KAAK,GAAGA,IAAK;QAC3C,MAAME,QAAQL,MAAM,CAACG,EAAE;QAEvB,IAAI,UAAUE,OAAO;YACnB,IACE,CAACN,WAAWO,IAAI,CAAC,CAACC,YAAc,CAAE,CAAA,UAAUA,SAAQ,KAAMA,UAAUC,IAAI,KAAKH,MAAMG,IAAI,GACvF;gBACA,IAAIH,MAAMG,IAAI,KAAK,YAAYH,MAAMI,IAAI,KAAK,SAAS;oBACrDP,YAAYQ,IAAI,CAACL;oBACjB,iFAAiF;oBACjFL,OAAOW,MAAM,CAACX,OAAOY,OAAO,CAACP,QAAQ;gBACvC;YACF;QACF;IACF;IAEA,IAAIQ,MAAMC,OAAO,CAACpB,sBAAsBM,OAAOI,MAAM,GAAG,GAAG;QACzD,+DAA+D;QAC/D,MAAMW,cAA0Bf,OAAOM,IAAI,CACzC,CAACD,QAAUA,MAAMI,IAAI,KAAK,WAAWJ,MAAMG,IAAI,KAAK;QAEtD,IAAI,CAACO,aAAa;YAChB,MAAM,IAAIC,MACR;QAEJ;QACAD,YAAYf,MAAM,GAAGa,MAAMC,OAAO,CAACC,YAAYf,MAAM,IAAIe,YAAYf,MAAM,GAAG,EAAE;QAChFe,YAAYf,MAAM,CAACU,IAAI,IACjBG,MAAMC,OAAO,CAACpB,qBAAqBA,kBAAkBuB,MAAM,CAACf,eAAeA;IAEnF;IACA,OAAOF;AACT"}
+{"version":3,"sources":["../../../../../../src/field/features/link/plugins/floatingLinkEditor/utilities.ts"],"sourcesContent":["import type { SanitizedConfig } from 'payload/config'\nimport type { Field } from 'payload/types'\n\nimport { getBaseFields } from '../../drawer/baseFields.js'\n\n/**\n * This function is run to enrich the basefields which every link has with potential, custom user-added fields.\n */\nexport function transformExtraFields(\n  customFieldSchema:\n    | ((args: { config: SanitizedConfig; defaultFields: Field[] }) => Field[])\n    | Field[],\n  config: SanitizedConfig,\n  enabledCollections?: false | string[],\n  disabledCollections?: false | string[],\n  maxDepth?: number,\n): Field[] {\n  const baseFields: Field[] = getBaseFields(\n    config,\n    enabledCollections,\n    disabledCollections,\n    maxDepth,\n  )\n\n  let fields: Field[]\n\n  if (typeof customFieldSchema === 'function') {\n    fields = customFieldSchema({ config, defaultFields: baseFields })\n  } else if (Array.isArray(customFieldSchema)) {\n    fields = customFieldSchema\n  } else {\n    fields = baseFields\n  }\n\n  return fields\n}\n"],"names":["getBaseFields","transformExtraFields","customFieldSchema","config","enabledCollections","disabledCollections","maxDepth","baseFields","fields","defaultFields","Array","isArray"],"rangeMappings":";;;;;;;;;;;;;;;;;","mappings":"AAGA,SAASA,aAAa,QAAQ,6BAA4B;AAE1D;;CAEC,GACD,OAAO,SAASC,qBACdC,iBAEW,EACXC,MAAuB,EACvBC,kBAAqC,EACrCC,mBAAsC,EACtCC,QAAiB;IAEjB,MAAMC,aAAsBP,cAC1BG,QACAC,oBACAC,qBACAC;IAGF,IAAIE;IAEJ,IAAI,OAAON,sBAAsB,YAAY;QAC3CM,SAASN,kBAAkB;YAAEC;YAAQM,eAAeF;QAAW;IACjE,OAAO,IAAIG,MAAMC,OAAO,CAACT,oBAAoB;QAC3CM,SAASN;IACX,OAAO;QACLM,SAASD;IACX;IAEA,OAAOC;AACT"}

package/dist/field/features/link/plugins/link/index.d.ts

@@ -1,2 +1,4 @@
-export declare function LinkPlugin(): null;
+import type { PluginComponent } from '../../../types.js';
+import type { ClientProps } from '../../feature.client.js';
+export declare const LinkPlugin: PluginComponent<ClientProps>;
 //# sourceMappingURL=index.d.ts.map

package/dist/field/features/link/plugins/link/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/field/features/link/plugins/link/index.tsx"],"names":[],"mappings":"AAkBA,wBAAgB,UAAU,IAAI,IAAI,CAkEjC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/field/features/link/plugins/link/index.tsx"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAO1D,eAAO,MAAM,UAAU,EAAE,eAAe,CAAC,WAAW,CA2DnD,CAAA"}

package/dist/field/features/link/plugins/link/index.js

@@ -1,14 +1,11 @@
 'use client';
-import lexicalComposerContextImport from '@lexical/react/LexicalComposerContext.js';
-const { useLexicalComposerContext } = lexicalComposerContextImport;
-import lexicalUtilsImport from '@lexical/utils';
-const { mergeRegister } = lexicalUtilsImport;
-import lexicalImport from 'lexical';
-const { $getSelection, $isElementNode, $isRangeSelection, COMMAND_PRIORITY_LOW, PASTE_COMMAND } = lexicalImport;
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js';
+import { mergeRegister } from '@lexical/utils';
+import { $getSelection, $isElementNode, $isRangeSelection, COMMAND_PRIORITY_LOW, PASTE_COMMAND } from 'lexical';
 import { useEffect } from 'react';
 import { validateUrl } from '../../../../lexical/utils/url.js';
 import { LinkNode, TOGGLE_LINK_COMMAND, toggleLink } from '../../nodes/LinkNode.js';
-export function LinkPlugin() {
+export const LinkPlugin = ()=>{
     const [editor] = useLexicalComposerContext();
     useEffect(()=>{
         if (!editor.hasNodes([
@@ -17,12 +14,6 @@ export function LinkPlugin() {
             throw new Error('LinkPlugin: LinkNode not registered on editor');
         }
         return mergeRegister(editor.registerCommand(TOGGLE_LINK_COMMAND, (payload)=>{
-            // validate
-            if (payload?.fields.linkType === 'custom') {
-                if (!(validateUrl === undefined || validateUrl(payload?.fields.url))) {
-                    return false;
-                }
-            }
             toggleLink(payload);
             return true;
         }, COMMAND_PRIORITY_LOW), validateUrl !== undefined ? editor.registerCommand(PASTE_COMMAND, (event)=>{
@@ -57,6 +48,6 @@ export function LinkPlugin() {
         editor
     ]);
     return null;
-}
+};
 
 //# sourceMappingURL=index.js.map

package/dist/field/features/link/plugins/link/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../src/field/features/link/plugins/link/index.tsx"],"sourcesContent":["'use client'\nimport lexicalComposerContextImport from '@lexical/react/LexicalComposerContext.js'\nconst { useLexicalComposerContext } = lexicalComposerContextImport\nimport lexicalUtilsImport from '@lexical/utils'\nconst { mergeRegister } = lexicalUtilsImport\n\nimport lexicalImport from 'lexical'\nconst { $getSelection, $isElementNode, $isRangeSelection, COMMAND_PRIORITY_LOW, PASTE_COMMAND } =\n  lexicalImport\n\nimport { useEffect } from 'react'\n\nimport type { LinkFields } from '../../nodes/types.js'\nimport type { LinkPayload } from '../floatingLinkEditor/types.js'\n\nimport { validateUrl } from '../../../../lexical/utils/url.js'\nimport { LinkNode, TOGGLE_LINK_COMMAND, toggleLink } from '../../nodes/LinkNode.js'\n\nexport function LinkPlugin(): null {\n  const [editor] = useLexicalComposerContext()\n\n  useEffect(() => {\n    if (!editor.hasNodes([LinkNode])) {\n      throw new Error('LinkPlugin: LinkNode not registered on editor')\n    }\n    return mergeRegister(\n      editor.registerCommand(\n        TOGGLE_LINK_COMMAND,\n        (payload: LinkPayload) => {\n          // validate\n          if (payload?.fields.linkType === 'custom') {\n            if (!(validateUrl === undefined || validateUrl(payload?.fields.url))) {\n              return false\n            }\n          }\n\n          toggleLink(payload)\n          return true\n        },\n        COMMAND_PRIORITY_LOW,\n      ),\n      validateUrl !== undefined\n        ? editor.registerCommand(\n            PASTE_COMMAND,\n            (event) => {\n              const selection = $getSelection()\n              if (\n                !$isRangeSelection(selection) ||\n                selection.isCollapsed() ||\n                !(event instanceof ClipboardEvent) ||\n                event.clipboardData == null\n              ) {\n                return false\n              }\n              const clipboardText = event.clipboardData.getData('text')\n              if (!validateUrl(clipboardText)) {\n                return false\n              }\n              // If we select nodes that are elements then avoid applying the link.\n              if (!selection.getNodes().some((node) => $isElementNode(node))) {\n                const linkFields: LinkFields = {\n                  doc: null,\n                  linkType: 'custom',\n                  newTab: false,\n                  url: clipboardText,\n                }\n                editor.dispatchCommand(TOGGLE_LINK_COMMAND, {\n                  fields: linkFields,\n                  text: null,\n                })\n                event.preventDefault()\n                return true\n              }\n              return false\n            },\n            COMMAND_PRIORITY_LOW,\n          )\n        : () => {\n            // Don't paste arbitrary text as a link when there's no validate function\n          },\n    )\n  }, [editor])\n\n  return null\n}\n"],"names":["lexicalComposerContextImport","useLexicalComposerContext","lexicalUtilsImport","mergeRegister","lexicalImport","$getSelection","$isElementNode","$isRangeSelection","COMMAND_PRIORITY_LOW","PASTE_COMMAND","useEffect","validateUrl","LinkNode","TOGGLE_LINK_COMMAND","toggleLink","LinkPlugin","editor","hasNodes","Error","registerCommand","payload","fields","linkType","undefined","url","event","selection","isCollapsed","ClipboardEvent","clipboardData","clipboardText","getData","getNodes","some","node","linkFields","doc","newTab","dispatchCommand","text","preventDefault"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;AACA,OAAOA,kCAAkC,2CAA0C;AACnF,MAAM,EAAEC,yBAAyB,EAAE,GAAGD;AACtC,OAAOE,wBAAwB,iBAAgB;AAC/C,MAAM,EAAEC,aAAa,EAAE,GAAGD;AAE1B,OAAOE,mBAAmB,UAAS;AACnC,MAAM,EAAEC,aAAa,EAAEC,cAAc,EAAEC,iBAAiB,EAAEC,oBAAoB,EAAEC,aAAa,EAAE,GAC7FL;AAEF,SAASM,SAAS,QAAQ,QAAO;AAKjC,SAASC,WAAW,QAAQ,mCAAkC;AAC9D,SAASC,QAAQ,EAAEC,mBAAmB,EAAEC,UAAU,QAAQ,0BAAyB;AAEnF,OAAO,SAASC;IACd,MAAM,CAACC,OAAO,GAAGf;IAEjBS,UAAU;QACR,IAAI,CAACM,OAAOC,QAAQ,CAAC;YAACL;SAAS,GAAG;YAChC,MAAM,IAAIM,MAAM;QAClB;QACA,OAAOf,cACLa,OAAOG,eAAe,CACpBN,qBACA,CAACO;YACC,WAAW;YACX,IAAIA,SAASC,OAAOC,aAAa,UAAU;gBACzC,IAAI,CAAEX,CAAAA,gBAAgBY,aAAaZ,YAAYS,SAASC,OAAOG,IAAG,GAAI;oBACpE,OAAO;gBACT;YACF;YAEAV,WAAWM;YACX,OAAO;QACT,GACAZ,uBAEFG,gBAAgBY,YACZP,OAAOG,eAAe,CACpBV,eACA,CAACgB;YACC,MAAMC,YAAYrB;YAClB,IACE,CAACE,kBAAkBmB,cACnBA,UAAUC,WAAW,MACrB,CAAEF,CAAAA,iBAAiBG,cAAa,KAChCH,MAAMI,aAAa,IAAI,MACvB;gBACA,OAAO;YACT;YACA,MAAMC,gBAAgBL,MAAMI,aAAa,CAACE,OAAO,CAAC;YAClD,IAAI,CAACpB,YAAYmB,gBAAgB;gBAC/B,OAAO;YACT;YACA,qEAAqE;YACrE,IAAI,CAACJ,UAAUM,QAAQ,GAAGC,IAAI,CAAC,CAACC,OAAS5B,eAAe4B,QAAQ;gBAC9D,MAAMC,aAAyB;oBAC7BC,KAAK;oBACLd,UAAU;oBACVe,QAAQ;oBACRb,KAAKM;gBACP;gBACAd,OAAOsB,eAAe,CAACzB,qBAAqB;oBAC1CQ,QAAQc;oBACRI,MAAM;gBACR;gBACAd,MAAMe,cAAc;gBACpB,OAAO;YACT;YACA,OAAO;QACT,GACAhC,wBAEF;QACE,yEAAyE;QAC3E;IAER,GAAG;QAACQ;KAAO;IAEX,OAAO;AACT"}
+{"version":3,"sources":["../../../../../../src/field/features/link/plugins/link/index.tsx"],"sourcesContent":["'use client'\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js'\nimport { mergeRegister } from '@lexical/utils'\nimport {\n  $getSelection,\n  $isElementNode,\n  $isRangeSelection,\n  COMMAND_PRIORITY_LOW,\n  PASTE_COMMAND,\n} from 'lexical'\nimport { useEffect } from 'react'\n\nimport type { PluginComponent } from '../../../types.js'\nimport type { ClientProps } from '../../feature.client.js'\nimport type { LinkFields } from '../../nodes/types.js'\nimport type { LinkPayload } from '../floatingLinkEditor/types.js'\n\nimport { validateUrl } from '../../../../lexical/utils/url.js'\nimport { LinkNode, TOGGLE_LINK_COMMAND, toggleLink } from '../../nodes/LinkNode.js'\n\nexport const LinkPlugin: PluginComponent<ClientProps> = () => {\n  const [editor] = useLexicalComposerContext()\n\n  useEffect(() => {\n    if (!editor.hasNodes([LinkNode])) {\n      throw new Error('LinkPlugin: LinkNode not registered on editor')\n    }\n    return mergeRegister(\n      editor.registerCommand(\n        TOGGLE_LINK_COMMAND,\n        (payload: LinkPayload) => {\n          toggleLink(payload)\n          return true\n        },\n        COMMAND_PRIORITY_LOW,\n      ),\n      validateUrl !== undefined\n        ? editor.registerCommand(\n            PASTE_COMMAND,\n            (event) => {\n              const selection = $getSelection()\n              if (\n                !$isRangeSelection(selection) ||\n                selection.isCollapsed() ||\n                !(event instanceof ClipboardEvent) ||\n                event.clipboardData == null\n              ) {\n                return false\n              }\n              const clipboardText = event.clipboardData.getData('text')\n              if (!validateUrl(clipboardText)) {\n                return false\n              }\n              // If we select nodes that are elements then avoid applying the link.\n              if (!selection.getNodes().some((node) => $isElementNode(node))) {\n                const linkFields: LinkFields = {\n                  doc: null,\n                  linkType: 'custom',\n                  newTab: false,\n                  url: clipboardText,\n                }\n                editor.dispatchCommand(TOGGLE_LINK_COMMAND, {\n                  fields: linkFields,\n                  text: null,\n                })\n                event.preventDefault()\n                return true\n              }\n              return false\n            },\n            COMMAND_PRIORITY_LOW,\n          )\n        : () => {\n            // Don't paste arbitrary text as a link when there's no validate function\n          },\n    )\n  }, [editor])\n\n  return null\n}\n"],"names":["useLexicalComposerContext","mergeRegister","$getSelection","$isElementNode","$isRangeSelection","COMMAND_PRIORITY_LOW","PASTE_COMMAND","useEffect","validateUrl","LinkNode","TOGGLE_LINK_COMMAND","toggleLink","LinkPlugin","editor","hasNodes","Error","registerCommand","payload","undefined","event","selection","isCollapsed","ClipboardEvent","clipboardData","clipboardText","getData","getNodes","some","node","linkFields","doc","linkType","newTab","url","dispatchCommand","fields","text","preventDefault"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;AACA,SAASA,yBAAyB,QAAQ,2CAA0C;AACpF,SAASC,aAAa,QAAQ,iBAAgB;AAC9C,SACEC,aAAa,EACbC,cAAc,EACdC,iBAAiB,EACjBC,oBAAoB,EACpBC,aAAa,QACR,UAAS;AAChB,SAASC,SAAS,QAAQ,QAAO;AAOjC,SAASC,WAAW,QAAQ,mCAAkC;AAC9D,SAASC,QAAQ,EAAEC,mBAAmB,EAAEC,UAAU,QAAQ,0BAAyB;AAEnF,OAAO,MAAMC,aAA2C;IACtD,MAAM,CAACC,OAAO,GAAGb;IAEjBO,UAAU;QACR,IAAI,CAACM,OAAOC,QAAQ,CAAC;YAACL;SAAS,GAAG;YAChC,MAAM,IAAIM,MAAM;QAClB;QACA,OAAOd,cACLY,OAAOG,eAAe,CACpBN,qBACA,CAACO;YACCN,WAAWM;YACX,OAAO;QACT,GACAZ,uBAEFG,gBAAgBU,YACZL,OAAOG,eAAe,CACpBV,eACA,CAACa;YACC,MAAMC,YAAYlB;YAClB,IACE,CAACE,kBAAkBgB,cACnBA,UAAUC,WAAW,MACrB,CAAEF,CAAAA,iBAAiBG,cAAa,KAChCH,MAAMI,aAAa,IAAI,MACvB;gBACA,OAAO;YACT;YACA,MAAMC,gBAAgBL,MAAMI,aAAa,CAACE,OAAO,CAAC;YAClD,IAAI,CAACjB,YAAYgB,gBAAgB;gBAC/B,OAAO;YACT;YACA,qEAAqE;YACrE,IAAI,CAACJ,UAAUM,QAAQ,GAAGC,IAAI,CAAC,CAACC,OAASzB,eAAeyB,QAAQ;gBAC9D,MAAMC,aAAyB;oBAC7BC,KAAK;oBACLC,UAAU;oBACVC,QAAQ;oBACRC,KAAKT;gBACP;gBACAX,OAAOqB,eAAe,CAACxB,qBAAqB;oBAC1CyB,QAAQN;oBACRO,MAAM;gBACR;gBACAjB,MAAMkB,cAAc;gBACpB,OAAO;YACT;YACA,OAAO;QACT,GACAhC,wBAEF;QACE,yEAAyE;QAC3E;IAER,GAAG;QAACQ;KAAO;IAEX,OAAO;AACT,EAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"populationPromise.d.ts","sourceRoot":"","sources":["../../../../src/field/features/link/populationPromise.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AACpD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAA;AACjE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAK1D,eAAO,MAAM,wBAAwB,UAC5B,sBAAsB,KAC5B,kBAAkB,kBAAkB,CA+DtC,CAAA"}
+{"version":3,"file":"populationPromise.d.ts","sourceRoot":"","sources":["../../../../src/field/features/link/populationPromise.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AACpD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAA;AACjE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAI1D,eAAO,MAAM,wBAAwB,UAC5B,sBAAsB,KAC5B,kBAAkB,kBAAkB,CA2CtC,CAAA"}

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,
+                flattenLocales: false,
                 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: false, // Disable localization handling which does not work properly yet. Once we fully support hooks, this can be enabled (pass through flattenLocales again)\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,gBAAgB;gBAChBE;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 'The following fields are invalid: ' + 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 'The following fields are invalid: ' + 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,uCAAuCH,WAAWI,IAAI,CAAC;QAChE;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":";AA8GA,eAAO,MAAM,+BAA+B;;;EAAgD,CAAA"}

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

@@ -1,14 +1,50 @@
 '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 { slashMenuListGroupWithItems } from '../shared/slashMenuListGroup.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: ({ i18n })=>{
+                return i18n.t('lexical:checklist:label');
+            },
+            onSelect: ({ editor })=>{
+                editor.dispatchCommand(INSERT_CHECK_LIST_COMMAND, undefined);
+            },
+            order: 12
+        }
+    ])
+];
+const ChecklistFeatureClient = (props)=>{
     return {
         clientFeatureProps: props,
         feature: ({ featureProviderMap })=>{
@@ -18,7 +54,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 +62,46 @@ 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: [
-                        {
-                            displayName: 'Lists',
-                            key: 'lists',
-                            options: [
-                                new SlashMenuOption('checklist', {
-                                    Icon: ChecklistIcon,
-                                    displayName: 'Check List',
-                                    keywords: [
-                                        'check list',
-                                        'check',
-                                        'checklist',
-                                        'cl'
-                                    ],
-                                    onSelect: ({ editor })=>{
-                                        editor.dispatchCommand(INSERT_CHECK_LIST_COMMAND, undefined);
-                                    }
-                                })
-                            ]
-                        }
+                    groups: [
+                        slashMenuListGroupWithItems([
+                            {
+                                Icon: ChecklistIcon,
+                                key: 'checklist',
+                                keywords: [
+                                    'check list',
+                                    'check',
+                                    'checklist',
+                                    'cl'
+                                ],
+                                label: ({ i18n })=>{
+                                    return i18n.t('lexical:checklist:label');
+                                },
+                                onSelect: ({ editor })=>{
+                                    editor.dispatchCommand(INSERT_CHECK_LIST_COMMAND, undefined);
+                                }
+                            }
+                        ])
                     ]
+                },
+                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 { slashMenuListGroupWithItems } from '../shared/slashMenuListGroup.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: ({ i18n }) => {\n        return i18n.t('lexical:checklist:label')\n      },\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            slashMenuListGroupWithItems([\n              {\n                Icon: ChecklistIcon,\n                key: 'checklist',\n                keywords: ['check list', 'check', 'checklist', 'cl'],\n                label: ({ i18n }) => {\n                  return i18n.t('lexical:checklist:label')\n                },\n                onSelect: ({ editor }) => {\n                  editor.dispatchCommand(INSERT_CHECK_LIST_COMMAND, undefined)\n                },\n              },\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","slashMenuListGroupWithItems","CHECK_LIST","LexicalCheckListPlugin","toolbarGroups","ChildComponent","isActive","selection","node","getNodes","getListType","parent","getParent","parentParent","key","label","i18n","t","onSelect","editor","dispatchCommand","undefined","order","ChecklistFeatureClient","props","clientFeatureProps","feature","featureProviderMap","plugins","Component","position","has","push","markdownTransformers","nodes","slashMenu","groups","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,2BAA2B,QAAQ,kCAAiC;AAC7E,SAASC,UAAU,QAAQ,4BAA2B;AACtD,SAASC,sBAAsB,QAAQ,oBAAmB;AAE1D,MAAMC,gBAAgC;IACpCL,kCAAkC;QAChC;YACEM,gBAAgBR;YAChBS,UAAU,CAAC,EAAEC,SAAS,EAAE;gBACtB,IAAI,CAACX,kBAAkBW,YAAY;oBACjC,OAAO;gBACT;gBACA,KAAK,MAAMC,QAAQD,UAAUE,QAAQ,GAAI;oBACvC,IAAIjB,YAAYgB,SAASA,KAAKE,WAAW,OAAO,SAAS;wBACvD;oBACF;oBAEA,MAAMC,SAASH,KAAKI,SAAS;oBAE7B,IAAIpB,YAAYmB,WAAWA,OAAOD,WAAW,OAAO,SAAS;wBAC3D;oBACF;oBAEA,MAAMG,eAAeF,QAAQC;oBAC7B,oFAAoF;oBACpF,IAAIpB,YAAYqB,iBAAiBA,aAAaH,WAAW,OAAO,SAAS;wBACvE;oBACF;oBAEA,OAAO;gBACT;gBACA,OAAO;YACT;YACAI,KAAK;YACLC,OAAO,CAAC,EAAEC,IAAI,EAAE;gBACd,OAAOA,KAAKC,CAAC,CAAC;YAChB;YACAC,UAAU,CAAC,EAAEC,MAAM,EAAE;gBACnBA,OAAOC,eAAe,CAAC3B,2BAA2B4B;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,WAAW1B;oBACX2B,UAAU;gBACZ;aACD;YAED,IAAI,CAACH,mBAAmBI,GAAG,CAAC,oBAAoB,CAACJ,mBAAmBI,GAAG,CAAC,gBAAgB;gBACtFH,QAAQI,IAAI,CAAC;oBACXH,WAAW7B;oBACX8B,UAAU;gBACZ;YACF;YAEA,OAAO;gBACLL,oBAAoBD;gBACpBS,sBAAsB;oBAAC/B;iBAAW;gBAClCgC,OACEP,mBAAmBI,GAAG,CAAC,oBAAoBJ,mBAAmBI,GAAG,CAAC,iBAC9D,EAAE,GACF;oBAACpC;oBAAUD;iBAAa;gBAC9BkC;gBACAO,WAAW;oBACTC,QAAQ;wBACNnC,4BAA4B;4BAC1B;gCACEoC,MAAMxC;gCACNiB,KAAK;gCACLwB,UAAU;oCAAC;oCAAc;oCAAS;oCAAa;iCAAK;gCACpDvB,OAAO,CAAC,EAAEC,IAAI,EAAE;oCACd,OAAOA,KAAKC,CAAC,CAAC;gCAChB;gCACAC,UAAU,CAAC,EAAEC,MAAM,EAAE;oCACnBA,OAAOC,eAAe,CAAC3B,2BAA2B4B;gCACpD;4BACF;yBACD;qBACF;gBACH;gBACAkB,cAAc;oBACZH,QAAQhC;gBACV;gBACAoC,eAAe;oBACbJ,QAAQhC;gBACV;YACF;QACF;IACF;AACF;AAEA,OAAO,MAAMqC,kCAAkC3C,sBAAsByB,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;AAQnE,eAAO,MAAM,gBAAgB,EAAE,6BAA6B,CAAC,SAAS,EAAE,SAAS,CA8BhF,CAAA"}

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

@@ -1,29 +1,31 @@
-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 { i18n } from './i18n.js';
 import { CHECK_LIST } from './markdownTransformers.js';
-export const CheckListFeature = (props)=>{
+export const ChecklistFeature = (props)=>{
     return {
         feature: ({ featureProviderMap })=>{
             return {
-                ClientComponent: CheckListFeatureClientComponent,
+                ClientComponent: ChecklistFeatureClientComponent,
+                i18n,
                 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 { i18n } from './i18n.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        i18n,\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","i18n","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,IAAI,QAAQ,YAAW;AAChC,SAASC,UAAU,QAAQ,4BAA2B;AAEtD,OAAO,MAAMC,mBAAwE,CAACC;IACpF,OAAO;QACLC,SAAS,CAAC,EAAEC,kBAAkB,EAAE;YAC9B,OAAO;gBACLC,iBAAiBP;gBACjBC;gBACAO,sBAAsB;oBAACN;iBAAW;gBAClCO,OACEH,mBAAmBI,GAAG,CAAC,oBAAoBJ,mBAAmBI,GAAG,CAAC,iBAC9D,EAAE,GACF;oBACEb,WAAW;wBACTc,YAAY;4BACVC,MAAMd;wBACR;wBACAe,MAAMjB;oBACR;oBACAC,WAAW;wBACTc,YAAY;4BACVC,MAAMb;wBACR;wBACAc,MAAMlB;oBACR;iBACD;gBACPmB,oBAAoBV;YACtB;QACF;QACAW,KAAK;QACLD,oBAAoBV;IACtB;AACF,EAAC"}

package/dist/field/features/lists/checklist/i18n.d.ts

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

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

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