@payloadcms/richtext-lexical 3.68.0-internal-debug.591ab42 → 3.68.0-internal.2b8df4a

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":[]}

package/dist/utilities/createServerFeature.js

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

package/dist/utilities/createServerFeature.js.map

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