@payloadcms/richtext-lexical 3.78.0-internal-debug.f663370 → 3.78.0-internal.ab11ffa

package/dist/utilities/applyBaseFilterToFields.js

@@ -5,90 +5,93 @@ 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;
-                }
-                // 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;
+ */
+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;
         }
-        // Recursively process nested fields
-        if ('fields' in field && field.fields) {
-            return {
-                ...field,
-                fields: applyBaseFilterToFields(field.fields, config)
-            };
+        // 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;
         }
-        // Handle tabs
-        if (field.type === 'tabs' && 'tabs' in field) {
-            return {
-                ...field,
-                tabs: field.tabs.map((tab)=>({
-                        ...tab,
-                        fields: applyBaseFilterToFields(tab.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 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)
-                    };
-                })
-            };
+        // If original result is true, just return the baseFilter
+        if (originalResult === true) {
+          return baseFilterResult;
         }
-        return field;
-    });
+        // 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;
+  });
 }
-
 //# sourceMappingURL=applyBaseFilterToFields.js.map

package/dist/utilities/applyBaseFilterToFields.js.map

@@ -1 +1 @@
-{"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"}
+{"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":[]}

package/dist/utilities/buildEditorState.js

@@ -34,44 +34,45 @@
  *   ],
  * })
  * ```
- */ 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
-        });
+ */export function buildEditorState({
+  nodes,
+  text
+}) {
+  const editorJSON = {
+    root: {
+      type: 'root',
+      children: [],
+      direction: 'ltr',
+      format: '',
+      indent: 0,
+      version: 1
     }
-    if (nodes?.length) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        editorJSON.root.children.push(...nodes);
-    }
-    return editorJSON;
+  };
+  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;
 }
 /**
  *
@@ -79,6 +80,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,"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"}
+{"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":[]}

package/dist/utilities/buildInitialState.js

@@ -1,56 +1,57 @@
 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,
-                // 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;
-                }
-            }
+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;
         }
+      }
     }
-    return initialState;
+  }
+  return initialState;
 }
-
 //# sourceMappingURL=buildInitialState.js.map

package/dist/utilities/buildInitialState.js.map

@@ -1 +1 @@
-{"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"}
+{"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":[]}

package/dist/utilities/createClientFeature.js

@@ -1,45 +1,51 @@
-/** 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 featureProviderClient;
+export const createClientFeature = feature => {
+  const featureProviderProvideClient = props => {
+    const featureProviderClient = {
+      clientFeatureProps: props
     };
-    return featureProviderProvideClient;
+    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 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 { 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"}
+{"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":[]}