@payloadcms/richtext-lexical 3.70.0 → 3.71.0-internal-debug.80dab4c

package/dist/utilities/applyBaseFilterToFields.js

@@ -5,93 +5,90 @@ import { combineWhereConstraints } from 'payload/shared';
  * collection-level filters like multi-tenant filtering.
  *
  * Based on the fix from PR #13229 for LinkFeature
- */
-export function applyBaseFilterToFields(fields, config) {
-  return fields.map(field => {
-    // Handle relationship fields
-    if (field.type === 'relationship') {
-      const relationshipField = field;
-      // Store the original filterOptions
-      const originalFilterOptions = relationshipField.filterOptions;
-      // Create new filterOptions that includes baseFilter
-      relationshipField.filterOptions = async args => {
-        const {
-          relationTo,
-          req,
-          user
-        } = args;
-        // Call original filterOptions if it exists
-        const originalResult = typeof originalFilterOptions === 'function' ? await originalFilterOptions(args) : originalFilterOptions ?? true;
-        // If original filter returns false, respect that
-        if (originalResult === false) {
-          return false;
+ */ export function applyBaseFilterToFields(fields, config) {
+    return fields.map((field)=>{
+        // Handle relationship fields
+        if (field.type === 'relationship') {
+            const relationshipField = field;
+            // Store the original filterOptions
+            const originalFilterOptions = relationshipField.filterOptions;
+            // Create new filterOptions that includes baseFilter
+            relationshipField.filterOptions = async (args)=>{
+                const { relationTo, req, user } = args;
+                // Call original filterOptions if it exists
+                const originalResult = typeof originalFilterOptions === 'function' ? await originalFilterOptions(args) : originalFilterOptions ?? true;
+                // If original filter returns false, respect that
+                if (originalResult === false) {
+                    return false;
+                }
+                // Get the collection's admin config
+                const admin = config.collections.find(({ slug })=>slug === relationTo)?.admin;
+                // Check if collection is hidden
+                const hidden = admin?.hidden;
+                if (typeof hidden === 'function' && hidden({
+                    user
+                })) {
+                    return false;
+                }
+                // Apply baseFilter (with backwards compatibility for baseListFilter)
+                const baseFilter = admin?.baseFilter ?? admin?.baseListFilter;
+                const baseFilterResult = await baseFilter?.({
+                    limit: 0,
+                    page: 1,
+                    req,
+                    sort: 'id'
+                });
+                // If no baseFilter, return original result
+                if (!baseFilterResult) {
+                    return originalResult;
+                }
+                // If original result is true, just return the baseFilter
+                if (originalResult === true) {
+                    return baseFilterResult;
+                }
+                // Combine original and baseFilter results
+                return combineWhereConstraints([
+                    originalResult,
+                    baseFilterResult
+                ], 'and');
+            };
+            return relationshipField;
         }
-        // Get the collection's admin config
-        const admin = config.collections.find(({
-          slug
-        }) => slug === relationTo)?.admin;
-        // Check if collection is hidden
-        const hidden = admin?.hidden;
-        if (typeof hidden === 'function' && hidden({
-          user
-        })) {
-          return false;
+        // Recursively process nested fields
+        if ('fields' in field && field.fields) {
+            return {
+                ...field,
+                fields: applyBaseFilterToFields(field.fields, config)
+            };
         }
-        // Apply baseFilter (with backwards compatibility for baseListFilter)
-        const baseFilter = admin?.baseFilter ?? admin?.baseListFilter;
-        const baseFilterResult = await baseFilter?.({
-          limit: 0,
-          page: 1,
-          req,
-          sort: 'id'
-        });
-        // If no baseFilter, return original result
-        if (!baseFilterResult) {
-          return originalResult;
+        // Handle tabs
+        if (field.type === 'tabs' && 'tabs' in field) {
+            return {
+                ...field,
+                tabs: field.tabs.map((tab)=>({
+                        ...tab,
+                        fields: applyBaseFilterToFields(tab.fields, config)
+                    }))
+            };
         }
-        // If original result is true, just return the baseFilter
-        if (originalResult === true) {
-          return baseFilterResult;
+        // Handle blocks
+        if (field.type === 'blocks') {
+            const blocks = field.blockReferences ?? field.blocks ?? [];
+            return {
+                ...field,
+                blocks: blocks.map((block)=>{
+                    if (typeof block === 'string') {
+                        return block;
+                    }
+                    return {
+                        ...block,
+                        fields: applyBaseFilterToFields(block.fields, config)
+                    };
+                })
+            };
         }
-        // Combine original and baseFilter results
-        return combineWhereConstraints([originalResult, baseFilterResult], 'and');
-      };
-      return relationshipField;
-    }
-    // Recursively process nested fields
-    if ('fields' in field && field.fields) {
-      return {
-        ...field,
-        fields: applyBaseFilterToFields(field.fields, config)
-      };
-    }
-    // Handle tabs
-    if (field.type === 'tabs' && 'tabs' in field) {
-      return {
-        ...field,
-        tabs: field.tabs.map(tab => ({
-          ...tab,
-          fields: applyBaseFilterToFields(tab.fields, config)
-        }))
-      };
-    }
-    // Handle blocks
-    if (field.type === 'blocks') {
-      const blocks = field.blockReferences ?? field.blocks ?? [];
-      return {
-        ...field,
-        blocks: blocks.map(block => {
-          if (typeof block === 'string') {
-            return block;
-          }
-          return {
-            ...block,
-            fields: applyBaseFilterToFields(block.fields, config)
-          };
-        })
-      };
-    }
-    return field;
-  });
+        return field;
+    });
 }
+
 //# sourceMappingURL=applyBaseFilterToFields.js.map

package/dist/utilities/applyBaseFilterToFields.js.map

@@ -1 +1 @@
-{"version":3,"file":"applyBaseFilterToFields.js","names":["combineWhereConstraints","applyBaseFilterToFields","fields","config","map","field","type","relationshipField","originalFilterOptions","filterOptions","args","relationTo","req","user","originalResult","admin","collections","find","slug","hidden","baseFilter","baseListFilter","baseFilterResult","limit","page","sort","tabs","tab","blocks","blockReferences","block"],"sources":["../../src/utilities/applyBaseFilterToFields.ts"],"sourcesContent":["import type { Block, Field, SanitizedConfig, TypedUser } from 'payload'\n\nimport { combineWhereConstraints } from 'payload/shared'\n\n/**\n * Recursively applies baseFilter from collection config to relationship fields\n * within blocks. This ensures that relationship drawers in blocks respect\n * collection-level filters like multi-tenant filtering.\n *\n * Based on the fix from PR #13229 for LinkFeature\n */\nexport function applyBaseFilterToFields(fields: Field[], config: SanitizedConfig): Field[] {\n  return fields.map((field) => {\n    // Handle relationship fields\n    if (field.type === 'relationship') {\n      const relationshipField = field\n\n      // Store the original filterOptions\n      const originalFilterOptions = relationshipField.filterOptions\n\n      // Create new filterOptions that includes baseFilter\n      relationshipField.filterOptions = async (args) => {\n        const { relationTo, req, user } = args\n\n        // Call original filterOptions if it exists\n        const originalResult =\n          typeof originalFilterOptions === 'function'\n            ? await originalFilterOptions(args)\n            : (originalFilterOptions ?? true)\n\n        // If original filter returns false, respect that\n        if (originalResult === false) {\n          return false\n        }\n\n        // Get the collection's admin config\n        const admin = config.collections.find(({ slug }) => slug === relationTo)?.admin\n\n        // Check if collection is hidden\n        const hidden = admin?.hidden\n        if (typeof hidden === 'function' && hidden({ user } as { user: TypedUser })) {\n          return false\n        }\n\n        // Apply baseFilter (with backwards compatibility for baseListFilter)\n        const baseFilter = admin?.baseFilter ?? admin?.baseListFilter\n        const baseFilterResult = await baseFilter?.({\n          limit: 0,\n          page: 1,\n          req,\n          sort: 'id',\n        })\n\n        // If no baseFilter, return original result\n        if (!baseFilterResult) {\n          return originalResult\n        }\n\n        // If original result is true, just return the baseFilter\n        if (originalResult === true) {\n          return baseFilterResult\n        }\n\n        // Combine original and baseFilter results\n        return combineWhereConstraints([originalResult, baseFilterResult], 'and')\n      }\n\n      return relationshipField\n    }\n\n    // Recursively process nested fields\n    if ('fields' in field && field.fields) {\n      return {\n        ...field,\n        fields: applyBaseFilterToFields(field.fields, config),\n      }\n    }\n\n    // Handle tabs\n    if (field.type === 'tabs' && 'tabs' in field) {\n      return {\n        ...field,\n        tabs: field.tabs.map((tab) => ({\n          ...tab,\n          fields: applyBaseFilterToFields(tab.fields, config),\n        })),\n      }\n    }\n\n    // Handle blocks\n    if (field.type === 'blocks') {\n      const blocks = (field.blockReferences ?? field.blocks ?? []) as Block[]\n      return {\n        ...field,\n        blocks: blocks.map((block) => {\n          if (typeof block === 'string') {\n            return block\n          }\n          return {\n            ...block,\n            fields: applyBaseFilterToFields(block.fields, config),\n          }\n        }),\n      }\n    }\n\n    return field\n  })\n}\n"],"mappings":"AAEA,SAASA,uBAAuB,QAAQ;AAExC;;;;;;;AAOA,OAAO,SAASC,wBAAwBC,MAAe,EAAEC,MAAuB;EAC9E,OAAOD,MAAA,CAAOE,GAAG,CAAEC,KAAA;IACjB;IACA,IAAIA,KAAA,CAAMC,IAAI,KAAK,gBAAgB;MACjC,MAAMC,iBAAA,GAAoBF,KAAA;MAE1B;MACA,MAAMG,qBAAA,GAAwBD,iBAAA,CAAkBE,aAAa;MAE7D;MACAF,iBAAA,CAAkBE,aAAa,GAAG,MAAOC,IAAA;QACvC,MAAM;UAAEC,UAAU;UAAEC,GAAG;UAAEC;QAAI,CAAE,GAAGH,IAAA;QAElC;QACA,MAAMI,cAAA,GACJ,OAAON,qBAAA,KAA0B,aAC7B,MAAMA,qBAAA,CAAsBE,IAAA,IAC3BF,qBAAA,IAAyB;QAEhC;QACA,IAAIM,cAAA,KAAmB,OAAO;UAC5B,OAAO;QACT;QAEA;QACA,MAAMC,KAAA,GAAQZ,MAAA,CAAOa,WAAW,CAACC,IAAI,CAAC,CAAC;UAAEC;QAAI,CAAE,KAAKA,IAAA,KAASP,UAAA,GAAaI,KAAA;QAE1E;QACA,MAAMI,MAAA,GAASJ,KAAA,EAAOI,MAAA;QACtB,IAAI,OAAOA,MAAA,KAAW,cAAcA,MAAA,CAAO;UAAEN;QAAK,IAA2B;UAC3E,OAAO;QACT;QAEA;QACA,MAAMO,UAAA,GAAaL,KAAA,EAAOK,UAAA,IAAcL,KAAA,EAAOM,cAAA;QAC/C,MAAMC,gBAAA,GAAmB,MAAMF,UAAA,GAAa;UAC1CG,KAAA,EAAO;UACPC,IAAA,EAAM;UACNZ,GAAA;UACAa,IAAA,EAAM;QACR;QAEA;QACA,IAAI,CAACH,gBAAA,EAAkB;UACrB,OAAOR,cAAA;QACT;QAEA;QACA,IAAIA,cAAA,KAAmB,MAAM;UAC3B,OAAOQ,gBAAA;QACT;QAEA;QACA,OAAOtB,uBAAA,CAAwB,CAACc,cAAA,EAAgBQ,gBAAA,CAAiB,EAAE;MACrE;MAEA,OAAOf,iBAAA;IACT;IAEA;IACA,IAAI,YAAYF,KAAA,IAASA,KAAA,CAAMH,MAAM,EAAE;MACrC,OAAO;QACL,GAAGG,KAAK;QACRH,MAAA,EAAQD,uBAAA,CAAwBI,KAAA,CAAMH,MAAM,EAAEC,MAAA;MAChD;IACF;IAEA;IACA,IAAIE,KAAA,CAAMC,IAAI,KAAK,UAAU,UAAUD,KAAA,EAAO;MAC5C,OAAO;QACL,GAAGA,KAAK;QACRqB,IAAA,EAAMrB,KAAA,CAAMqB,IAAI,CAACtB,GAAG,CAAEuB,GAAA,KAAS;UAC7B,GAAGA,GAAG;UACNzB,MAAA,EAAQD,uBAAA,CAAwB0B,GAAA,CAAIzB,MAAM,EAAEC,MAAA;QAC9C;MACF;IACF;IAEA;IACA,IAAIE,KAAA,CAAMC,IAAI,KAAK,UAAU;MAC3B,MAAMsB,MAAA,GAAUvB,KAAA,CAAMwB,eAAe,IAAIxB,KAAA,CAAMuB,MAAM,IAAI,EAAE;MAC3D,OAAO;QACL,GAAGvB,KAAK;QACRuB,MAAA,EAAQA,MAAA,CAAOxB,GAAG,CAAE0B,KAAA;UAClB,IAAI,OAAOA,KAAA,KAAU,UAAU;YAC7B,OAAOA,KAAA;UACT;UACA,OAAO;YACL,GAAGA,KAAK;YACR5B,MAAA,EAAQD,uBAAA,CAAwB6B,KAAA,CAAM5B,MAAM,EAAEC,MAAA;UAChD;QACF;MACF;IACF;IAEA,OAAOE,KAAA;EACT;AACF","ignoreList":[]}
+{"version":3,"sources":["../../src/utilities/applyBaseFilterToFields.ts"],"sourcesContent":["import type { Block, Field, SanitizedConfig, TypedUser } from 'payload'\n\nimport { combineWhereConstraints } from 'payload/shared'\n\n/**\n * Recursively applies baseFilter from collection config to relationship fields\n * within blocks. This ensures that relationship drawers in blocks respect\n * collection-level filters like multi-tenant filtering.\n *\n * Based on the fix from PR #13229 for LinkFeature\n */\nexport function applyBaseFilterToFields(fields: Field[], config: SanitizedConfig): Field[] {\n  return fields.map((field) => {\n    // Handle relationship fields\n    if (field.type === 'relationship') {\n      const relationshipField = field\n\n      // Store the original filterOptions\n      const originalFilterOptions = relationshipField.filterOptions\n\n      // Create new filterOptions that includes baseFilter\n      relationshipField.filterOptions = async (args) => {\n        const { relationTo, req, user } = args\n\n        // Call original filterOptions if it exists\n        const originalResult =\n          typeof originalFilterOptions === 'function'\n            ? await originalFilterOptions(args)\n            : (originalFilterOptions ?? true)\n\n        // If original filter returns false, respect that\n        if (originalResult === false) {\n          return false\n        }\n\n        // Get the collection's admin config\n        const admin = config.collections.find(({ slug }) => slug === relationTo)?.admin\n\n        // Check if collection is hidden\n        const hidden = admin?.hidden\n        if (typeof hidden === 'function' && hidden({ user } as { user: TypedUser })) {\n          return false\n        }\n\n        // Apply baseFilter (with backwards compatibility for baseListFilter)\n        const baseFilter = admin?.baseFilter ?? admin?.baseListFilter\n        const baseFilterResult = await baseFilter?.({\n          limit: 0,\n          page: 1,\n          req,\n          sort: 'id',\n        })\n\n        // If no baseFilter, return original result\n        if (!baseFilterResult) {\n          return originalResult\n        }\n\n        // If original result is true, just return the baseFilter\n        if (originalResult === true) {\n          return baseFilterResult\n        }\n\n        // Combine original and baseFilter results\n        return combineWhereConstraints([originalResult, baseFilterResult], 'and')\n      }\n\n      return relationshipField\n    }\n\n    // Recursively process nested fields\n    if ('fields' in field && field.fields) {\n      return {\n        ...field,\n        fields: applyBaseFilterToFields(field.fields, config),\n      }\n    }\n\n    // Handle tabs\n    if (field.type === 'tabs' && 'tabs' in field) {\n      return {\n        ...field,\n        tabs: field.tabs.map((tab) => ({\n          ...tab,\n          fields: applyBaseFilterToFields(tab.fields, config),\n        })),\n      }\n    }\n\n    // Handle blocks\n    if (field.type === 'blocks') {\n      const blocks = (field.blockReferences ?? field.blocks ?? []) as Block[]\n      return {\n        ...field,\n        blocks: blocks.map((block) => {\n          if (typeof block === 'string') {\n            return block\n          }\n          return {\n            ...block,\n            fields: applyBaseFilterToFields(block.fields, config),\n          }\n        }),\n      }\n    }\n\n    return field\n  })\n}\n"],"names":["combineWhereConstraints","applyBaseFilterToFields","fields","config","map","field","type","relationshipField","originalFilterOptions","filterOptions","args","relationTo","req","user","originalResult","admin","collections","find","slug","hidden","baseFilter","baseListFilter","baseFilterResult","limit","page","sort","tabs","tab","blocks","blockReferences","block"],"mappings":"AAEA,SAASA,uBAAuB,QAAQ,iBAAgB;AAExD;;;;;;CAMC,GACD,OAAO,SAASC,wBAAwBC,MAAe,EAAEC,MAAuB;IAC9E,OAAOD,OAAOE,GAAG,CAAC,CAACC;QACjB,6BAA6B;QAC7B,IAAIA,MAAMC,IAAI,KAAK,gBAAgB;YACjC,MAAMC,oBAAoBF;YAE1B,mCAAmC;YACnC,MAAMG,wBAAwBD,kBAAkBE,aAAa;YAE7D,oDAAoD;YACpDF,kBAAkBE,aAAa,GAAG,OAAOC;gBACvC,MAAM,EAAEC,UAAU,EAAEC,GAAG,EAAEC,IAAI,EAAE,GAAGH;gBAElC,2CAA2C;gBAC3C,MAAMI,iBACJ,OAAON,0BAA0B,aAC7B,MAAMA,sBAAsBE,QAC3BF,yBAAyB;gBAEhC,iDAAiD;gBACjD,IAAIM,mBAAmB,OAAO;oBAC5B,OAAO;gBACT;gBAEA,oCAAoC;gBACpC,MAAMC,QAAQZ,OAAOa,WAAW,CAACC,IAAI,CAAC,CAAC,EAAEC,IAAI,EAAE,GAAKA,SAASP,aAAaI;gBAE1E,gCAAgC;gBAChC,MAAMI,SAASJ,OAAOI;gBACtB,IAAI,OAAOA,WAAW,cAAcA,OAAO;oBAAEN;gBAAK,IAA2B;oBAC3E,OAAO;gBACT;gBAEA,qEAAqE;gBACrE,MAAMO,aAAaL,OAAOK,cAAcL,OAAOM;gBAC/C,MAAMC,mBAAmB,MAAMF,aAAa;oBAC1CG,OAAO;oBACPC,MAAM;oBACNZ;oBACAa,MAAM;gBACR;gBAEA,2CAA2C;gBAC3C,IAAI,CAACH,kBAAkB;oBACrB,OAAOR;gBACT;gBAEA,yDAAyD;gBACzD,IAAIA,mBAAmB,MAAM;oBAC3B,OAAOQ;gBACT;gBAEA,0CAA0C;gBAC1C,OAAOtB,wBAAwB;oBAACc;oBAAgBQ;iBAAiB,EAAE;YACrE;YAEA,OAAOf;QACT;QAEA,oCAAoC;QACpC,IAAI,YAAYF,SAASA,MAAMH,MAAM,EAAE;YACrC,OAAO;gBACL,GAAGG,KAAK;gBACRH,QAAQD,wBAAwBI,MAAMH,MAAM,EAAEC;YAChD;QACF;QAEA,cAAc;QACd,IAAIE,MAAMC,IAAI,KAAK,UAAU,UAAUD,OAAO;YAC5C,OAAO;gBACL,GAAGA,KAAK;gBACRqB,MAAMrB,MAAMqB,IAAI,CAACtB,GAAG,CAAC,CAACuB,MAAS,CAAA;wBAC7B,GAAGA,GAAG;wBACNzB,QAAQD,wBAAwB0B,IAAIzB,MAAM,EAAEC;oBAC9C,CAAA;YACF;QACF;QAEA,gBAAgB;QAChB,IAAIE,MAAMC,IAAI,KAAK,UAAU;YAC3B,MAAMsB,SAAUvB,MAAMwB,eAAe,IAAIxB,MAAMuB,MAAM,IAAI,EAAE;YAC3D,OAAO;gBACL,GAAGvB,KAAK;gBACRuB,QAAQA,OAAOxB,GAAG,CAAC,CAAC0B;oBAClB,IAAI,OAAOA,UAAU,UAAU;wBAC7B,OAAOA;oBACT;oBACA,OAAO;wBACL,GAAGA,KAAK;wBACR5B,QAAQD,wBAAwB6B,MAAM5B,MAAM,EAAEC;oBAChD;gBACF;YACF;QACF;QAEA,OAAOE;IACT;AACF"}

package/dist/utilities/buildEditorState.js

@@ -34,45 +34,44 @@
  *   ],
  * })
  * ```
- */export function buildEditorState({
-  nodes,
-  text
-}) {
-  const editorJSON = {
-    root: {
-      type: 'root',
-      children: [],
-      direction: 'ltr',
-      format: '',
-      indent: 0,
-      version: 1
+ */ export function buildEditorState({ nodes, text }) {
+    const editorJSON = {
+        root: {
+            type: 'root',
+            children: [],
+            direction: 'ltr',
+            format: '',
+            indent: 0,
+            version: 1
+        }
+    };
+    if (text) {
+        editorJSON.root.children.push({
+            type: 'paragraph',
+            children: [
+                {
+                    type: 'text',
+                    detail: 0,
+                    format: 0,
+                    mode: 'normal',
+                    style: '',
+                    text,
+                    version: 1
+                }
+            ],
+            direction: 'ltr',
+            format: '',
+            indent: 0,
+            textFormat: 0,
+            textStyle: '',
+            version: 1
+        });
     }
-  };
-  if (text) {
-    editorJSON.root.children.push({
-      type: 'paragraph',
-      children: [{
-        type: 'text',
-        detail: 0,
-        format: 0,
-        mode: 'normal',
-        style: '',
-        text,
-        version: 1
-      }],
-      direction: 'ltr',
-      format: '',
-      indent: 0,
-      textFormat: 0,
-      textStyle: '',
-      version: 1
-    });
-  }
-  if (nodes?.length) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    editorJSON.root.children.push(...nodes);
-  }
-  return editorJSON;
+    if (nodes?.length) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        editorJSON.root.children.push(...nodes);
+    }
+    return editorJSON;
 }
 /**
  *
@@ -80,6 +79,6 @@
  *
  * @experimental this API may change or be removed in a minor release
  * @internal
- */
-export const buildDefaultEditorState = buildEditorState;
+ */ export const buildDefaultEditorState = buildEditorState;
+
 //# sourceMappingURL=buildEditorState.js.map

package/dist/utilities/buildEditorState.js.map

@@ -1 +1 @@
-{"version":3,"file":"buildEditorState.js","names":["buildEditorState","nodes","text","editorJSON","root","type","children","direction","format","indent","version","push","detail","mode","style","textFormat","textStyle","length","buildDefaultEditorState"],"sources":["../../src/utilities/buildEditorState.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\n\nimport type { DefaultNodeTypes, DefaultTypedEditorState, TypedEditorState } from '../nodeTypes.js'\n\n/**\n * Helper to build lexical editor state JSON from text and/or nodes.\n *\n * @param nodes - The nodes to include in the editor state. If you pass the `text` argument, this will append your nodes after the first paragraph node.\n * @param text - The text content to include in the editor state. This will create a paragraph node with a text node for you and set that as the first node.\n * @returns The constructed editor state JSON.\n *\n * @example\n *\n * just passing text:\n *\n * ```ts\n * const editorState = buildEditorState<DefaultNodeTypes>({ text: 'Hello world' }) // result typed as DefaultTypedEditorState\n * ```\n *\n * @example\n *\n * passing nodes:\n *\n * ```ts\n * const editorState = // result typed as TypedEditorState<DefaultNodeTypes | SerializedBlockNode> (or TypedEditorState<SerializedBlockNode>)\n * buildEditorState<DefaultNodeTypes | SerializedBlockNode>({ // or just buildEditorState<SerializedBlockNode> if you *only* want to allow block nodes\n *   nodes: [\n *     {\n *       type: 'block',\n *        fields: {\n *          id: 'id',\n *          blockName: 'Cool block',\n *          blockType: 'myBlock',\n *        },\n *        format: 'left',\n *        version: 1,\n *      }\n *   ],\n * })\n * ```\n */\nexport function buildEditorState<T extends SerializedLexicalNode>({\n  nodes,\n  text,\n}: {\n  nodes?: TypedEditorState<T>['root']['children']\n  text?: string\n}): TypedEditorState<T> {\n  const editorJSON: DefaultTypedEditorState = {\n    root: {\n      type: 'root',\n      children: [],\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      version: 1,\n    },\n  }\n\n  if (text) {\n    editorJSON.root.children.push({\n      type: 'paragraph',\n      children: [\n        {\n          type: 'text',\n          detail: 0,\n          format: 0,\n          mode: 'normal',\n          style: '',\n          text,\n          version: 1,\n        },\n      ],\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      textFormat: 0,\n      textStyle: '',\n      version: 1,\n    })\n  }\n\n  if (nodes?.length) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    editorJSON.root.children.push(...(nodes as any))\n  }\n\n  return editorJSON as TypedEditorState<T>\n}\n\n/**\n *\n * Alias for `buildEditorState<DefaultNodeTypes>`\n *\n * @experimental this API may change or be removed in a minor release\n * @internal\n */\nexport const buildDefaultEditorState: typeof buildEditorState<DefaultNodeTypes> =\n  buildEditorState<DefaultNodeTypes>\n"],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCA,OAAO,SAASA,iBAAkD;EAChEC,KAAK;EACLC;AAAI,CAIL;EACC,MAAMC,UAAA,GAAsC;IAC1CC,IAAA,EAAM;MACJC,IAAA,EAAM;MACNC,QAAA,EAAU,EAAE;MACZC,SAAA,EAAW;MACXC,MAAA,EAAQ;MACRC,MAAA,EAAQ;MACRC,OAAA,EAAS;IACX;EACF;EAEA,IAAIR,IAAA,EAAM;IACRC,UAAA,CAAWC,IAAI,CAACE,QAAQ,CAACK,IAAI,CAAC;MAC5BN,IAAA,EAAM;MACNC,QAAA,EAAU,CACR;QACED,IAAA,EAAM;QACNO,MAAA,EAAQ;QACRJ,MAAA,EAAQ;QACRK,IAAA,EAAM;QACNC,KAAA,EAAO;QACPZ,IAAA;QACAQ,OAAA,EAAS;MACX,EACD;MACDH,SAAA,EAAW;MACXC,MAAA,EAAQ;MACRC,MAAA,EAAQ;MACRM,UAAA,EAAY;MACZC,SAAA,EAAW;MACXN,OAAA,EAAS;IACX;EACF;EAEA,IAAIT,KAAA,EAAOgB,MAAA,EAAQ;IACjB;IACAd,UAAA,CAAWC,IAAI,CAACE,QAAQ,CAACK,IAAI,IAAKV,KAAA;EACpC;EAEA,OAAOE,UAAA;AACT;AAEA;;;;;;;AAOA,OAAO,MAAMe,uBAAA,GACXlB,gBAAA","ignoreList":[]}
+{"version":3,"sources":["../../src/utilities/buildEditorState.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\n\nimport type { DefaultNodeTypes, DefaultTypedEditorState, TypedEditorState } from '../nodeTypes.js'\n\n/**\n * Helper to build lexical editor state JSON from text and/or nodes.\n *\n * @param nodes - The nodes to include in the editor state. If you pass the `text` argument, this will append your nodes after the first paragraph node.\n * @param text - The text content to include in the editor state. This will create a paragraph node with a text node for you and set that as the first node.\n * @returns The constructed editor state JSON.\n *\n * @example\n *\n * just passing text:\n *\n * ```ts\n * const editorState = buildEditorState<DefaultNodeTypes>({ text: 'Hello world' }) // result typed as DefaultTypedEditorState\n * ```\n *\n * @example\n *\n * passing nodes:\n *\n * ```ts\n * const editorState = // result typed as TypedEditorState<DefaultNodeTypes | SerializedBlockNode> (or TypedEditorState<SerializedBlockNode>)\n * buildEditorState<DefaultNodeTypes | SerializedBlockNode>({ // or just buildEditorState<SerializedBlockNode> if you *only* want to allow block nodes\n *   nodes: [\n *     {\n *       type: 'block',\n *        fields: {\n *          id: 'id',\n *          blockName: 'Cool block',\n *          blockType: 'myBlock',\n *        },\n *        format: 'left',\n *        version: 1,\n *      }\n *   ],\n * })\n * ```\n */\nexport function buildEditorState<T extends SerializedLexicalNode>({\n  nodes,\n  text,\n}: {\n  nodes?: TypedEditorState<T>['root']['children']\n  text?: string\n}): TypedEditorState<T> {\n  const editorJSON: DefaultTypedEditorState = {\n    root: {\n      type: 'root',\n      children: [],\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      version: 1,\n    },\n  }\n\n  if (text) {\n    editorJSON.root.children.push({\n      type: 'paragraph',\n      children: [\n        {\n          type: 'text',\n          detail: 0,\n          format: 0,\n          mode: 'normal',\n          style: '',\n          text,\n          version: 1,\n        },\n      ],\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      textFormat: 0,\n      textStyle: '',\n      version: 1,\n    })\n  }\n\n  if (nodes?.length) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    editorJSON.root.children.push(...(nodes as any))\n  }\n\n  return editorJSON as TypedEditorState<T>\n}\n\n/**\n *\n * Alias for `buildEditorState<DefaultNodeTypes>`\n *\n * @experimental this API may change or be removed in a minor release\n * @internal\n */\nexport const buildDefaultEditorState: typeof buildEditorState<DefaultNodeTypes> =\n  buildEditorState<DefaultNodeTypes>\n"],"names":["buildEditorState","nodes","text","editorJSON","root","type","children","direction","format","indent","version","push","detail","mode","style","textFormat","textStyle","length","buildDefaultEditorState"],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCC,GACD,OAAO,SAASA,iBAAkD,EAChEC,KAAK,EACLC,IAAI,EAIL;IACC,MAAMC,aAAsC;QAC1CC,MAAM;YACJC,MAAM;YACNC,UAAU,EAAE;YACZC,WAAW;YACXC,QAAQ;YACRC,QAAQ;YACRC,SAAS;QACX;IACF;IAEA,IAAIR,MAAM;QACRC,WAAWC,IAAI,CAACE,QAAQ,CAACK,IAAI,CAAC;YAC5BN,MAAM;YACNC,UAAU;gBACR;oBACED,MAAM;oBACNO,QAAQ;oBACRJ,QAAQ;oBACRK,MAAM;oBACNC,OAAO;oBACPZ;oBACAQ,SAAS;gBACX;aACD;YACDH,WAAW;YACXC,QAAQ;YACRC,QAAQ;YACRM,YAAY;YACZC,WAAW;YACXN,SAAS;QACX;IACF;IAEA,IAAIT,OAAOgB,QAAQ;QACjB,8DAA8D;QAC9Dd,WAAWC,IAAI,CAACE,QAAQ,CAACK,IAAI,IAAKV;IACpC;IAEA,OAAOE;AACT;AAEA;;;;;;CAMC,GACD,OAAO,MAAMe,0BACXlB,iBAAkC"}

package/dist/utilities/buildInitialState.js

@@ -1,57 +1,56 @@
 import { fieldSchemasToFormState } from '@payloadcms/ui/forms/fieldSchemasToFormState';
-export async function buildInitialState({
-  context,
-  initialState: initialStateFromArgs,
-  nodeData
-}) {
-  let initialState = initialStateFromArgs ?? {};
-  for (const node of nodeData) {
-    if ('children' in node) {
-      initialState = await buildInitialState({
-        context,
-        initialState,
-        nodeData: node.children
-      });
-    }
-    if (node.type === 'block' || node.type === 'inlineBlock') {
-      const blockNode = node;
-      const id = blockNode?.fields?.id;
-      if (!id) {
-        continue;
-      }
-      const schemaFieldsPath = node.type === 'block' ? `${context.lexicalFieldSchemaPath}.lexical_internal_feature.blocks.lexical_blocks.${blockNode.fields.blockType}.fields` : `${context.lexicalFieldSchemaPath}.lexical_internal_feature.blocks.lexical_inline_blocks.${blockNode.fields.blockType}.fields`;
-      // Build form state for the block
-      const formStateResult = await fieldSchemasToFormState({
-        id: context.id,
-        clientFieldSchemaMap: context.clientFieldSchemaMap,
-        collectionSlug: context.collectionSlug,
-        data: blockNode.fields,
-        documentData: context.documentData,
-        fields: context.fieldSchemaMap.get(schemaFieldsPath)?.fields,
-        fieldSchemaMap: context.fieldSchemaMap,
-        initialBlockData: blockNode.fields,
-        operation: context.operation,
-        permissions: true,
-        preferences: context.preferences,
-        readOnly: context.disabled,
-        renderAllFields: true,
-        renderFieldFn: context.renderFieldFn,
-        req: context.req,
-        schemaPath: schemaFieldsPath
-      });
-      if (!initialState[id]) {
-        initialState[id] = {};
-      }
-      initialState[id].formState = formStateResult;
-      if (node.type === 'block') {
-        const currentFieldPreferences = context.preferences?.fields?.[context.field.name];
-        const collapsedArray = currentFieldPreferences?.collapsed;
-        if (Array.isArray(collapsedArray) && collapsedArray.includes(id)) {
-          initialState[id].collapsed = true;
+export async function buildInitialState({ context, initialState: initialStateFromArgs, nodeData }) {
+    let initialState = initialStateFromArgs ?? {};
+    for (const node of nodeData){
+        if ('children' in node) {
+            initialState = await buildInitialState({
+                context,
+                initialState,
+                nodeData: node.children
+            });
+        }
+        if (node.type === 'block' || node.type === 'inlineBlock') {
+            const blockNode = node;
+            const id = blockNode?.fields?.id;
+            if (!id) {
+                continue;
+            }
+            const schemaFieldsPath = node.type === 'block' ? `${context.lexicalFieldSchemaPath}.lexical_internal_feature.blocks.lexical_blocks.${blockNode.fields.blockType}.fields` : `${context.lexicalFieldSchemaPath}.lexical_internal_feature.blocks.lexical_inline_blocks.${blockNode.fields.blockType}.fields`;
+            // Build form state for the block
+            const formStateResult = await fieldSchemasToFormState({
+                id: context.id,
+                clientFieldSchemaMap: context.clientFieldSchemaMap,
+                collectionSlug: context.collectionSlug,
+                data: blockNode.fields,
+                documentData: context.documentData,
+                fields: context.fieldSchemaMap.get(schemaFieldsPath)?.fields,
+                fieldSchemaMap: context.fieldSchemaMap,
+                initialBlockData: blockNode.fields,
+                operation: context.operation,
+                // TODO: Type
+                permissions: true,
+                preferences: context.preferences,
+                readOnly: context.disabled,
+                renderAllFields: true,
+                // If this function runs, the parent lexical field is being re-rendered => thus we can assume all its sub-fields need to be re-rendered
+                renderFieldFn: context.renderFieldFn,
+                req: context.req,
+                schemaPath: schemaFieldsPath
+            });
+            if (!initialState[id]) {
+                initialState[id] = {};
+            }
+            initialState[id].formState = formStateResult;
+            if (node.type === 'block') {
+                const currentFieldPreferences = context.preferences?.fields?.[context.field.name];
+                const collapsedArray = currentFieldPreferences?.collapsed;
+                if (Array.isArray(collapsedArray) && collapsedArray.includes(id)) {
+                    initialState[id].collapsed = true;
+                }
+            }
         }
-      }
     }
-  }
-  return initialState;
+    return initialState;
 }
+
 //# sourceMappingURL=buildInitialState.js.map

package/dist/utilities/buildInitialState.js.map

@@ -1 +1 @@
-{"version":3,"file":"buildInitialState.js","names":["fieldSchemasToFormState","buildInitialState","context","initialState","initialStateFromArgs","nodeData","node","children","type","blockNode","id","fields","schemaFieldsPath","lexicalFieldSchemaPath","blockType","formStateResult","clientFieldSchemaMap","collectionSlug","data","documentData","fieldSchemaMap","get","initialBlockData","operation","permissions","preferences","readOnly","disabled","renderAllFields","renderFieldFn","req","schemaPath","formState","currentFieldPreferences","field","name","collapsedArray","collapsed","Array","isArray","includes"],"sources":["../../src/utilities/buildInitialState.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\nimport type {\n  ClientFieldSchemaMap,\n  DocumentPreferences,\n  FieldSchemaMap,\n  FormState,\n  Operation,\n  PayloadRequest,\n  RichTextField,\n  SanitizedFieldPermissions,\n} from 'payload'\n\nimport { fieldSchemasToFormState } from '@payloadcms/ui/forms/fieldSchemasToFormState'\n\nimport type { SerializedBlockNode } from '../nodeTypes.js'\n\nexport type InitialLexicalFormState = {\n  [nodeID: string]: {\n    [key: string]: any\n    formState?: FormState\n  }\n}\n\ntype Props = {\n  context: {\n    clientFieldSchemaMap: ClientFieldSchemaMap\n    collectionSlug: string\n    disabled?: boolean\n    documentData?: any\n    field: RichTextField\n    fieldSchemaMap: FieldSchemaMap\n    id?: number | string\n    lexicalFieldSchemaPath: string\n    operation: Operation\n    permissions?: SanitizedFieldPermissions\n    preferences: DocumentPreferences\n    renderFieldFn: any\n    req: PayloadRequest\n  }\n  initialState?: InitialLexicalFormState\n  nodeData: SerializedLexicalNode[]\n}\n\nexport async function buildInitialState({\n  context,\n  initialState: initialStateFromArgs,\n  nodeData,\n}: Props): Promise<InitialLexicalFormState> {\n  let initialState: InitialLexicalFormState = initialStateFromArgs ?? {}\n  for (const node of nodeData) {\n    if ('children' in node) {\n      initialState = await buildInitialState({\n        context,\n        initialState,\n        nodeData: node.children as SerializedLexicalNode[],\n      })\n    }\n\n    if (node.type === 'block' || node.type === 'inlineBlock') {\n      const blockNode = node as SerializedBlockNode\n      const id = blockNode?.fields?.id\n      if (!id) {\n        continue\n      }\n\n      const schemaFieldsPath =\n        node.type === 'block'\n          ? `${context.lexicalFieldSchemaPath}.lexical_internal_feature.blocks.lexical_blocks.${blockNode.fields.blockType}.fields`\n          : `${context.lexicalFieldSchemaPath}.lexical_internal_feature.blocks.lexical_inline_blocks.${blockNode.fields.blockType}.fields`\n\n      // Build form state for the block\n\n      const formStateResult = await fieldSchemasToFormState({\n        id: context.id,\n        clientFieldSchemaMap: context.clientFieldSchemaMap,\n        collectionSlug: context.collectionSlug,\n        data: blockNode.fields,\n        documentData: context.documentData,\n        fields: (context.fieldSchemaMap.get(schemaFieldsPath) as any)?.fields,\n        fieldSchemaMap: context.fieldSchemaMap,\n        initialBlockData: blockNode.fields,\n        operation: context.operation as any, // TODO: Type\n        permissions: true,\n        preferences: context.preferences,\n        readOnly: context.disabled,\n        renderAllFields: true, // If this function runs, the parent lexical field is being re-rendered => thus we can assume all its sub-fields need to be re-rendered\n        renderFieldFn: context.renderFieldFn,\n        req: context.req,\n        schemaPath: schemaFieldsPath,\n      })\n\n      if (!initialState[id]) {\n        initialState[id] = {}\n      }\n\n      initialState[id].formState = formStateResult\n\n      if (node.type === 'block') {\n        const currentFieldPreferences = context.preferences?.fields?.[context.field.name]\n        const collapsedArray = currentFieldPreferences?.collapsed\n        if (Array.isArray(collapsedArray) && collapsedArray.includes(id)) {\n          initialState[id].collapsed = true\n        }\n      }\n    }\n  }\n  return initialState\n}\n"],"mappings":"AAYA,SAASA,uBAAuB,QAAQ;AA+BxC,OAAO,eAAeC,kBAAkB;EACtCC,OAAO;EACPC,YAAA,EAAcC,oBAAoB;EAClCC;AAAQ,CACF;EACN,IAAIF,YAAA,GAAwCC,oBAAA,IAAwB,CAAC;EACrE,KAAK,MAAME,IAAA,IAAQD,QAAA,EAAU;IAC3B,IAAI,cAAcC,IAAA,EAAM;MACtBH,YAAA,GAAe,MAAMF,iBAAA,CAAkB;QACrCC,OAAA;QACAC,YAAA;QACAE,QAAA,EAAUC,IAAA,CAAKC;MACjB;IACF;IAEA,IAAID,IAAA,CAAKE,IAAI,KAAK,WAAWF,IAAA,CAAKE,IAAI,KAAK,eAAe;MACxD,MAAMC,SAAA,GAAYH,IAAA;MAClB,MAAMI,EAAA,GAAKD,SAAA,EAAWE,MAAA,EAAQD,EAAA;MAC9B,IAAI,CAACA,EAAA,EAAI;QACP;MACF;MAEA,MAAME,gBAAA,GACJN,IAAA,CAAKE,IAAI,KAAK,UACV,GAAGN,OAAA,CAAQW,sBAAsB,mDAAmDJ,SAAA,CAAUE,MAAM,CAACG,SAAS,SAAS,GACvH,GAAGZ,OAAA,CAAQW,sBAAsB,0DAA0DJ,SAAA,CAAUE,MAAM,CAACG,SAAS,SAAS;MAEpI;MAEA,MAAMC,eAAA,GAAkB,MAAMf,uBAAA,CAAwB;QACpDU,EAAA,EAAIR,OAAA,CAAQQ,EAAE;QACdM,oBAAA,EAAsBd,OAAA,CAAQc,oBAAoB;QAClDC,cAAA,EAAgBf,OAAA,CAAQe,cAAc;QACtCC,IAAA,EAAMT,SAAA,CAAUE,MAAM;QACtBQ,YAAA,EAAcjB,OAAA,CAAQiB,YAAY;QAClCR,MAAA,EAAST,OAAA,CAAQkB,cAAc,CAACC,GAAG,CAACT,gBAAA,GAA2BD,MAAA;QAC/DS,cAAA,EAAgBlB,OAAA,CAAQkB,cAAc;QACtCE,gBAAA,EAAkBb,SAAA,CAAUE,MAAM;QAClCY,SAAA,EAAWrB,OAAA,CAAQqB,SAAS;QAC5BC,WAAA,EAAa;QACbC,WAAA,EAAavB,OAAA,CAAQuB,WAAW;QAChCC,QAAA,EAAUxB,OAAA,CAAQyB,QAAQ;QAC1BC,eAAA,EAAiB;QACjBC,aAAA,EAAe3B,OAAA,CAAQ2B,aAAa;QACpCC,GAAA,EAAK5B,OAAA,CAAQ4B,GAAG;QAChBC,UAAA,EAAYnB;MACd;MAEA,IAAI,CAACT,YAAY,CAACO,EAAA,CAAG,EAAE;QACrBP,YAAY,CAACO,EAAA,CAAG,GAAG,CAAC;MACtB;MAEAP,YAAY,CAACO,EAAA,CAAG,CAACsB,SAAS,GAAGjB,eAAA;MAE7B,IAAIT,IAAA,CAAKE,IAAI,KAAK,SAAS;QACzB,MAAMyB,uBAAA,GAA0B/B,OAAA,CAAQuB,WAAW,EAAEd,MAAA,GAAST,OAAA,CAAQgC,KAAK,CAACC,IAAI,CAAC;QACjF,MAAMC,cAAA,GAAiBH,uBAAA,EAAyBI,SAAA;QAChD,IAAIC,KAAA,CAAMC,OAAO,CAACH,cAAA,KAAmBA,cAAA,CAAeI,QAAQ,CAAC9B,EAAA,GAAK;UAChEP,YAAY,CAACO,EAAA,CAAG,CAAC2B,SAAS,GAAG;QAC/B;MACF;IACF;EACF;EACA,OAAOlC,YAAA;AACT","ignoreList":[]}
+{"version":3,"sources":["../../src/utilities/buildInitialState.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\nimport type {\n  ClientFieldSchemaMap,\n  DocumentPreferences,\n  FieldSchemaMap,\n  FormState,\n  Operation,\n  PayloadRequest,\n  RichTextField,\n  SanitizedFieldPermissions,\n} from 'payload'\n\nimport { fieldSchemasToFormState } from '@payloadcms/ui/forms/fieldSchemasToFormState'\n\nimport type { SerializedBlockNode } from '../nodeTypes.js'\n\nexport type InitialLexicalFormState = {\n  [nodeID: string]: {\n    [key: string]: any\n    formState?: FormState\n  }\n}\n\ntype Props = {\n  context: {\n    clientFieldSchemaMap: ClientFieldSchemaMap\n    collectionSlug: string\n    disabled?: boolean\n    documentData?: any\n    field: RichTextField\n    fieldSchemaMap: FieldSchemaMap\n    id?: number | string\n    lexicalFieldSchemaPath: string\n    operation: Operation\n    permissions?: SanitizedFieldPermissions\n    preferences: DocumentPreferences\n    renderFieldFn: any\n    req: PayloadRequest\n  }\n  initialState?: InitialLexicalFormState\n  nodeData: SerializedLexicalNode[]\n}\n\nexport async function buildInitialState({\n  context,\n  initialState: initialStateFromArgs,\n  nodeData,\n}: Props): Promise<InitialLexicalFormState> {\n  let initialState: InitialLexicalFormState = initialStateFromArgs ?? {}\n  for (const node of nodeData) {\n    if ('children' in node) {\n      initialState = await buildInitialState({\n        context,\n        initialState,\n        nodeData: node.children as SerializedLexicalNode[],\n      })\n    }\n\n    if (node.type === 'block' || node.type === 'inlineBlock') {\n      const blockNode = node as SerializedBlockNode\n      const id = blockNode?.fields?.id\n      if (!id) {\n        continue\n      }\n\n      const schemaFieldsPath =\n        node.type === 'block'\n          ? `${context.lexicalFieldSchemaPath}.lexical_internal_feature.blocks.lexical_blocks.${blockNode.fields.blockType}.fields`\n          : `${context.lexicalFieldSchemaPath}.lexical_internal_feature.blocks.lexical_inline_blocks.${blockNode.fields.blockType}.fields`\n\n      // Build form state for the block\n\n      const formStateResult = await fieldSchemasToFormState({\n        id: context.id,\n        clientFieldSchemaMap: context.clientFieldSchemaMap,\n        collectionSlug: context.collectionSlug,\n        data: blockNode.fields,\n        documentData: context.documentData,\n        fields: (context.fieldSchemaMap.get(schemaFieldsPath) as any)?.fields,\n        fieldSchemaMap: context.fieldSchemaMap,\n        initialBlockData: blockNode.fields,\n        operation: context.operation as any, // TODO: Type\n        permissions: true,\n        preferences: context.preferences,\n        readOnly: context.disabled,\n        renderAllFields: true, // If this function runs, the parent lexical field is being re-rendered => thus we can assume all its sub-fields need to be re-rendered\n        renderFieldFn: context.renderFieldFn,\n        req: context.req,\n        schemaPath: schemaFieldsPath,\n      })\n\n      if (!initialState[id]) {\n        initialState[id] = {}\n      }\n\n      initialState[id].formState = formStateResult\n\n      if (node.type === 'block') {\n        const currentFieldPreferences = context.preferences?.fields?.[context.field.name]\n        const collapsedArray = currentFieldPreferences?.collapsed\n        if (Array.isArray(collapsedArray) && collapsedArray.includes(id)) {\n          initialState[id].collapsed = true\n        }\n      }\n    }\n  }\n  return initialState\n}\n"],"names":["fieldSchemasToFormState","buildInitialState","context","initialState","initialStateFromArgs","nodeData","node","children","type","blockNode","id","fields","schemaFieldsPath","lexicalFieldSchemaPath","blockType","formStateResult","clientFieldSchemaMap","collectionSlug","data","documentData","fieldSchemaMap","get","initialBlockData","operation","permissions","preferences","readOnly","disabled","renderAllFields","renderFieldFn","req","schemaPath","formState","currentFieldPreferences","field","name","collapsedArray","collapsed","Array","isArray","includes"],"mappings":"AAYA,SAASA,uBAAuB,QAAQ,+CAA8C;AA+BtF,OAAO,eAAeC,kBAAkB,EACtCC,OAAO,EACPC,cAAcC,oBAAoB,EAClCC,QAAQ,EACF;IACN,IAAIF,eAAwCC,wBAAwB,CAAC;IACrE,KAAK,MAAME,QAAQD,SAAU;QAC3B,IAAI,cAAcC,MAAM;YACtBH,eAAe,MAAMF,kBAAkB;gBACrCC;gBACAC;gBACAE,UAAUC,KAAKC,QAAQ;YACzB;QACF;QAEA,IAAID,KAAKE,IAAI,KAAK,WAAWF,KAAKE,IAAI,KAAK,eAAe;YACxD,MAAMC,YAAYH;YAClB,MAAMI,KAAKD,WAAWE,QAAQD;YAC9B,IAAI,CAACA,IAAI;gBACP;YACF;YAEA,MAAME,mBACJN,KAAKE,IAAI,KAAK,UACV,GAAGN,QAAQW,sBAAsB,CAAC,gDAAgD,EAAEJ,UAAUE,MAAM,CAACG,SAAS,CAAC,OAAO,CAAC,GACvH,GAAGZ,QAAQW,sBAAsB,CAAC,uDAAuD,EAAEJ,UAAUE,MAAM,CAACG,SAAS,CAAC,OAAO,CAAC;YAEpI,iCAAiC;YAEjC,MAAMC,kBAAkB,MAAMf,wBAAwB;gBACpDU,IAAIR,QAAQQ,EAAE;gBACdM,sBAAsBd,QAAQc,oBAAoB;gBAClDC,gBAAgBf,QAAQe,cAAc;gBACtCC,MAAMT,UAAUE,MAAM;gBACtBQ,cAAcjB,QAAQiB,YAAY;gBAClCR,QAAST,QAAQkB,cAAc,CAACC,GAAG,CAACT,mBAA2BD;gBAC/DS,gBAAgBlB,QAAQkB,cAAc;gBACtCE,kBAAkBb,UAAUE,MAAM;gBAClCY,WAAWrB,QAAQqB,SAAS;gBAAS,aAAa;gBAClDC,aAAa;gBACbC,aAAavB,QAAQuB,WAAW;gBAChCC,UAAUxB,QAAQyB,QAAQ;gBAC1BC,iBAAiB;gBAAM,uIAAuI;gBAC9JC,eAAe3B,QAAQ2B,aAAa;gBACpCC,KAAK5B,QAAQ4B,GAAG;gBAChBC,YAAYnB;YACd;YAEA,IAAI,CAACT,YAAY,CAACO,GAAG,EAAE;gBACrBP,YAAY,CAACO,GAAG,GAAG,CAAC;YACtB;YAEAP,YAAY,CAACO,GAAG,CAACsB,SAAS,GAAGjB;YAE7B,IAAIT,KAAKE,IAAI,KAAK,SAAS;gBACzB,MAAMyB,0BAA0B/B,QAAQuB,WAAW,EAAEd,QAAQ,CAACT,QAAQgC,KAAK,CAACC,IAAI,CAAC;gBACjF,MAAMC,iBAAiBH,yBAAyBI;gBAChD,IAAIC,MAAMC,OAAO,CAACH,mBAAmBA,eAAeI,QAAQ,CAAC9B,KAAK;oBAChEP,YAAY,CAACO,GAAG,CAAC2B,SAAS,GAAG;gBAC/B;YACF;QACF;IACF;IACA,OAAOlC;AACT"}

package/dist/utilities/createClientFeature.js

@@ -1,51 +1,45 @@
-export const createClientFeature = feature => {
-  const featureProviderProvideClient = props => {
-    const featureProviderClient = {
-      clientFeatureProps: props
-    };
-    if (typeof feature === 'function') {
-      featureProviderClient.feature = ({
-        config,
-        featureClientImportMap,
-        featureClientSchemaMap,
-        featureProviderMap,
-        field,
-        resolvedFeatures,
-        schemaPath,
-        unSanitizedEditorConfig
-      }) => {
-        const toReturn = feature({
-          config,
-          featureClientImportMap,
-          featureClientSchemaMap,
-          featureProviderMap,
-          field,
-          props,
-          resolvedFeatures,
-          schemaPath,
-          unSanitizedEditorConfig
-        });
-        if (toReturn.sanitizedClientFeatureProps === null) {
-          toReturn.sanitizedClientFeatureProps = props;
+/** unSanitizedEditorConfig.features, but mapped */ // other resolved features, which have been loaded before this one. All features declared in 'dependencies' should be available here
+// unSanitized EditorConfig,
+export const createClientFeature = (feature)=>{
+    const featureProviderProvideClient = (props)=>{
+        const featureProviderClient = {
+            clientFeatureProps: props
+        };
+        if (typeof feature === 'function') {
+            featureProviderClient.feature = ({ config, featureClientImportMap, featureClientSchemaMap, featureProviderMap, field, resolvedFeatures, schemaPath, unSanitizedEditorConfig })=>{
+                const toReturn = feature({
+                    config,
+                    featureClientImportMap,
+                    featureClientSchemaMap,
+                    featureProviderMap,
+                    field,
+                    props,
+                    resolvedFeatures,
+                    schemaPath,
+                    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 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;
+        return featureProviderClient;
+    };
+    return featureProviderProvideClient;
 };
+
 //# sourceMappingURL=createClientFeature.js.map

package/dist/utilities/createClientFeature.js.map

@@ -1 +1 @@
-{"version":3,"file":"createClientFeature.js","names":["createClientFeature","feature","featureProviderProvideClient","props","featureProviderClient","clientFeatureProps","config","featureClientImportMap","featureClientSchemaMap","featureProviderMap","field","resolvedFeatures","schemaPath","unSanitizedEditorConfig","toReturn","sanitizedClientFeatureProps","newFeature"],"sources":["../../src/utilities/createClientFeature.ts"],"sourcesContent":["import type { ClientConfig, RichTextFieldClient } from 'payload'\n\nimport 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'\nimport type { FeatureClientSchemaMap } from '../types.js'\n\nexport type CreateClientFeatureArgs<UnSanitizedClientProps, ClientProps> =\n  | ((props: {\n      config: ClientConfig\n      featureClientImportMap: Record<string, any>\n      featureClientSchemaMap: FeatureClientSchemaMap\n      /** unSanitizedEditorConfig.features, but mapped */\n      featureProviderMap: ClientFeatureProviderMap\n      field?: RichTextFieldClient\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      schemaPath: string\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        config,\n        featureClientImportMap,\n        featureClientSchemaMap,\n        featureProviderMap,\n        field,\n        resolvedFeatures,\n        schemaPath,\n        unSanitizedEditorConfig,\n      }) => {\n        const toReturn = feature({\n          config,\n          featureClientImportMap,\n          featureClientSchemaMap,\n          featureProviderMap,\n          field,\n          props,\n          resolvedFeatures,\n          schemaPath,\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":"AA8BA,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,MAAM;QACNC,sBAAsB;QACtBC,sBAAsB;QACtBC,kBAAkB;QAClBC,KAAK;QACLC,gBAAgB;QAChBC,UAAU;QACVC;MAAuB,CACxB;QACC,MAAMC,QAAA,GAAWb,OAAA,CAAQ;UACvBK,MAAA;UACAC,sBAAA;UACAC,sBAAA;UACAC,kBAAA;UACAC,KAAA;UACAP,KAAA;UACAQ,gBAAA;UACAC,UAAA;UACAC;QACF;QAEA,IAAIC,QAAA,CAASC,2BAA2B,KAAK,MAAM;UACjDD,QAAA,CAASC,2BAA2B,GAAGZ,KAAA;QACzC;QAEA,OAAOW,QAAA;MACT;IACF,OAAO;MACL;MACA;MACA;MACA;MACA;MACA;MACA;MACA,MAAME,UAAA,GAAiC;QAAE,GAAGf;MAAQ;MACpDe,UAAA,CAAWD,2BAA2B,GAAGZ,KAAA;MACzCC,qBAAA,CAAsBH,OAAO,GAAGe,UAAA;IAClC;IACA,OAAOZ,qBAAA;EACT;EAEA,OAAOF,4BAAA;AACT","ignoreList":[]}
+{"version":3,"sources":["../../src/utilities/createClientFeature.ts"],"sourcesContent":["import type { ClientConfig, RichTextFieldClient } from 'payload'\n\nimport 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'\nimport type { FeatureClientSchemaMap } from '../types.js'\n\nexport type CreateClientFeatureArgs<UnSanitizedClientProps, ClientProps> =\n  | ((props: {\n      config: ClientConfig\n      featureClientImportMap: Record<string, any>\n      featureClientSchemaMap: FeatureClientSchemaMap\n      /** unSanitizedEditorConfig.features, but mapped */\n      featureProviderMap: ClientFeatureProviderMap\n      field?: RichTextFieldClient\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      schemaPath: string\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        config,\n        featureClientImportMap,\n        featureClientSchemaMap,\n        featureProviderMap,\n        field,\n        resolvedFeatures,\n        schemaPath,\n        unSanitizedEditorConfig,\n      }) => {\n        const toReturn = feature({\n          config,\n          featureClientImportMap,\n          featureClientSchemaMap,\n          featureProviderMap,\n          field,\n          props,\n          resolvedFeatures,\n          schemaPath,\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"],"names":["createClientFeature","feature","featureProviderProvideClient","props","featureProviderClient","clientFeatureProps","config","featureClientImportMap","featureClientSchemaMap","featureProviderMap","field","resolvedFeatures","schemaPath","unSanitizedEditorConfig","toReturn","sanitizedClientFeatureProps","newFeature"],"mappings":"AAkBM,iDAAiD,GAIjD,oIAAoI;AAGpI,4BAA4B;AAKlC,OAAO,MAAMA,sBAK6D,CAACC;IACzE,MAAMC,+BAAwE,CAACC;QAC7E,MAAMC,wBAAkE;YACtEC,oBAAoBF;QACtB;QAEA,IAAI,OAAOF,YAAY,YAAY;YACjCG,sBAAsBH,OAAO,GAAG,CAAC,EAC/BK,MAAM,EACNC,sBAAsB,EACtBC,sBAAsB,EACtBC,kBAAkB,EAClBC,KAAK,EACLC,gBAAgB,EAChBC,UAAU,EACVC,uBAAuB,EACxB;gBACC,MAAMC,WAAWb,QAAQ;oBACvBK;oBACAC;oBACAC;oBACAC;oBACAC;oBACAP;oBACAQ;oBACAC;oBACAC;gBACF;gBAEA,IAAIC,SAASC,2BAA2B,KAAK,MAAM;oBACjDD,SAASC,2BAA2B,GAAGZ;gBACzC;gBAEA,OAAOW;YACT;QACF,OAAO;YACL,wGAAwG;YACxG,iGAAiG;YACjG,mHAAmH;YACnH,kEAAkE;YAClE,wHAAwH;YACxH,oHAAoH;YACpH,0FAA0F;YAC1F,MAAME,aAAiC;gBAAE,GAAGf,OAAO;YAAC;YACpDe,WAAWD,2BAA2B,GAAGZ;YACzCC,sBAAsBH,OAAO,GAAGe;QAClC;QACA,OAAOZ;IACT;IAEA,OAAOF;AACT,EAAC"}