@payloadcms/richtext-lexical 3.0.0-canary.95fcd13 → 3.0.0-canary.96477cf

package/dist/populateGraphQL/populateLexicalPopulationPromises.js

@@ -1,37 +1,53 @@
 import { recurseNodes } from '../utilities/forEachNodeRecursively.js';
 /**
  * Appends all new populationPromises to the populationPromises prop
- */ export const populateLexicalPopulationPromises = ({ context, currentDepth, depth, draft, editorPopulationPromises, field, fieldPromises, findMany, flattenLocales, overrideAccess, populationPromises, req, showHiddenFields, siblingDoc })=>{
-    const shouldPopulate = depth && currentDepth <= depth;
-    if (!shouldPopulate) {
-        return;
-    }
-    recurseNodes({
-        callback: (node)=>{
-            if (editorPopulationPromises?.has(node.type)) {
-                for (const promise of editorPopulationPromises.get(node.type)){
-                    promise({
-                        context,
-                        currentDepth,
-                        depth,
-                        draft,
-                        editorPopulationPromises,
-                        field,
-                        fieldPromises,
-                        findMany,
-                        flattenLocales,
-                        node,
-                        overrideAccess,
-                        populationPromises,
-                        req,
-                        showHiddenFields,
-                        siblingDoc
-                    });
-                }
-            }
-        },
-        nodes: siblingDoc[field?.name]?.root?.children ?? []
-    });
+ */
+export const populateLexicalPopulationPromises = ({
+  context,
+  currentDepth,
+  depth,
+  draft,
+  editorPopulationPromises,
+  field,
+  fieldPromises,
+  findMany,
+  flattenLocales,
+  overrideAccess,
+  populationPromises,
+  req,
+  showHiddenFields,
+  siblingDoc
+}) => {
+  const shouldPopulate = depth && currentDepth <= depth;
+  if (!shouldPopulate) {
+    return;
+  }
+  recurseNodes({
+    callback: node => {
+      const editorPopulationPromisesOfNodeType = editorPopulationPromises?.get(node.type);
+      if (editorPopulationPromisesOfNodeType) {
+        for (const promise of editorPopulationPromisesOfNodeType) {
+          promise({
+            context,
+            currentDepth: currentDepth,
+            depth,
+            draft,
+            editorPopulationPromises,
+            field,
+            fieldPromises,
+            findMany,
+            flattenLocales,
+            node,
+            overrideAccess: overrideAccess,
+            populationPromises,
+            req,
+            showHiddenFields,
+            siblingDoc
+          });
+        }
+      }
+    },
+    nodes: siblingDoc[field?.name]?.root?.children ?? []
+  });
 };
-
 //# sourceMappingURL=populateLexicalPopulationPromises.js.map

package/dist/populateGraphQL/populateLexicalPopulationPromises.js.map

@@ -1 +1 @@
-{"version":3,"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} & Parameters<RichTextAdapter<SerializedEditorState, AdapterProps>['graphQLPopulationPromises']>[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  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      if (editorPopulationPromises?.has(node.type)) {\n        for (const promise of editorPopulationPromises.get(node.type)) {\n          promise({\n            context,\n            currentDepth,\n            depth,\n            draft,\n            editorPopulationPromises,\n            field,\n            fieldPromises,\n            findMany,\n            flattenLocales,\n            node,\n            overrideAccess,\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"],"names":["recurseNodes","populateLexicalPopulationPromises","context","currentDepth","depth","draft","editorPopulationPromises","field","fieldPromises","findMany","flattenLocales","overrideAccess","populationPromises","req","showHiddenFields","siblingDoc","shouldPopulate","callback","node","has","type","promise","get","nodes","name","root","children"],"mappings":"AAMA,SAASA,YAAY,QAAQ,yCAAwC;AAMrE;;CAEC,GACD,OAAO,MAAMC,oCAAoC,CAAC,EAChDC,OAAO,EACPC,YAAY,EACZC,KAAK,EACLC,KAAK,EACLC,wBAAwB,EACxBC,KAAK,EACLC,aAAa,EACbC,QAAQ,EACRC,cAAc,EACdC,cAAc,EACdC,kBAAkB,EAClBC,GAAG,EACHC,gBAAgB,EAChBC,UAAU,EACL;IACL,MAAMC,iBAAiBZ,SAASD,gBAAgBC;IAEhD,IAAI,CAACY,gBAAgB;QACnB;IACF;IAEAhB,aAAa;QACXiB,UAAU,CAACC;YACT,IAAIZ,0BAA0Ba,IAAID,KAAKE,IAAI,GAAG;gBAC5C,KAAK,MAAMC,WAAWf,yBAAyBgB,GAAG,CAACJ,KAAKE,IAAI,EAAG;oBAC7DC,QAAQ;wBACNnB;wBACAC;wBACAC;wBACAC;wBACAC;wBACAC;wBACAC;wBACAC;wBACAC;wBACAQ;wBACAP;wBACAC;wBACAC;wBACAC;wBACAC;oBACF;gBACF;YACF;QACF;QAEAQ,OAAO,AAACR,UAAU,CAACR,OAAOiB,KAAK,EAA4BC,MAAMC,YAAY,EAAE;IACjF;AACF,EAAC"}
+{"version":3,"file":"populateLexicalPopulationPromises.js","names":["recurseNodes","populateLexicalPopulationPromises","context","currentDepth","depth","draft","editorPopulationPromises","field","fieldPromises","findMany","flattenLocales","overrideAccess","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} & 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  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            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;AAQ7B;;;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,kBAAkB;EAClBC,GAAG;EACHC,gBAAgB;EAChBC;AAAU,CACL;EACL,MAAMC,cAAA,GAAiBZ,KAAA,IAASD,YAAA,IAAiBC,KAAA;EAEjD,IAAI,CAACY,cAAA,EAAgB;IACnB;EACF;EAEAhB,YAAA,CAAa;IACXiB,QAAA,EAAWC,IAAA;MACT,MAAMC,kCAAA,GAAqCb,wBAAA,EAA0Bc,GAAA,CAAIF,IAAA,CAAKG,IAAI;MAClF,IAAIF,kCAAA,EAAoC;QACtC,KAAK,MAAMG,OAAA,IAAWH,kCAAA,EAAoC;UACxDG,OAAA,CAAQ;YACNpB,OAAA;YACAC,YAAA,EAAcA,YAAA;YACdC,KAAA;YACAC,KAAA;YACAC,wBAAA;YACAC,KAAA;YACAC,aAAA;YACAC,QAAA;YACAC,cAAA;YACAQ,IAAA;YACAP,cAAA,EAAgBA,cAAA;YAChBC,kBAAA;YACAC,GAAA;YACAC,gBAAA;YACAC;UACF;QACF;MACF;IACF;IAEAQ,KAAA,EAAOR,UAAW,CAACR,KAAA,EAAOiB,IAAA,CAAK,EAA4BC,IAAA,EAAMC,QAAA,IAAY;EAC/E;AACF","ignoreList":[]}

package/dist/populateGraphQL/recursivelyPopulateFieldsForGraphQL.js

@@ -1,28 +1,42 @@
 import { afterReadTraverseFields } from 'payload';
-export const recursivelyPopulateFieldsForGraphQL = ({ context, currentDepth = 0, data, depth, draft, fieldPromises, fields, findMany, flattenLocales, overrideAccess = false, populationPromises, req, showHiddenFields, siblingDoc })=>{
-    afterReadTraverseFields({
-        collection: null,
-        context,
-        currentDepth,
-        depth,
-        doc: data,
-        draft,
-        fallbackLocale: req.fallbackLocale,
-        fieldPromises,
-        fields,
-        findMany,
-        flattenLocales,
-        global: null,
-        locale: req.locale,
-        overrideAccess,
-        path: [],
-        populationPromises,
-        req,
-        schemaPath: [],
-        showHiddenFields,
-        siblingDoc,
-        triggerHooks: false
-    });
+export const recursivelyPopulateFieldsForGraphQL = ({
+  context,
+  currentDepth = 0,
+  data,
+  depth,
+  draft,
+  fieldPromises,
+  fields,
+  findMany,
+  flattenLocales,
+  overrideAccess = false,
+  populationPromises,
+  req,
+  showHiddenFields,
+  siblingDoc
+}) => {
+  afterReadTraverseFields({
+    collection: null,
+    context,
+    currentDepth,
+    depth,
+    doc: data,
+    draft,
+    fallbackLocale: req.fallbackLocale,
+    fieldPromises,
+    fields,
+    findMany,
+    flattenLocales,
+    global: null,
+    locale: req.locale,
+    overrideAccess,
+    path: [],
+    populationPromises,
+    req,
+    schemaPath: [],
+    showHiddenFields,
+    siblingDoc,
+    triggerHooks: false
+  });
 };
-
 //# sourceMappingURL=recursivelyPopulateFieldsForGraphQL.js.map

package/dist/populateGraphQL/recursivelyPopulateFieldsForGraphQL.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/populateGraphQL/recursivelyPopulateFieldsForGraphQL.ts"],"sourcesContent":["import type { Field, JsonObject, PayloadRequest, RequestContext } from 'payload'\n\nimport { afterReadTraverseFields } from 'payload'\n\nimport type { PopulationPromise } from '../features/typesServer.js'\n\ntype NestedRichTextFieldsArgs = {\n  context: RequestContext\n  currentDepth?: number\n  data: unknown\n  depth: number\n  draft: boolean\n  /**\n   * This maps all the population promises to the node types\n   */\n  editorPopulationPromises: Map<string, Array<PopulationPromise>>\n  /**\n   * fieldPromises are used for things like field hooks. They should be awaited before awaiting populationPromises\n   */\n  fieldPromises: Promise<void>[]\n  fields: Field[]\n  findMany: boolean\n  flattenLocales: boolean\n  overrideAccess: boolean\n  populationPromises: Promise<void>[]\n  req: PayloadRequest\n  showHiddenFields: boolean\n  siblingDoc: JsonObject\n}\n\nexport const recursivelyPopulateFieldsForGraphQL = ({\n  context,\n  currentDepth = 0,\n  data,\n  depth,\n  draft,\n  fieldPromises,\n  fields,\n  findMany,\n  flattenLocales,\n  overrideAccess = false,\n  populationPromises,\n  req,\n  showHiddenFields,\n  siblingDoc,\n}: NestedRichTextFieldsArgs): void => {\n  afterReadTraverseFields({\n    collection: null, // Pass from core? This is only needed for hooks, so we can leave this null for now\n    context,\n    currentDepth,\n    depth,\n    doc: data as any, // Looks like it's only needed for hooks and access control, so doesn't matter what we pass here right now\n    draft,\n    fallbackLocale: req.fallbackLocale,\n    fieldPromises,\n    fields,\n    findMany,\n    flattenLocales,\n    global: null, // Pass from core? This is only needed for hooks, so we can leave this null for now\n    locale: req.locale,\n    overrideAccess,\n    path: [],\n    populationPromises, // This is not the same as populationPromises passed into this recurseNestedFields. These are just promises resolved at the very end.\n    req,\n    schemaPath: [],\n    showHiddenFields,\n    siblingDoc,\n    triggerHooks: false,\n  })\n}\n"],"names":["afterReadTraverseFields","recursivelyPopulateFieldsForGraphQL","context","currentDepth","data","depth","draft","fieldPromises","fields","findMany","flattenLocales","overrideAccess","populationPromises","req","showHiddenFields","siblingDoc","collection","doc","fallbackLocale","global","locale","path","schemaPath","triggerHooks"],"mappings":"AAEA,SAASA,uBAAuB,QAAQ,UAAS;AA4BjD,OAAO,MAAMC,sCAAsC,CAAC,EAClDC,OAAO,EACPC,eAAe,CAAC,EAChBC,IAAI,EACJC,KAAK,EACLC,KAAK,EACLC,aAAa,EACbC,MAAM,EACNC,QAAQ,EACRC,cAAc,EACdC,iBAAiB,KAAK,EACtBC,kBAAkB,EAClBC,GAAG,EACHC,gBAAgB,EAChBC,UAAU,EACe;IACzBf,wBAAwB;QACtBgB,YAAY;QACZd;QACAC;QACAE;QACAY,KAAKb;QACLE;QACAY,gBAAgBL,IAAIK,cAAc;QAClCX;QACAC;QACAC;QACAC;QACAS,QAAQ;QACRC,QAAQP,IAAIO,MAAM;QAClBT;QACAU,MAAM,EAAE;QACRT;QACAC;QACAS,YAAY,EAAE;QACdR;QACAC;QACAQ,cAAc;IAChB;AACF,EAAC"}
+{"version":3,"file":"recursivelyPopulateFieldsForGraphQL.js","names":["afterReadTraverseFields","recursivelyPopulateFieldsForGraphQL","context","currentDepth","data","depth","draft","fieldPromises","fields","findMany","flattenLocales","overrideAccess","populationPromises","req","showHiddenFields","siblingDoc","collection","doc","fallbackLocale","global","locale","path","schemaPath","triggerHooks"],"sources":["../../src/populateGraphQL/recursivelyPopulateFieldsForGraphQL.ts"],"sourcesContent":["import type { Field, JsonObject, PayloadRequest, RequestContext } from 'payload'\n\nimport { afterReadTraverseFields } from 'payload'\n\nimport type { PopulationPromise } from '../features/typesServer.js'\n\ntype NestedRichTextFieldsArgs = {\n  context: RequestContext\n  currentDepth?: number\n  data: unknown\n  depth: number\n  draft: boolean\n  /**\n   * This maps all the population promises to the node types\n   */\n  editorPopulationPromises: Map<string, Array<PopulationPromise>>\n  /**\n   * fieldPromises are used for things like field hooks. They should be awaited before awaiting populationPromises\n   */\n  fieldPromises: Promise<void>[]\n  fields: Field[]\n  findMany: boolean\n  flattenLocales: boolean\n  overrideAccess: boolean\n  populationPromises: Promise<void>[]\n  req: PayloadRequest\n  showHiddenFields: boolean\n  siblingDoc: JsonObject\n}\n\nexport const recursivelyPopulateFieldsForGraphQL = ({\n  context,\n  currentDepth = 0,\n  data,\n  depth,\n  draft,\n  fieldPromises,\n  fields,\n  findMany,\n  flattenLocales,\n  overrideAccess = false,\n  populationPromises,\n  req,\n  showHiddenFields,\n  siblingDoc,\n}: NestedRichTextFieldsArgs): void => {\n  afterReadTraverseFields({\n    collection: null, // Pass from core? This is only needed for hooks, so we can leave this null for now\n    context,\n    currentDepth,\n    depth,\n    doc: data as any, // Looks like it's only needed for hooks and access control, so doesn't matter what we pass here right now\n    draft,\n    fallbackLocale: req.fallbackLocale!,\n    fieldPromises,\n    fields,\n    findMany,\n    flattenLocales,\n    global: null, // Pass from core? This is only needed for hooks, so we can leave this null for now\n    locale: req.locale!,\n    overrideAccess,\n    path: [],\n    populationPromises, // This is not the same as populationPromises passed into this recurseNestedFields. These are just promises resolved at the very end.\n    req,\n    schemaPath: [],\n    showHiddenFields,\n    siblingDoc,\n    triggerHooks: false,\n  })\n}\n"],"mappings":"AAEA,SAASA,uBAAuB,QAAQ;AA4BxC,OAAO,MAAMC,mCAAA,GAAsCA,CAAC;EAClDC,OAAO;EACPC,YAAA,GAAe,CAAC;EAChBC,IAAI;EACJC,KAAK;EACLC,KAAK;EACLC,aAAa;EACbC,MAAM;EACNC,QAAQ;EACRC,cAAc;EACdC,cAAA,GAAiB,KAAK;EACtBC,kBAAkB;EAClBC,GAAG;EACHC,gBAAgB;EAChBC;AAAU,CACe;EACzBf,uBAAA,CAAwB;IACtBgB,UAAA,EAAY;IACZd,OAAA;IACAC,YAAA;IACAE,KAAA;IACAY,GAAA,EAAKb,IAAA;IACLE,KAAA;IACAY,cAAA,EAAgBL,GAAA,CAAIK,cAAc;IAClCX,aAAA;IACAC,MAAA;IACAC,QAAA;IACAC,cAAA;IACAS,MAAA,EAAQ;IACRC,MAAA,EAAQP,GAAA,CAAIO,MAAM;IAClBT,cAAA;IACAU,IAAA,EAAM,EAAE;IACRT,kBAAA;IACAC,GAAA;IACAS,UAAA,EAAY,EAAE;IACdR,gBAAA;IACAC,UAAA;IACAQ,YAAA,EAAc;EAChB;AACF","ignoreList":[]}

package/dist/types.d.ts

@@ -1,6 +1,6 @@
 import type { EditorConfig as LexicalEditorConfig, SerializedEditorState } from 'lexical';
-import type { FieldPermissions, FieldTypes, RichTextAdapter, RichTextFieldProps, SanitizedConfig } from 'payload';
-import type React from 'react';
+import type { RichTextAdapter, RichTextFieldClientProps, SanitizedConfig } from 'payload';
+import type { BaseClientFeatureProps, FeatureProviderProviderClient } from './features/typesClient.js';
 import type { FeatureProviderServer } from './features/typesServer.js';
 import type { SanitizedServerEditorConfig } from './lexical/config/types.js';
 export type LexicalFieldAdminProps = {
@@ -43,27 +43,25 @@ export type LexicalEditorProps = {
 export type LexicalRichTextAdapter = {
     editorConfig: SanitizedServerEditorConfig;
     features: FeatureProviderServer<any, any, any>[];
-} & RichTextAdapter<SerializedEditorState, AdapterProps, any>;
+} & RichTextAdapter<SerializedEditorState, AdapterProps>;
 export type LexicalRichTextAdapterProvider = 
 /**
  * This is being called during the payload sanitization process
  */
-({ config, isRoot, }: {
+({ config, isRoot, parentIsLocalized, }: {
     config: SanitizedConfig;
     isRoot?: boolean;
+    parentIsLocalized: boolean;
 }) => Promise<LexicalRichTextAdapter>;
-export type FieldProps = {
-    fieldTypes: FieldTypes;
-    indexPath: string;
-    path?: string;
-    permissions: FieldPermissions;
-} & RichTextFieldProps<SerializedEditorState, AdapterProps, AdapterProps>;
+export type LexicalRichTextFieldProps = {
+    admin: LexicalFieldAdminProps;
+    lexicalEditorConfig: LexicalEditorConfig;
+} & RichTextFieldClientProps<SerializedEditorState, AdapterProps, object>;
 export type AdapterProps = {
     editorConfig: SanitizedServerEditorConfig;
 };
 export type GeneratedFeatureProviderComponent = {
-    ClientFeature: React.ReactNode;
-    key: string;
-    order: number;
+    clientFeature: FeatureProviderProviderClient<any, any>;
+    clientFeatureProps: BaseClientFeatureProps<object>;
 };
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,IAAI,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AACzF,OAAO,KAAK,EACV,gBAAgB,EAChB,UAAU,EACV,eAAe,EACf,kBAAkB,EAClB,eAAe,EAChB,MAAM,SAAS,CAAA;AAChB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAA;AACtE,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,2BAA2B,CAAA;AAE5E,MAAM,MAAM,sBAAsB,GAAG;IACnC;;OAEG;IACH,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,CAAC,EAAE,sBAAsB,CAAA;IAC9B,QAAQ,CAAC,EACL,CAAC,CAAC,EACA,eAAe,EACf,YAAY,GACb,EAAE;QACD;;;;;;;;;;WAUG;QACH,eAAe,EAAE,qBAAqB,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,CAAA;QACvD;;;;;;;;;;;WAWG;QACH,YAAY,EAAE,qBAAqB,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,CAAA;KACrD,KAAK,qBAAqB,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAC7C,qBAAqB,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,CAAA;IAC1C,OAAO,CAAC,EAAE,mBAAmB,CAAA;CAC9B,CAAA;AAED,MAAM,MAAM,sBAAsB,GAAG;IACnC,YAAY,EAAE,2BAA2B,CAAA;IACzC,QAAQ,EAAE,qBAAqB,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,CAAA;CACjD,GAAG,eAAe,CAAC,qBAAqB,EAAE,YAAY,EAAE,GAAG,CAAC,CAAA;AAE7D,MAAM,MAAM,8BAA8B;AACxC;;GAEG;AACH,CAAC,EACC,MAAM,EACN,MAAM,GACP,EAAE;IACD,MAAM,EAAE,eAAe,CAAA;IACvB,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB,KAAK,OAAO,CAAC,sBAAsB,CAAC,CAAA;AAEvC,MAAM,MAAM,UAAU,GAAG;IACvB,UAAU,EAAE,UAAU,CAAA;IACtB,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,gBAAgB,CAAA;CAC9B,GAAG,kBAAkB,CAAC,qBAAqB,EAAE,YAAY,EAAE,YAAY,CAAC,CAAA;AAEzE,MAAM,MAAM,YAAY,GAAG;IACzB,YAAY,EAAE,2BAA2B,CAAA;CAC1C,CAAA;AAED,MAAM,MAAM,iCAAiC,GAAG;IAC9C,aAAa,EAAE,KAAK,CAAC,SAAS,CAAA;IAC9B,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,MAAM,CAAA;CACd,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,IAAI,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AACzF,OAAO,KAAK,EAAE,eAAe,EAAE,wBAAwB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAEzF,OAAO,KAAK,EACV,sBAAsB,EACtB,6BAA6B,EAC9B,MAAM,2BAA2B,CAAA;AAClC,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAA;AACtE,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,2BAA2B,CAAA;AAE5E,MAAM,MAAM,sBAAsB,GAAG;IACnC;;OAEG;IACH,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,CAAC,EAAE,sBAAsB,CAAA;IAC9B,QAAQ,CAAC,EACL,CAAC,CAAC,EACA,eAAe,EACf,YAAY,GACb,EAAE;QACD;;;;;;;;;;WAUG;QACH,eAAe,EAAE,qBAAqB,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,CAAA;QACvD;;;;;;;;;;;WAWG;QACH,YAAY,EAAE,qBAAqB,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,CAAA;KACrD,KAAK,qBAAqB,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAC7C,qBAAqB,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,CAAA;IAC1C,OAAO,CAAC,EAAE,mBAAmB,CAAA;CAC9B,CAAA;AAED,MAAM,MAAM,sBAAsB,GAAG;IACnC,YAAY,EAAE,2BAA2B,CAAA;IACzC,QAAQ,EAAE,qBAAqB,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,CAAA;CACjD,GAAG,eAAe,CAAC,qBAAqB,EAAE,YAAY,CAAC,CAAA;AAExD,MAAM,MAAM,8BAA8B;AACxC;;GAEG;AACH,CAAC,EACC,MAAM,EACN,MAAM,EACN,iBAAiB,GAClB,EAAE;IACD,MAAM,EAAE,eAAe,CAAA;IACvB,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,iBAAiB,EAAE,OAAO,CAAA;CAC3B,KAAK,OAAO,CAAC,sBAAsB,CAAC,CAAA;AAEvC,MAAM,MAAM,yBAAyB,GAAG;IACtC,KAAK,EAAE,sBAAsB,CAAA;IAC7B,mBAAmB,EAAE,mBAAmB,CAAA;CACzC,GAAG,wBAAwB,CAAC,qBAAqB,EAAE,YAAY,EAAE,MAAM,CAAC,CAAA;AAEzE,MAAM,MAAM,YAAY,GAAG;IACzB,YAAY,EAAE,2BAA2B,CAAA;CAC1C,CAAA;AAED,MAAM,MAAM,iCAAiC,GAAG;IAC9C,aAAa,EAAE,6BAA6B,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;IACtD,kBAAkB,EAAE,sBAAsB,CAAC,MAAM,CAAC,CAAA;CACnD,CAAA"}

package/dist/types.js

@@ -1,3 +1,2 @@
-export { };
-
+export {};
 //# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/types.ts"],"sourcesContent":["import type { EditorConfig as LexicalEditorConfig, SerializedEditorState } from 'lexical'\nimport type {\n  FieldPermissions,\n  FieldTypes,\n  RichTextAdapter,\n  RichTextFieldProps,\n  SanitizedConfig,\n} from 'payload'\nimport type React from 'react'\n\nimport type { FeatureProviderServer } from './features/typesServer.js'\nimport type { SanitizedServerEditorConfig } from './lexical/config/types.js'\n\nexport type LexicalFieldAdminProps = {\n  /**\n   * Controls if the gutter (padding to the left & gray vertical line) should be hidden. @default false\n   */\n  hideGutter?: boolean\n}\n\nexport type LexicalEditorProps = {\n  admin?: LexicalFieldAdminProps\n  features?:\n    | (({\n        defaultFeatures,\n        rootFeatures,\n      }: {\n        /**\n         * This opinionated array contains all \"recommended\" default features.\n         *\n         * @Example\n         *\n         * ```ts\n         *  editor: lexicalEditor({\n         *    features: ({ defaultFeatures }) => [...defaultFeatures, FixedToolbarFeature()],\n         *  })\n         *  ```\n         */\n        defaultFeatures: FeatureProviderServer<any, any, any>[]\n        /**\n         * This array contains all features that are enabled in the root richText editor (the one defined in the payload.config.ts).\n         * If this field is the root richText editor, or if the root richText editor is not a lexical editor, this array will be empty.\n         *\n         * @Example\n         *\n         * ```ts\n         *  editor: lexicalEditor({\n         *    features: ({ rootFeatures }) => [...rootFeatures, FixedToolbarFeature()],\n         *  })\n         *  ```\n         */\n        rootFeatures: FeatureProviderServer<any, any, any>[]\n      }) => FeatureProviderServer<any, any, any>[])\n    | FeatureProviderServer<any, any, any>[]\n  lexical?: LexicalEditorConfig\n}\n\nexport type LexicalRichTextAdapter = {\n  editorConfig: SanitizedServerEditorConfig\n  features: FeatureProviderServer<any, any, any>[]\n} & RichTextAdapter<SerializedEditorState, AdapterProps, any>\n\nexport type LexicalRichTextAdapterProvider =\n  /**\n   * This is being called during the payload sanitization process\n   */\n  ({\n    config,\n    isRoot,\n  }: {\n    config: SanitizedConfig\n    isRoot?: boolean\n  }) => Promise<LexicalRichTextAdapter>\n\nexport type FieldProps = {\n  fieldTypes: FieldTypes\n  indexPath: string\n  path?: string\n  permissions: FieldPermissions\n} & RichTextFieldProps<SerializedEditorState, AdapterProps, AdapterProps>\n\nexport type AdapterProps = {\n  editorConfig: SanitizedServerEditorConfig\n}\n\nexport type GeneratedFeatureProviderComponent = {\n  ClientFeature: React.ReactNode\n  key: string\n  order: number\n}\n"],"names":[],"mappings":"AAqFA,WAIC"}
+{"version":3,"file":"types.js","names":[],"sources":["../src/types.ts"],"sourcesContent":["import type { EditorConfig as LexicalEditorConfig, SerializedEditorState } from 'lexical'\nimport type { RichTextAdapter, RichTextFieldClientProps, SanitizedConfig } from 'payload'\n\nimport type {\n  BaseClientFeatureProps,\n  FeatureProviderProviderClient,\n} from './features/typesClient.js'\nimport type { FeatureProviderServer } from './features/typesServer.js'\nimport type { SanitizedServerEditorConfig } from './lexical/config/types.js'\n\nexport type LexicalFieldAdminProps = {\n  /**\n   * Controls if the gutter (padding to the left & gray vertical line) should be hidden. @default false\n   */\n  hideGutter?: boolean\n}\n\nexport type LexicalEditorProps = {\n  admin?: LexicalFieldAdminProps\n  features?:\n    | (({\n        defaultFeatures,\n        rootFeatures,\n      }: {\n        /**\n         * This opinionated array contains all \"recommended\" default features.\n         *\n         * @Example\n         *\n         * ```ts\n         *  editor: lexicalEditor({\n         *    features: ({ defaultFeatures }) => [...defaultFeatures, FixedToolbarFeature()],\n         *  })\n         *  ```\n         */\n        defaultFeatures: FeatureProviderServer<any, any, any>[]\n        /**\n         * This array contains all features that are enabled in the root richText editor (the one defined in the payload.config.ts).\n         * If this field is the root richText editor, or if the root richText editor is not a lexical editor, this array will be empty.\n         *\n         * @Example\n         *\n         * ```ts\n         *  editor: lexicalEditor({\n         *    features: ({ rootFeatures }) => [...rootFeatures, FixedToolbarFeature()],\n         *  })\n         *  ```\n         */\n        rootFeatures: FeatureProviderServer<any, any, any>[]\n      }) => FeatureProviderServer<any, any, any>[])\n    | FeatureProviderServer<any, any, any>[]\n  lexical?: LexicalEditorConfig\n}\n\nexport type LexicalRichTextAdapter = {\n  editorConfig: SanitizedServerEditorConfig\n  features: FeatureProviderServer<any, any, any>[]\n} & RichTextAdapter<SerializedEditorState, AdapterProps>\n\nexport type LexicalRichTextAdapterProvider =\n  /**\n   * This is being called during the payload sanitization process\n   */\n  ({\n    config,\n    isRoot,\n    parentIsLocalized,\n  }: {\n    config: SanitizedConfig\n    isRoot?: boolean\n    parentIsLocalized: boolean\n  }) => Promise<LexicalRichTextAdapter>\n\nexport type LexicalRichTextFieldProps = {\n  admin: LexicalFieldAdminProps\n  lexicalEditorConfig: LexicalEditorConfig\n} & RichTextFieldClientProps<SerializedEditorState, AdapterProps, object>\n\nexport type AdapterProps = {\n  editorConfig: SanitizedServerEditorConfig\n}\n\nexport type GeneratedFeatureProviderComponent = {\n  clientFeature: FeatureProviderProviderClient<any, any>\n  clientFeatureProps: BaseClientFeatureProps<object>\n}\n"],"mappings":"AAkFA","ignoreList":[]}

package/dist/utilities/createClientFeature.d.ts

@@ -1,13 +1,11 @@
-import type React from 'react';
-import type { ClientComponentProps, ClientFeature, ClientFeatureProviderMap, ResolvedClientFeatureMap } from '../features/typesClient.js';
+import type { BaseClientFeatureProps, ClientFeature, ClientFeatureProviderMap, FeatureProviderProviderClient, ResolvedClientFeatureMap } from '../features/typesClient.js';
 import type { ClientEditorConfig } from '../lexical/config/types.js';
 export type CreateClientFeatureArgs<UnSanitizedClientProps, ClientProps> = ((props: {
-    clientFunctions: Record<string, any>;
     /** unSanitizedEditorConfig.features, but mapped */
     featureProviderMap: ClientFeatureProviderMap;
-    props: ClientComponentProps<UnSanitizedClientProps>;
+    props: BaseClientFeatureProps<UnSanitizedClientProps>;
     resolvedFeatures: ResolvedClientFeatureMap;
     unSanitizedEditorConfig: ClientEditorConfig;
 }) => ClientFeature<ClientProps>) | Omit<ClientFeature<ClientProps>, 'sanitizedClientFeatureProps'>;
-export declare const createClientFeature: <UnSanitizedClientProps = undefined, ClientProps = UnSanitizedClientProps>(args: CreateClientFeatureArgs<UnSanitizedClientProps, ClientProps>) => React.FC<ClientComponentProps<ClientProps>>;
+export declare const createClientFeature: <UnSanitizedClientProps = undefined, ClientProps = UnSanitizedClientProps>(args: CreateClientFeatureArgs<UnSanitizedClientProps, ClientProps>) => FeatureProviderProviderClient<UnSanitizedClientProps, ClientProps>;
 //# sourceMappingURL=createClientFeature.d.ts.map

package/dist/utilities/createClientFeature.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createClientFeature.d.ts","sourceRoot":"","sources":["../../src/utilities/createClientFeature.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,KAAK,EACV,oBAAoB,EACpB,aAAa,EACb,wBAAwB,EAGxB,wBAAwB,EACzB,MAAM,4BAA4B,CAAA;AACnC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAA;AAIpE,MAAM,MAAM,uBAAuB,CAAC,sBAAsB,EAAE,WAAW,IACnE,CAAC,CAAC,KAAK,EAAE;IACP,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IACpC,mDAAmD;IACnD,kBAAkB,EAAE,wBAAwB,CAAA;IAC5C,KAAK,EAAE,oBAAoB,CAAC,sBAAsB,CAAC,CAAA;IAEnD,gBAAgB,EAAE,wBAAwB,CAAA;IAE1C,uBAAuB,EAAE,kBAAkB,CAAA;CAC5C,KAAK,aAAa,CAAC,WAAW,CAAC,CAAC,GACjC,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,EAAE,6BAA6B,CAAC,CAAA;AAEnE,eAAO,MAAM,mBAAmB,EAAE,CAChC,sBAAsB,GAAG,SAAS,EAClC,WAAW,GAAG,sBAAsB,EAEpC,IAAI,EAAE,uBAAuB,CAAC,sBAAsB,EAAE,WAAW,CAAC,KAC/D,KAAK,CAAC,EAAE,CAAC,oBAAoB,CAAC,WAAW,CAAC,CAmC9C,CAAA"}
+{"version":3,"file":"createClientFeature.d.ts","sourceRoot":"","sources":["../../src/utilities/createClientFeature.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,sBAAsB,EACtB,aAAa,EACb,wBAAwB,EAExB,6BAA6B,EAC7B,wBAAwB,EACzB,MAAM,4BAA4B,CAAA;AACnC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAA;AAEpE,MAAM,MAAM,uBAAuB,CAAC,sBAAsB,EAAE,WAAW,IACnE,CAAC,CAAC,KAAK,EAAE;IACP,mDAAmD;IACnD,kBAAkB,EAAE,wBAAwB,CAAA;IAC5C,KAAK,EAAE,sBAAsB,CAAC,sBAAsB,CAAC,CAAA;IAErD,gBAAgB,EAAE,wBAAwB,CAAA;IAE1C,uBAAuB,EAAE,kBAAkB,CAAA;CAC5C,KAAK,aAAa,CAAC,WAAW,CAAC,CAAC,GACjC,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,EAAE,6BAA6B,CAAC,CAAA;AAEnE,eAAO,MAAM,mBAAmB,EAAE,CAChC,sBAAsB,GAAG,SAAS,EAClC,WAAW,GAAG,sBAAsB,EAEpC,IAAI,EAAE,uBAAuB,CAAC,sBAAsB,EAAE,WAAW,CAAC,KAC/D,6BAA6B,CAAC,sBAAsB,EAAE,WAAW,CAyCrE,CAAA"}

package/dist/utilities/createClientFeature.js

@@ -1,30 +1,41 @@
-import { createClientComponent } from '../features/createClientComponent.js';
-export const createClientFeature = (feature)=>{
-    const featureProviderProvideClient = (props)=>{
-        const featureProviderClient = {
-            clientFeatureProps: props
-        };
-        if (typeof feature === 'function') {
-            featureProviderClient.feature = ({ clientFunctions, featureProviderMap, resolvedFeatures, unSanitizedEditorConfig })=>{
-                const toReturn = feature({
-                    clientFunctions,
-                    featureProviderMap,
-                    props,
-                    resolvedFeatures,
-                    unSanitizedEditorConfig
-                });
-                if (toReturn.sanitizedClientFeatureProps === null) {
-                    toReturn.sanitizedClientFeatureProps = props;
-                }
-                return toReturn;
-            };
-        } else {
-            feature.sanitizedClientFeatureProps = props;
-            featureProviderClient.feature = feature;
-        }
-        return featureProviderClient;
+export const createClientFeature = feature => {
+  const featureProviderProvideClient = props => {
+    const featureProviderClient = {
+      clientFeatureProps: props
     };
-    return createClientComponent(featureProviderProvideClient);
+    if (typeof feature === 'function') {
+      featureProviderClient.feature = ({
+        featureProviderMap,
+        resolvedFeatures,
+        unSanitizedEditorConfig
+      }) => {
+        const toReturn = feature({
+          featureProviderMap,
+          props,
+          resolvedFeatures,
+          unSanitizedEditorConfig
+        });
+        if (toReturn.sanitizedClientFeatureProps === null) {
+          toReturn.sanitizedClientFeatureProps = props;
+        }
+        return toReturn;
+      };
+    } else {
+      // We have to spread feature here! Otherwise, if the arg of createClientFeature is not a function, and 2
+      // richText editors have the same feature (even if both call it, e.g. both call UploadFeature()),
+      // the second richText editor here will override sanitizedClientFeatureProps of the first feature, as both richText
+      // editor features share the same reference to the feature object.
+      // Example: richText editor 1 and 2 both have UploadFeature. richText editor 1 calls UploadFeature() with custom fields,
+      // richText editor 2 calls UploadFeature() with NO custom fields. If we don't spread feature here, richText editor 1
+      // will not have any custom fields, as richText editor 2 will override the feature object.
+      const newFeature = {
+        ...feature
+      };
+      newFeature.sanitizedClientFeatureProps = props;
+      featureProviderClient.feature = newFeature;
+    }
+    return featureProviderClient;
+  };
+  return featureProviderProvideClient;
 };
-
 //# sourceMappingURL=createClientFeature.js.map

package/dist/utilities/createClientFeature.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utilities/createClientFeature.ts"],"sourcesContent":["import type React from 'react'\n\nimport type {\n  ClientComponentProps,\n  ClientFeature,\n  ClientFeatureProviderMap,\n  FeatureProviderClient,\n  FeatureProviderProviderClient,\n  ResolvedClientFeatureMap,\n} from '../features/typesClient.js'\nimport type { ClientEditorConfig } from '../lexical/config/types.js'\n\nimport { createClientComponent } from '../features/createClientComponent.js'\n\nexport type CreateClientFeatureArgs<UnSanitizedClientProps, ClientProps> =\n  | ((props: {\n      clientFunctions: Record<string, any>\n      /** unSanitizedEditorConfig.features, but mapped */\n      featureProviderMap: ClientFeatureProviderMap\n      props: ClientComponentProps<UnSanitizedClientProps>\n      // other resolved features, which have been loaded before this one. All features declared in 'dependencies' should be available here\n      resolvedFeatures: ResolvedClientFeatureMap\n      // unSanitized EditorConfig,\n      unSanitizedEditorConfig: ClientEditorConfig\n    }) => ClientFeature<ClientProps>)\n  | Omit<ClientFeature<ClientProps>, 'sanitizedClientFeatureProps'>\n\nexport const createClientFeature: <\n  UnSanitizedClientProps = undefined,\n  ClientProps = UnSanitizedClientProps,\n>(\n  args: CreateClientFeatureArgs<UnSanitizedClientProps, ClientProps>,\n) => React.FC<ClientComponentProps<ClientProps>> = (feature) => {\n  const featureProviderProvideClient: FeatureProviderProviderClient<any, any> = (props) => {\n    const featureProviderClient: Partial<FeatureProviderClient<any, any>> = {\n      clientFeatureProps: props,\n    }\n\n    if (typeof feature === 'function') {\n      featureProviderClient.feature = ({\n        clientFunctions,\n        featureProviderMap,\n        resolvedFeatures,\n        unSanitizedEditorConfig,\n      }) => {\n        const toReturn = feature({\n          clientFunctions,\n          featureProviderMap,\n          props,\n          resolvedFeatures,\n          unSanitizedEditorConfig,\n        })\n\n        if (toReturn.sanitizedClientFeatureProps === null) {\n          toReturn.sanitizedClientFeatureProps = props\n        }\n\n        return toReturn\n      }\n    } else {\n      ;(feature as ClientFeature<any>).sanitizedClientFeatureProps = props\n      featureProviderClient.feature = feature as ClientFeature<any>\n    }\n    return featureProviderClient as FeatureProviderClient<any, any>\n  }\n\n  return createClientComponent(featureProviderProvideClient)\n}\n"],"names":["createClientComponent","createClientFeature","feature","featureProviderProvideClient","props","featureProviderClient","clientFeatureProps","clientFunctions","featureProviderMap","resolvedFeatures","unSanitizedEditorConfig","toReturn","sanitizedClientFeatureProps"],"mappings":"AAYA,SAASA,qBAAqB,QAAQ,uCAAsC;AAe5E,OAAO,MAAMC,sBAKsC,CAACC;IAClD,MAAMC,+BAAwE,CAACC;QAC7E,MAAMC,wBAAkE;YACtEC,oBAAoBF;QACtB;QAEA,IAAI,OAAOF,YAAY,YAAY;YACjCG,sBAAsBH,OAAO,GAAG,CAAC,EAC/BK,eAAe,EACfC,kBAAkB,EAClBC,gBAAgB,EAChBC,uBAAuB,EACxB;gBACC,MAAMC,WAAWT,QAAQ;oBACvBK;oBACAC;oBACAJ;oBACAK;oBACAC;gBACF;gBAEA,IAAIC,SAASC,2BAA2B,KAAK,MAAM;oBACjDD,SAASC,2BAA2B,GAAGR;gBACzC;gBAEA,OAAOO;YACT;QACF,OAAO;YACHT,QAA+BU,2BAA2B,GAAGR;YAC/DC,sBAAsBH,OAAO,GAAGA;QAClC;QACA,OAAOG;IACT;IAEA,OAAOL,sBAAsBG;AAC/B,EAAC"}
+{"version":3,"file":"createClientFeature.js","names":["createClientFeature","feature","featureProviderProvideClient","props","featureProviderClient","clientFeatureProps","featureProviderMap","resolvedFeatures","unSanitizedEditorConfig","toReturn","sanitizedClientFeatureProps","newFeature"],"sources":["../../src/utilities/createClientFeature.ts"],"sourcesContent":["import type {\n  BaseClientFeatureProps,\n  ClientFeature,\n  ClientFeatureProviderMap,\n  FeatureProviderClient,\n  FeatureProviderProviderClient,\n  ResolvedClientFeatureMap,\n} from '../features/typesClient.js'\nimport type { ClientEditorConfig } from '../lexical/config/types.js'\n\nexport type CreateClientFeatureArgs<UnSanitizedClientProps, ClientProps> =\n  | ((props: {\n      /** unSanitizedEditorConfig.features, but mapped */\n      featureProviderMap: ClientFeatureProviderMap\n      props: BaseClientFeatureProps<UnSanitizedClientProps>\n      // other resolved features, which have been loaded before this one. All features declared in 'dependencies' should be available here\n      resolvedFeatures: ResolvedClientFeatureMap\n      // unSanitized EditorConfig,\n      unSanitizedEditorConfig: ClientEditorConfig\n    }) => ClientFeature<ClientProps>)\n  | Omit<ClientFeature<ClientProps>, 'sanitizedClientFeatureProps'>\n\nexport const createClientFeature: <\n  UnSanitizedClientProps = undefined,\n  ClientProps = UnSanitizedClientProps,\n>(\n  args: CreateClientFeatureArgs<UnSanitizedClientProps, ClientProps>,\n) => FeatureProviderProviderClient<UnSanitizedClientProps, ClientProps> = (feature) => {\n  const featureProviderProvideClient: FeatureProviderProviderClient<any, any> = (props) => {\n    const featureProviderClient: Partial<FeatureProviderClient<any, any>> = {\n      clientFeatureProps: props,\n    }\n\n    if (typeof feature === 'function') {\n      featureProviderClient.feature = ({\n        featureProviderMap,\n        resolvedFeatures,\n        unSanitizedEditorConfig,\n      }) => {\n        const toReturn = feature({\n          featureProviderMap,\n          props,\n          resolvedFeatures,\n          unSanitizedEditorConfig,\n        })\n\n        if (toReturn.sanitizedClientFeatureProps === null) {\n          toReturn.sanitizedClientFeatureProps = props\n        }\n\n        return toReturn\n      }\n    } else {\n      // We have to spread feature here! Otherwise, if the arg of createClientFeature is not a function, and 2\n      // richText editors have the same feature (even if both call it, e.g. both call UploadFeature()),\n      // the second richText editor here will override sanitizedClientFeatureProps of the first feature, as both richText\n      // editor features share the same reference to the feature object.\n      // Example: richText editor 1 and 2 both have UploadFeature. richText editor 1 calls UploadFeature() with custom fields,\n      // richText editor 2 calls UploadFeature() with NO custom fields. If we don't spread feature here, richText editor 1\n      // will not have any custom fields, as richText editor 2 will override the feature object.\n      const newFeature: ClientFeature<any> = { ...feature }\n      newFeature.sanitizedClientFeatureProps = props\n      featureProviderClient.feature = newFeature\n    }\n    return featureProviderClient as FeatureProviderClient<any, any>\n  }\n\n  return featureProviderProvideClient\n}\n"],"mappings":"AAsBA,OAAO,MAAMA,mBAAA,GAK8DC,OAAA;EACzE,MAAMC,4BAAA,GAAyEC,KAAA;IAC7E,MAAMC,qBAAA,GAAkE;MACtEC,kBAAA,EAAoBF;IACtB;IAEA,IAAI,OAAOF,OAAA,KAAY,YAAY;MACjCG,qBAAA,CAAsBH,OAAO,GAAG,CAAC;QAC/BK,kBAAkB;QAClBC,gBAAgB;QAChBC;MAAuB,CACxB;QACC,MAAMC,QAAA,GAAWR,OAAA,CAAQ;UACvBK,kBAAA;UACAH,KAAA;UACAI,gBAAA;UACAC;QACF;QAEA,IAAIC,QAAA,CAASC,2BAA2B,KAAK,MAAM;UACjDD,QAAA,CAASC,2BAA2B,GAAGP,KAAA;QACzC;QAEA,OAAOM,QAAA;MACT;IACF,OAAO;MACL;MACA;MACA;MACA;MACA;MACA;MACA;MACA,MAAME,UAAA,GAAiC;QAAE,GAAGV;MAAQ;MACpDU,UAAA,CAAWD,2BAA2B,GAAGP,KAAA;MACzCC,qBAAA,CAAsBH,OAAO,GAAGU,UAAA;IAClC;IACA,OAAOP,qBAAA;EACT;EAEA,OAAOF,4BAAA;AACT","ignoreList":[]}

package/dist/utilities/createServerFeature.d.ts

@@ -7,6 +7,7 @@ export type CreateServerFeatureArgs<UnSanitizedProps, SanitizedProps, ClientProp
         /** unSanitizedEditorConfig.features, but mapped */
         featureProviderMap: ServerFeatureProviderMap;
         isRoot?: boolean;
+        parentIsLocalized: boolean;
         props: UnSanitizedProps;
         resolvedFeatures: ResolvedServerFeatureMap;
         unSanitizedEditorConfig: ServerEditorConfig;

package/dist/utilities/createServerFeature.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createServerFeature.d.ts","sourceRoot":"","sources":["../../src/utilities/createServerFeature.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAE9C,OAAO,KAAK,EACV,6BAA6B,EAC7B,qBAAqB,EACrB,wBAAwB,EACxB,aAAa,EACb,wBAAwB,EACzB,MAAM,4BAA4B,CAAA;AACnC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAA;AAEpE,MAAM,MAAM,uBAAuB,CAAC,gBAAgB,EAAE,cAAc,EAAE,WAAW,IAAI;IACnF,OAAO,EACH,CAAC,CAAC,KAAK,EAAE;QACP,MAAM,EAAE,eAAe,CAAA;QACvB,mDAAmD;QACnD,kBAAkB,EAAE,wBAAwB,CAAA;QAC5C,MAAM,CAAC,EAAE,OAAO,CAAA;QAChB,KAAK,EAAE,gBAAgB,CAAA;QAEvB,gBAAgB,EAAE,wBAAwB,CAAA;QAE1C,uBAAuB,EAAE,kBAAkB,CAAA;KAC5C,KACG,OAAO,CAAC,aAAa,CAAC,cAAc,EAAE,WAAW,CAAC,CAAC,GACnD,aAAa,CAAC,cAAc,EAAE,WAAW,CAAC,CAAC,GAC/C,IAAI,CAAC,aAAa,CAAC,cAAc,EAAE,WAAW,CAAC,EAAE,6BAA6B,CAAC,CAAA;CACpF,GAAG,IAAI,CACN,qBAAqB,CAAC,gBAAgB,EAAE,WAAW,CAAC,EACpD,cAAc,GAAG,sBAAsB,GAAG,kBAAkB,GAAG,KAAK,CACrE,CAAA;AAED,eAAO,MAAM,mBAAmB,EAAE,CAChC,gBAAgB,GAAG,SAAS,EAC5B,cAAc,GAAG,gBAAgB,EACjC,WAAW,GAAG,SAAS,EAEvB,IAAI,EAAE,uBAAuB,CAAC,gBAAgB,EAAE,cAAc,EAAE,WAAW,CAAC,KACzE,6BAA6B,CAAC,gBAAgB,EAAE,cAAc,EAAE,WAAW,CA8C/E,CAAA"}
+{"version":3,"file":"createServerFeature.d.ts","sourceRoot":"","sources":["../../src/utilities/createServerFeature.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAE9C,OAAO,KAAK,EACV,6BAA6B,EAC7B,qBAAqB,EACrB,wBAAwB,EACxB,aAAa,EACb,wBAAwB,EACzB,MAAM,4BAA4B,CAAA;AACnC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAA;AAEpE,MAAM,MAAM,uBAAuB,CAAC,gBAAgB,EAAE,cAAc,EAAE,WAAW,IAAI;IACnF,OAAO,EACH,CAAC,CAAC,KAAK,EAAE;QACP,MAAM,EAAE,eAAe,CAAA;QACvB,mDAAmD;QACnD,kBAAkB,EAAE,wBAAwB,CAAA;QAC5C,MAAM,CAAC,EAAE,OAAO,CAAA;QAChB,iBAAiB,EAAE,OAAO,CAAA;QAC1B,KAAK,EAAE,gBAAgB,CAAA;QAEvB,gBAAgB,EAAE,wBAAwB,CAAA;QAE1C,uBAAuB,EAAE,kBAAkB,CAAA;KAC5C,KACG,OAAO,CAAC,aAAa,CAAC,cAAc,EAAE,WAAW,CAAC,CAAC,GACnD,aAAa,CAAC,cAAc,EAAE,WAAW,CAAC,CAAC,GAC/C,IAAI,CAAC,aAAa,CAAC,cAAc,EAAE,WAAW,CAAC,EAAE,6BAA6B,CAAC,CAAA;CACpF,GAAG,IAAI,CACN,qBAAqB,CAAC,gBAAgB,EAAE,WAAW,CAAC,EACpD,cAAc,GAAG,sBAAsB,GAAG,kBAAkB,GAAG,KAAK,CACrE,CAAA;AAED,eAAO,MAAM,mBAAmB,EAAE,CAChC,gBAAgB,GAAG,SAAS,EAC5B,cAAc,GAAG,gBAAgB,EACjC,WAAW,GAAG,SAAS,EAEvB,IAAI,EAAE,uBAAuB,CAAC,gBAAgB,EAAE,cAAc,EAAE,WAAW,CAAC,KACzE,6BAA6B,CAAC,gBAAgB,EAAE,cAAc,EAAE,WAAW,CAmD/E,CAAA"}

package/dist/utilities/createServerFeature.js

@@ -1,34 +1,51 @@
-export const createServerFeature = ({ dependencies, dependenciesPriority, dependenciesSoft, feature, key })=>{
-    const featureProviderProviderServer = (props)=>{
-        const featureProviderServer = {
-            dependencies,
-            dependenciesPriority,
-            dependenciesSoft,
-            key,
-            serverFeatureProps: props
-        };
-        if (typeof feature === 'function') {
-            featureProviderServer.feature = async ({ config, featureProviderMap, isRoot, resolvedFeatures, unSanitizedEditorConfig })=>{
-                const toReturn = await feature({
-                    config,
-                    featureProviderMap,
-                    isRoot,
-                    props,
-                    resolvedFeatures,
-                    unSanitizedEditorConfig
-                });
-                if (toReturn.sanitizedServerFeatureProps === null) {
-                    toReturn.sanitizedServerFeatureProps = props;
-                }
-                return toReturn;
-            };
-        } else {
-            feature.sanitizedServerFeatureProps = props;
-            featureProviderServer.feature = feature;
-        }
-        return featureProviderServer;
+export const createServerFeature = ({
+  dependencies,
+  dependenciesPriority,
+  dependenciesSoft,
+  feature,
+  key
+}) => {
+  const featureProviderProviderServer = props => {
+    const featureProviderServer = {
+      dependencies,
+      dependenciesPriority,
+      dependenciesSoft,
+      key,
+      serverFeatureProps: props
     };
-    return featureProviderProviderServer;
+    if (typeof feature === 'function') {
+      featureProviderServer.feature = async ({
+        config,
+        featureProviderMap,
+        isRoot,
+        parentIsLocalized,
+        resolvedFeatures,
+        unSanitizedEditorConfig
+      }) => {
+        const toReturn = await feature({
+          config,
+          featureProviderMap,
+          isRoot,
+          parentIsLocalized,
+          props,
+          resolvedFeatures,
+          unSanitizedEditorConfig
+        });
+        if (toReturn.sanitizedServerFeatureProps === null) {
+          toReturn.sanitizedServerFeatureProps = props;
+        }
+        return toReturn;
+      };
+    } else {
+      // For explanation why we have to spread feature, see createClientFeature.ts
+      const newFeature = {
+        ...feature
+      };
+      newFeature.sanitizedServerFeatureProps = props;
+      featureProviderServer.feature = newFeature;
+    }
+    return featureProviderServer;
+  };
+  return featureProviderProviderServer;
 };
-
 //# sourceMappingURL=createServerFeature.js.map

package/dist/utilities/createServerFeature.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utilities/createServerFeature.ts"],"sourcesContent":["import type { SanitizedConfig } from 'payload'\n\nimport type {\n  FeatureProviderProviderServer,\n  FeatureProviderServer,\n  ResolvedServerFeatureMap,\n  ServerFeature,\n  ServerFeatureProviderMap,\n} from '../features/typesServer.js'\nimport type { ServerEditorConfig } from '../lexical/config/types.js'\n\nexport type CreateServerFeatureArgs<UnSanitizedProps, SanitizedProps, ClientProps> = {\n  feature:\n    | ((props: {\n        config: SanitizedConfig\n        /** unSanitizedEditorConfig.features, but mapped */\n        featureProviderMap: ServerFeatureProviderMap\n        isRoot?: boolean\n        props: UnSanitizedProps\n        // other resolved features, which have been loaded before this one. All features declared in 'dependencies' should be available here\n        resolvedFeatures: ResolvedServerFeatureMap\n        // unSanitized EditorConfig,\n        unSanitizedEditorConfig: ServerEditorConfig\n      }) =>\n        | Promise<ServerFeature<SanitizedProps, ClientProps>>\n        | ServerFeature<SanitizedProps, ClientProps>)\n    | Omit<ServerFeature<SanitizedProps, ClientProps>, 'sanitizedServerFeatureProps'>\n} & Pick<\n  FeatureProviderServer<UnSanitizedProps, ClientProps>,\n  'dependencies' | 'dependenciesPriority' | 'dependenciesSoft' | 'key'\n>\n\nexport const createServerFeature: <\n  UnSanitizedProps = undefined,\n  SanitizedProps = UnSanitizedProps,\n  ClientProps = undefined,\n>(\n  args: CreateServerFeatureArgs<UnSanitizedProps, SanitizedProps, ClientProps>,\n) => FeatureProviderProviderServer<UnSanitizedProps, SanitizedProps, ClientProps> = ({\n  dependencies,\n  dependenciesPriority,\n  dependenciesSoft,\n  feature,\n  key,\n}) => {\n  const featureProviderProviderServer: FeatureProviderProviderServer<any, any, any> = (props) => {\n    const featureProviderServer: Partial<FeatureProviderServer<any, any, any>> = {\n      dependencies,\n      dependenciesPriority,\n      dependenciesSoft,\n      key,\n      serverFeatureProps: props,\n    }\n\n    if (typeof feature === 'function') {\n      featureProviderServer.feature = async ({\n        config,\n        featureProviderMap,\n        isRoot,\n        resolvedFeatures,\n        unSanitizedEditorConfig,\n      }) => {\n        const toReturn = await feature({\n          config,\n          featureProviderMap,\n          isRoot,\n          props,\n          resolvedFeatures,\n          unSanitizedEditorConfig,\n        })\n\n        if (toReturn.sanitizedServerFeatureProps === null) {\n          toReturn.sanitizedServerFeatureProps = props\n        }\n        return toReturn\n      }\n    } else {\n      ;(feature as ServerFeature<any, any>).sanitizedServerFeatureProps = props\n      featureProviderServer.feature = feature as ServerFeature<any, any>\n    }\n    return featureProviderServer as FeatureProviderServer<any, any, any>\n  }\n\n  return featureProviderProviderServer\n}\n"],"names":["createServerFeature","dependencies","dependenciesPriority","dependenciesSoft","feature","key","featureProviderProviderServer","props","featureProviderServer","serverFeatureProps","config","featureProviderMap","isRoot","resolvedFeatures","unSanitizedEditorConfig","toReturn","sanitizedServerFeatureProps"],"mappings":"AAgCA,OAAO,MAAMA,sBAMuE,CAAC,EACnFC,YAAY,EACZC,oBAAoB,EACpBC,gBAAgB,EAChBC,OAAO,EACPC,GAAG,EACJ;IACC,MAAMC,gCAA8E,CAACC;QACnF,MAAMC,wBAAuE;YAC3EP;YACAC;YACAC;YACAE;YACAI,oBAAoBF;QACtB;QAEA,IAAI,OAAOH,YAAY,YAAY;YACjCI,sBAAsBJ,OAAO,GAAG,OAAO,EACrCM,MAAM,EACNC,kBAAkB,EAClBC,MAAM,EACNC,gBAAgB,EAChBC,uBAAuB,EACxB;gBACC,MAAMC,WAAW,MAAMX,QAAQ;oBAC7BM;oBACAC;oBACAC;oBACAL;oBACAM;oBACAC;gBACF;gBAEA,IAAIC,SAASC,2BAA2B,KAAK,MAAM;oBACjDD,SAASC,2BAA2B,GAAGT;gBACzC;gBACA,OAAOQ;YACT;QACF,OAAO;YACHX,QAAoCY,2BAA2B,GAAGT;YACpEC,sBAAsBJ,OAAO,GAAGA;QAClC;QACA,OAAOI;IACT;IAEA,OAAOF;AACT,EAAC"}
+{"version":3,"file":"createServerFeature.js","names":["createServerFeature","dependencies","dependenciesPriority","dependenciesSoft","feature","key","featureProviderProviderServer","props","featureProviderServer","serverFeatureProps","config","featureProviderMap","isRoot","parentIsLocalized","resolvedFeatures","unSanitizedEditorConfig","toReturn","sanitizedServerFeatureProps","newFeature"],"sources":["../../src/utilities/createServerFeature.ts"],"sourcesContent":["import type { SanitizedConfig } from 'payload'\n\nimport type {\n  FeatureProviderProviderServer,\n  FeatureProviderServer,\n  ResolvedServerFeatureMap,\n  ServerFeature,\n  ServerFeatureProviderMap,\n} from '../features/typesServer.js'\nimport type { ServerEditorConfig } from '../lexical/config/types.js'\n\nexport type CreateServerFeatureArgs<UnSanitizedProps, SanitizedProps, ClientProps> = {\n  feature:\n    | ((props: {\n        config: SanitizedConfig\n        /** unSanitizedEditorConfig.features, but mapped */\n        featureProviderMap: ServerFeatureProviderMap\n        isRoot?: boolean\n        parentIsLocalized: boolean\n        props: UnSanitizedProps\n        // other resolved features, which have been loaded before this one. All features declared in 'dependencies' should be available here\n        resolvedFeatures: ResolvedServerFeatureMap\n        // unSanitized EditorConfig,\n        unSanitizedEditorConfig: ServerEditorConfig\n      }) =>\n        | Promise<ServerFeature<SanitizedProps, ClientProps>>\n        | ServerFeature<SanitizedProps, ClientProps>)\n    | Omit<ServerFeature<SanitizedProps, ClientProps>, 'sanitizedServerFeatureProps'>\n} & Pick<\n  FeatureProviderServer<UnSanitizedProps, ClientProps>,\n  'dependencies' | 'dependenciesPriority' | 'dependenciesSoft' | 'key'\n>\n\nexport const createServerFeature: <\n  UnSanitizedProps = undefined,\n  SanitizedProps = UnSanitizedProps,\n  ClientProps = undefined,\n>(\n  args: CreateServerFeatureArgs<UnSanitizedProps, SanitizedProps, ClientProps>,\n) => FeatureProviderProviderServer<UnSanitizedProps, SanitizedProps, ClientProps> = ({\n  dependencies,\n  dependenciesPriority,\n  dependenciesSoft,\n  feature,\n  key,\n}) => {\n  const featureProviderProviderServer: FeatureProviderProviderServer<any, any, any> = (props) => {\n    const featureProviderServer: Partial<FeatureProviderServer<any, any, any>> = {\n      dependencies,\n      dependenciesPriority,\n      dependenciesSoft,\n      key,\n      serverFeatureProps: props,\n    }\n\n    if (typeof feature === 'function') {\n      featureProviderServer.feature = async ({\n        config,\n        featureProviderMap,\n        isRoot,\n        parentIsLocalized,\n        resolvedFeatures,\n        unSanitizedEditorConfig,\n      }) => {\n        const toReturn = await feature({\n          config,\n          featureProviderMap,\n          isRoot,\n          parentIsLocalized,\n          props,\n          resolvedFeatures,\n          unSanitizedEditorConfig,\n        })\n\n        if (toReturn.sanitizedServerFeatureProps === null) {\n          toReturn.sanitizedServerFeatureProps = props\n        }\n        return toReturn\n      }\n    } else {\n      // For explanation why we have to spread feature, see createClientFeature.ts\n      const newFeature: ServerFeature<any, any> = { ...feature }\n\n      newFeature.sanitizedServerFeatureProps = props\n      featureProviderServer.feature = newFeature\n    }\n    return featureProviderServer as FeatureProviderServer<any, any, any>\n  }\n\n  return featureProviderProviderServer\n}\n"],"mappings":"AAiCA,OAAO,MAAMA,mBAAA,GAMuEA,CAAC;EACnFC,YAAY;EACZC,oBAAoB;EACpBC,gBAAgB;EAChBC,OAAO;EACPC;AAAG,CACJ;EACC,MAAMC,6BAAA,GAA+EC,KAAA;IACnF,MAAMC,qBAAA,GAAuE;MAC3EP,YAAA;MACAC,oBAAA;MACAC,gBAAA;MACAE,GAAA;MACAI,kBAAA,EAAoBF;IACtB;IAEA,IAAI,OAAOH,OAAA,KAAY,YAAY;MACjCI,qBAAA,CAAsBJ,OAAO,GAAG,OAAO;QACrCM,MAAM;QACNC,kBAAkB;QAClBC,MAAM;QACNC,iBAAiB;QACjBC,gBAAgB;QAChBC;MAAuB,CACxB;QACC,MAAMC,QAAA,GAAW,MAAMZ,OAAA,CAAQ;UAC7BM,MAAA;UACAC,kBAAA;UACAC,MAAA;UACAC,iBAAA;UACAN,KAAA;UACAO,gBAAA;UACAC;QACF;QAEA,IAAIC,QAAA,CAASC,2BAA2B,KAAK,MAAM;UACjDD,QAAA,CAASC,2BAA2B,GAAGV,KAAA;QACzC;QACA,OAAOS,QAAA;MACT;IACF,OAAO;MACL;MACA,MAAME,UAAA,GAAsC;QAAE,GAAGd;MAAQ;MAEzDc,UAAA,CAAWD,2BAA2B,GAAGV,KAAA;MACzCC,qBAAA,CAAsBJ,OAAO,GAAGc,UAAA;IAClC;IACA,OAAOV,qBAAA;EACT;EAEA,OAAOF,6BAAA;AACT","ignoreList":[]}

package/dist/utilities/fieldsDrawer/Drawer.d.ts

@@ -1,13 +1,15 @@
-import type { Data, FormState, JsonObject } from 'payload';
+import type { ClientField, Data, FormState, JsonObject } from 'payload';
 import React from 'react';
 export type FieldsDrawerProps = {
-    className?: string;
-    data?: Data;
-    drawerSlug: string;
-    drawerTitle?: string;
-    featureKey: string;
-    handleDrawerSubmit: (fields: FormState, data: JsonObject) => void;
-    schemaPathSuffix?: string;
+    readonly className?: string;
+    readonly data?: Data;
+    readonly drawerSlug: string;
+    readonly drawerTitle?: string;
+    readonly featureKey: string;
+    readonly fieldMapOverride?: ClientField[];
+    readonly handleDrawerSubmit: (fields: FormState, data: JsonObject) => void;
+    readonly schemaFieldsPathOverride?: string;
+    readonly schemaPathSuffix?: string;
 };
 /**
  * This FieldsDrawer component can be used to easily create a Drawer that contains a form with fields within your feature.

package/dist/utilities/fieldsDrawer/Drawer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Drawer.d.ts","sourceRoot":"","sources":["../../../src/utilities/fieldsDrawer/Drawer.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAG1D,OAAO,KAAK,MAAM,OAAO,CAAA;AAIzB,MAAM,MAAM,iBAAiB,GAAG;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,IAAI,CAAC,EAAE,IAAI,CAAA;IACX,UAAU,EAAE,MAAM,CAAA;IAClB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,UAAU,EAAE,MAAM,CAAA;IAClB,kBAAkB,EAAE,CAAC,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,UAAU,KAAK,IAAI,CAAA;IACjE,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAC1B,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC,iBAAiB,CAqBpD,CAAA"}
+{"version":3,"file":"Drawer.d.ts","sourceRoot":"","sources":["../../../src/utilities/fieldsDrawer/Drawer.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAGvE,OAAO,KAAK,MAAM,OAAO,CAAA;AAIzB,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,CAAA;IACpB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,gBAAgB,CAAC,EAAE,WAAW,EAAE,CAAA;IACzC,QAAQ,CAAC,kBAAkB,EAAE,CAAC,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,UAAU,KAAK,IAAI,CAAA;IAC1E,QAAQ,CAAC,wBAAwB,CAAC,EAAE,MAAM,CAAA;IAC1C,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;CACnC,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC,iBAAiB,CAyBpD,CAAA"}

package/dist/utilities/fieldsDrawer/Drawer.js

@@ -1,4 +1,5 @@
 'use client';
+
 import { jsx as _jsx } from "react/jsx-runtime";
 import { Drawer } from '@payloadcms/ui';
 import React from 'react';
@@ -7,20 +8,32 @@ import { DrawerContent } from './DrawerContent.js';
  * This FieldsDrawer component can be used to easily create a Drawer that contains a form with fields within your feature.
  * The fields are taken directly from the schema map based on your `featureKey` and `schemaPathSuffix`. Thus, this can only
  * be used if you provide your field schema inside the `generateSchemaMap` prop of your feature.server.ts.
- */ export const FieldsDrawer = ({ className, data, drawerSlug, drawerTitle, featureKey, handleDrawerSubmit, schemaPathSuffix })=>{
-    // The Drawer only renders its children (and itself) if it's open. Thus, by extracting the main content
-    // to DrawerContent, this should be faster
-    return /*#__PURE__*/ _jsx(Drawer, {
-        className: className,
-        slug: drawerSlug,
-        title: drawerTitle ?? '',
-        children: /*#__PURE__*/ _jsx(DrawerContent, {
-            data: data,
-            featureKey: featureKey,
-            handleDrawerSubmit: handleDrawerSubmit,
-            schemaPathSuffix: schemaPathSuffix
-        })
-    });
+ */
+export const FieldsDrawer = ({
+  className,
+  data,
+  drawerSlug,
+  drawerTitle,
+  featureKey,
+  fieldMapOverride,
+  handleDrawerSubmit,
+  schemaFieldsPathOverride,
+  schemaPathSuffix
+}) => {
+  // The Drawer only renders its children (and itself) if it's open. Thus, by extracting the main content
+  // to DrawerContent, this should be faster
+  return /*#__PURE__*/_jsx(Drawer, {
+    className: className,
+    slug: drawerSlug,
+    title: drawerTitle ?? '',
+    children: /*#__PURE__*/_jsx(DrawerContent, {
+      data: data,
+      featureKey: featureKey,
+      fieldMapOverride: fieldMapOverride,
+      handleDrawerSubmit: handleDrawerSubmit,
+      schemaFieldsPathOverride: schemaFieldsPathOverride,
+      schemaPathSuffix: schemaPathSuffix
+    })
+  });
 };
-
 //# sourceMappingURL=Drawer.js.map