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

package/dist/field/lexical/config/server/sanitize.js

@@ -9,8 +9,13 @@ export const sanitizeServerFeatures = (features)=>{
             modifyOutputSchemas: []
         },
         hooks: {
-            afterReadPromises: []
+            afterChange: new Map(),
+            afterRead: new Map(),
+            beforeChange: new Map(),
+            beforeDuplicate: new Map(),
+            beforeValidate: new Map()
         },
+        i18n: {},
         markdownTransformers: [],
         nodes: [],
         populationPromises: new Map(),
@@ -23,9 +28,14 @@ export const sanitizeServerFeatures = (features)=>{
         if (feature?.generatedTypes?.modifyOutputSchema) {
             sanitized.generatedTypes.modifyOutputSchemas.push(feature.generatedTypes.modifyOutputSchema);
         }
-        if (feature.hooks) {
-            if (feature.hooks.afterReadPromise) {
-                sanitized.hooks.afterReadPromises = sanitized.hooks.afterReadPromises.concat(feature.hooks.afterReadPromise);
+        if (feature?.i18n) {
+            for(const lang in feature.i18n){
+                if (!sanitized.i18n[lang]) {
+                    sanitized.i18n[lang] = {
+                        lexical: {}
+                    };
+                }
+                sanitized.i18n[lang].lexical[feature.key] = feature.i18n[lang];
             }
         }
         if (feature.nodes?.length) {
@@ -42,6 +52,21 @@ export const sanitizeServerFeatures = (features)=>{
                 if (node?.converters?.html) {
                     sanitized.converters.html.push(node.converters.html);
                 }
+                if (node?.hooks?.afterChange) {
+                    sanitized.hooks.afterChange.set(nodeType, node.hooks.afterChange);
+                }
+                if (node?.hooks?.afterRead) {
+                    sanitized.hooks.afterRead.set(nodeType, node.hooks.afterRead);
+                }
+                if (node?.hooks?.beforeChange) {
+                    sanitized.hooks.beforeChange.set(nodeType, node.hooks.beforeChange);
+                }
+                if (node?.hooks?.beforeDuplicate) {
+                    sanitized.hooks.beforeDuplicate.set(nodeType, node.hooks.beforeDuplicate);
+                }
+                if (node?.hooks?.beforeValidate) {
+                    sanitized.hooks.beforeValidate.set(nodeType, node.hooks.beforeValidate);
+                }
             });
         }
         if (feature.markdownTransformers?.length) {
@@ -51,8 +76,9 @@ export const sanitizeServerFeatures = (features)=>{
     });
     return sanitized;
 };
-export function sanitizeServerEditorConfig(editorConfig) {
-    const resolvedFeatureMap = loadFeatures({
+export async function sanitizeServerEditorConfig(editorConfig, config) {
+    const resolvedFeatureMap = await loadFeatures({
+        config,
         unSanitizedEditorConfig: editorConfig
     });
     return {

package/dist/field/lexical/config/server/sanitize.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/field/lexical/config/server/sanitize.ts"],"sourcesContent":["import type { ResolvedServerFeatureMap, SanitizedServerFeatures } from '../../../features/types.js'\nimport type { SanitizedServerEditorConfig, ServerEditorConfig } from '../types.js'\n\nimport { loadFeatures } from './loader.js'\n\nexport const sanitizeServerFeatures = (\n  features: ResolvedServerFeatureMap,\n): SanitizedServerFeatures => {\n  const sanitized: SanitizedServerFeatures = {\n    converters: {\n      html: [],\n    },\n    enabledFeatures: [],\n\n    generatedTypes: {\n      modifyOutputSchemas: [],\n    },\n    hooks: {\n      afterReadPromises: [],\n    },\n    markdownTransformers: [],\n    nodes: [],\n    populationPromises: new Map(),\n\n    validations: new Map(),\n  }\n\n  if (!features?.size) {\n    return sanitized\n  }\n\n  features.forEach((feature) => {\n    if (feature?.generatedTypes?.modifyOutputSchema) {\n      sanitized.generatedTypes.modifyOutputSchemas.push(feature.generatedTypes.modifyOutputSchema)\n    }\n    if (feature.hooks) {\n      if (feature.hooks.afterReadPromise) {\n        sanitized.hooks.afterReadPromises = sanitized.hooks.afterReadPromises.concat(\n          feature.hooks.afterReadPromise,\n        )\n      }\n    }\n\n    if (feature.nodes?.length) {\n      sanitized.nodes = sanitized.nodes.concat(feature.nodes)\n      feature.nodes.forEach((node) => {\n        const nodeType = 'with' in node.node ? node.node.replace.getType() : node.node.getType() // TODO: Idk if this works for node replacements\n        if (node?.populationPromises?.length) {\n          sanitized.populationPromises.set(nodeType, node.populationPromises)\n        }\n        if (node?.validations?.length) {\n          sanitized.validations.set(nodeType, node.validations)\n        }\n        if (node?.converters?.html) {\n          sanitized.converters.html.push(node.converters.html)\n        }\n      })\n    }\n\n    if (feature.markdownTransformers?.length) {\n      sanitized.markdownTransformers = sanitized.markdownTransformers.concat(\n        feature.markdownTransformers,\n      )\n    }\n\n    sanitized.enabledFeatures.push(feature.key)\n  })\n\n  return sanitized\n}\n\nexport function sanitizeServerEditorConfig(\n  editorConfig: ServerEditorConfig,\n): SanitizedServerEditorConfig {\n  const resolvedFeatureMap = loadFeatures({\n    unSanitizedEditorConfig: editorConfig,\n  })\n\n  return {\n    features: sanitizeServerFeatures(resolvedFeatureMap),\n    lexical: editorConfig.lexical,\n    resolvedFeatureMap,\n  }\n}\n"],"names":["loadFeatures","sanitizeServerFeatures","features","sanitized","converters","html","enabledFeatures","generatedTypes","modifyOutputSchemas","hooks","afterReadPromises","markdownTransformers","nodes","populationPromises","Map","validations","size","forEach","feature","modifyOutputSchema","push","afterReadPromise","concat","length","node","nodeType","replace","getType","set","key","sanitizeServerEditorConfig","editorConfig","resolvedFeatureMap","unSanitizedEditorConfig","lexical"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAGA,SAASA,YAAY,QAAQ,cAAa;AAE1C,OAAO,MAAMC,yBAAyB,CACpCC;IAEA,MAAMC,YAAqC;QACzCC,YAAY;YACVC,MAAM,EAAE;QACV;QACAC,iBAAiB,EAAE;QAEnBC,gBAAgB;YACdC,qBAAqB,EAAE;QACzB;QACAC,OAAO;YACLC,mBAAmB,EAAE;QACvB;QACAC,sBAAsB,EAAE;QACxBC,OAAO,EAAE;QACTC,oBAAoB,IAAIC;QAExBC,aAAa,IAAID;IACnB;IAEA,IAAI,CAACZ,UAAUc,MAAM;QACnB,OAAOb;IACT;IAEAD,SAASe,OAAO,CAAC,CAACC;QAChB,IAAIA,SAASX,gBAAgBY,oBAAoB;YAC/ChB,UAAUI,cAAc,CAACC,mBAAmB,CAACY,IAAI,CAACF,QAAQX,cAAc,CAACY,kBAAkB;QAC7F;QACA,IAAID,QAAQT,KAAK,EAAE;YACjB,IAAIS,QAAQT,KAAK,CAACY,gBAAgB,EAAE;gBAClClB,UAAUM,KAAK,CAACC,iBAAiB,GAAGP,UAAUM,KAAK,CAACC,iBAAiB,CAACY,MAAM,CAC1EJ,QAAQT,KAAK,CAACY,gBAAgB;YAElC;QACF;QAEA,IAAIH,QAAQN,KAAK,EAAEW,QAAQ;YACzBpB,UAAUS,KAAK,GAAGT,UAAUS,KAAK,CAACU,MAAM,CAACJ,QAAQN,KAAK;YACtDM,QAAQN,KAAK,CAACK,OAAO,CAAC,CAACO;gBACrB,MAAMC,WAAW,UAAUD,KAAKA,IAAI,GAAGA,KAAKA,IAAI,CAACE,OAAO,CAACC,OAAO,KAAKH,KAAKA,IAAI,CAACG,OAAO,GAAG,gDAAgD;;gBACzI,IAAIH,MAAMX,oBAAoBU,QAAQ;oBACpCpB,UAAUU,kBAAkB,CAACe,GAAG,CAACH,UAAUD,KAAKX,kBAAkB;gBACpE;gBACA,IAAIW,MAAMT,aAAaQ,QAAQ;oBAC7BpB,UAAUY,WAAW,CAACa,GAAG,CAACH,UAAUD,KAAKT,WAAW;gBACtD;gBACA,IAAIS,MAAMpB,YAAYC,MAAM;oBAC1BF,UAAUC,UAAU,CAACC,IAAI,CAACe,IAAI,CAACI,KAAKpB,UAAU,CAACC,IAAI;gBACrD;YACF;QACF;QAEA,IAAIa,QAAQP,oBAAoB,EAAEY,QAAQ;YACxCpB,UAAUQ,oBAAoB,GAAGR,UAAUQ,oBAAoB,CAACW,MAAM,CACpEJ,QAAQP,oBAAoB;QAEhC;QAEAR,UAAUG,eAAe,CAACc,IAAI,CAACF,QAAQW,GAAG;IAC5C;IAEA,OAAO1B;AACT,EAAC;AAED,OAAO,SAAS2B,2BACdC,YAAgC;IAEhC,MAAMC,qBAAqBhC,aAAa;QACtCiC,yBAAyBF;IAC3B;IAEA,OAAO;QACL7B,UAAUD,uBAAuB+B;QACjCE,SAASH,aAAaG,OAAO;QAC7BF;IACF;AACF"}
+{"version":3,"sources":["../../../../../src/field/lexical/config/server/sanitize.ts"],"sourcesContent":["import type { Config, SanitizedConfig } from 'payload/config'\n\nimport type { ResolvedServerFeatureMap, SanitizedServerFeatures } from '../../../features/types.js'\nimport type { SanitizedServerEditorConfig, ServerEditorConfig } from '../types.js'\n\nimport { loadFeatures } from './loader.js'\n\nexport const sanitizeServerFeatures = (\n  features: ResolvedServerFeatureMap,\n): SanitizedServerFeatures => {\n  const sanitized: SanitizedServerFeatures = {\n    converters: {\n      html: [],\n    },\n    enabledFeatures: [],\n    generatedTypes: {\n      modifyOutputSchemas: [],\n    },\n\n    hooks: {\n      afterChange: new Map(),\n      afterRead: new Map(),\n      beforeChange: new Map(),\n      beforeDuplicate: new Map(),\n      beforeValidate: new Map(),\n    },\n    i18n: {},\n    markdownTransformers: [],\n    nodes: [],\n    populationPromises: new Map(),\n\n    validations: new Map(),\n  }\n\n  if (!features?.size) {\n    return sanitized\n  }\n\n  features.forEach((feature) => {\n    if (feature?.generatedTypes?.modifyOutputSchema) {\n      sanitized.generatedTypes.modifyOutputSchemas.push(feature.generatedTypes.modifyOutputSchema)\n    }\n\n    if (feature?.i18n) {\n      for (const lang in feature.i18n) {\n        if (!sanitized.i18n[lang]) {\n          sanitized.i18n[lang] = {\n            lexical: {},\n          }\n        }\n        sanitized.i18n[lang].lexical[feature.key] = feature.i18n[lang]\n      }\n    }\n\n    if (feature.nodes?.length) {\n      sanitized.nodes = sanitized.nodes.concat(feature.nodes)\n      feature.nodes.forEach((node) => {\n        const nodeType = 'with' in node.node ? node.node.replace.getType() : node.node.getType() // TODO: Idk if this works for node replacements\n        if (node?.populationPromises?.length) {\n          sanitized.populationPromises.set(nodeType, node.populationPromises)\n        }\n        if (node?.validations?.length) {\n          sanitized.validations.set(nodeType, node.validations)\n        }\n        if (node?.converters?.html) {\n          sanitized.converters.html.push(node.converters.html)\n        }\n        if (node?.hooks?.afterChange) {\n          sanitized.hooks.afterChange.set(nodeType, node.hooks.afterChange)\n        }\n        if (node?.hooks?.afterRead) {\n          sanitized.hooks.afterRead.set(nodeType, node.hooks.afterRead)\n        }\n        if (node?.hooks?.beforeChange) {\n          sanitized.hooks.beforeChange.set(nodeType, node.hooks.beforeChange)\n        }\n        if (node?.hooks?.beforeDuplicate) {\n          sanitized.hooks.beforeDuplicate.set(nodeType, node.hooks.beforeDuplicate)\n        }\n        if (node?.hooks?.beforeValidate) {\n          sanitized.hooks.beforeValidate.set(nodeType, node.hooks.beforeValidate)\n        }\n      })\n    }\n\n    if (feature.markdownTransformers?.length) {\n      sanitized.markdownTransformers = sanitized.markdownTransformers.concat(\n        feature.markdownTransformers,\n      )\n    }\n\n    sanitized.enabledFeatures.push(feature.key)\n  })\n\n  return sanitized\n}\n\nexport async function sanitizeServerEditorConfig(\n  editorConfig: ServerEditorConfig,\n  config: SanitizedConfig,\n): Promise<SanitizedServerEditorConfig> {\n  const resolvedFeatureMap = await loadFeatures({\n    config,\n    unSanitizedEditorConfig: editorConfig,\n  })\n\n  return {\n    features: sanitizeServerFeatures(resolvedFeatureMap),\n    lexical: editorConfig.lexical,\n    resolvedFeatureMap,\n  }\n}\n"],"names":["loadFeatures","sanitizeServerFeatures","features","sanitized","converters","html","enabledFeatures","generatedTypes","modifyOutputSchemas","hooks","afterChange","Map","afterRead","beforeChange","beforeDuplicate","beforeValidate","i18n","markdownTransformers","nodes","populationPromises","validations","size","forEach","feature","modifyOutputSchema","push","lang","lexical","key","length","concat","node","nodeType","replace","getType","set","sanitizeServerEditorConfig","editorConfig","config","resolvedFeatureMap","unSanitizedEditorConfig"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAKA,SAASA,YAAY,QAAQ,cAAa;AAE1C,OAAO,MAAMC,yBAAyB,CACpCC;IAEA,MAAMC,YAAqC;QACzCC,YAAY;YACVC,MAAM,EAAE;QACV;QACAC,iBAAiB,EAAE;QACnBC,gBAAgB;YACdC,qBAAqB,EAAE;QACzB;QAEAC,OAAO;YACLC,aAAa,IAAIC;YACjBC,WAAW,IAAID;YACfE,cAAc,IAAIF;YAClBG,iBAAiB,IAAIH;YACrBI,gBAAgB,IAAIJ;QACtB;QACAK,MAAM,CAAC;QACPC,sBAAsB,EAAE;QACxBC,OAAO,EAAE;QACTC,oBAAoB,IAAIR;QAExBS,aAAa,IAAIT;IACnB;IAEA,IAAI,CAACT,UAAUmB,MAAM;QACnB,OAAOlB;IACT;IAEAD,SAASoB,OAAO,CAAC,CAACC;QAChB,IAAIA,SAAShB,gBAAgBiB,oBAAoB;YAC/CrB,UAAUI,cAAc,CAACC,mBAAmB,CAACiB,IAAI,CAACF,QAAQhB,cAAc,CAACiB,kBAAkB;QAC7F;QAEA,IAAID,SAASP,MAAM;YACjB,IAAK,MAAMU,QAAQH,QAAQP,IAAI,CAAE;gBAC/B,IAAI,CAACb,UAAUa,IAAI,CAACU,KAAK,EAAE;oBACzBvB,UAAUa,IAAI,CAACU,KAAK,GAAG;wBACrBC,SAAS,CAAC;oBACZ;gBACF;gBACAxB,UAAUa,IAAI,CAACU,KAAK,CAACC,OAAO,CAACJ,QAAQK,GAAG,CAAC,GAAGL,QAAQP,IAAI,CAACU,KAAK;YAChE;QACF;QAEA,IAAIH,QAAQL,KAAK,EAAEW,QAAQ;YACzB1B,UAAUe,KAAK,GAAGf,UAAUe,KAAK,CAACY,MAAM,CAACP,QAAQL,KAAK;YACtDK,QAAQL,KAAK,CAACI,OAAO,CAAC,CAACS;gBACrB,MAAMC,WAAW,UAAUD,KAAKA,IAAI,GAAGA,KAAKA,IAAI,CAACE,OAAO,CAACC,OAAO,KAAKH,KAAKA,IAAI,CAACG,OAAO,GAAG,gDAAgD;;gBACzI,IAAIH,MAAMZ,oBAAoBU,QAAQ;oBACpC1B,UAAUgB,kBAAkB,CAACgB,GAAG,CAACH,UAAUD,KAAKZ,kBAAkB;gBACpE;gBACA,IAAIY,MAAMX,aAAaS,QAAQ;oBAC7B1B,UAAUiB,WAAW,CAACe,GAAG,CAACH,UAAUD,KAAKX,WAAW;gBACtD;gBACA,IAAIW,MAAM3B,YAAYC,MAAM;oBAC1BF,UAAUC,UAAU,CAACC,IAAI,CAACoB,IAAI,CAACM,KAAK3B,UAAU,CAACC,IAAI;gBACrD;gBACA,IAAI0B,MAAMtB,OAAOC,aAAa;oBAC5BP,UAAUM,KAAK,CAACC,WAAW,CAACyB,GAAG,CAACH,UAAUD,KAAKtB,KAAK,CAACC,WAAW;gBAClE;gBACA,IAAIqB,MAAMtB,OAAOG,WAAW;oBAC1BT,UAAUM,KAAK,CAACG,SAAS,CAACuB,GAAG,CAACH,UAAUD,KAAKtB,KAAK,CAACG,SAAS;gBAC9D;gBACA,IAAImB,MAAMtB,OAAOI,cAAc;oBAC7BV,UAAUM,KAAK,CAACI,YAAY,CAACsB,GAAG,CAACH,UAAUD,KAAKtB,KAAK,CAACI,YAAY;gBACpE;gBACA,IAAIkB,MAAMtB,OAAOK,iBAAiB;oBAChCX,UAAUM,KAAK,CAACK,eAAe,CAACqB,GAAG,CAACH,UAAUD,KAAKtB,KAAK,CAACK,eAAe;gBAC1E;gBACA,IAAIiB,MAAMtB,OAAOM,gBAAgB;oBAC/BZ,UAAUM,KAAK,CAACM,cAAc,CAACoB,GAAG,CAACH,UAAUD,KAAKtB,KAAK,CAACM,cAAc;gBACxE;YACF;QACF;QAEA,IAAIQ,QAAQN,oBAAoB,EAAEY,QAAQ;YACxC1B,UAAUc,oBAAoB,GAAGd,UAAUc,oBAAoB,CAACa,MAAM,CACpEP,QAAQN,oBAAoB;QAEhC;QAEAd,UAAUG,eAAe,CAACmB,IAAI,CAACF,QAAQK,GAAG;IAC5C;IAEA,OAAOzB;AACT,EAAC;AAED,OAAO,eAAeiC,2BACpBC,YAAgC,EAChCC,MAAuB;IAEvB,MAAMC,qBAAqB,MAAMvC,aAAa;QAC5CsC;QACAE,yBAAyBH;IAC3B;IAEA,OAAO;QACLnC,UAAUD,uBAAuBsC;QACjCZ,SAASU,aAAaV,OAAO;QAC7BY;IACF;AACF"}

package/dist/field/lexical/config/types.d.ts

@@ -1,4 +1,5 @@
-import type { EditorConfig as LexicalEditorConfig } from 'lexical/LexicalEditor.js';
+import type { EditorConfig as LexicalEditorConfig } from 'lexical';
+import type { LexicalFieldAdminProps } from '../../../types.js';
 import type { FeatureProviderClient, FeatureProviderServer, ResolvedClientFeatureMap, ResolvedServerFeatureMap, SanitizedClientFeatures, SanitizedServerFeatures } from '../../features/types.js';
 export type ServerEditorConfig = {
     features: FeatureProviderServer<unknown, unknown>[];
@@ -14,6 +15,7 @@ export type ClientEditorConfig = {
     lexical?: LexicalEditorConfig;
 };
 export type SanitizedClientEditorConfig = {
+    admin?: LexicalFieldAdminProps;
     features: SanitizedClientFeatures;
     lexical: LexicalEditorConfig;
     resolvedFeatureMap: ResolvedClientFeatureMap;

package/dist/field/lexical/config/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/field/lexical/config/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,IAAI,mBAAmB,EAAE,MAAM,0BAA0B,CAAA;AAEnF,OAAO,KAAK,EACV,qBAAqB,EACrB,qBAAqB,EACrB,wBAAwB,EACxB,wBAAwB,EACxB,uBAAuB,EACvB,uBAAuB,EACxB,MAAM,yBAAyB,CAAA;AAEhC,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,EAAE,qBAAqB,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,CAAA;IACnD,OAAO,CAAC,EAAE,mBAAmB,CAAA;CAC9B,CAAA;AAED,MAAM,MAAM,2BAA2B,GAAG;IACxC,QAAQ,EAAE,uBAAuB,CAAA;IACjC,OAAO,EAAE,mBAAmB,CAAA;IAC5B,kBAAkB,EAAE,wBAAwB,CAAA;CAC7C,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,EAAE,qBAAqB,CAAC,OAAO,CAAC,EAAE,CAAA;IAC1C,OAAO,CAAC,EAAE,mBAAmB,CAAA;CAC9B,CAAA;AAED,MAAM,MAAM,2BAA2B,GAAG;IACxC,QAAQ,EAAE,uBAAuB,CAAA;IACjC,OAAO,EAAE,mBAAmB,CAAA;IAC5B,kBAAkB,EAAE,wBAAwB,CAAA;CAC7C,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/field/lexical/config/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,IAAI,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAElE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAA;AAC/D,OAAO,KAAK,EACV,qBAAqB,EACrB,qBAAqB,EACrB,wBAAwB,EACxB,wBAAwB,EACxB,uBAAuB,EACvB,uBAAuB,EACxB,MAAM,yBAAyB,CAAA;AAEhC,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,EAAE,qBAAqB,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,CAAA;IACnD,OAAO,CAAC,EAAE,mBAAmB,CAAA;CAC9B,CAAA;AAED,MAAM,MAAM,2BAA2B,GAAG;IACxC,QAAQ,EAAE,uBAAuB,CAAA;IACjC,OAAO,EAAE,mBAAmB,CAAA;IAC5B,kBAAkB,EAAE,wBAAwB,CAAA;CAC7C,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,EAAE,qBAAqB,CAAC,OAAO,CAAC,EAAE,CAAA;IAC1C,OAAO,CAAC,EAAE,mBAAmB,CAAA;CAC9B,CAAA;AAED,MAAM,MAAM,2BAA2B,GAAG;IACxC,KAAK,CAAC,EAAE,sBAAsB,CAAA;IAC9B,QAAQ,EAAE,uBAAuB,CAAA;IACjC,OAAO,EAAE,mBAAmB,CAAA;IAC5B,kBAAkB,EAAE,wBAAwB,CAAA;CAC7C,CAAA"}

package/dist/field/lexical/config/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/field/lexical/config/types.ts"],"sourcesContent":["import type { EditorConfig as LexicalEditorConfig } from 'lexical/LexicalEditor.js'\n\nimport type {\n  FeatureProviderClient,\n  FeatureProviderServer,\n  ResolvedClientFeatureMap,\n  ResolvedServerFeatureMap,\n  SanitizedClientFeatures,\n  SanitizedServerFeatures,\n} from '../../features/types.js'\n\nexport type ServerEditorConfig = {\n  features: FeatureProviderServer<unknown, unknown>[]\n  lexical?: LexicalEditorConfig\n}\n\nexport type SanitizedServerEditorConfig = {\n  features: SanitizedServerFeatures\n  lexical: LexicalEditorConfig\n  resolvedFeatureMap: ResolvedServerFeatureMap\n}\n\nexport type ClientEditorConfig = {\n  features: FeatureProviderClient<unknown>[]\n  lexical?: LexicalEditorConfig\n}\n\nexport type SanitizedClientEditorConfig = {\n  features: SanitizedClientFeatures\n  lexical: LexicalEditorConfig\n  resolvedFeatureMap: ResolvedClientFeatureMap\n}\n"],"names":[],"rangeMappings":"","mappings":"AA2BA,WAIC"}
+{"version":3,"sources":["../../../../src/field/lexical/config/types.ts"],"sourcesContent":["import type { EditorConfig as LexicalEditorConfig } from 'lexical'\n\nimport type { LexicalFieldAdminProps } from '../../../types.js'\nimport type {\n  FeatureProviderClient,\n  FeatureProviderServer,\n  ResolvedClientFeatureMap,\n  ResolvedServerFeatureMap,\n  SanitizedClientFeatures,\n  SanitizedServerFeatures,\n} from '../../features/types.js'\n\nexport type ServerEditorConfig = {\n  features: FeatureProviderServer<unknown, unknown>[]\n  lexical?: LexicalEditorConfig\n}\n\nexport type SanitizedServerEditorConfig = {\n  features: SanitizedServerFeatures\n  lexical: LexicalEditorConfig\n  resolvedFeatureMap: ResolvedServerFeatureMap\n}\n\nexport type ClientEditorConfig = {\n  features: FeatureProviderClient<unknown>[]\n  lexical?: LexicalEditorConfig\n}\n\nexport type SanitizedClientEditorConfig = {\n  admin?: LexicalFieldAdminProps\n  features: SanitizedClientFeatures\n  lexical: LexicalEditorConfig\n  resolvedFeatureMap: ResolvedClientFeatureMap\n}\n"],"names":[],"rangeMappings":"","mappings":"AA4BA,WAKC"}

package/dist/field/lexical/plugins/MarkdownShortcut/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/lexical/plugins/MarkdownShortcut/index.tsx"],"names":[],"mappings":"AAMA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAI9B,eAAO,MAAM,sBAAsB,EAAE,KAAK,CAAC,EAI1C,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/lexical/plugins/MarkdownShortcut/index.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAI9B,eAAO,MAAM,sBAAsB,EAAE,KAAK,CAAC,EAI1C,CAAA"}

package/dist/field/lexical/plugins/MarkdownShortcut/index.js

@@ -1,11 +1,11 @@
 'use client';
-import lexicalMarkdownShortcutPluginImport from '@lexical/react/LexicalMarkdownShortcutPlugin.js';
-const { MarkdownShortcutPlugin: LexicalMarkdownShortcutPlugin } = lexicalMarkdownShortcutPluginImport;
+import { jsx as _jsx } from "react/jsx-runtime";
+import { MarkdownShortcutPlugin as LexicalMarkdownShortcutPlugin } from '@lexical/react/LexicalMarkdownShortcutPlugin.js';
 import * as React from 'react';
 import { useEditorConfigContext } from '../../config/client/EditorConfigProvider.js';
 export const MarkdownShortcutPlugin = ()=>{
     const { editorConfig } = useEditorConfigContext();
-    return /*#__PURE__*/ React.createElement(LexicalMarkdownShortcutPlugin, {
+    return /*#__PURE__*/ _jsx(LexicalMarkdownShortcutPlugin, {
         transformers: editorConfig.features.markdownTransformers
     });
 };

package/dist/field/lexical/plugins/MarkdownShortcut/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/field/lexical/plugins/MarkdownShortcut/index.tsx"],"sourcesContent":["'use client'\n\nimport lexicalMarkdownShortcutPluginImport from '@lexical/react/LexicalMarkdownShortcutPlugin.js'\nconst { MarkdownShortcutPlugin: LexicalMarkdownShortcutPlugin } =\n  lexicalMarkdownShortcutPluginImport\n\nimport * as React from 'react'\n\nimport { useEditorConfigContext } from '../../config/client/EditorConfigProvider.js'\n\nexport const MarkdownShortcutPlugin: React.FC = () => {\n  const { editorConfig } = useEditorConfigContext()\n\n  return <LexicalMarkdownShortcutPlugin transformers={editorConfig.features.markdownTransformers} />\n}\n"],"names":["lexicalMarkdownShortcutPluginImport","MarkdownShortcutPlugin","LexicalMarkdownShortcutPlugin","React","useEditorConfigContext","editorConfig","transformers","features","markdownTransformers"],"rangeMappings":";;;;;;;;;;","mappings":"AAAA;AAEA,OAAOA,yCAAyC,kDAAiD;AACjG,MAAM,EAAEC,wBAAwBC,6BAA6B,EAAE,GAC7DF;AAEF,YAAYG,WAAW,QAAO;AAE9B,SAASC,sBAAsB,QAAQ,8CAA6C;AAEpF,OAAO,MAAMH,yBAAmC;IAC9C,MAAM,EAAEI,YAAY,EAAE,GAAGD;IAEzB,qBAAO,oBAACF;QAA8BI,cAAcD,aAAaE,QAAQ,CAACC,oBAAoB;;AAChG,EAAC"}
+{"version":3,"sources":["../../../../../src/field/lexical/plugins/MarkdownShortcut/index.tsx"],"sourcesContent":["'use client'\n\nimport { MarkdownShortcutPlugin as LexicalMarkdownShortcutPlugin } from '@lexical/react/LexicalMarkdownShortcutPlugin.js'\nimport * as React from 'react'\n\nimport { useEditorConfigContext } from '../../config/client/EditorConfigProvider.js'\n\nexport const MarkdownShortcutPlugin: React.FC = () => {\n  const { editorConfig } = useEditorConfigContext()\n\n  return <LexicalMarkdownShortcutPlugin transformers={editorConfig.features.markdownTransformers} />\n}\n"],"names":["MarkdownShortcutPlugin","LexicalMarkdownShortcutPlugin","React","useEditorConfigContext","editorConfig","transformers","features","markdownTransformers"],"rangeMappings":";;;;;;;;;;","mappings":"AAAA;;AAEA,SAASA,0BAA0BC,6BAA6B,QAAQ,kDAAiD;AACzH,YAAYC,WAAW,QAAO;AAE9B,SAASC,sBAAsB,QAAQ,8CAA6C;AAEpF,OAAO,MAAMH,yBAAmC;IAC9C,MAAM,EAAEI,YAAY,EAAE,GAAGD;IAEzB,qBAAO,KAACF;QAA8BI,cAAcD,aAAaE,QAAQ,CAACC,oBAAoB;;AAChG,EAAC"}

package/dist/field/lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/LexicalMenu.d.ts

@@ -1,30 +1,30 @@
 import type { LexicalCommand, LexicalEditor, TextNode } from 'lexical';
-import type { MutableRefObject, ReactPortal } from 'react';
+import type { JSX, MutableRefObject, ReactPortal } from 'react';
 import type { MenuTextMatch } from '../useMenuTriggerMatch.js';
-import type { SlashMenuGroup, SlashMenuOption } from './types.js';
+import type { SlashMenuGroupInternal, SlashMenuItem, SlashMenuItemInternal } from './types.js';
 export type MenuResolution = {
     getRect: () => DOMRect;
     match?: MenuTextMatch;
 };
 export type MenuRenderFn = (anchorElementRef: MutableRefObject<HTMLElement | null>, itemProps: {
-    groupsWithOptions: Array<SlashMenuGroup>;
-    selectOptionAndCleanUp: (selectedOption: SlashMenuOption) => void;
-    selectedOptionKey: null | string;
-    setSelectedOptionKey: (optionKey: string) => void;
+    groups: Array<SlashMenuGroupInternal>;
+    selectItemAndCleanUp: (selectedItem: SlashMenuItem) => void;
+    selectedItemKey: null | string;
+    setSelectedItemKey: (itemKey: string) => void;
 }, matchingString: null | string) => JSX.Element | ReactPortal | null;
 export declare function getScrollParent(element: HTMLElement, includeHidden: boolean): HTMLBodyElement | HTMLElement;
 export declare function useDynamicPositioning(resolution: MenuResolution | null, targetElement: HTMLElement | null, onReposition: () => void, onVisibilityChange?: (isInView: boolean) => void): void;
 export declare const SCROLL_TYPEAHEAD_OPTION_INTO_VIEW_COMMAND: LexicalCommand<{
     index: number;
-    option: SlashMenuOption;
+    item: SlashMenuItemInternal;
 }>;
-export declare function LexicalMenu({ anchorElementRef, close, editor, groupsWithOptions, menuRenderFn, onSelectOption, resolution, shouldSplitNodeWithQuery, }: {
+export declare function LexicalMenu({ anchorElementRef, close, editor, groups, menuRenderFn, onSelectItem, resolution, shouldSplitNodeWithQuery, }: {
     anchorElementRef: MutableRefObject<HTMLElement>;
     close: () => void;
     editor: LexicalEditor;
-    groupsWithOptions: Array<SlashMenuGroup>;
+    groups: Array<SlashMenuGroupInternal>;
     menuRenderFn: MenuRenderFn;
-    onSelectOption: (option: SlashMenuOption, textNodeContainingQuery: TextNode | null, closeMenu: () => void, matchingString: string) => void;
+    onSelectItem: (item: SlashMenuItem, textNodeContainingQuery: TextNode | null, closeMenu: () => void, matchingString: string) => void;
     resolution: MenuResolution;
     shouldSplitNodeWithQuery?: boolean;
 }): JSX.Element | null;

package/dist/field/lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/LexicalMenu.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LexicalMenu.d.ts","sourceRoot":"","sources":["../../../../../../src/field/lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/LexicalMenu.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AACtE,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,OAAO,CAAA;AAuB1D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA;AAC9D,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAEjE,MAAM,MAAM,cAAc,GAAG;IAC3B,OAAO,EAAE,MAAM,OAAO,CAAA;IACtB,KAAK,CAAC,EAAE,aAAa,CAAA;CACtB,CAAA;AAID,MAAM,MAAM,YAAY,GAAG,CACzB,gBAAgB,EAAE,gBAAgB,CAAC,WAAW,GAAG,IAAI,CAAC,EACtD,SAAS,EAAE;IACT,iBAAiB,EAAE,KAAK,CAAC,cAAc,CAAC,CAAA;IACxC,sBAAsB,EAAE,CAAC,cAAc,EAAE,eAAe,KAAK,IAAI,CAAA;IACjE,iBAAiB,EAAE,IAAI,GAAG,MAAM,CAAA;IAChC,oBAAoB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAA;CAClD,EACD,cAAc,EAAE,IAAI,GAAG,MAAM,KAC1B,GAAG,CAAC,OAAO,GAAG,WAAW,GAAG,IAAI,CAAA;AA2ErC,wBAAgB,eAAe,CAC7B,OAAO,EAAE,WAAW,EACpB,aAAa,EAAE,OAAO,GACrB,eAAe,GAAG,WAAW,CAiB/B;AAYD,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,cAAc,GAAG,IAAI,EACjC,aAAa,EAAE,WAAW,GAAG,IAAI,EACjC,YAAY,EAAE,MAAM,IAAI,EACxB,kBAAkB,CAAC,EAAE,CAAC,QAAQ,EAAE,OAAO,KAAK,IAAI,QA2CjD;AAED,eAAO,MAAM,yCAAyC,EAAE,cAAc,CAAC;IACrE,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,eAAe,CAAA;CACxB,CAA8D,CAAA;AAE/D,wBAAgB,WAAW,CAAC,EAC1B,gBAAgB,EAChB,KAAK,EACL,MAAM,EAEN,iBAAiB,EACjB,YAAY,EACZ,cAAc,EACd,UAAU,EACV,wBAAgC,GACjC,EAAE;IACD,gBAAgB,EAAE,gBAAgB,CAAC,WAAW,CAAC,CAAA;IAC/C,KAAK,EAAE,MAAM,IAAI,CAAA;IACjB,MAAM,EAAE,aAAa,CAAA;IACrB,iBAAiB,EAAE,KAAK,CAAC,cAAc,CAAC,CAAA;IACxC,YAAY,EAAE,YAAY,CAAA;IAC1B,cAAc,EAAE,CACd,MAAM,EAAE,eAAe,EACvB,uBAAuB,EAAE,QAAQ,GAAG,IAAI,EACxC,SAAS,EAAE,MAAM,IAAI,EACrB,cAAc,EAAE,MAAM,KACnB,IAAI,CAAA;IACT,UAAU,EAAE,cAAc,CAAA;IAC1B,wBAAwB,CAAC,EAAE,OAAO,CAAA;CACnC,GAAG,GAAG,CAAC,OAAO,GAAG,IAAI,CAoOrB;AAED,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,WAAW,EACvB,UAAU,EAAE,cAAc,GAAG,IAAI,EACjC,aAAa,EAAE,CAAC,CAAC,EAAE,cAAc,GAAG,IAAI,KAAK,IAAI,EACjD,SAAS,CAAC,EAAE,MAAM,GACjB,gBAAgB,CAAC,WAAW,CAAC,CA6F/B"}
+{"version":3,"file":"LexicalMenu.d.ts","sourceRoot":"","sources":["../../../../../../src/field/lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/LexicalMenu.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AACtE,OAAO,KAAK,EAAE,GAAG,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,OAAO,CAAA;AAiB/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA;AAC9D,OAAO,KAAK,EAAE,sBAAsB,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAA;AAE9F,MAAM,MAAM,cAAc,GAAG;IAC3B,OAAO,EAAE,MAAM,OAAO,CAAA;IACtB,KAAK,CAAC,EAAE,aAAa,CAAA;CACtB,CAAA;AAID,MAAM,MAAM,YAAY,GAAG,CACzB,gBAAgB,EAAE,gBAAgB,CAAC,WAAW,GAAG,IAAI,CAAC,EACtD,SAAS,EAAE;IACT,MAAM,EAAE,KAAK,CAAC,sBAAsB,CAAC,CAAA;IACrC,oBAAoB,EAAE,CAAC,YAAY,EAAE,aAAa,KAAK,IAAI,CAAA;IAC3D,eAAe,EAAE,IAAI,GAAG,MAAM,CAAA;IAC9B,kBAAkB,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;CAC9C,EACD,cAAc,EAAE,IAAI,GAAG,MAAM,KAC1B,GAAG,CAAC,OAAO,GAAG,WAAW,GAAG,IAAI,CAAA;AA2ErC,wBAAgB,eAAe,CAC7B,OAAO,EAAE,WAAW,EACpB,aAAa,EAAE,OAAO,GACrB,eAAe,GAAG,WAAW,CAiB/B;AAYD,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,cAAc,GAAG,IAAI,EACjC,aAAa,EAAE,WAAW,GAAG,IAAI,EACjC,YAAY,EAAE,MAAM,IAAI,EACxB,kBAAkB,CAAC,EAAE,CAAC,QAAQ,EAAE,OAAO,KAAK,IAAI,QA2CjD;AAED,eAAO,MAAM,yCAAyC,EAAE,cAAc,CAAC;IACrE,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,qBAAqB,CAAA;CAC5B,CAA8D,CAAA;AAE/D,wBAAgB,WAAW,CAAC,EAC1B,gBAAgB,EAChB,KAAK,EACL,MAAM,EAEN,MAAM,EACN,YAAY,EACZ,YAAY,EACZ,UAAU,EACV,wBAAgC,GACjC,EAAE;IACD,gBAAgB,EAAE,gBAAgB,CAAC,WAAW,CAAC,CAAA;IAC/C,KAAK,EAAE,MAAM,IAAI,CAAA;IACjB,MAAM,EAAE,aAAa,CAAA;IACrB,MAAM,EAAE,KAAK,CAAC,sBAAsB,CAAC,CAAA;IACrC,YAAY,EAAE,YAAY,CAAA;IAC1B,YAAY,EAAE,CACZ,IAAI,EAAE,aAAa,EACnB,uBAAuB,EAAE,QAAQ,GAAG,IAAI,EACxC,SAAS,EAAE,MAAM,IAAI,EACrB,cAAc,EAAE,MAAM,KACnB,IAAI,CAAA;IACT,UAAU,EAAE,cAAc,CAAA;IAC1B,wBAAwB,CAAC,EAAE,OAAO,CAAA;CACnC,GAAG,GAAG,CAAC,OAAO,GAAG,IAAI,CAgNrB;AAED,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,WAAW,EACvB,UAAU,EAAE,cAAc,GAAG,IAAI,EACjC,aAAa,EAAE,CAAC,CAAC,EAAE,cAAc,GAAG,IAAI,KAAK,IAAI,EACjD,SAAS,CAAC,EAAE,MAAM,GACjB,gBAAgB,CAAC,WAAW,CAAC,CA6F/B"}

package/dist/field/lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/LexicalMenu.js

@@ -1,10 +1,7 @@
 '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, $isRangeSelection, COMMAND_PRIORITY_LOW, KEY_ARROW_DOWN_COMMAND, KEY_ARROW_UP_COMMAND, KEY_ENTER_COMMAND, KEY_ESCAPE_COMMAND, KEY_TAB_COMMAND, createCommand } = lexicalImport;
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js';
+import { mergeRegister } from '@lexical/utils';
+import { $getSelection, $isRangeSelection, COMMAND_PRIORITY_LOW, KEY_ARROW_DOWN_COMMAND, KEY_ARROW_UP_COMMAND, KEY_ENTER_COMMAND, KEY_ESCAPE_COMMAND, KEY_TAB_COMMAND, createCommand } from 'lexical';
 import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react';
 const baseClass = 'slash-menu-popup';
 const scrollIntoViewIfNeeded = (target)=>{
@@ -31,7 +28,7 @@ const scrollIntoViewIfNeeded = (target)=>{
  */ function getFullMatchOffset(documentText, entryText, offset) {
     let triggerOffset = offset;
     for(let i = triggerOffset; i <= entryText.length; i++){
-        if (documentText.substr(-i) === entryText.substr(0, i)) {
+        if (documentText.substring(documentText.length - i) === entryText.substring(0, i)) {
             triggerOffset = i;
         }
     }
@@ -142,50 +139,50 @@ export function useDynamicPositioning(resolution, targetElement, onReposition, o
     ]);
 }
 export const SCROLL_TYPEAHEAD_OPTION_INTO_VIEW_COMMAND = createCommand('SCROLL_TYPEAHEAD_OPTION_INTO_VIEW_COMMAND');
-export function LexicalMenu({ anchorElementRef, close, editor, // groupsWithOptions filtering is already handled in SlashMenu/index.tsx. Thus, groupsWithOptions always contains the matching options.
-groupsWithOptions, menuRenderFn, onSelectOption, resolution, shouldSplitNodeWithQuery = false }) {
-    const [selectedOptionKey, setSelectedOptionKey] = useState(null);
+export function LexicalMenu({ anchorElementRef, close, editor, // groups filtering is already handled in SlashMenu/index.tsx. Thus, groups always contains the matching items.
+groups, menuRenderFn, onSelectItem, resolution, shouldSplitNodeWithQuery = false }) {
+    const [selectedItemKey, setSelectedItemKey] = useState(null);
     const matchingString = resolution.match && resolution.match.matchingString || '';
-    const updateSelectedOption = useCallback((option)=>{
+    const updateSelectedItem = useCallback((item)=>{
         const rootElem = editor.getRootElement();
         if (rootElem !== null) {
-            rootElem.setAttribute('aria-activedescendant', `${baseClass}__item-${option.key}`);
-            setSelectedOptionKey(option.key);
+            rootElem.setAttribute('aria-activedescendant', `${baseClass}__item-${item.key}`);
+            setSelectedItemKey(item.key);
         }
     }, [
         editor
     ]);
-    const setSelectedOptionKeyToFirstMatchingOption = useCallback(()=>{
-        // set selected option to the first of the matching ones
-        if (groupsWithOptions !== null && matchingString != null) {
-            // groupsWithOptions filtering is already handled in SlashMenu/index.tsx. Thus, groupsWithOptions always contains the matching options.
-            const allOptions = groupsWithOptions.flatMap((group)=>group.options);
-            if (allOptions.length) {
-                const firstMatchingOption = allOptions[0];
-                updateSelectedOption(firstMatchingOption);
+    const setSelectedItemKeyToFirstMatchingItem = useCallback(()=>{
+        // set selected item to the first of the matching ones
+        if (groups !== null && matchingString != null) {
+            // groups filtering is already handled in SlashMenu/index.tsx. Thus, groups always contains the matching items.
+            const allItems = groups.flatMap((group)=>group.items);
+            if (allItems.length) {
+                const firstMatchingItem = allItems[0];
+                updateSelectedItem(firstMatchingItem);
             }
         }
     }, [
-        groupsWithOptions,
-        updateSelectedOption,
+        groups,
+        updateSelectedItem,
         matchingString
     ]);
     useEffect(()=>{
-        setSelectedOptionKeyToFirstMatchingOption();
+        setSelectedItemKeyToFirstMatchingItem();
     }, [
         matchingString,
-        setSelectedOptionKeyToFirstMatchingOption
+        setSelectedItemKeyToFirstMatchingItem
     ]);
-    const selectOptionAndCleanUp = useCallback((selectedOption)=>{
+    const selectItemAndCleanUp = useCallback((selectedItem)=>{
         editor.update(()=>{
             const textNodeContainingQuery = resolution.match != null && shouldSplitNodeWithQuery ? $splitNodeContainingQuery(resolution.match) : null;
-            onSelectOption(selectedOption, textNodeContainingQuery, close, resolution.match ? resolution.match.matchingString : '');
+            onSelectItem(selectedItem, textNodeContainingQuery, close, resolution.match ? resolution.match.matchingString : '');
         });
     }, [
         editor,
         shouldSplitNodeWithQuery,
         resolution.match,
-        onSelectOption,
+        onSelectItem,
         close
     ]);
     useEffect(()=>{
@@ -199,42 +196,42 @@ groupsWithOptions, menuRenderFn, onSelectOption, resolution, shouldSplitNodeWith
         editor
     ]);
     useLayoutEffect(()=>{
-        if (groupsWithOptions === null) {
-            setSelectedOptionKey(null);
-        } else if (selectedOptionKey === null) {
-            setSelectedOptionKeyToFirstMatchingOption();
+        if (groups === null) {
+            setSelectedItemKey(null);
+        } else if (selectedItemKey === null) {
+            setSelectedItemKeyToFirstMatchingItem();
         }
     }, [
-        groupsWithOptions,
-        selectedOptionKey,
-        updateSelectedOption,
-        setSelectedOptionKeyToFirstMatchingOption
+        groups,
+        selectedItemKey,
+        updateSelectedItem,
+        setSelectedItemKeyToFirstMatchingItem
     ]);
     useEffect(()=>{
-        return mergeRegister(editor.registerCommand(SCROLL_TYPEAHEAD_OPTION_INTO_VIEW_COMMAND, ({ option })=>{
-            if (option.ref && option.ref.current != null) {
-                scrollIntoViewIfNeeded(option.ref.current);
+        return mergeRegister(editor.registerCommand(SCROLL_TYPEAHEAD_OPTION_INTO_VIEW_COMMAND, ({ item })=>{
+            if (item.ref && item.ref.current != null) {
+                scrollIntoViewIfNeeded(item.ref.current);
                 return true;
             }
             return false;
         }, COMMAND_PRIORITY_LOW));
     }, [
         editor,
-        updateSelectedOption
+        updateSelectedItem
     ]);
     useEffect(()=>{
         return mergeRegister(editor.registerCommand(KEY_ARROW_DOWN_COMMAND, (payload)=>{
             const event = payload;
-            if (groupsWithOptions !== null && groupsWithOptions.length && selectedOptionKey !== null) {
-                const allOptions = groupsWithOptions.flatMap((group)=>group.options);
-                const selectedIndex = allOptions.findIndex((option)=>option.key === selectedOptionKey);
-                const newSelectedIndex = selectedIndex !== allOptions.length - 1 ? selectedIndex + 1 : 0;
-                const newSelectedOption = allOptions[newSelectedIndex];
-                updateSelectedOption(newSelectedOption);
-                if (newSelectedOption.ref != null && newSelectedOption.ref.current) {
+            if (groups !== null && groups.length && selectedItemKey !== null) {
+                const allItems = groups.flatMap((group)=>group.items);
+                const selectedIndex = allItems.findIndex((item)=>item.key === selectedItemKey);
+                const newSelectedIndex = selectedIndex !== allItems.length - 1 ? selectedIndex + 1 : 0;
+                const newSelectedItem = allItems[newSelectedIndex];
+                updateSelectedItem(newSelectedItem);
+                if (newSelectedItem.ref != null && newSelectedItem.ref.current) {
                     editor.dispatchCommand(SCROLL_TYPEAHEAD_OPTION_INTO_VIEW_COMMAND, {
                         index: newSelectedIndex,
-                        option: newSelectedOption
+                        item: newSelectedItem
                     });
                 }
                 event.preventDefault();
@@ -243,14 +240,14 @@ groupsWithOptions, menuRenderFn, onSelectOption, resolution, shouldSplitNodeWith
             return true;
         }, COMMAND_PRIORITY_LOW), editor.registerCommand(KEY_ARROW_UP_COMMAND, (payload)=>{
             const event = payload;
-            if (groupsWithOptions !== null && groupsWithOptions.length && selectedOptionKey !== null) {
-                const allOptions = groupsWithOptions.flatMap((group)=>group.options);
-                const selectedIndex = allOptions.findIndex((option)=>option.key === selectedOptionKey);
-                const newSelectedIndex = selectedIndex !== 0 ? selectedIndex - 1 : allOptions.length - 1;
-                const newSelectedOption = allOptions[newSelectedIndex];
-                updateSelectedOption(newSelectedOption);
-                if (newSelectedOption.ref != null && newSelectedOption.ref.current) {
-                    scrollIntoViewIfNeeded(newSelectedOption.ref.current);
+            if (groups !== null && groups.length && selectedItemKey !== null) {
+                const allItems = groups.flatMap((group)=>group.items);
+                const selectedIndex = allItems.findIndex((item)=>item.key === selectedItemKey);
+                const newSelectedIndex = selectedIndex !== 0 ? selectedIndex - 1 : allItems.length - 1;
+                const newSelectedItem = allItems[newSelectedIndex];
+                updateSelectedItem(newSelectedItem);
+                if (newSelectedItem.ref != null && newSelectedItem.ref.current) {
+                    scrollIntoViewIfNeeded(newSelectedItem.ref.current);
                 }
                 event.preventDefault();
                 event.stopImmediatePropagation();
@@ -264,51 +261,51 @@ groupsWithOptions, menuRenderFn, onSelectOption, resolution, shouldSplitNodeWith
             return true;
         }, COMMAND_PRIORITY_LOW), editor.registerCommand(KEY_TAB_COMMAND, (payload)=>{
             const event = payload;
-            if (groupsWithOptions === null || selectedOptionKey === null) {
+            if (groups === null || selectedItemKey === null) {
                 return false;
             }
-            const allOptions = groupsWithOptions.flatMap((group)=>group.options);
-            const selectedOption = allOptions.find((option)=>option.key === selectedOptionKey);
-            if (!selectedOption) {
+            const allItems = groups.flatMap((group)=>group.items);
+            const selectedItem = allItems.find((item)=>item.key === selectedItemKey);
+            if (!selectedItem) {
                 return false;
             }
             event.preventDefault();
             event.stopImmediatePropagation();
-            selectOptionAndCleanUp(selectedOption);
+            selectItemAndCleanUp(selectedItem);
             return true;
         }, COMMAND_PRIORITY_LOW), editor.registerCommand(KEY_ENTER_COMMAND, (event)=>{
-            if (groupsWithOptions === null || selectedOptionKey === null) {
+            if (groups === null || selectedItemKey === null) {
                 return false;
             }
-            const allOptions = groupsWithOptions.flatMap((group)=>group.options);
-            const selectedOption = allOptions.find((option)=>option.key === selectedOptionKey);
-            if (!selectedOption) {
+            const allItems = groups.flatMap((group)=>group.items);
+            const selectedItem = allItems.find((item)=>item.key === selectedItemKey);
+            if (!selectedItem) {
                 return false;
             }
             if (event !== null) {
                 event.preventDefault();
                 event.stopImmediatePropagation();
             }
-            selectOptionAndCleanUp(selectedOption);
+            selectItemAndCleanUp(selectedItem);
             return true;
         }, COMMAND_PRIORITY_LOW));
     }, [
-        selectOptionAndCleanUp,
+        selectItemAndCleanUp,
         close,
         editor,
-        groupsWithOptions,
-        selectedOptionKey,
-        updateSelectedOption
+        groups,
+        selectedItemKey,
+        updateSelectedItem
     ]);
     const listItemProps = useMemo(()=>({
-            groupsWithOptions,
-            selectOptionAndCleanUp,
-            selectedOptionKey,
-            setSelectedOptionKey
+            groups,
+            selectItemAndCleanUp,
+            selectedItemKey,
+            setSelectedItemKey
         }), [
-        selectOptionAndCleanUp,
-        selectedOptionKey,
-        groupsWithOptions
+        selectItemAndCleanUp,
+        selectedItemKey,
+        groups
     ]);
     return menuRenderFn(anchorElementRef, listItemProps, resolution.match ? resolution.match.matchingString : '');
 }