@payloadcms/richtext-lexical 4.0.0-internal.5b1e7cd → 4.0.0-internal.5e065b3

package/dist/lexical-proxy/@lexical-react/ReactExtension.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReactExtension.js","names":[],"sources":["../../../src/lexical-proxy/@lexical-react/ReactExtension.tsx"],"sourcesContent":["export * from '@lexical/react/ReactExtension'\n"],"mappings":"AAAA,cAAc","ignoreList":[]}

package/dist/lexical-proxy/@lexical-react/ReactPluginHostExtension.d.ts

@@ -0,0 +1,2 @@
+export * from '@lexical/react/ReactPluginHostExtension';
+//# sourceMappingURL=ReactPluginHostExtension.d.ts.map

package/dist/lexical-proxy/@lexical-react/ReactPluginHostExtension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReactPluginHostExtension.d.ts","sourceRoot":"","sources":["../../../src/lexical-proxy/@lexical-react/ReactPluginHostExtension.tsx"],"names":[],"mappings":"AAAA,cAAc,yCAAyC,CAAA"}

package/dist/lexical-proxy/@lexical-react/ReactPluginHostExtension.js

@@ -0,0 +1,2 @@
+export * from '@lexical/react/ReactPluginHostExtension';
+//# sourceMappingURL=ReactPluginHostExtension.js.map

package/dist/lexical-proxy/@lexical-react/ReactPluginHostExtension.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReactPluginHostExtension.js","names":[],"sources":["../../../src/lexical-proxy/@lexical-react/ReactPluginHostExtension.tsx"],"sourcesContent":["export * from '@lexical/react/ReactPluginHostExtension'\n"],"mappings":"AAAA,cAAc","ignoreList":[]}

package/dist/lexical-proxy/@lexical-react/ReactProviderExtension.d.ts

@@ -0,0 +1,2 @@
+export * from '@lexical/react/ReactProviderExtension';
+//# sourceMappingURL=ReactProviderExtension.d.ts.map

package/dist/lexical-proxy/@lexical-react/ReactProviderExtension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReactProviderExtension.d.ts","sourceRoot":"","sources":["../../../src/lexical-proxy/@lexical-react/ReactProviderExtension.tsx"],"names":[],"mappings":"AAAA,cAAc,uCAAuC,CAAA"}

package/dist/lexical-proxy/@lexical-react/ReactProviderExtension.js

@@ -0,0 +1,2 @@
+export * from '@lexical/react/ReactProviderExtension';
+//# sourceMappingURL=ReactProviderExtension.js.map

package/dist/lexical-proxy/@lexical-react/ReactProviderExtension.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReactProviderExtension.js","names":[],"sources":["../../../src/lexical-proxy/@lexical-react/ReactProviderExtension.tsx"],"sourcesContent":["export * from '@lexical/react/ReactProviderExtension'\n"],"mappings":"AAAA,cAAc","ignoreList":[]}

package/dist/lexical-proxy/@lexical-react/TreeViewExtension.d.ts

@@ -0,0 +1,2 @@
+export * from '@lexical/react/TreeViewExtension';
+//# sourceMappingURL=TreeViewExtension.d.ts.map

package/dist/lexical-proxy/@lexical-react/TreeViewExtension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TreeViewExtension.d.ts","sourceRoot":"","sources":["../../../src/lexical-proxy/@lexical-react/TreeViewExtension.tsx"],"names":[],"mappings":"AAAA,cAAc,kCAAkC,CAAA"}

package/dist/lexical-proxy/@lexical-react/TreeViewExtension.js

@@ -0,0 +1,2 @@
+export * from '@lexical/react/TreeViewExtension';
+//# sourceMappingURL=TreeViewExtension.js.map

package/dist/lexical-proxy/@lexical-react/TreeViewExtension.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TreeViewExtension.js","names":[],"sources":["../../../src/lexical-proxy/@lexical-react/TreeViewExtension.tsx"],"sourcesContent":["export * from '@lexical/react/TreeViewExtension'\n"],"mappings":"AAAA,cAAc","ignoreList":[]}

package/dist/lexical-proxy/@lexical-react/useExtensionComponent.d.ts

@@ -0,0 +1,2 @@
+export * from '@lexical/react/useExtensionComponent';
+//# sourceMappingURL=useExtensionComponent.d.ts.map

package/dist/lexical-proxy/@lexical-react/useExtensionComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useExtensionComponent.d.ts","sourceRoot":"","sources":["../../../src/lexical-proxy/@lexical-react/useExtensionComponent.tsx"],"names":[],"mappings":"AAAA,cAAc,sCAAsC,CAAA"}

package/dist/lexical-proxy/@lexical-react/useExtensionComponent.js

@@ -0,0 +1,2 @@
+export * from '@lexical/react/useExtensionComponent';
+//# sourceMappingURL=useExtensionComponent.js.map

package/dist/lexical-proxy/@lexical-react/useExtensionComponent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useExtensionComponent.js","names":[],"sources":["../../../src/lexical-proxy/@lexical-react/useExtensionComponent.tsx"],"sourcesContent":["export * from '@lexical/react/useExtensionComponent'\n"],"mappings":"AAAA,cAAc","ignoreList":[]}

package/dist/lexical-proxy/@lexical-react/useExtensionSignalValue.d.ts

@@ -0,0 +1,2 @@
+export * from '@lexical/react/useExtensionSignalValue';
+//# sourceMappingURL=useExtensionSignalValue.d.ts.map

package/dist/lexical-proxy/@lexical-react/useExtensionSignalValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useExtensionSignalValue.d.ts","sourceRoot":"","sources":["../../../src/lexical-proxy/@lexical-react/useExtensionSignalValue.ts"],"names":[],"mappings":"AAAA,cAAc,wCAAwC,CAAA"}

package/dist/lexical-proxy/@lexical-react/useExtensionSignalValue.js

@@ -0,0 +1,2 @@
+export * from '@lexical/react/useExtensionSignalValue';
+//# sourceMappingURL=useExtensionSignalValue.js.map

package/dist/lexical-proxy/@lexical-react/useExtensionSignalValue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useExtensionSignalValue.js","names":[],"sources":["../../../src/lexical-proxy/@lexical-react/useExtensionSignalValue.ts"],"sourcesContent":["export * from '@lexical/react/useExtensionSignalValue'\n"],"mappings":"AAAA,cAAc","ignoreList":[]}

package/dist/lexical-proxy/@lexical-react/useLexicalAriaLiveRegion.d.ts

@@ -0,0 +1,2 @@
+export * from '@lexical/react/useLexicalAriaLiveRegion';
+//# sourceMappingURL=useLexicalAriaLiveRegion.d.ts.map

package/dist/lexical-proxy/@lexical-react/useLexicalAriaLiveRegion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLexicalAriaLiveRegion.d.ts","sourceRoot":"","sources":["../../../src/lexical-proxy/@lexical-react/useLexicalAriaLiveRegion.ts"],"names":[],"mappings":"AAAA,cAAc,yCAAyC,CAAA"}

package/dist/lexical-proxy/@lexical-react/useLexicalAriaLiveRegion.js

@@ -0,0 +1,2 @@
+export * from '@lexical/react/useLexicalAriaLiveRegion';
+//# sourceMappingURL=useLexicalAriaLiveRegion.js.map

package/dist/lexical-proxy/@lexical-react/useLexicalAriaLiveRegion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLexicalAriaLiveRegion.js","names":[],"sources":["../../../src/lexical-proxy/@lexical-react/useLexicalAriaLiveRegion.ts"],"sourcesContent":["export * from '@lexical/react/useLexicalAriaLiveRegion'\n"],"mappings":"AAAA,cAAc","ignoreList":[]}

package/dist/lexical-proxy/@lexical-react/useLexicalFocusManagerRef.d.ts

@@ -0,0 +1,2 @@
+export * from '@lexical/react/useLexicalFocusManagerRef';
+//# sourceMappingURL=useLexicalFocusManagerRef.d.ts.map

package/dist/lexical-proxy/@lexical-react/useLexicalFocusManagerRef.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLexicalFocusManagerRef.d.ts","sourceRoot":"","sources":["../../../src/lexical-proxy/@lexical-react/useLexicalFocusManagerRef.ts"],"names":[],"mappings":"AAAA,cAAc,0CAA0C,CAAA"}

package/dist/lexical-proxy/@lexical-react/useLexicalFocusManagerRef.js

@@ -0,0 +1,2 @@
+export * from '@lexical/react/useLexicalFocusManagerRef';
+//# sourceMappingURL=useLexicalFocusManagerRef.js.map

package/dist/lexical-proxy/@lexical-react/useLexicalFocusManagerRef.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLexicalFocusManagerRef.js","names":[],"sources":["../../../src/lexical-proxy/@lexical-react/useLexicalFocusManagerRef.ts"],"sourcesContent":["export * from '@lexical/react/useLexicalFocusManagerRef'\n"],"mappings":"AAAA,cAAc","ignoreList":[]}

package/dist/lexical-proxy/@lexical-react/useLexicalFocusTrapRef.d.ts

@@ -0,0 +1,2 @@
+export * from '@lexical/react/useLexicalFocusTrapRef';
+//# sourceMappingURL=useLexicalFocusTrapRef.d.ts.map

package/dist/lexical-proxy/@lexical-react/useLexicalFocusTrapRef.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLexicalFocusTrapRef.d.ts","sourceRoot":"","sources":["../../../src/lexical-proxy/@lexical-react/useLexicalFocusTrapRef.ts"],"names":[],"mappings":"AAAA,cAAc,uCAAuC,CAAA"}

package/dist/lexical-proxy/@lexical-react/useLexicalFocusTrapRef.js

@@ -0,0 +1,2 @@
+export * from '@lexical/react/useLexicalFocusTrapRef';
+//# sourceMappingURL=useLexicalFocusTrapRef.js.map

package/dist/lexical-proxy/@lexical-react/useLexicalFocusTrapRef.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLexicalFocusTrapRef.js","names":[],"sources":["../../../src/lexical-proxy/@lexical-react/useLexicalFocusTrapRef.ts"],"sourcesContent":["export * from '@lexical/react/useLexicalFocusTrapRef'\n"],"mappings":"AAAA,cAAc","ignoreList":[]}

package/dist/lexical-proxy/@lexical-react/useLexicalRovingTabIndexRef.d.ts

@@ -0,0 +1,2 @@
+export * from '@lexical/react/useLexicalRovingTabIndexRef';
+//# sourceMappingURL=useLexicalRovingTabIndexRef.d.ts.map

package/dist/lexical-proxy/@lexical-react/useLexicalRovingTabIndexRef.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLexicalRovingTabIndexRef.d.ts","sourceRoot":"","sources":["../../../src/lexical-proxy/@lexical-react/useLexicalRovingTabIndexRef.ts"],"names":[],"mappings":"AAAA,cAAc,4CAA4C,CAAA"}

package/dist/lexical-proxy/@lexical-react/useLexicalRovingTabIndexRef.js

@@ -0,0 +1,2 @@
+export * from '@lexical/react/useLexicalRovingTabIndexRef';
+//# sourceMappingURL=useLexicalRovingTabIndexRef.js.map

package/dist/lexical-proxy/@lexical-react/useLexicalRovingTabIndexRef.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLexicalRovingTabIndexRef.js","names":[],"sources":["../../../src/lexical-proxy/@lexical-react/useLexicalRovingTabIndexRef.ts"],"sourcesContent":["export * from '@lexical/react/useLexicalRovingTabIndexRef'\n"],"mappings":"AAAA,cAAc","ignoreList":[]}

package/dist/lexical-proxy/@lexical-react/useLexicalSlotRef.d.ts

@@ -0,0 +1,2 @@
+export * from '@lexical/react/useLexicalSlotRef';
+//# sourceMappingURL=useLexicalSlotRef.d.ts.map

package/dist/lexical-proxy/@lexical-react/useLexicalSlotRef.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLexicalSlotRef.d.ts","sourceRoot":"","sources":["../../../src/lexical-proxy/@lexical-react/useLexicalSlotRef.ts"],"names":[],"mappings":"AAAA,cAAc,kCAAkC,CAAA"}

package/dist/lexical-proxy/@lexical-react/useLexicalSlotRef.js

@@ -0,0 +1,2 @@
+export * from '@lexical/react/useLexicalSlotRef';
+//# sourceMappingURL=useLexicalSlotRef.js.map

package/dist/lexical-proxy/@lexical-react/useLexicalSlotRef.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLexicalSlotRef.js","names":[],"sources":["../../../src/lexical-proxy/@lexical-react/useLexicalSlotRef.ts"],"sourcesContent":["export * from '@lexical/react/useLexicalSlotRef'\n"],"mappings":"AAAA,cAAc","ignoreList":[]}

package/dist/populateGraphQL/populateLexicalPopulationPromises.d.ts

@@ -1,7 +1,7 @@
 import type { SerializedEditorState } from 'lexical';
 import type { RichTextAdapter } from 'payload';
 import type { PopulationPromise } from '../features/typesServer.js';
-import type { AdapterProps } from '../types.js';
+import type { AdapterProps } from '../types/index.js';
 export type Args = {
     editorPopulationPromises: Map<string, Array<PopulationPromise>>;
     parentIsLocalized: boolean;

package/dist/populateGraphQL/populateLexicalPopulationPromises.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"populateLexicalPopulationPromises.d.ts","sourceRoot":"","sources":["../../src/populateGraphQL/populateLexicalPopulationPromises.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AACpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAE9C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAA;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAI/C,MAAM,MAAM,IAAI,GAAG;IACjB,wBAAwB,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAA;IAC/D,iBAAiB,EAAE,OAAO,CAAA;CAC3B,GAAG,UAAU,CACZ,WAAW,CAAC,eAAe,CAAC,qBAAqB,EAAE,YAAY,CAAC,CAAC,2BAA2B,CAAC,CAAC,CAC/F,CAAC,CAAC,CAAC,CAAA;AAEJ;;GAEG;AACH,eAAO,MAAM,iCAAiC,iNAgB3C,IAAI,SAoCN,CAAA"}
+{"version":3,"file":"populateLexicalPopulationPromises.d.ts","sourceRoot":"","sources":["../../src/populateGraphQL/populateLexicalPopulationPromises.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AACpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAE9C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAA;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAIrD,MAAM,MAAM,IAAI,GAAG;IACjB,wBAAwB,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAA;IAC/D,iBAAiB,EAAE,OAAO,CAAA;CAC3B,GAAG,UAAU,CACZ,WAAW,CAAC,eAAe,CAAC,qBAAqB,EAAE,YAAY,CAAC,CAAC,2BAA2B,CAAC,CAAC,CAC/F,CAAC,CAAC,CAAC,CAAA;AAEJ;;GAEG;AACH,eAAO,MAAM,iCAAiC,iNAgB3C,IAAI,SAoCN,CAAA"}

package/dist/populateGraphQL/populateLexicalPopulationPromises.js.map

@@ -1 +1 @@
-{"version":3,"file":"populateLexicalPopulationPromises.js","names":["recurseNodes","populateLexicalPopulationPromises","context","currentDepth","depth","draft","editorPopulationPromises","field","fieldPromises","findMany","flattenLocales","overrideAccess","parentIsLocalized","populationPromises","req","showHiddenFields","siblingDoc","shouldPopulate","callback","node","editorPopulationPromisesOfNodeType","get","type","promise","nodes","name","root","children"],"sources":["../../src/populateGraphQL/populateLexicalPopulationPromises.ts"],"sourcesContent":["import type { SerializedEditorState } from 'lexical'\nimport type { RichTextAdapter } from 'payload'\n\nimport type { PopulationPromise } from '../features/typesServer.js'\nimport type { AdapterProps } from '../types.js'\n\nimport { recurseNodes } from '../utilities/forEachNodeRecursively.js'\n\nexport type Args = {\n  editorPopulationPromises: Map<string, Array<PopulationPromise>>\n  parentIsLocalized: boolean\n} & Parameters<\n  NonNullable<RichTextAdapter<SerializedEditorState, AdapterProps>['graphQLPopulationPromises']>\n>[0]\n\n/**\n * Appends all new populationPromises to the populationPromises prop\n */\nexport const populateLexicalPopulationPromises = ({\n  context,\n  currentDepth,\n  depth,\n  draft,\n  editorPopulationPromises,\n  field,\n  fieldPromises,\n  findMany,\n  flattenLocales,\n  overrideAccess,\n  parentIsLocalized,\n  populationPromises,\n  req,\n  showHiddenFields,\n  siblingDoc,\n}: Args) => {\n  const shouldPopulate = depth && currentDepth! <= depth\n\n  if (!shouldPopulate) {\n    return\n  }\n\n  recurseNodes({\n    callback: (node) => {\n      const editorPopulationPromisesOfNodeType = editorPopulationPromises?.get(node.type)\n      if (editorPopulationPromisesOfNodeType) {\n        for (const promise of editorPopulationPromisesOfNodeType) {\n          promise({\n            context,\n            currentDepth: currentDepth!,\n            depth,\n            draft,\n            editorPopulationPromises,\n            field,\n            fieldPromises,\n            findMany,\n            flattenLocales,\n            node,\n            overrideAccess: overrideAccess!,\n            parentIsLocalized,\n            populationPromises,\n            req,\n            showHiddenFields,\n            siblingDoc,\n          })\n        }\n      }\n    },\n\n    nodes: (siblingDoc[field?.name] as SerializedEditorState)?.root?.children ?? [],\n  })\n}\n"],"mappings":"AAMA,SAASA,YAAY,QAAQ;AAS7B;;;AAGA,OAAO,MAAMC,iCAAA,GAAoCA,CAAC;EAChDC,OAAO;EACPC,YAAY;EACZC,KAAK;EACLC,KAAK;EACLC,wBAAwB;EACxBC,KAAK;EACLC,aAAa;EACbC,QAAQ;EACRC,cAAc;EACdC,cAAc;EACdC,iBAAiB;EACjBC,kBAAkB;EAClBC,GAAG;EACHC,gBAAgB;EAChBC;AAAU,CACL;EACL,MAAMC,cAAA,GAAiBb,KAAA,IAASD,YAAA,IAAiBC,KAAA;EAEjD,IAAI,CAACa,cAAA,EAAgB;IACnB;EACF;EAEAjB,YAAA,CAAa;IACXkB,QAAA,EAAWC,IAAA;MACT,MAAMC,kCAAA,GAAqCd,wBAAA,EAA0Be,GAAA,CAAIF,IAAA,CAAKG,IAAI;MAClF,IAAIF,kCAAA,EAAoC;QACtC,KAAK,MAAMG,OAAA,IAAWH,kCAAA,EAAoC;UACxDG,OAAA,CAAQ;YACNrB,OAAA;YACAC,YAAA,EAAcA,YAAA;YACdC,KAAA;YACAC,KAAA;YACAC,wBAAA;YACAC,KAAA;YACAC,aAAA;YACAC,QAAA;YACAC,cAAA;YACAS,IAAA;YACAR,cAAA,EAAgBA,cAAA;YAChBC,iBAAA;YACAC,kBAAA;YACAC,GAAA;YACAC,gBAAA;YACAC;UACF;QACF;MACF;IACF;IAEAQ,KAAA,EAAOR,UAAW,CAACT,KAAA,EAAOkB,IAAA,CAAK,EAA4BC,IAAA,EAAMC,QAAA,IAAY;EAC/E;AACF","ignoreList":[]}
+{"version":3,"file":"populateLexicalPopulationPromises.js","names":["recurseNodes","populateLexicalPopulationPromises","context","currentDepth","depth","draft","editorPopulationPromises","field","fieldPromises","findMany","flattenLocales","overrideAccess","parentIsLocalized","populationPromises","req","showHiddenFields","siblingDoc","shouldPopulate","callback","node","editorPopulationPromisesOfNodeType","get","type","promise","nodes","name","root","children"],"sources":["../../src/populateGraphQL/populateLexicalPopulationPromises.ts"],"sourcesContent":["import type { SerializedEditorState } from 'lexical'\nimport type { RichTextAdapter } from 'payload'\n\nimport type { PopulationPromise } from '../features/typesServer.js'\nimport type { AdapterProps } from '../types/index.js'\n\nimport { recurseNodes } from '../utilities/forEachNodeRecursively.js'\n\nexport type Args = {\n  editorPopulationPromises: Map<string, Array<PopulationPromise>>\n  parentIsLocalized: boolean\n} & Parameters<\n  NonNullable<RichTextAdapter<SerializedEditorState, AdapterProps>['graphQLPopulationPromises']>\n>[0]\n\n/**\n * Appends all new populationPromises to the populationPromises prop\n */\nexport const populateLexicalPopulationPromises = ({\n  context,\n  currentDepth,\n  depth,\n  draft,\n  editorPopulationPromises,\n  field,\n  fieldPromises,\n  findMany,\n  flattenLocales,\n  overrideAccess,\n  parentIsLocalized,\n  populationPromises,\n  req,\n  showHiddenFields,\n  siblingDoc,\n}: Args) => {\n  const shouldPopulate = depth && currentDepth! <= depth\n\n  if (!shouldPopulate) {\n    return\n  }\n\n  recurseNodes({\n    callback: (node) => {\n      const editorPopulationPromisesOfNodeType = editorPopulationPromises?.get(node.type)\n      if (editorPopulationPromisesOfNodeType) {\n        for (const promise of editorPopulationPromisesOfNodeType) {\n          promise({\n            context,\n            currentDepth: currentDepth!,\n            depth,\n            draft,\n            editorPopulationPromises,\n            field,\n            fieldPromises,\n            findMany,\n            flattenLocales,\n            node,\n            overrideAccess: overrideAccess!,\n            parentIsLocalized,\n            populationPromises,\n            req,\n            showHiddenFields,\n            siblingDoc,\n          })\n        }\n      }\n    },\n\n    nodes: (siblingDoc[field?.name] as SerializedEditorState)?.root?.children ?? [],\n  })\n}\n"],"mappings":"AAMA,SAASA,YAAY,QAAQ;AAS7B;;;AAGA,OAAO,MAAMC,iCAAA,GAAoCA,CAAC;EAChDC,OAAO;EACPC,YAAY;EACZC,KAAK;EACLC,KAAK;EACLC,wBAAwB;EACxBC,KAAK;EACLC,aAAa;EACbC,QAAQ;EACRC,cAAc;EACdC,cAAc;EACdC,iBAAiB;EACjBC,kBAAkB;EAClBC,GAAG;EACHC,gBAAgB;EAChBC;AAAU,CACL;EACL,MAAMC,cAAA,GAAiBb,KAAA,IAASD,YAAA,IAAiBC,KAAA;EAEjD,IAAI,CAACa,cAAA,EAAgB;IACnB;EACF;EAEAjB,YAAA,CAAa;IACXkB,QAAA,EAAWC,IAAA;MACT,MAAMC,kCAAA,GAAqCd,wBAAA,EAA0Be,GAAA,CAAIF,IAAA,CAAKG,IAAI;MAClF,IAAIF,kCAAA,EAAoC;QACtC,KAAK,MAAMG,OAAA,IAAWH,kCAAA,EAAoC;UACxDG,OAAA,CAAQ;YACNrB,OAAA;YACAC,YAAA,EAAcA,YAAA;YACdC,KAAA;YACAC,KAAA;YACAC,wBAAA;YACAC,KAAA;YACAC,aAAA;YACAC,QAAA;YACAC,cAAA;YACAS,IAAA;YACAR,cAAA,EAAgBA,cAAA;YAChBC,iBAAA;YACAC,kBAAA;YACAC,GAAA;YACAC,gBAAA;YACAC;UACF;QACF;MACF;IACF;IAEAQ,KAAA,EAAOR,UAAW,CAACT,KAAA,EAAOkB,IAAA,CAAK,EAA4BC,IAAA,EAAMC,QAAA,IAAY;EAC/E;AACF","ignoreList":[]}

package/dist/presets/llmInstructions.d.ts

@@ -0,0 +1,2 @@
+export declare const getLLMInstructionsFeatures: () => (import("../index.js").FeatureProviderServer<undefined, undefined, undefined> | import("../index.js").FeatureProviderServer<undefined, undefined, null> | import("../index.js").FeatureProviderServer<import("../features/toolbars/fixed/server/index.js").FixedToolbarFeatureProps, import("../features/toolbars/fixed/server/index.js").FixedToolbarFeatureProps, import("../features/toolbars/fixed/server/index.js").FixedToolbarFeatureProps> | import("../index.js").FeatureProviderServer<import("../features/heading/server/index.js").HeadingFeatureProps, import("../features/heading/server/index.js").HeadingFeatureProps, import("../features/heading/server/index.js").HeadingFeatureProps>)[];
+//# sourceMappingURL=llmInstructions.d.ts.map

package/dist/presets/llmInstructions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"llmInstructions.d.ts","sourceRoot":"","sources":["../../src/presets/llmInstructions.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,0BAA0B,orBAUtC,CAAA"}

package/dist/presets/llmInstructions.js

@@ -0,0 +1,13 @@
+import { BoldFeature } from '../features/format/bold/feature.server.js';
+import { ItalicFeature } from '../features/format/italic/feature.server.js';
+import { StrikethroughFeature } from '../features/format/strikethrough/feature.server.js';
+import { HeadingFeature } from '../features/heading/server/index.js';
+import { OrderedListFeature } from '../features/lists/orderedList/server/index.js';
+import { UnorderedListFeature } from '../features/lists/unorderedList/server/index.js';
+import { ParagraphFeature } from '../features/paragraph/server/index.js';
+import { FixedToolbarFeature } from '../features/toolbars/fixed/server/index.js';
+import { InlineToolbarFeature } from '../features/toolbars/inline/server/index.js';
+export const getLLMInstructionsFeatures = () => [ParagraphFeature(), HeadingFeature({
+  enabledHeadingSizes: ['h2', 'h3', 'h4']
+}), BoldFeature(), ItalicFeature(), StrikethroughFeature(), UnorderedListFeature(), OrderedListFeature(), FixedToolbarFeature(), InlineToolbarFeature()];
+//# sourceMappingURL=llmInstructions.js.map

package/dist/presets/llmInstructions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"llmInstructions.js","names":["BoldFeature","ItalicFeature","StrikethroughFeature","HeadingFeature","OrderedListFeature","UnorderedListFeature","ParagraphFeature","FixedToolbarFeature","InlineToolbarFeature","getLLMInstructionsFeatures","enabledHeadingSizes"],"sources":["../../src/presets/llmInstructions.ts"],"sourcesContent":["import { BoldFeature } from '../features/format/bold/feature.server.js'\nimport { ItalicFeature } from '../features/format/italic/feature.server.js'\nimport { StrikethroughFeature } from '../features/format/strikethrough/feature.server.js'\nimport { HeadingFeature } from '../features/heading/server/index.js'\nimport { OrderedListFeature } from '../features/lists/orderedList/server/index.js'\nimport { UnorderedListFeature } from '../features/lists/unorderedList/server/index.js'\nimport { ParagraphFeature } from '../features/paragraph/server/index.js'\nimport { FixedToolbarFeature } from '../features/toolbars/fixed/server/index.js'\nimport { InlineToolbarFeature } from '../features/toolbars/inline/server/index.js'\n\nexport const getLLMInstructionsFeatures = () => [\n  ParagraphFeature(),\n  HeadingFeature({ enabledHeadingSizes: ['h2', 'h3', 'h4'] }),\n  BoldFeature(),\n  ItalicFeature(),\n  StrikethroughFeature(),\n  UnorderedListFeature(),\n  OrderedListFeature(),\n  FixedToolbarFeature(),\n  InlineToolbarFeature(),\n]\n"],"mappings":"AAAA,SAASA,WAAW,QAAQ;AAC5B,SAASC,aAAa,QAAQ;AAC9B,SAASC,oBAAoB,QAAQ;AACrC,SAASC,cAAc,QAAQ;AAC/B,SAASC,kBAAkB,QAAQ;AACnC,SAASC,oBAAoB,QAAQ;AACrC,SAASC,gBAAgB,QAAQ;AACjC,SAASC,mBAAmB,QAAQ;AACpC,SAASC,oBAAoB,QAAQ;AAErC,OAAO,MAAMC,0BAAA,GAA6BA,CAAA,KAAM,CAC9CH,gBAAA,IACAH,cAAA,CAAe;EAAEO,mBAAA,EAAqB,CAAC,MAAM,MAAM;AAAM,IACzDV,WAAA,IACAC,aAAA,IACAC,oBAAA,IACAG,oBAAA,IACAD,kBAAA,IACAG,mBAAA,IACAC,oBAAA,GACD","ignoreList":[]}

package/dist/types/builtInNodes.d.ts

@@ -0,0 +1,14 @@
+import type { JSONSchemaFn } from '../features/typesServer.js';
+/**
+ * Cross-cutting Lexical types shared by every element node. Inlined into
+ * `payload-types.ts`. Must stay byte-for-byte in sync with the runtime twins
+ * in `types/nodeTypes.ts` (`LexicalElementFormat`, `LexicalElementDirection`,
+ * `SerializedLexicalElementBase`) — cross-module assignability depends on it.
+ */
+export declare const CORE_LEXICAL_TYPE_STRING = "/** @internal Core Lexical types \u2014 see @payloadcms/richtext-lexical. */\nexport type LexicalElementFormat = 'left' | 'start' | 'center' | 'right' | 'end' | 'justify' | '';\nexport type LexicalElementDirection = ('ltr' | 'rtl') | null;\n\nexport interface SerializedLexicalElementBase<TChildren> {\n  children: TChildren[];\n  direction: LexicalElementDirection;\n  format: LexicalElementFormat;\n  indent: number;\n  textFormat?: number;\n  textStyle?: string;\n  version: number;\n}";
+export declare const textNodeJSONSchema: JSONSchemaFn;
+export declare const tabNodeJSONSchema: JSONSchemaFn;
+export declare const lineBreakNodeJSONSchema: JSONSchemaFn;
+export declare const paragraphNodeJSONSchema: JSONSchemaFn;
+export declare const rootNodeJSONSchema: JSONSchemaFn;
+//# sourceMappingURL=builtInNodes.d.ts.map

package/dist/types/builtInNodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtInNodes.d.ts","sourceRoot":"","sources":["../../src/types/builtInNodes.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAI9D;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,6eAYnC,CAAA;AA4DF,eAAO,MAAM,kBAAkB,EAAE,YAkBhC,CAAA;AAED,eAAO,MAAM,iBAAiB,EAAE,YAoB/B,CAAA;AAED,eAAO,MAAM,uBAAuB,EAAE,YAYrC,CAAA;AAED,eAAO,MAAM,uBAAuB,EAAE,YAerC,CAAA;AAeD,eAAO,MAAM,kBAAkB,EAAE,YAoBhC,CAAA"}

package/dist/types/builtInNodes.js

@@ -0,0 +1,203 @@
+import { withNullableJSONSchemaType } from 'payload';
+import { versionSchema } from './jsonSchemaHelpers.js';
+/**
+ * Cross-cutting Lexical types shared by every element node. Inlined into
+ * `payload-types.ts`. Must stay byte-for-byte in sync with the runtime twins
+ * in `types/nodeTypes.ts` (`LexicalElementFormat`, `LexicalElementDirection`,
+ * `SerializedLexicalElementBase`) — cross-module assignability depends on it.
+ */
+export const CORE_LEXICAL_TYPE_STRING = `/** @internal Core Lexical types — see @payloadcms/richtext-lexical. */
+export type LexicalElementFormat = 'left' | 'start' | 'center' | 'right' | 'end' | 'justify' | '';
+export type LexicalElementDirection = ('ltr' | 'rtl') | null;
+
+export interface SerializedLexicalElementBase<TChildren> {
+  children: TChildren[];
+  direction: LexicalElementDirection;
+  format: LexicalElementFormat;
+  indent: number;
+  textFormat?: number;
+  textStyle?: string;
+  version: number;
+}`;
+/**
+ * Built-in Lexical node schemas (always present regardless of feature config).
+ * Co-located with the TS source they reference — each `JSONSchemaFn` adds
+ * its helper interface(s) to `typeStringDefinitions` and returns the JSON
+ * schema for that node.
+ */ /** MUST stay byte-for-byte in sync with `LexicalTextMode` in `types/nodeTypes.ts`. */
+const LEXICAL_TEXT_MODE_TS = `export type LexicalTextMode = 'normal' | 'token' | 'segmented';`;
+/** MUST stay byte-for-byte in sync with `SerializedTextNode` in `types/nodeTypes.ts`. */
+const SERIALIZED_TEXT_NODE_TS = `export interface SerializedTextNode {
+  type: 'text';
+  detail: number;
+  format: number;
+  mode: LexicalTextMode;
+  style: string;
+  text: string;
+  version: number;
+}`;
+/** MUST stay byte-for-byte in sync with `SerializedTabNode` in `types/nodeTypes.ts`. */
+const SERIALIZED_TAB_NODE_TS = `export interface SerializedTabNode {
+  type: 'tab';
+  detail: number;
+  format: number;
+  mode: LexicalTextMode;
+  style: string;
+  text: string;
+  version: number;
+}`;
+/** MUST stay byte-for-byte in sync with `SerializedLineBreakNode` in `types/nodeTypes.ts`. */
+const SERIALIZED_LINE_BREAK_NODE_TS = `export interface SerializedLineBreakNode {
+  type: 'linebreak';
+  version: number;
+}`;
+/** MUST stay byte-for-byte in sync with `SerializedParagraphNode` in `types/nodeTypes.ts`. */
+const SERIALIZED_PARAGRAPH_NODE_TS = `export interface SerializedParagraphNode<TChildren> extends SerializedLexicalElementBase<TChildren> {
+  type: 'paragraph';
+  textFormat: number;
+  textStyle: string;
+}`;
+const textModeSchema = {
+  type: 'string',
+  enum: ['normal', 'token', 'segmented'],
+  tsType: 'LexicalTextMode'
+};
+/** Text-node `format` bitmask (Lexical text-format flags). */
+const textFormatSchema = {
+  type: 'integer',
+  description: 'Active text formats as a bitmask, OR-ed together (0 = none): bold=1, italic=2, strikethrough=4, underline=8, code=16, subscript=32, superscript=64, highlight=128, lowercase=256, uppercase=512. e.g. bold + italic = 3.'
+};
+export const textNodeJSONSchema = ({
+  typeStringDefinitions
+}) => {
+  typeStringDefinitions.add(LEXICAL_TEXT_MODE_TS);
+  typeStringDefinitions.add(SERIALIZED_TEXT_NODE_TS);
+  return {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+      type: {
+        type: 'string',
+        const: 'text'
+      },
+      detail: {
+        type: 'integer'
+      },
+      format: textFormatSchema,
+      mode: textModeSchema,
+      style: {
+        type: 'string'
+      },
+      text: {
+        type: 'string'
+      },
+      version: versionSchema
+    },
+    required: ['detail', 'format', 'mode', 'style', 'text', 'type', 'version'],
+    tsType: 'SerializedTextNode'
+  };
+};
+export const tabNodeJSONSchema = ({
+  typeStringDefinitions
+}) => {
+  typeStringDefinitions.add(LEXICAL_TEXT_MODE_TS);
+  typeStringDefinitions.add(SERIALIZED_TAB_NODE_TS);
+  return {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+      type: {
+        type: 'string',
+        const: 'tab'
+      },
+      // A tab node is fully fixed: Lexical marks it unmergeable (`detail` = IS_UNMERGEABLE = 2) and
+      // its text is a single tab. Any other `detail` makes `TabNode.setDetail` throw on load.
+      detail: {
+        const: 2,
+        description: 'Always 2 (Lexical IS_UNMERGEABLE); other values throw.'
+      },
+      format: textFormatSchema,
+      mode: textModeSchema,
+      style: {
+        type: 'string'
+      },
+      text: {
+        const: '\t',
+        description: 'Always a single tab character.'
+      },
+      version: versionSchema
+    },
+    required: ['detail', 'format', 'mode', 'style', 'text', 'type', 'version'],
+    tsType: 'SerializedTabNode'
+  };
+};
+export const lineBreakNodeJSONSchema = ({
+  typeStringDefinitions
+}) => {
+  typeStringDefinitions.add(SERIALIZED_LINE_BREAK_NODE_TS);
+  return {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+      type: {
+        type: 'string',
+        const: 'linebreak'
+      },
+      version: versionSchema
+    },
+    required: ['type', 'version'],
+    tsType: 'SerializedLineBreakNode'
+  };
+};
+export const paragraphNodeJSONSchema = ({
+  elementNodeSchema,
+  nodeUnionName,
+  typeStringDefinitions
+}) => {
+  typeStringDefinitions.add(SERIALIZED_PARAGRAPH_NODE_TS);
+  return elementNodeSchema({
+    nodeType: 'paragraph',
+    properties: {
+      textFormat: {
+        type: 'integer'
+      },
+      textStyle: {
+        type: 'string'
+      }
+    },
+    required: ['textFormat', 'textStyle'],
+    tsType: `SerializedParagraphNode<${nodeUnionName}>`
+  });
+};
+/** MUST stay byte-for-byte in sync with `LexicalRichText` in `types/nodeTypes.ts`. */
+const ROOT_NODE_TS = `/** Shape of a Lexical \`richText\` field. */
+export interface LexicalRichText<TNode> {
+  root: {
+    children: TNode[];
+    direction: LexicalElementDirection;
+    format: LexicalElementFormat;
+    indent: number;
+    type: 'root';
+    version: number;
+  };
+}`;
+export const rootNodeJSONSchema = ({
+  elementNodeSchema,
+  field,
+  nodeUnionName,
+  typeStringDefinitions
+}) => {
+  typeStringDefinitions.add(ROOT_NODE_TS);
+  return {
+    type: withNullableJSONSchemaType('object', !!field.required),
+    additionalProperties: false,
+    properties: {
+      root: elementNodeSchema({
+        nodeType: 'root'
+      })
+    },
+    required: ['root'],
+    tsType: field.required ? `LexicalRichText<${nodeUnionName}>` : `LexicalRichText<${nodeUnionName}> | null`
+  };
+};
+//# sourceMappingURL=builtInNodes.js.map

package/dist/types/builtInNodes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtInNodes.js","names":["withNullableJSONSchemaType","versionSchema","CORE_LEXICAL_TYPE_STRING","LEXICAL_TEXT_MODE_TS","SERIALIZED_TEXT_NODE_TS","SERIALIZED_TAB_NODE_TS","SERIALIZED_LINE_BREAK_NODE_TS","SERIALIZED_PARAGRAPH_NODE_TS","textModeSchema","type","enum","tsType","textFormatSchema","description","textNodeJSONSchema","typeStringDefinitions","add","additionalProperties","properties","const","detail","format","mode","style","text","version","required","tabNodeJSONSchema","lineBreakNodeJSONSchema","paragraphNodeJSONSchema","elementNodeSchema","nodeUnionName","nodeType","textFormat","textStyle","ROOT_NODE_TS","rootNodeJSONSchema","field","root"],"sources":["../../src/types/builtInNodes.ts"],"sourcesContent":["import type { JSONSchema4 } from 'json-schema'\n\nimport { withNullableJSONSchemaType } from 'payload'\n\nimport type { JSONSchemaFn } from '../features/typesServer.js'\n\nimport { versionSchema } from './jsonSchemaHelpers.js'\n\n/**\n * Cross-cutting Lexical types shared by every element node. Inlined into\n * `payload-types.ts`. Must stay byte-for-byte in sync with the runtime twins\n * in `types/nodeTypes.ts` (`LexicalElementFormat`, `LexicalElementDirection`,\n * `SerializedLexicalElementBase`) — cross-module assignability depends on it.\n */\nexport const CORE_LEXICAL_TYPE_STRING = `/** @internal Core Lexical types — see @payloadcms/richtext-lexical. */\nexport type LexicalElementFormat = 'left' | 'start' | 'center' | 'right' | 'end' | 'justify' | '';\nexport type LexicalElementDirection = ('ltr' | 'rtl') | null;\n\nexport interface SerializedLexicalElementBase<TChildren> {\n  children: TChildren[];\n  direction: LexicalElementDirection;\n  format: LexicalElementFormat;\n  indent: number;\n  textFormat?: number;\n  textStyle?: string;\n  version: number;\n}`\n\n/**\n * Built-in Lexical node schemas (always present regardless of feature config).\n * Co-located with the TS source they reference — each `JSONSchemaFn` adds\n * its helper interface(s) to `typeStringDefinitions` and returns the JSON\n * schema for that node.\n */\n\n/** MUST stay byte-for-byte in sync with `LexicalTextMode` in `types/nodeTypes.ts`. */\nconst LEXICAL_TEXT_MODE_TS = `export type LexicalTextMode = 'normal' | 'token' | 'segmented';`\n\n/** MUST stay byte-for-byte in sync with `SerializedTextNode` in `types/nodeTypes.ts`. */\nconst SERIALIZED_TEXT_NODE_TS = `export interface SerializedTextNode {\n  type: 'text';\n  detail: number;\n  format: number;\n  mode: LexicalTextMode;\n  style: string;\n  text: string;\n  version: number;\n}`\n\n/** MUST stay byte-for-byte in sync with `SerializedTabNode` in `types/nodeTypes.ts`. */\nconst SERIALIZED_TAB_NODE_TS = `export interface SerializedTabNode {\n  type: 'tab';\n  detail: number;\n  format: number;\n  mode: LexicalTextMode;\n  style: string;\n  text: string;\n  version: number;\n}`\n\n/** MUST stay byte-for-byte in sync with `SerializedLineBreakNode` in `types/nodeTypes.ts`. */\nconst SERIALIZED_LINE_BREAK_NODE_TS = `export interface SerializedLineBreakNode {\n  type: 'linebreak';\n  version: number;\n}`\n\n/** MUST stay byte-for-byte in sync with `SerializedParagraphNode` in `types/nodeTypes.ts`. */\nconst SERIALIZED_PARAGRAPH_NODE_TS = `export interface SerializedParagraphNode<TChildren> extends SerializedLexicalElementBase<TChildren> {\n  type: 'paragraph';\n  textFormat: number;\n  textStyle: string;\n}`\n\nconst textModeSchema: JSONSchema4 = {\n  type: 'string',\n  enum: ['normal', 'token', 'segmented'],\n  tsType: 'LexicalTextMode',\n}\n\n/** Text-node `format` bitmask (Lexical text-format flags). */\nconst textFormatSchema: JSONSchema4 = {\n  type: 'integer',\n  description:\n    'Active text formats as a bitmask, OR-ed together (0 = none): bold=1, italic=2, strikethrough=4, underline=8, code=16, subscript=32, superscript=64, highlight=128, lowercase=256, uppercase=512. e.g. bold + italic = 3.',\n}\n\nexport const textNodeJSONSchema: JSONSchemaFn = ({ typeStringDefinitions }) => {\n  typeStringDefinitions.add(LEXICAL_TEXT_MODE_TS)\n  typeStringDefinitions.add(SERIALIZED_TEXT_NODE_TS)\n  return {\n    type: 'object',\n    additionalProperties: false,\n    properties: {\n      type: { type: 'string', const: 'text' },\n      detail: { type: 'integer' },\n      format: textFormatSchema,\n      mode: textModeSchema,\n      style: { type: 'string' },\n      text: { type: 'string' },\n      version: versionSchema,\n    },\n    required: ['detail', 'format', 'mode', 'style', 'text', 'type', 'version'],\n    tsType: 'SerializedTextNode',\n  }\n}\n\nexport const tabNodeJSONSchema: JSONSchemaFn = ({ typeStringDefinitions }) => {\n  typeStringDefinitions.add(LEXICAL_TEXT_MODE_TS)\n  typeStringDefinitions.add(SERIALIZED_TAB_NODE_TS)\n  return {\n    type: 'object',\n    additionalProperties: false,\n    properties: {\n      type: { type: 'string', const: 'tab' },\n      // A tab node is fully fixed: Lexical marks it unmergeable (`detail` = IS_UNMERGEABLE = 2) and\n      // its text is a single tab. Any other `detail` makes `TabNode.setDetail` throw on load.\n      detail: { const: 2, description: 'Always 2 (Lexical IS_UNMERGEABLE); other values throw.' },\n      format: textFormatSchema,\n      mode: textModeSchema,\n      style: { type: 'string' },\n      text: { const: '\\t', description: 'Always a single tab character.' },\n      version: versionSchema,\n    },\n    required: ['detail', 'format', 'mode', 'style', 'text', 'type', 'version'],\n    tsType: 'SerializedTabNode',\n  }\n}\n\nexport const lineBreakNodeJSONSchema: JSONSchemaFn = ({ typeStringDefinitions }) => {\n  typeStringDefinitions.add(SERIALIZED_LINE_BREAK_NODE_TS)\n  return {\n    type: 'object',\n    additionalProperties: false,\n    properties: {\n      type: { type: 'string', const: 'linebreak' },\n      version: versionSchema,\n    },\n    required: ['type', 'version'],\n    tsType: 'SerializedLineBreakNode',\n  }\n}\n\nexport const paragraphNodeJSONSchema: JSONSchemaFn = ({\n  elementNodeSchema,\n  nodeUnionName,\n  typeStringDefinitions,\n}) => {\n  typeStringDefinitions.add(SERIALIZED_PARAGRAPH_NODE_TS)\n  return elementNodeSchema({\n    nodeType: 'paragraph',\n    properties: {\n      textFormat: { type: 'integer' },\n      textStyle: { type: 'string' },\n    },\n    required: ['textFormat', 'textStyle'],\n    tsType: `SerializedParagraphNode<${nodeUnionName}>`,\n  })\n}\n\n/** MUST stay byte-for-byte in sync with `LexicalRichText` in `types/nodeTypes.ts`. */\nconst ROOT_NODE_TS = `/** Shape of a Lexical \\`richText\\` field. */\nexport interface LexicalRichText<TNode> {\n  root: {\n    children: TNode[];\n    direction: LexicalElementDirection;\n    format: LexicalElementFormat;\n    indent: number;\n    type: 'root';\n    version: number;\n  };\n}`\n\nexport const rootNodeJSONSchema: JSONSchemaFn = ({\n  elementNodeSchema,\n  field,\n  nodeUnionName,\n  typeStringDefinitions,\n}) => {\n  typeStringDefinitions.add(ROOT_NODE_TS)\n  return {\n    type: withNullableJSONSchemaType('object', !!field.required),\n    additionalProperties: false,\n    properties: {\n      root: elementNodeSchema({\n        nodeType: 'root',\n      }),\n    },\n    required: ['root'],\n    tsType: field.required\n      ? `LexicalRichText<${nodeUnionName}>`\n      : `LexicalRichText<${nodeUnionName}> | null`,\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/{types.d.ts → types/index.d.ts}

@@ -1,22 +1,21 @@
 import type { DecoratorNode, EditorConfig, LexicalEditor, EditorConfig as LexicalEditorConfig, LexicalNode, SerializedEditorState, SerializedLexicalNode } from 'lexical';
-import type { ClientField, DefaultServerCellComponentProps, LabelFunction, PayloadComponent, RichTextAdapter, RichTextField, RichTextFieldClient, RichTextFieldClientProps, SanitizedConfig, ServerFieldBase, StaticLabel } from 'payload';
-import type { BlockComponentContextType } from './features/blocks/client/component/BlockContent.js';
+import type { ClientField, DefaultServerCellComponentProps, LabelFunction, MarkdownRichTextAdapter, PayloadComponent, RichTextField, RichTextFieldClient, RichTextFieldClientProps, SanitizedConfig, ServerFieldBase, StaticLabel } from 'payload';
+import type { BlockComponentContextType } from '../features/blocks/client/component/BlockContent.js';
 export type { BlockComponentContextType };
-import type { BlockComponentProps } from './features/blocks/client/component/index.js';
-import type { InlineBlockComponentContextType } from './features/blocks/client/componentInline/index.js';
-import type { JSXConverterArgs, JSXConverters, SerializedLexicalNodeWithParent } from './features/converters/lexicalToJSX/converter/types.js';
-import type { BaseClientFeatureProps, FeatureProviderProviderClient } from './features/typesClient.js';
-import type { FeatureProviderServer } from './features/typesServer.js';
-import type { SanitizedServerEditorConfig } from './lexical/config/types.js';
+import type { BlockComponentProps } from '../features/blocks/client/component/index.js';
+import type { InlineBlockComponentContextType } from '../features/blocks/client/componentInline/index.js';
+import type { JSXConverterArgs, JSXConverters, SerializedLexicalNodeWithParent } from '../features/converters/lexicalToJSX/converter/types.js';
+import type { BaseClientFeatureProps, FeatureProviderProviderClient } from '../features/typesClient.js';
+import type { FeatureProviderServer } from '../features/typesServer.js';
+import type { SanitizedServerEditorConfig } from '../lexical/config/types.js';
+import type { InitialLexicalFormState } from '../utilities/buildInitialState.js';
 import type { DefaultNodeTypes, SerializedBlockNode, SerializedInlineBlockNode } from './nodeTypes.js';
-import type { InitialLexicalFormState } from './utilities/buildInitialState.js';
 /**
  * Base constraint for serialized Lexical node types.
  * Used as the generic constraint for node map types.
  * Extends the base SerializedLexicalNode with optional type for flexibility.
  */
 export type SerializedNodeBase = {
-    [key: string]: unknown;
     type?: string;
 };
 export type LexicalFieldAdminProps = {
@@ -314,26 +313,26 @@ export type LexicalEditorNodeMap<TNodes extends SerializedNodeBase = DefaultNode
     }>>;
 } & {
     blocks?: {
-        [K in Extract<Extract<TNodes, {
+        [K in (Extract<TNodes, {
             type: 'block';
-        }> extends SerializedBlockNode<infer B> ? B extends {
-            blockType: string;
-        } ? B['blockType'] : never : never, string>]?: NodeMapBlockValue<Extract<TNodes, {
+        }> & SerializedBlockNode)['fields']['blockType']]?: NodeMapBlockValue<Extract<Extract<TNodes, {
             type: 'block';
-        }> extends SerializedBlockNode<infer B> ? SerializedBlockNode<Extract<B, {
-            blockType: K;
-        }>> : SerializedBlockNode>;
+        }> & SerializedBlockNode, {
+            fields: {
+                blockType: K;
+            };
+        }>>;
     };
     inlineBlocks?: {
-        [K in Extract<Extract<TNodes, {
+        [K in (Extract<TNodes, {
             type: 'inlineBlock';
-        }> extends SerializedInlineBlockNode<infer B> ? B extends {
-            blockType: string;
-        } ? B['blockType'] : never : never, string>]?: NodeMapInlineBlockValue<Extract<TNodes, {
+        }> & SerializedInlineBlockNode)['fields']['blockType']]?: NodeMapInlineBlockValue<Extract<Extract<TNodes, {
             type: 'inlineBlock';
-        }> extends SerializedInlineBlockNode<infer B> ? SerializedInlineBlockNode<Extract<B, {
-            blockType: K;
-        }>> : SerializedInlineBlockNode>;
+        }> & SerializedInlineBlockNode, {
+            fields: {
+                blockType: K;
+            };
+        }>>;
     };
     unknown?: NodeMapValue<SerializedLexicalNode>;
 };
@@ -410,7 +409,7 @@ export type LexicalEditorProps = {
 export type LexicalRichTextAdapter = {
     editorConfig: SanitizedServerEditorConfig;
     features: FeatureProviderServer<any, any, any>[];
-} & RichTextAdapter<SerializedEditorState, AdapterProps>;
+} & MarkdownRichTextAdapter<SerializedEditorState, AdapterProps>;
 export type LexicalRichTextAdapterProvider = 
 /**
  * This is being called during the payload sanitization process
@@ -419,7 +418,7 @@ export type LexicalRichTextAdapterProvider =
     config: SanitizedConfig;
     isRoot?: boolean;
     parentIsLocalized: boolean;
-}) => Promise<LexicalRichTextAdapter>;
+}) => LexicalRichTextAdapter;
 export type SingleFeatureClientSchemaMap = {
     [key: string]: ClientField[];
 };
@@ -435,8 +434,8 @@ export type LexicalRichTextFieldProps = {
      */
     featureClientImportMap?: Record<string, any>;
     featureClientSchemaMap: FeatureClientSchemaMap;
-    initialLexicalFormState: InitialLexicalFormState;
-    lexicalEditorConfig: LexicalEditorConfig | undefined;
+    initialLexicalFormState?: InitialLexicalFormState;
+    lexicalEditorConfig?: LexicalEditorConfig;
     views?: LexicalEditorViewMap;
 } & Pick<ServerFieldBase, 'permissions'> & RichTextFieldClientProps<SerializedEditorState, AdapterProps, object>;
 export type LexicalRichTextCellProps = DefaultServerCellComponentProps<RichTextFieldClient<SerializedEditorState, AdapterProps, object>, SerializedEditorState>;
@@ -448,4 +447,4 @@ export type GeneratedFeatureProviderComponent = {
     clientFeatureProps: BaseClientFeatureProps<object>;
 };
 export type LexicalRichTextField = RichTextField<SerializedEditorState, AdapterProps>;
-//# sourceMappingURL=types.d.ts.map
+//# sourceMappingURL=index.d.ts.map