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

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/field/lexical/config/client/sanitize.ts"],"sourcesContent":["'use client'\n\nimport type { EditorConfig as LexicalEditorConfig } from 'lexical/LexicalEditor.js'\n\nimport type { ResolvedClientFeatureMap, SanitizedClientFeatures } from '../../../features/types.js'\nimport type { SanitizedClientEditorConfig } from '../types.js'\n\nexport const sanitizeClientFeatures = (\n  features: ResolvedClientFeatureMap,\n): SanitizedClientFeatures => {\n  const sanitized: SanitizedClientFeatures = {\n    enabledFeatures: [],\n    floatingSelectToolbar: {\n      sections: [],\n    },\n    hooks: {\n      load: [],\n      save: [],\n    },\n    markdownTransformers: [],\n    nodes: [],\n    plugins: [],\n    slashMenu: {\n      dynamicOptions: [],\n      groupsWithOptions: [],\n    },\n  }\n\n  if (!features?.size) {\n    return sanitized\n  }\n\n  features.forEach((feature) => {\n    if (feature.hooks) {\n      if (feature.hooks?.load?.length) {\n        sanitized.hooks.load = sanitized.hooks.load.concat(feature.hooks.load)\n      }\n      if (feature.hooks?.save?.length) {\n        sanitized.hooks.save = sanitized.hooks.save.concat(feature.hooks.save)\n      }\n    }\n\n    if (feature.nodes?.length) {\n      sanitized.nodes = sanitized.nodes.concat(feature.nodes)\n    }\n    if (feature.plugins?.length) {\n      feature.plugins.forEach((plugin, i) => {\n        sanitized.plugins.push({\n          Component: plugin.Component,\n          key: feature.key + i,\n          position: plugin.position,\n        })\n      })\n    }\n\n    if (feature.floatingSelectToolbar?.sections?.length) {\n      for (const section of feature.floatingSelectToolbar.sections) {\n        // 1. find the section with the same key or create new one\n        let foundSection = sanitized.floatingSelectToolbar.sections.find(\n          (sanitizedSection) => sanitizedSection.key === section.key,\n        )\n        if (!foundSection) {\n          foundSection = {\n            ...section,\n            entries: [],\n          }\n        } else {\n          sanitized.floatingSelectToolbar.sections =\n            sanitized.floatingSelectToolbar.sections.filter(\n              (sanitizedSection) => sanitizedSection.key !== section.key,\n            )\n        }\n\n        // 2. Add options to group options array and add to sanitized.slashMenu.groupsWithOptions\n        if (section?.entries?.length) {\n          foundSection.entries = foundSection.entries.concat(section.entries)\n        }\n        sanitized.floatingSelectToolbar?.sections.push(foundSection)\n      }\n    }\n\n    if (feature.slashMenu?.options) {\n      if (feature.slashMenu.dynamicOptions?.length) {\n        sanitized.slashMenu.dynamicOptions = sanitized.slashMenu.dynamicOptions.concat(\n          feature.slashMenu.dynamicOptions,\n        )\n      }\n\n      for (const optionGroup of feature.slashMenu.options) {\n        // 1. find the group with the same name or create new one\n        let group = sanitized.slashMenu.groupsWithOptions.find(\n          (group) => group.key === optionGroup.key,\n        )\n        if (!group) {\n          group = {\n            ...optionGroup,\n            options: [],\n          }\n        } else {\n          sanitized.slashMenu.groupsWithOptions = sanitized.slashMenu.groupsWithOptions.filter(\n            (group) => group.key !== optionGroup.key,\n          )\n        }\n\n        // 2. Add options to group options array and add to sanitized.slashMenu.groupsWithOptions\n        if (optionGroup?.options?.length) {\n          group.options = group.options.concat(optionGroup.options)\n        }\n        sanitized.slashMenu.groupsWithOptions.push(group)\n      }\n    }\n\n    if (feature.markdownTransformers?.length) {\n      sanitized.markdownTransformers = sanitized.markdownTransformers.concat(\n        feature.markdownTransformers,\n      )\n    }\n    sanitized.enabledFeatures.push(feature.key)\n  })\n\n  // Sort sanitized.floatingSelectToolbar.sections by order property\n  sanitized.floatingSelectToolbar.sections.sort((a, b) => {\n    if (a.order && b.order) {\n      return a.order - b.order\n    } else if (a.order) {\n      return -1\n    } else if (b.order) {\n      return 1\n    } else {\n      return 0\n    }\n  })\n\n  // Sort sanitized.floatingSelectToolbar.sections.[section].entries by order property\n  for (const section of sanitized.floatingSelectToolbar.sections) {\n    section.entries.sort((a, b) => {\n      if (a.order && b.order) {\n        return a.order - b.order\n      } else if (a.order) {\n        return -1\n      } else if (b.order) {\n        return 1\n      } else {\n        return 0\n      }\n    })\n  }\n\n  return sanitized\n}\n\nexport function sanitizeClientEditorConfig(\n  lexical: LexicalEditorConfig,\n  resolvedClientFeatureMap: ResolvedClientFeatureMap,\n): SanitizedClientEditorConfig {\n  return {\n    features: sanitizeClientFeatures(resolvedClientFeatureMap),\n    lexical,\n    resolvedFeatureMap: resolvedClientFeatureMap,\n  }\n}\n"],"names":["sanitizeClientFeatures","features","sanitized","enabledFeatures","floatingSelectToolbar","sections","hooks","load","save","markdownTransformers","nodes","plugins","slashMenu","dynamicOptions","groupsWithOptions","size","forEach","feature","length","concat","plugin","i","push","Component","key","position","section","foundSection","find","sanitizedSection","entries","filter","options","optionGroup","group","sort","a","b","order","sanitizeClientEditorConfig","lexical","resolvedClientFeatureMap","resolvedFeatureMap"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}
+{"version":3,"sources":["../../../../../src/field/lexical/config/client/sanitize.ts"],"sourcesContent":["'use client'\n\nimport type { EditorConfig as LexicalEditorConfig } from 'lexical'\n\nimport type { ResolvedClientFeatureMap, SanitizedClientFeatures } from '../../../features/types.js'\nimport type { SanitizedClientEditorConfig } from '../types.js'\n\nexport const sanitizeClientFeatures = (\n  features: ResolvedClientFeatureMap,\n): SanitizedClientFeatures => {\n  const sanitized: SanitizedClientFeatures = {\n    enabledFeatures: [],\n    hooks: {\n      load: [],\n      save: [],\n    },\n    markdownTransformers: [],\n    nodes: [],\n    plugins: [],\n    slashMenu: {\n      dynamicGroups: [],\n      groups: [],\n    },\n    toolbarFixed: {\n      groups: [],\n    },\n    toolbarInline: {\n      groups: [],\n    },\n  }\n\n  if (!features?.size) {\n    return sanitized\n  }\n\n  features.forEach((feature) => {\n    if (feature.hooks) {\n      if (feature.hooks?.load?.length) {\n        sanitized.hooks.load = sanitized.hooks.load.concat(feature.hooks.load)\n      }\n      if (feature.hooks?.save?.length) {\n        sanitized.hooks.save = sanitized.hooks.save.concat(feature.hooks.save)\n      }\n    }\n\n    if (feature.nodes?.length) {\n      sanitized.nodes = sanitized.nodes.concat(feature.nodes)\n    }\n    if (feature.plugins?.length) {\n      feature.plugins.forEach((plugin, i) => {\n        sanitized.plugins.push({\n          Component: plugin.Component,\n          clientProps: feature.clientFeatureProps,\n          key: feature.key + i,\n          position: plugin.position,\n        })\n      })\n    }\n\n    if (feature.toolbarInline?.groups?.length) {\n      for (const group of feature.toolbarInline.groups) {\n        // 1. find the group with the same key or create new one\n        let foundGroup = sanitized.toolbarInline.groups.find(\n          (sanitizedGroup) => sanitizedGroup.key === group.key,\n        )\n        if (!foundGroup) {\n          foundGroup = {\n            ...group,\n            items: [],\n          }\n        } else {\n          sanitized.toolbarInline.groups = sanitized.toolbarInline.groups.filter(\n            (sanitizedGroup) => sanitizedGroup.key !== group.key,\n          )\n        }\n\n        // 2. Add options to group options array and add to sanitized.slashMenu.groupsWithOptions\n        if (group?.items?.length) {\n          foundGroup.items = foundGroup.items.concat(group.items)\n        }\n        sanitized.toolbarInline?.groups.push(foundGroup)\n      }\n    }\n\n    if (feature.toolbarFixed?.groups?.length) {\n      for (const group of feature.toolbarFixed.groups) {\n        // 1. find the group with the same key or create new one\n        let foundGroup = sanitized.toolbarFixed.groups.find(\n          (sanitizedGroup) => sanitizedGroup.key === group.key,\n        )\n        if (!foundGroup) {\n          foundGroup = {\n            ...group,\n            items: [],\n          }\n        } else {\n          sanitized.toolbarFixed.groups = sanitized.toolbarFixed.groups.filter(\n            (sanitizedGroup) => sanitizedGroup.key !== group.key,\n          )\n        }\n\n        // 2. Add options to group options array and add to sanitized.slashMenu.groupsWithOptions\n        if (group?.items?.length) {\n          foundGroup.items = foundGroup.items.concat(group.items)\n        }\n        sanitized.toolbarFixed?.groups.push(foundGroup)\n      }\n    }\n\n    if (feature.slashMenu?.groups) {\n      if (feature.slashMenu.dynamicGroups?.length) {\n        sanitized.slashMenu.dynamicGroups = sanitized.slashMenu.dynamicGroups.concat(\n          feature.slashMenu.dynamicGroups,\n        )\n      }\n\n      for (const optionGroup of feature.slashMenu.groups) {\n        // 1. find the group with the same name or create new one\n        let group = sanitized.slashMenu.groups.find((group) => group.key === optionGroup.key)\n        if (!group) {\n          group = {\n            ...optionGroup,\n            items: [],\n          }\n        } else {\n          sanitized.slashMenu.groups = sanitized.slashMenu.groups.filter(\n            (group) => group.key !== optionGroup.key,\n          )\n        }\n\n        // 2. Add options to group options array and add to sanitized.slashMenu.groupsWithOptions\n        if (optionGroup?.items?.length) {\n          group.items = group.items.concat(optionGroup.items)\n        }\n        sanitized.slashMenu.groups.push(group)\n      }\n    }\n\n    if (feature.markdownTransformers?.length) {\n      sanitized.markdownTransformers = sanitized.markdownTransformers.concat(\n        feature.markdownTransformers,\n      )\n    }\n    sanitized.enabledFeatures.push(feature.key)\n  })\n\n  // Sort sanitized.toolbarInline.groups by order property\n  sanitized.toolbarInline.groups.sort((a, b) => {\n    if (a.order && b.order) {\n      return a.order - b.order\n    } else if (a.order) {\n      return -1\n    } else if (b.order) {\n      return 1\n    } else {\n      return 0\n    }\n  })\n  // Sort sanitized.toolbarFixed.groups by order property\n  sanitized.toolbarFixed.groups.sort((a, b) => {\n    if (a.order && b.order) {\n      return a.order - b.order\n    } else if (a.order) {\n      return -1\n    } else if (b.order) {\n      return 1\n    } else {\n      return 0\n    }\n  })\n\n  // Sort sanitized.toolbarInline.groups.[group].entries by order property\n  for (const group of sanitized.toolbarInline.groups) {\n    group.items.sort((a, b) => {\n      if (a.order && b.order) {\n        return a.order - b.order\n      } else if (a.order) {\n        return -1\n      } else if (b.order) {\n        return 1\n      } else {\n        return 0\n      }\n    })\n  }\n\n  // Sort sanitized.toolbarFixed.groups.[group].entries by order property\n  for (const group of sanitized.toolbarFixed.groups) {\n    group.items.sort((a, b) => {\n      if (a.order && b.order) {\n        return a.order - b.order\n      } else if (a.order) {\n        return -1\n      } else if (b.order) {\n        return 1\n      } else {\n        return 0\n      }\n    })\n  }\n\n  return sanitized\n}\n\nexport function sanitizeClientEditorConfig(\n  lexical: LexicalEditorConfig,\n  resolvedClientFeatureMap: ResolvedClientFeatureMap,\n): SanitizedClientEditorConfig {\n  return {\n    features: sanitizeClientFeatures(resolvedClientFeatureMap),\n    lexical,\n    resolvedFeatureMap: resolvedClientFeatureMap,\n  }\n}\n"],"names":["sanitizeClientFeatures","features","sanitized","enabledFeatures","hooks","load","save","markdownTransformers","nodes","plugins","slashMenu","dynamicGroups","groups","toolbarFixed","toolbarInline","size","forEach","feature","length","concat","plugin","i","push","Component","clientProps","clientFeatureProps","key","position","group","foundGroup","find","sanitizedGroup","items","filter","optionGroup","sort","a","b","order","sanitizeClientEditorConfig","lexical","resolvedClientFeatureMap","resolvedFeatureMap"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/dist/field/lexical/config/server/default.d.ts

@@ -1,8 +1,7 @@
-import type { EditorConfig as LexicalEditorConfig } from 'lexical/LexicalEditor.js';
+import type { EditorConfig as LexicalEditorConfig } from 'lexical';
 import type { FeatureProviderServer } from '../../../features/types.js';
-import type { SanitizedServerEditorConfig, ServerEditorConfig } from '../types.js';
+import type { ServerEditorConfig } from '../types.js';
 export declare const defaultEditorLexicalConfig: LexicalEditorConfig;
 export declare const defaultEditorFeatures: FeatureProviderServer<unknown, unknown>[];
 export declare const defaultEditorConfig: ServerEditorConfig;
-export declare const defaultSanitizedServerEditorConfig: SanitizedServerEditorConfig;
 //# sourceMappingURL=default.d.ts.map

package/dist/field/lexical/config/server/default.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"default.d.ts","sourceRoot":"","sources":["../../../../../src/field/lexical/config/server/default.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,IAAI,mBAAmB,EAAE,MAAM,0BAA0B,CAAA;AAEnF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAA;AACvE,OAAO,KAAK,EAAE,2BAA2B,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAuBlF,eAAO,MAAM,0BAA0B,EAAE,mBAGxC,CAAA;AAED,eAAO,MAAM,qBAAqB,EAAE,qBAAqB,CAAC,OAAO,EAAE,OAAO,CAAC,EAmB1E,CAAA;AAED,eAAO,MAAM,mBAAmB,EAAE,kBAGjC,CAAA;AAED,eAAO,MAAM,kCAAkC,EAAE,2BACA,CAAA"}
+{"version":3,"file":"default.d.ts","sourceRoot":"","sources":["../../../../../src/field/lexical/config/server/default.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,IAAI,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAElE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAA;AACvE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAyBrD,eAAO,MAAM,0BAA0B,EAAE,mBAGxC,CAAA;AAED,eAAO,MAAM,qBAAqB,EAAE,qBAAqB,CAAC,OAAO,EAAE,OAAO,CAAC,EAqB1E,CAAA;AAED,eAAO,MAAM,mBAAmB,EAAE,kBAGjC,CAAA"}

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

@@ -1,23 +1,24 @@
 import { AlignFeature } from '../../../features/align/feature.server.js';
-import { BlockQuoteFeature } from '../../../features/blockquote/feature.server.js';
+import { BlockquoteFeature } from '../../../features/blockquote/feature.server.js';
 import { BoldFeature } from '../../../features/format/bold/feature.server.js';
-import { InlineCodeFeature } from '../../../features/format/inlinecode/feature.server.js';
+import { InlineCodeFeature } from '../../../features/format/inlineCode/feature.server.js';
 import { ItalicFeature } from '../../../features/format/italic/feature.server.js';
 import { StrikethroughFeature } from '../../../features/format/strikethrough/feature.server.js';
 import { SubscriptFeature } from '../../../features/format/subscript/feature.server.js';
 import { SuperscriptFeature } from '../../../features/format/superscript/feature.server.js';
 import { UnderlineFeature } from '../../../features/format/underline/feature.server.js';
 import { HeadingFeature } from '../../../features/heading/feature.server.js';
+import { HorizontalRuleFeature } from '../../../features/horizontalRule/feature.server.js';
 import { IndentFeature } from '../../../features/indent/feature.server.js';
 import { LinkFeature } from '../../../features/link/feature.server.js';
-import { CheckListFeature } from '../../../features/lists/checklist/feature.server.js';
-import { OrderedListFeature } from '../../../features/lists/orderedlist/feature.server.js';
-import { UnorderedListFeature } from '../../../features/lists/unorderedlist/feature.server.js';
+import { ChecklistFeature } from '../../../features/lists/checklist/feature.server.js';
+import { OrderedListFeature } from '../../../features/lists/orderedList/feature.server.js';
+import { UnorderedListFeature } from '../../../features/lists/unorderedList/feature.server.js';
 import { ParagraphFeature } from '../../../features/paragraph/feature.server.js';
 import { RelationshipFeature } from '../../../features/relationship/feature.server.js';
+import { InlineToolbarFeature } from '../../../features/toolbars/inline/feature.server.js';
 import { UploadFeature } from '../../../features/upload/feature.server.js';
 import { LexicalEditorTheme } from '../../theme/EditorTheme.js';
-import { sanitizeServerEditorConfig } from './sanitize.js';
 export const defaultEditorLexicalConfig = {
     namespace: 'lexical',
     theme: LexicalEditorTheme
@@ -36,16 +37,17 @@ export const defaultEditorFeatures = [
     IndentFeature(),
     UnorderedListFeature(),
     OrderedListFeature(),
-    CheckListFeature(),
+    ChecklistFeature(),
     LinkFeature(),
     RelationshipFeature(),
-    BlockQuoteFeature(),
-    UploadFeature()
+    BlockquoteFeature(),
+    UploadFeature(),
+    HorizontalRuleFeature(),
+    InlineToolbarFeature()
 ];
 export const defaultEditorConfig = {
     features: defaultEditorFeatures,
     lexical: defaultEditorLexicalConfig
 };
-export const defaultSanitizedServerEditorConfig = sanitizeServerEditorConfig(defaultEditorConfig);
 
 //# sourceMappingURL=default.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/field/lexical/config/server/default.ts"],"sourcesContent":["import type { EditorConfig as LexicalEditorConfig } from 'lexical/LexicalEditor.js'\n\nimport type { FeatureProviderServer } from '../../../features/types.js'\nimport type { SanitizedServerEditorConfig, ServerEditorConfig } from '../types.js'\n\nimport { AlignFeature } from '../../../features/align/feature.server.js'\nimport { BlockQuoteFeature } from '../../../features/blockquote/feature.server.js'\nimport { BoldFeature } from '../../../features/format/bold/feature.server.js'\nimport { InlineCodeFeature } from '../../../features/format/inlinecode/feature.server.js'\nimport { ItalicFeature } from '../../../features/format/italic/feature.server.js'\nimport { StrikethroughFeature } from '../../../features/format/strikethrough/feature.server.js'\nimport { SubscriptFeature } from '../../../features/format/subscript/feature.server.js'\nimport { SuperscriptFeature } from '../../../features/format/superscript/feature.server.js'\nimport { UnderlineFeature } from '../../../features/format/underline/feature.server.js'\nimport { HeadingFeature } from '../../../features/heading/feature.server.js'\nimport { IndentFeature } from '../../../features/indent/feature.server.js'\nimport { LinkFeature } from '../../../features/link/feature.server.js'\nimport { CheckListFeature } from '../../../features/lists/checklist/feature.server.js'\nimport { OrderedListFeature } from '../../../features/lists/orderedlist/feature.server.js'\nimport { UnorderedListFeature } from '../../../features/lists/unorderedlist/feature.server.js'\nimport { ParagraphFeature } from '../../../features/paragraph/feature.server.js'\nimport { RelationshipFeature } from '../../../features/relationship/feature.server.js'\nimport { UploadFeature } from '../../../features/upload/feature.server.js'\nimport { LexicalEditorTheme } from '../../theme/EditorTheme.js'\nimport { sanitizeServerEditorConfig } from './sanitize.js'\n\nexport const defaultEditorLexicalConfig: LexicalEditorConfig = {\n  namespace: 'lexical',\n  theme: LexicalEditorTheme,\n}\n\nexport const defaultEditorFeatures: FeatureProviderServer<unknown, unknown>[] = [\n  BoldFeature(),\n  ItalicFeature(),\n  UnderlineFeature(),\n  StrikethroughFeature(),\n  SubscriptFeature(),\n  SuperscriptFeature(),\n  InlineCodeFeature(),\n  ParagraphFeature(),\n  HeadingFeature(),\n  AlignFeature(),\n  IndentFeature(),\n  UnorderedListFeature(),\n  OrderedListFeature(),\n  CheckListFeature(),\n  LinkFeature(),\n  RelationshipFeature(),\n  BlockQuoteFeature(),\n  UploadFeature(),\n]\n\nexport const defaultEditorConfig: ServerEditorConfig = {\n  features: defaultEditorFeatures,\n  lexical: defaultEditorLexicalConfig,\n}\n\nexport const defaultSanitizedServerEditorConfig: SanitizedServerEditorConfig =\n  sanitizeServerEditorConfig(defaultEditorConfig)\n"],"names":["AlignFeature","BlockQuoteFeature","BoldFeature","InlineCodeFeature","ItalicFeature","StrikethroughFeature","SubscriptFeature","SuperscriptFeature","UnderlineFeature","HeadingFeature","IndentFeature","LinkFeature","CheckListFeature","OrderedListFeature","UnorderedListFeature","ParagraphFeature","RelationshipFeature","UploadFeature","LexicalEditorTheme","sanitizeServerEditorConfig","defaultEditorLexicalConfig","namespace","theme","defaultEditorFeatures","defaultEditorConfig","features","lexical","defaultSanitizedServerEditorConfig"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAKA,SAASA,YAAY,QAAQ,4CAA2C;AACxE,SAASC,iBAAiB,QAAQ,iDAAgD;AAClF,SAASC,WAAW,QAAQ,kDAAiD;AAC7E,SAASC,iBAAiB,QAAQ,wDAAuD;AACzF,SAASC,aAAa,QAAQ,oDAAmD;AACjF,SAASC,oBAAoB,QAAQ,2DAA0D;AAC/F,SAASC,gBAAgB,QAAQ,uDAAsD;AACvF,SAASC,kBAAkB,QAAQ,yDAAwD;AAC3F,SAASC,gBAAgB,QAAQ,uDAAsD;AACvF,SAASC,cAAc,QAAQ,8CAA6C;AAC5E,SAASC,aAAa,QAAQ,6CAA4C;AAC1E,SAASC,WAAW,QAAQ,2CAA0C;AACtE,SAASC,gBAAgB,QAAQ,sDAAqD;AACtF,SAASC,kBAAkB,QAAQ,wDAAuD;AAC1F,SAASC,oBAAoB,QAAQ,0DAAyD;AAC9F,SAASC,gBAAgB,QAAQ,gDAA+C;AAChF,SAASC,mBAAmB,QAAQ,mDAAkD;AACtF,SAASC,aAAa,QAAQ,6CAA4C;AAC1E,SAASC,kBAAkB,QAAQ,6BAA4B;AAC/D,SAASC,0BAA0B,QAAQ,gBAAe;AAE1D,OAAO,MAAMC,6BAAkD;IAC7DC,WAAW;IACXC,OAAOJ;AACT,EAAC;AAED,OAAO,MAAMK,wBAAmE;IAC9ErB;IACAE;IACAI;IACAH;IACAC;IACAC;IACAJ;IACAY;IACAN;IACAT;IACAU;IACAI;IACAD;IACAD;IACAD;IACAK;IACAf;IACAgB;CACD,CAAA;AAED,OAAO,MAAMO,sBAA0C;IACrDC,UAAUF;IACVG,SAASN;AACX,EAAC;AAED,OAAO,MAAMO,qCACXR,2BAA2BK,qBAAoB"}
+{"version":3,"sources":["../../../../../src/field/lexical/config/server/default.ts"],"sourcesContent":["import type { EditorConfig as LexicalEditorConfig } from 'lexical'\n\nimport type { FeatureProviderServer } from '../../../features/types.js'\nimport type { ServerEditorConfig } from '../types.js'\n\nimport { AlignFeature } from '../../../features/align/feature.server.js'\nimport { BlockquoteFeature } from '../../../features/blockquote/feature.server.js'\nimport { BoldFeature } from '../../../features/format/bold/feature.server.js'\nimport { InlineCodeFeature } from '../../../features/format/inlineCode/feature.server.js'\nimport { ItalicFeature } from '../../../features/format/italic/feature.server.js'\nimport { StrikethroughFeature } from '../../../features/format/strikethrough/feature.server.js'\nimport { SubscriptFeature } from '../../../features/format/subscript/feature.server.js'\nimport { SuperscriptFeature } from '../../../features/format/superscript/feature.server.js'\nimport { UnderlineFeature } from '../../../features/format/underline/feature.server.js'\nimport { HeadingFeature } from '../../../features/heading/feature.server.js'\nimport { HorizontalRuleFeature } from '../../../features/horizontalRule/feature.server.js'\nimport { IndentFeature } from '../../../features/indent/feature.server.js'\nimport { LinkFeature } from '../../../features/link/feature.server.js'\nimport { ChecklistFeature } from '../../../features/lists/checklist/feature.server.js'\nimport { OrderedListFeature } from '../../../features/lists/orderedList/feature.server.js'\nimport { UnorderedListFeature } from '../../../features/lists/unorderedList/feature.server.js'\nimport { ParagraphFeature } from '../../../features/paragraph/feature.server.js'\nimport { RelationshipFeature } from '../../../features/relationship/feature.server.js'\nimport { FixedToolbarFeature } from '../../../features/toolbars/fixed/feature.server.js'\nimport { InlineToolbarFeature } from '../../../features/toolbars/inline/feature.server.js'\nimport { UploadFeature } from '../../../features/upload/feature.server.js'\nimport { LexicalEditorTheme } from '../../theme/EditorTheme.js'\n\nexport const defaultEditorLexicalConfig: LexicalEditorConfig = {\n  namespace: 'lexical',\n  theme: LexicalEditorTheme,\n}\n\nexport const defaultEditorFeatures: FeatureProviderServer<unknown, unknown>[] = [\n  BoldFeature(),\n  ItalicFeature(),\n  UnderlineFeature(),\n  StrikethroughFeature(),\n  SubscriptFeature(),\n  SuperscriptFeature(),\n  InlineCodeFeature(),\n  ParagraphFeature(),\n  HeadingFeature(),\n  AlignFeature(),\n  IndentFeature(),\n  UnorderedListFeature(),\n  OrderedListFeature(),\n  ChecklistFeature(),\n  LinkFeature(),\n  RelationshipFeature(),\n  BlockquoteFeature(),\n  UploadFeature(),\n  HorizontalRuleFeature(),\n  InlineToolbarFeature(),\n]\n\nexport const defaultEditorConfig: ServerEditorConfig = {\n  features: defaultEditorFeatures,\n  lexical: defaultEditorLexicalConfig,\n}\n"],"names":["AlignFeature","BlockquoteFeature","BoldFeature","InlineCodeFeature","ItalicFeature","StrikethroughFeature","SubscriptFeature","SuperscriptFeature","UnderlineFeature","HeadingFeature","HorizontalRuleFeature","IndentFeature","LinkFeature","ChecklistFeature","OrderedListFeature","UnorderedListFeature","ParagraphFeature","RelationshipFeature","InlineToolbarFeature","UploadFeature","LexicalEditorTheme","defaultEditorLexicalConfig","namespace","theme","defaultEditorFeatures","defaultEditorConfig","features","lexical"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAKA,SAASA,YAAY,QAAQ,4CAA2C;AACxE,SAASC,iBAAiB,QAAQ,iDAAgD;AAClF,SAASC,WAAW,QAAQ,kDAAiD;AAC7E,SAASC,iBAAiB,QAAQ,wDAAuD;AACzF,SAASC,aAAa,QAAQ,oDAAmD;AACjF,SAASC,oBAAoB,QAAQ,2DAA0D;AAC/F,SAASC,gBAAgB,QAAQ,uDAAsD;AACvF,SAASC,kBAAkB,QAAQ,yDAAwD;AAC3F,SAASC,gBAAgB,QAAQ,uDAAsD;AACvF,SAASC,cAAc,QAAQ,8CAA6C;AAC5E,SAASC,qBAAqB,QAAQ,qDAAoD;AAC1F,SAASC,aAAa,QAAQ,6CAA4C;AAC1E,SAASC,WAAW,QAAQ,2CAA0C;AACtE,SAASC,gBAAgB,QAAQ,sDAAqD;AACtF,SAASC,kBAAkB,QAAQ,wDAAuD;AAC1F,SAASC,oBAAoB,QAAQ,0DAAyD;AAC9F,SAASC,gBAAgB,QAAQ,gDAA+C;AAChF,SAASC,mBAAmB,QAAQ,mDAAkD;AAEtF,SAASC,oBAAoB,QAAQ,sDAAqD;AAC1F,SAASC,aAAa,QAAQ,6CAA4C;AAC1E,SAASC,kBAAkB,QAAQ,6BAA4B;AAE/D,OAAO,MAAMC,6BAAkD;IAC7DC,WAAW;IACXC,OAAOH;AACT,EAAC;AAED,OAAO,MAAMI,wBAAmE;IAC9EtB;IACAE;IACAI;IACAH;IACAC;IACAC;IACAJ;IACAa;IACAP;IACAT;IACAW;IACAI;IACAD;IACAD;IACAD;IACAK;IACAhB;IACAkB;IACAT;IACAQ;CACD,CAAA;AAED,OAAO,MAAMO,sBAA0C;IACrDC,UAAUF;IACVG,SAASN;AACX,EAAC"}

package/dist/field/lexical/config/server/loader.d.ts

@@ -1,7 +1,10 @@
+import type { SanitizedConfig } from 'payload/config';
 import type { FeatureProviderServer, ResolvedServerFeatureMap } from '../../../features/types.js';
 import type { ServerEditorConfig } from '../types.js';
 export declare function sortFeaturesForOptimalLoading(featureProviders: FeatureProviderServer<unknown, unknown>[]): FeatureProviderServer<unknown, unknown>[];
-export declare function loadFeatures({ unSanitizedEditorConfig, }: {
+export declare function loadFeatures({ config, isRoot, unSanitizedEditorConfig, }: {
+    config: SanitizedConfig;
+    isRoot?: boolean;
     unSanitizedEditorConfig: ServerEditorConfig;
-}): ResolvedServerFeatureMap;
+}): Promise<ResolvedServerFeatureMap>;
 //# sourceMappingURL=loader.d.ts.map

package/dist/field/lexical/config/server/loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../../../../src/field/lexical/config/server/loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,qBAAqB,EACrB,wBAAwB,EAEzB,MAAM,4BAA4B,CAAA;AACnC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AA8FrD,wBAAgB,6BAA6B,CAC3C,gBAAgB,EAAE,qBAAqB,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,GAC1D,qBAAqB,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,CAE3C;AAED,wBAAgB,YAAY,CAAC,EAC3B,uBAAuB,GACxB,EAAE;IACD,uBAAuB,EAAE,kBAAkB,CAAA;CAC5C,GAAG,wBAAwB,CA8E3B"}
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../../../../src/field/lexical/config/server/loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAU,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAE7D,OAAO,KAAK,EACV,qBAAqB,EACrB,wBAAwB,EAEzB,MAAM,4BAA4B,CAAA;AACnC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AA8FrD,wBAAgB,6BAA6B,CAC3C,gBAAgB,EAAE,qBAAqB,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,GAC1D,qBAAqB,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,CAE3C;AAED,wBAAsB,YAAY,CAAC,EACjC,MAAM,EACN,MAAM,EACN,uBAAuB,GACxB,EAAE;IACD,MAAM,EAAE,eAAe,CAAA;IACvB,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,uBAAuB,EAAE,kBAAkB,CAAA;CAC5C,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAgFpC"}

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

@@ -57,7 +57,7 @@ function visit(graph, key, visited, stack, currentPath = []) {
 export function sortFeaturesForOptimalLoading(featureProviders) {
     return topologicallySortFeatures(featureProviders);
 }
-export function loadFeatures({ unSanitizedEditorConfig }) {
+export async function loadFeatures({ config, isRoot, unSanitizedEditorConfig }) {
     // First remove all duplicate features. The LAST feature with a given key wins.
     unSanitizedEditorConfig.features = unSanitizedEditorConfig.features.reverse().filter((f, i, arr)=>{
         const firstIndex = arr.findIndex((f2)=>f2.key === f.key);
@@ -97,8 +97,10 @@ export function loadFeatures({ unSanitizedEditorConfig }) {
                 }
             }
         }
-        const feature = featureProvider.feature({
+        const feature = await featureProvider.feature({
+            config,
             featureProviderMap,
+            isRoot,
             resolvedFeatures,
             unSanitizedEditorConfig
         });

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/field/lexical/config/server/loader.ts"],"sourcesContent":["import type {\n  FeatureProviderServer,\n  ResolvedServerFeatureMap,\n  ServerFeatureProviderMap,\n} from '../../../features/types.js'\nimport type { ServerEditorConfig } from '../types.js'\n\ntype DependencyGraph = {\n  [key: string]: {\n    dependencies: string[]\n    dependenciesPriority: string[]\n    dependenciesSoft: string[]\n    featureProvider: FeatureProviderServer<unknown, unknown>\n  }\n}\n\nfunction createDependencyGraph(\n  featureProviders: FeatureProviderServer<unknown, unknown>[],\n): DependencyGraph {\n  const graph: DependencyGraph = {}\n  for (const fp of featureProviders) {\n    graph[fp.key] = {\n      dependencies: fp.dependencies || [],\n      dependenciesPriority: fp.dependenciesPriority || [],\n      dependenciesSoft: fp.dependenciesSoft || [],\n      featureProvider: fp,\n    }\n  }\n  return graph\n}\n\nfunction topologicallySortFeatures(\n  featureProviders: FeatureProviderServer<unknown, unknown>[],\n): FeatureProviderServer<unknown, unknown>[] {\n  const graph = createDependencyGraph(featureProviders)\n  const visited: { [key: string]: boolean } = {}\n  const stack: FeatureProviderServer<unknown, unknown>[] = []\n\n  for (const key in graph) {\n    if (!visited[key]) {\n      visit(graph, key, visited, stack)\n    }\n  }\n\n  return stack.reverse()\n}\n\nfunction visit(\n  graph: DependencyGraph,\n  key: string,\n  visited: { [key: string]: boolean },\n  stack: FeatureProviderServer<unknown, unknown>[],\n  currentPath: string[] = [],\n) {\n  if (!graph[key]) {\n    throw new Error(`Feature key ${key} is not present in the dependency graph.`)\n  }\n\n  if (currentPath.includes(key)) {\n    throw new Error(`Circular dependency detected: ${currentPath.join(' -> ')} -> ${key}`)\n  }\n\n  if (visited[key]) {\n    return\n  }\n\n  visited[key] = true\n  currentPath.push(key)\n\n  // First process the hard priority dependencies\n  for (const dep of graph[key].dependenciesPriority) {\n    if (!visited[dep]) {\n      visit(graph, dep, visited, stack, currentPath)\n    }\n  }\n\n  // Then process the normal dependencies, but make sure to not violate hard dependencies\n  for (const dep of graph[key].dependencies) {\n    if (!visited[dep] && !graph[key].dependenciesPriority.includes(dep)) {\n      visit(graph, dep, visited, stack, currentPath)\n    }\n  }\n\n  // Then process the soft dependencies. Make sure to not violate hard and normal dependencies.\n  for (const dep of graph[key].dependenciesSoft) {\n    if (\n      graph[dep] &&\n      !visited[dep] &&\n      !graph[key].dependenciesPriority.includes(dep) &&\n      !graph[key].dependencies.includes(dep)\n    ) {\n      visit(graph, dep, visited, stack, currentPath)\n    }\n  }\n\n  stack.push(graph[key].featureProvider)\n  currentPath.pop()\n}\n\nexport function sortFeaturesForOptimalLoading(\n  featureProviders: FeatureProviderServer<unknown, unknown>[],\n): FeatureProviderServer<unknown, unknown>[] {\n  return topologicallySortFeatures(featureProviders)\n}\n\nexport function loadFeatures({\n  unSanitizedEditorConfig,\n}: {\n  unSanitizedEditorConfig: ServerEditorConfig\n}): ResolvedServerFeatureMap {\n  // First remove all duplicate features. The LAST feature with a given key wins.\n  unSanitizedEditorConfig.features = unSanitizedEditorConfig.features\n    .reverse()\n    .filter((f, i, arr) => {\n      const firstIndex = arr.findIndex((f2) => f2.key === f.key)\n      return firstIndex === i\n    })\n    .reverse()\n\n  unSanitizedEditorConfig.features = sortFeaturesForOptimalLoading(unSanitizedEditorConfig.features)\n\n  const featureProviderMap: ServerFeatureProviderMap = new Map(\n    unSanitizedEditorConfig.features.map(\n      (f) => [f.key, f] as [string, FeatureProviderServer<unknown, unknown>],\n    ),\n  )\n\n  const resolvedFeatures: ResolvedServerFeatureMap = new Map()\n\n  // Make sure all dependencies declared in the respective features exist\n  let loaded = 0\n  for (const featureProvider of unSanitizedEditorConfig.features) {\n    if (!featureProvider.key) {\n      throw new Error(\n        `A Feature you've added does not have a key. Please add a key to the feature. This is used to uniquely identify the feature.`,\n      )\n    }\n    if (featureProvider.dependencies?.length) {\n      for (const dependencyKey of featureProvider.dependencies) {\n        const found = unSanitizedEditorConfig.features.find((f) => f.key === dependencyKey)\n        if (!found) {\n          throw new Error(\n            `Feature ${featureProvider.key} has a dependency ${dependencyKey} which does not exist.`,\n          )\n        }\n      }\n    }\n\n    if (featureProvider.dependenciesPriority?.length) {\n      for (const priorityDependencyKey of featureProvider.dependenciesPriority) {\n        // look in the resolved features instead of the editorConfig.features, as a dependency requires the feature to be loaded before it, contrary to a soft-dependency\n        const found = resolvedFeatures.get(priorityDependencyKey)\n        if (!found) {\n          const existsInEditorConfig = unSanitizedEditorConfig.features.find(\n            (f) => f.key === priorityDependencyKey,\n          )\n          if (!existsInEditorConfig) {\n            throw new Error(\n              `Feature ${featureProvider.key} has a priority dependency ${priorityDependencyKey} which does not exist.`,\n            )\n          } else {\n            throw new Error(\n              `Feature ${featureProvider.key} has a priority dependency ${priorityDependencyKey} which is not loaded before it.`,\n            )\n          }\n        }\n      }\n    }\n\n    const feature = featureProvider.feature({\n      featureProviderMap,\n      resolvedFeatures,\n      unSanitizedEditorConfig,\n    })\n    resolvedFeatures.set(featureProvider.key, {\n      ...feature,\n      dependencies: featureProvider.dependencies,\n      dependenciesPriority: featureProvider.dependenciesPriority,\n      dependenciesSoft: featureProvider.dependenciesSoft,\n      key: featureProvider.key,\n      order: loaded,\n    })\n\n    loaded++\n  }\n\n  return resolvedFeatures\n}\n"],"names":["createDependencyGraph","featureProviders","graph","fp","key","dependencies","dependenciesPriority","dependenciesSoft","featureProvider","topologicallySortFeatures","visited","stack","visit","reverse","currentPath","Error","includes","join","push","dep","pop","sortFeaturesForOptimalLoading","loadFeatures","unSanitizedEditorConfig","features","filter","f","i","arr","firstIndex","findIndex","f2","featureProviderMap","Map","map","resolvedFeatures","loaded","length","dependencyKey","found","find","priorityDependencyKey","get","existsInEditorConfig","feature","set","order"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}
+{"version":3,"sources":["../../../../../src/field/lexical/config/server/loader.ts"],"sourcesContent":["import type { Config, SanitizedConfig } from 'payload/config'\n\nimport type {\n  FeatureProviderServer,\n  ResolvedServerFeatureMap,\n  ServerFeatureProviderMap,\n} from '../../../features/types.js'\nimport type { ServerEditorConfig } from '../types.js'\n\ntype DependencyGraph = {\n  [key: string]: {\n    dependencies: string[]\n    dependenciesPriority: string[]\n    dependenciesSoft: string[]\n    featureProvider: FeatureProviderServer<unknown, unknown>\n  }\n}\n\nfunction createDependencyGraph(\n  featureProviders: FeatureProviderServer<unknown, unknown>[],\n): DependencyGraph {\n  const graph: DependencyGraph = {}\n  for (const fp of featureProviders) {\n    graph[fp.key] = {\n      dependencies: fp.dependencies || [],\n      dependenciesPriority: fp.dependenciesPriority || [],\n      dependenciesSoft: fp.dependenciesSoft || [],\n      featureProvider: fp,\n    }\n  }\n  return graph\n}\n\nfunction topologicallySortFeatures(\n  featureProviders: FeatureProviderServer<unknown, unknown>[],\n): FeatureProviderServer<unknown, unknown>[] {\n  const graph = createDependencyGraph(featureProviders)\n  const visited: { [key: string]: boolean } = {}\n  const stack: FeatureProviderServer<unknown, unknown>[] = []\n\n  for (const key in graph) {\n    if (!visited[key]) {\n      visit(graph, key, visited, stack)\n    }\n  }\n\n  return stack.reverse()\n}\n\nfunction visit(\n  graph: DependencyGraph,\n  key: string,\n  visited: { [key: string]: boolean },\n  stack: FeatureProviderServer<unknown, unknown>[],\n  currentPath: string[] = [],\n) {\n  if (!graph[key]) {\n    throw new Error(`Feature key ${key} is not present in the dependency graph.`)\n  }\n\n  if (currentPath.includes(key)) {\n    throw new Error(`Circular dependency detected: ${currentPath.join(' -> ')} -> ${key}`)\n  }\n\n  if (visited[key]) {\n    return\n  }\n\n  visited[key] = true\n  currentPath.push(key)\n\n  // First process the hard priority dependencies\n  for (const dep of graph[key].dependenciesPriority) {\n    if (!visited[dep]) {\n      visit(graph, dep, visited, stack, currentPath)\n    }\n  }\n\n  // Then process the normal dependencies, but make sure to not violate hard dependencies\n  for (const dep of graph[key].dependencies) {\n    if (!visited[dep] && !graph[key].dependenciesPriority.includes(dep)) {\n      visit(graph, dep, visited, stack, currentPath)\n    }\n  }\n\n  // Then process the soft dependencies. Make sure to not violate hard and normal dependencies.\n  for (const dep of graph[key].dependenciesSoft) {\n    if (\n      graph[dep] &&\n      !visited[dep] &&\n      !graph[key].dependenciesPriority.includes(dep) &&\n      !graph[key].dependencies.includes(dep)\n    ) {\n      visit(graph, dep, visited, stack, currentPath)\n    }\n  }\n\n  stack.push(graph[key].featureProvider)\n  currentPath.pop()\n}\n\nexport function sortFeaturesForOptimalLoading(\n  featureProviders: FeatureProviderServer<unknown, unknown>[],\n): FeatureProviderServer<unknown, unknown>[] {\n  return topologicallySortFeatures(featureProviders)\n}\n\nexport async function loadFeatures({\n  config,\n  isRoot,\n  unSanitizedEditorConfig,\n}: {\n  config: SanitizedConfig\n  isRoot?: boolean\n  unSanitizedEditorConfig: ServerEditorConfig\n}): Promise<ResolvedServerFeatureMap> {\n  // First remove all duplicate features. The LAST feature with a given key wins.\n  unSanitizedEditorConfig.features = unSanitizedEditorConfig.features\n    .reverse()\n    .filter((f, i, arr) => {\n      const firstIndex = arr.findIndex((f2) => f2.key === f.key)\n      return firstIndex === i\n    })\n    .reverse()\n\n  unSanitizedEditorConfig.features = sortFeaturesForOptimalLoading(unSanitizedEditorConfig.features)\n\n  const featureProviderMap: ServerFeatureProviderMap = new Map(\n    unSanitizedEditorConfig.features.map(\n      (f) => [f.key, f] as [string, FeatureProviderServer<unknown, unknown>],\n    ),\n  )\n\n  const resolvedFeatures: ResolvedServerFeatureMap = new Map()\n\n  // Make sure all dependencies declared in the respective features exist\n  let loaded = 0\n  for (const featureProvider of unSanitizedEditorConfig.features) {\n    if (!featureProvider.key) {\n      throw new Error(\n        `A Feature you've added does not have a key. Please add a key to the feature. This is used to uniquely identify the feature.`,\n      )\n    }\n    if (featureProvider.dependencies?.length) {\n      for (const dependencyKey of featureProvider.dependencies) {\n        const found = unSanitizedEditorConfig.features.find((f) => f.key === dependencyKey)\n        if (!found) {\n          throw new Error(\n            `Feature ${featureProvider.key} has a dependency ${dependencyKey} which does not exist.`,\n          )\n        }\n      }\n    }\n\n    if (featureProvider.dependenciesPriority?.length) {\n      for (const priorityDependencyKey of featureProvider.dependenciesPriority) {\n        // look in the resolved features instead of the editorConfig.features, as a dependency requires the feature to be loaded before it, contrary to a soft-dependency\n        const found = resolvedFeatures.get(priorityDependencyKey)\n        if (!found) {\n          const existsInEditorConfig = unSanitizedEditorConfig.features.find(\n            (f) => f.key === priorityDependencyKey,\n          )\n          if (!existsInEditorConfig) {\n            throw new Error(\n              `Feature ${featureProvider.key} has a priority dependency ${priorityDependencyKey} which does not exist.`,\n            )\n          } else {\n            throw new Error(\n              `Feature ${featureProvider.key} has a priority dependency ${priorityDependencyKey} which is not loaded before it.`,\n            )\n          }\n        }\n      }\n    }\n\n    const feature = await featureProvider.feature({\n      config,\n      featureProviderMap,\n      isRoot,\n      resolvedFeatures,\n      unSanitizedEditorConfig,\n    })\n    resolvedFeatures.set(featureProvider.key, {\n      ...feature,\n      dependencies: featureProvider.dependencies,\n      dependenciesPriority: featureProvider.dependenciesPriority,\n      dependenciesSoft: featureProvider.dependenciesSoft,\n      key: featureProvider.key,\n      order: loaded,\n    })\n\n    loaded++\n  }\n\n  return resolvedFeatures\n}\n"],"names":["createDependencyGraph","featureProviders","graph","fp","key","dependencies","dependenciesPriority","dependenciesSoft","featureProvider","topologicallySortFeatures","visited","stack","visit","reverse","currentPath","Error","includes","join","push","dep","pop","sortFeaturesForOptimalLoading","loadFeatures","config","isRoot","unSanitizedEditorConfig","features","filter","f","i","arr","firstIndex","findIndex","f2","featureProviderMap","Map","map","resolvedFeatures","loaded","length","dependencyKey","found","find","priorityDependencyKey","get","existsInEditorConfig","feature","set","order"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/dist/field/lexical/config/server/sanitize.d.ts

@@ -1,5 +1,6 @@
+import type { SanitizedConfig } from 'payload/config';
 import type { ResolvedServerFeatureMap, SanitizedServerFeatures } from '../../../features/types.js';
 import type { SanitizedServerEditorConfig, ServerEditorConfig } from '../types.js';
 export declare const sanitizeServerFeatures: (features: ResolvedServerFeatureMap) => SanitizedServerFeatures;
-export declare function sanitizeServerEditorConfig(editorConfig: ServerEditorConfig): SanitizedServerEditorConfig;
+export declare function sanitizeServerEditorConfig(editorConfig: ServerEditorConfig, config: SanitizedConfig): Promise<SanitizedServerEditorConfig>;
 //# sourceMappingURL=sanitize.d.ts.map

package/dist/field/lexical/config/server/sanitize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sanitize.d.ts","sourceRoot":"","sources":["../../../../../src/field/lexical/config/server/sanitize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAA;AACnG,OAAO,KAAK,EAAE,2BAA2B,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAIlF,eAAO,MAAM,sBAAsB,0CAEhC,uBA8DF,CAAA;AAED,wBAAgB,0BAA0B,CACxC,YAAY,EAAE,kBAAkB,GAC/B,2BAA2B,CAU7B"}
+{"version":3,"file":"sanitize.d.ts","sourceRoot":"","sources":["../../../../../src/field/lexical/config/server/sanitize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAU,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAE7D,OAAO,KAAK,EAAE,wBAAwB,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAA;AACnG,OAAO,KAAK,EAAE,2BAA2B,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAIlF,eAAO,MAAM,sBAAsB,0CAEhC,uBA0EF,CAAA;AAED,wBAAsB,0BAA0B,CAC9C,YAAY,EAAE,kBAAkB,EAChC,MAAM,EAAE,eAAe,GACtB,OAAO,CAAC,2BAA2B,CAAC,CAWtC"}

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

@@ -9,7 +9,11 @@ export const sanitizeServerFeatures = (features)=>{
             modifyOutputSchemas: []
         },
         hooks: {
-            afterReadPromises: []
+            afterChange: new Map(),
+            afterRead: new Map(),
+            beforeChange: new Map(),
+            beforeDuplicate: new Map(),
+            beforeValidate: new Map()
         },
         markdownTransformers: [],
         nodes: [],
@@ -23,11 +27,6 @@ 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.nodes?.length) {
             sanitized.nodes = sanitized.nodes.concat(feature.nodes);
             feature.nodes.forEach((node)=>{
@@ -42,6 +41,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 +65,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\n    generatedTypes: {\n      modifyOutputSchemas: [],\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    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.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","markdownTransformers","nodes","populationPromises","validations","size","forEach","feature","modifyOutputSchema","push","length","concat","node","nodeType","replace","getType","set","key","sanitizeServerEditorConfig","editorConfig","config","resolvedFeatureMap","unSanitizedEditorConfig","lexical"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

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

@@ -1,4 +1,4 @@
-import type { EditorConfig as LexicalEditorConfig } from 'lexical/LexicalEditor.js';
+import type { EditorConfig as LexicalEditorConfig } from 'lexical';
 import type { FeatureProviderClient, FeatureProviderServer, ResolvedClientFeatureMap, ResolvedServerFeatureMap, SanitizedClientFeatures, SanitizedServerFeatures } from '../../features/types.js';
 export type ServerEditorConfig = {
     features: FeatureProviderServer<unknown, unknown>[];

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,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"}

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 {\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"}

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,6 +1,5 @@
 'use client';
-import lexicalMarkdownShortcutPluginImport from '@lexical/react/LexicalMarkdownShortcutPlugin.js';
-const { MarkdownShortcutPlugin: LexicalMarkdownShortcutPlugin } = lexicalMarkdownShortcutPluginImport;
+import { MarkdownShortcutPlugin as LexicalMarkdownShortcutPlugin } from '@lexical/react/LexicalMarkdownShortcutPlugin.js';
 import * as React from 'react';
 import { useEditorConfigContext } from '../../config/client/EditorConfigProvider.js';
 export const MarkdownShortcutPlugin = ()=>{

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,oBAACF;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 { 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,gBAAgB,EAAE,WAAW,EAAE,MAAM,OAAO,CAAA;AAiB1D,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"}