@payloadcms/richtext-lexical 3.67.0 → 3.68.0-internal-debug.2eb12b9

package/dist/utilities/editorConfigFactory.js

@@ -3,87 +3,86 @@ import { loadFeatures } from '../lexical/config/server/loader.js';
 import { sanitizeServerFeatures } from '../lexical/config/server/sanitize.js';
 import { getDefaultSanitizedEditorConfig } from './getDefaultSanitizedEditorConfig.js';
 export const editorConfigFactory = {
-  default: async args => {
-    return getDefaultSanitizedEditorConfig({
-      config: args.config,
-      parentIsLocalized: args.parentIsLocalized ?? false
-    });
-  },
-  /**
-  * If you have instantiated a lexical editor and are accessing it outside a field (=> this is the unsanitized editor),
-  * you can extract the editor config from it.
-  * This is common if you define the editor in a re-usable module scope variable and pass it to the richText field.
-  *
-  * This is the least efficient way to get the editor config, and not recommended. It is recommended to extract the `features` arg
-  * into a separate variable and use `fromFeatures` instead.
-  */
-  fromEditor: async args => {
-    const lexicalAdapter = await args.editor({
-      config: args.config,
-      isRoot: args.isRoot ?? false,
-      parentIsLocalized: args.parentIsLocalized ?? false
-    });
-    const sanitizedServerEditorConfig = lexicalAdapter.editorConfig;
-    return sanitizedServerEditorConfig;
-  },
-  /**
-  * Create a new editor config - behaves just like instantiating a new `lexicalEditor`
-  */
-  fromFeatures: async args => {
-    return (await featuresInputToEditorConfig(args)).sanitizedConfig;
-  },
-  fromField: args => {
-    const lexicalAdapter = args.field.editor;
-    const sanitizedServerEditorConfig = lexicalAdapter.editorConfig;
-    return sanitizedServerEditorConfig;
-  },
-  fromUnsanitizedField: async args => {
-    const lexicalAdapterProvider = args.field.editor;
-    const lexicalAdapter = await lexicalAdapterProvider({
-      config: args.config,
-      isRoot: args.isRoot ?? false,
-      parentIsLocalized: args.parentIsLocalized ?? false
-    });
-    const sanitizedServerEditorConfig = lexicalAdapter.editorConfig;
-    return sanitizedServerEditorConfig;
-  }
-};
-export const featuresInputToEditorConfig = async args => {
-  let features = [];
-  if (args.features && typeof args.features === 'function') {
-    const rootEditor = args.config.editor;
-    let rootEditorFeatures = [];
-    if (typeof rootEditor === 'object' && 'features' in rootEditor) {
-      rootEditorFeatures = rootEditor.features;
+    default: async (args)=>{
+        return getDefaultSanitizedEditorConfig({
+            config: args.config,
+            parentIsLocalized: args.parentIsLocalized ?? false
+        });
+    },
+    /**
+   * If you have instantiated a lexical editor and are accessing it outside a field (=> this is the unsanitized editor),
+   * you can extract the editor config from it.
+   * This is common if you define the editor in a re-usable module scope variable and pass it to the richText field.
+   *
+   * This is the least efficient way to get the editor config, and not recommended. It is recommended to extract the `features` arg
+   * into a separate variable and use `fromFeatures` instead.
+   */ fromEditor: async (args)=>{
+        const lexicalAdapter = await args.editor({
+            config: args.config,
+            isRoot: args.isRoot ?? false,
+            parentIsLocalized: args.parentIsLocalized ?? false
+        });
+        const sanitizedServerEditorConfig = lexicalAdapter.editorConfig;
+        return sanitizedServerEditorConfig;
+    },
+    /**
+   * Create a new editor config - behaves just like instantiating a new `lexicalEditor`
+   */ fromFeatures: async (args)=>{
+        return (await featuresInputToEditorConfig(args)).sanitizedConfig;
+    },
+    fromField: (args)=>{
+        const lexicalAdapter = args.field.editor;
+        const sanitizedServerEditorConfig = lexicalAdapter.editorConfig;
+        return sanitizedServerEditorConfig;
+    },
+    fromUnsanitizedField: async (args)=>{
+        const lexicalAdapterProvider = args.field.editor;
+        const lexicalAdapter = await lexicalAdapterProvider({
+            config: args.config,
+            isRoot: args.isRoot ?? false,
+            parentIsLocalized: args.parentIsLocalized ?? false
+        });
+        const sanitizedServerEditorConfig = lexicalAdapter.editorConfig;
+        return sanitizedServerEditorConfig;
     }
-    features = args.features({
-      defaultFeatures: defaultEditorFeatures,
-      rootFeatures: rootEditorFeatures
-    });
-  } else {
-    features = args.features;
-  }
-  if (!features) {
-    features = defaultEditorFeatures;
-  }
-  const lexical = args.lexical ?? defaultEditorConfig.lexical;
-  const resolvedFeatureMap = await loadFeatures({
-    config: args.config,
-    isRoot: args.isRoot ?? false,
-    parentIsLocalized: args.parentIsLocalized ?? false,
-    unSanitizedEditorConfig: {
-      features,
-      lexical
+};
+export const featuresInputToEditorConfig = async (args)=>{
+    let features = [];
+    if (args.features && typeof args.features === 'function') {
+        const rootEditor = args.config.editor;
+        let rootEditorFeatures = [];
+        if (typeof rootEditor === 'object' && 'features' in rootEditor) {
+            rootEditorFeatures = rootEditor.features;
+        }
+        features = args.features({
+            defaultFeatures: defaultEditorFeatures,
+            rootFeatures: rootEditorFeatures
+        });
+    } else {
+        features = args.features;
     }
-  });
-  return {
-    features,
-    resolvedFeatureMap,
-    sanitizedConfig: {
-      features: sanitizeServerFeatures(resolvedFeatureMap),
-      lexical: args.lexical,
-      resolvedFeatureMap
+    if (!features) {
+        features = defaultEditorFeatures;
     }
-  };
+    const lexical = args.lexical ?? defaultEditorConfig.lexical;
+    const resolvedFeatureMap = await loadFeatures({
+        config: args.config,
+        isRoot: args.isRoot ?? false,
+        parentIsLocalized: args.parentIsLocalized ?? false,
+        unSanitizedEditorConfig: {
+            features,
+            lexical
+        }
+    });
+    return {
+        features,
+        resolvedFeatureMap,
+        sanitizedConfig: {
+            features: sanitizeServerFeatures(resolvedFeatureMap),
+            lexical: args.lexical,
+            resolvedFeatureMap
+        }
+    };
 };
+
 //# sourceMappingURL=editorConfigFactory.js.map

package/dist/utilities/editorConfigFactory.js.map

@@ -1 +1 @@
-{"version":3,"file":"editorConfigFactory.js","names":["defaultEditorConfig","defaultEditorFeatures","loadFeatures","sanitizeServerFeatures","getDefaultSanitizedEditorConfig","editorConfigFactory","default","args","config","parentIsLocalized","fromEditor","lexicalAdapter","editor","isRoot","sanitizedServerEditorConfig","editorConfig","fromFeatures","featuresInputToEditorConfig","sanitizedConfig","fromField","field","fromUnsanitizedField","lexicalAdapterProvider","features","rootEditor","rootEditorFeatures","defaultFeatures","rootFeatures","lexical","resolvedFeatureMap","unSanitizedEditorConfig"],"sources":["../../src/utilities/editorConfigFactory.ts"],"sourcesContent":["import type { EditorConfig as LexicalEditorConfig } from 'lexical'\nimport type { RichTextAdapterProvider, RichTextField, SanitizedConfig } from 'payload'\n\nimport type { FeatureProviderServer, ResolvedServerFeatureMap } from '../features/typesServer.js'\nimport type { SanitizedServerEditorConfig } from '../lexical/config/types.js'\nimport type {\n  FeaturesInput,\n  LexicalRichTextAdapter,\n  LexicalRichTextAdapterProvider,\n} from '../types.js'\n\nimport { defaultEditorConfig, defaultEditorFeatures } from '../lexical/config/server/default.js'\nimport { loadFeatures } from '../lexical/config/server/loader.js'\nimport { sanitizeServerFeatures } from '../lexical/config/server/sanitize.js'\nimport { getDefaultSanitizedEditorConfig } from './getDefaultSanitizedEditorConfig.js'\n\nexport const editorConfigFactory = {\n  default: async (args: {\n    config: SanitizedConfig\n    parentIsLocalized?: boolean\n  }): Promise<SanitizedServerEditorConfig> => {\n    return getDefaultSanitizedEditorConfig({\n      config: args.config,\n      parentIsLocalized: args.parentIsLocalized ?? false,\n    })\n  },\n  /**\n   * If you have instantiated a lexical editor and are accessing it outside a field (=> this is the unsanitized editor),\n   * you can extract the editor config from it.\n   * This is common if you define the editor in a re-usable module scope variable and pass it to the richText field.\n   *\n   * This is the least efficient way to get the editor config, and not recommended. It is recommended to extract the `features` arg\n   * into a separate variable and use `fromFeatures` instead.\n   */\n  fromEditor: async (args: {\n    config: SanitizedConfig\n    editor: LexicalRichTextAdapterProvider\n    isRoot?: boolean\n    lexical?: LexicalEditorConfig\n    parentIsLocalized?: boolean\n  }): Promise<SanitizedServerEditorConfig> => {\n    const lexicalAdapter: LexicalRichTextAdapter = await args.editor({\n      config: args.config,\n      isRoot: args.isRoot ?? false,\n      parentIsLocalized: args.parentIsLocalized ?? false,\n    })\n\n    const sanitizedServerEditorConfig: SanitizedServerEditorConfig = lexicalAdapter.editorConfig\n    return sanitizedServerEditorConfig\n  },\n  /**\n   * Create a new editor config - behaves just like instantiating a new `lexicalEditor`\n   */\n  fromFeatures: async (args: {\n    config: SanitizedConfig\n    features?: FeaturesInput\n    isRoot?: boolean\n    lexical?: LexicalEditorConfig\n    parentIsLocalized?: boolean\n  }): Promise<SanitizedServerEditorConfig> => {\n    return (await featuresInputToEditorConfig(args)).sanitizedConfig\n  },\n  fromField: (args: { field: RichTextField }): SanitizedServerEditorConfig => {\n    const lexicalAdapter: LexicalRichTextAdapter = args.field.editor as LexicalRichTextAdapter\n\n    const sanitizedServerEditorConfig: SanitizedServerEditorConfig = lexicalAdapter.editorConfig\n    return sanitizedServerEditorConfig\n  },\n  fromUnsanitizedField: async (args: {\n    config: SanitizedConfig\n    field: RichTextField\n    isRoot?: boolean\n    parentIsLocalized?: boolean\n  }): Promise<SanitizedServerEditorConfig> => {\n    const lexicalAdapterProvider: RichTextAdapterProvider = args.field\n      .editor as RichTextAdapterProvider\n\n    const lexicalAdapter: LexicalRichTextAdapter = (await lexicalAdapterProvider({\n      config: args.config,\n      isRoot: args.isRoot ?? false,\n      parentIsLocalized: args.parentIsLocalized ?? false,\n    })) as LexicalRichTextAdapter\n\n    const sanitizedServerEditorConfig: SanitizedServerEditorConfig = lexicalAdapter.editorConfig\n    return sanitizedServerEditorConfig\n  },\n}\n\nexport const featuresInputToEditorConfig = async (args: {\n  config: SanitizedConfig\n  features?: FeaturesInput\n  isRoot?: boolean\n  lexical?: LexicalEditorConfig\n  parentIsLocalized?: boolean\n}): Promise<{\n  features: FeatureProviderServer<unknown, unknown, unknown>[]\n  resolvedFeatureMap: ResolvedServerFeatureMap\n  sanitizedConfig: SanitizedServerEditorConfig\n}> => {\n  let features: FeatureProviderServer<unknown, unknown, unknown>[] = []\n  if (args.features && typeof args.features === 'function') {\n    const rootEditor = args.config.editor\n    let rootEditorFeatures: FeatureProviderServer<unknown, unknown, unknown>[] = []\n    if (typeof rootEditor === 'object' && 'features' in rootEditor) {\n      rootEditorFeatures = (rootEditor as LexicalRichTextAdapter).features\n    }\n    features = args.features({\n      defaultFeatures: defaultEditorFeatures,\n      rootFeatures: rootEditorFeatures,\n    })\n  } else {\n    features = args.features as FeatureProviderServer<unknown, unknown, unknown>[]\n  }\n\n  if (!features) {\n    features = defaultEditorFeatures\n  }\n\n  const lexical = args.lexical ?? defaultEditorConfig.lexical\n\n  const resolvedFeatureMap = await loadFeatures({\n    config: args.config,\n    isRoot: args.isRoot ?? false,\n    parentIsLocalized: args.parentIsLocalized ?? false,\n    unSanitizedEditorConfig: {\n      features,\n      lexical,\n    },\n  })\n\n  return {\n    features,\n    resolvedFeatureMap,\n    sanitizedConfig: {\n      features: sanitizeServerFeatures(resolvedFeatureMap),\n      lexical: args.lexical,\n      resolvedFeatureMap,\n    },\n  }\n}\n"],"mappings":"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","ignoreList":[]}
+{"version":3,"sources":["../../src/utilities/editorConfigFactory.ts"],"sourcesContent":["import type { EditorConfig as LexicalEditorConfig } from 'lexical'\nimport type { RichTextAdapterProvider, RichTextField, SanitizedConfig } from 'payload'\n\nimport type { FeatureProviderServer, ResolvedServerFeatureMap } from '../features/typesServer.js'\nimport type { SanitizedServerEditorConfig } from '../lexical/config/types.js'\nimport type {\n  FeaturesInput,\n  LexicalRichTextAdapter,\n  LexicalRichTextAdapterProvider,\n} from '../types.js'\n\nimport { defaultEditorConfig, defaultEditorFeatures } from '../lexical/config/server/default.js'\nimport { loadFeatures } from '../lexical/config/server/loader.js'\nimport { sanitizeServerFeatures } from '../lexical/config/server/sanitize.js'\nimport { getDefaultSanitizedEditorConfig } from './getDefaultSanitizedEditorConfig.js'\n\nexport const editorConfigFactory = {\n  default: async (args: {\n    config: SanitizedConfig\n    parentIsLocalized?: boolean\n  }): Promise<SanitizedServerEditorConfig> => {\n    return getDefaultSanitizedEditorConfig({\n      config: args.config,\n      parentIsLocalized: args.parentIsLocalized ?? false,\n    })\n  },\n  /**\n   * If you have instantiated a lexical editor and are accessing it outside a field (=> this is the unsanitized editor),\n   * you can extract the editor config from it.\n   * This is common if you define the editor in a re-usable module scope variable and pass it to the richText field.\n   *\n   * This is the least efficient way to get the editor config, and not recommended. It is recommended to extract the `features` arg\n   * into a separate variable and use `fromFeatures` instead.\n   */\n  fromEditor: async (args: {\n    config: SanitizedConfig\n    editor: LexicalRichTextAdapterProvider\n    isRoot?: boolean\n    lexical?: LexicalEditorConfig\n    parentIsLocalized?: boolean\n  }): Promise<SanitizedServerEditorConfig> => {\n    const lexicalAdapter: LexicalRichTextAdapter = await args.editor({\n      config: args.config,\n      isRoot: args.isRoot ?? false,\n      parentIsLocalized: args.parentIsLocalized ?? false,\n    })\n\n    const sanitizedServerEditorConfig: SanitizedServerEditorConfig = lexicalAdapter.editorConfig\n    return sanitizedServerEditorConfig\n  },\n  /**\n   * Create a new editor config - behaves just like instantiating a new `lexicalEditor`\n   */\n  fromFeatures: async (args: {\n    config: SanitizedConfig\n    features?: FeaturesInput\n    isRoot?: boolean\n    lexical?: LexicalEditorConfig\n    parentIsLocalized?: boolean\n  }): Promise<SanitizedServerEditorConfig> => {\n    return (await featuresInputToEditorConfig(args)).sanitizedConfig\n  },\n  fromField: (args: { field: RichTextField }): SanitizedServerEditorConfig => {\n    const lexicalAdapter: LexicalRichTextAdapter = args.field.editor as LexicalRichTextAdapter\n\n    const sanitizedServerEditorConfig: SanitizedServerEditorConfig = lexicalAdapter.editorConfig\n    return sanitizedServerEditorConfig\n  },\n  fromUnsanitizedField: async (args: {\n    config: SanitizedConfig\n    field: RichTextField\n    isRoot?: boolean\n    parentIsLocalized?: boolean\n  }): Promise<SanitizedServerEditorConfig> => {\n    const lexicalAdapterProvider: RichTextAdapterProvider = args.field\n      .editor as RichTextAdapterProvider\n\n    const lexicalAdapter: LexicalRichTextAdapter = (await lexicalAdapterProvider({\n      config: args.config,\n      isRoot: args.isRoot ?? false,\n      parentIsLocalized: args.parentIsLocalized ?? false,\n    })) as LexicalRichTextAdapter\n\n    const sanitizedServerEditorConfig: SanitizedServerEditorConfig = lexicalAdapter.editorConfig\n    return sanitizedServerEditorConfig\n  },\n}\n\nexport const featuresInputToEditorConfig = async (args: {\n  config: SanitizedConfig\n  features?: FeaturesInput\n  isRoot?: boolean\n  lexical?: LexicalEditorConfig\n  parentIsLocalized?: boolean\n}): Promise<{\n  features: FeatureProviderServer<unknown, unknown, unknown>[]\n  resolvedFeatureMap: ResolvedServerFeatureMap\n  sanitizedConfig: SanitizedServerEditorConfig\n}> => {\n  let features: FeatureProviderServer<unknown, unknown, unknown>[] = []\n  if (args.features && typeof args.features === 'function') {\n    const rootEditor = args.config.editor\n    let rootEditorFeatures: FeatureProviderServer<unknown, unknown, unknown>[] = []\n    if (typeof rootEditor === 'object' && 'features' in rootEditor) {\n      rootEditorFeatures = (rootEditor as LexicalRichTextAdapter).features\n    }\n    features = args.features({\n      defaultFeatures: defaultEditorFeatures,\n      rootFeatures: rootEditorFeatures,\n    })\n  } else {\n    features = args.features as FeatureProviderServer<unknown, unknown, unknown>[]\n  }\n\n  if (!features) {\n    features = defaultEditorFeatures\n  }\n\n  const lexical = args.lexical ?? defaultEditorConfig.lexical\n\n  const resolvedFeatureMap = await loadFeatures({\n    config: args.config,\n    isRoot: args.isRoot ?? false,\n    parentIsLocalized: args.parentIsLocalized ?? false,\n    unSanitizedEditorConfig: {\n      features,\n      lexical,\n    },\n  })\n\n  return {\n    features,\n    resolvedFeatureMap,\n    sanitizedConfig: {\n      features: sanitizeServerFeatures(resolvedFeatureMap),\n      lexical: args.lexical,\n      resolvedFeatureMap,\n    },\n  }\n}\n"],"names":["defaultEditorConfig","defaultEditorFeatures","loadFeatures","sanitizeServerFeatures","getDefaultSanitizedEditorConfig","editorConfigFactory","default","args","config","parentIsLocalized","fromEditor","lexicalAdapter","editor","isRoot","sanitizedServerEditorConfig","editorConfig","fromFeatures","featuresInputToEditorConfig","sanitizedConfig","fromField","field","fromUnsanitizedField","lexicalAdapterProvider","features","rootEditor","rootEditorFeatures","defaultFeatures","rootFeatures","lexical","resolvedFeatureMap","unSanitizedEditorConfig"],"mappings":"AAWA,SAASA,mBAAmB,EAAEC,qBAAqB,QAAQ,sCAAqC;AAChG,SAASC,YAAY,QAAQ,qCAAoC;AACjE,SAASC,sBAAsB,QAAQ,uCAAsC;AAC7E,SAASC,+BAA+B,QAAQ,uCAAsC;AAEtF,OAAO,MAAMC,sBAAsB;IACjCC,SAAS,OAAOC;QAId,OAAOH,gCAAgC;YACrCI,QAAQD,KAAKC,MAAM;YACnBC,mBAAmBF,KAAKE,iBAAiB,IAAI;QAC/C;IACF;IACA;;;;;;;GAOC,GACDC,YAAY,OAAOH;QAOjB,MAAMI,iBAAyC,MAAMJ,KAAKK,MAAM,CAAC;YAC/DJ,QAAQD,KAAKC,MAAM;YACnBK,QAAQN,KAAKM,MAAM,IAAI;YACvBJ,mBAAmBF,KAAKE,iBAAiB,IAAI;QAC/C;QAEA,MAAMK,8BAA2DH,eAAeI,YAAY;QAC5F,OAAOD;IACT;IACA;;GAEC,GACDE,cAAc,OAAOT;QAOnB,OAAO,AAAC,CAAA,MAAMU,4BAA4BV,KAAI,EAAGW,eAAe;IAClE;IACAC,WAAW,CAACZ;QACV,MAAMI,iBAAyCJ,KAAKa,KAAK,CAACR,MAAM;QAEhE,MAAME,8BAA2DH,eAAeI,YAAY;QAC5F,OAAOD;IACT;IACAO,sBAAsB,OAAOd;QAM3B,MAAMe,yBAAkDf,KAAKa,KAAK,CAC/DR,MAAM;QAET,MAAMD,iBAA0C,MAAMW,uBAAuB;YAC3Ed,QAAQD,KAAKC,MAAM;YACnBK,QAAQN,KAAKM,MAAM,IAAI;YACvBJ,mBAAmBF,KAAKE,iBAAiB,IAAI;QAC/C;QAEA,MAAMK,8BAA2DH,eAAeI,YAAY;QAC5F,OAAOD;IACT;AACF,EAAC;AAED,OAAO,MAAMG,8BAA8B,OAAOV;IAWhD,IAAIgB,WAA+D,EAAE;IACrE,IAAIhB,KAAKgB,QAAQ,IAAI,OAAOhB,KAAKgB,QAAQ,KAAK,YAAY;QACxD,MAAMC,aAAajB,KAAKC,MAAM,CAACI,MAAM;QACrC,IAAIa,qBAAyE,EAAE;QAC/E,IAAI,OAAOD,eAAe,YAAY,cAAcA,YAAY;YAC9DC,qBAAqB,AAACD,WAAsCD,QAAQ;QACtE;QACAA,WAAWhB,KAAKgB,QAAQ,CAAC;YACvBG,iBAAiBzB;YACjB0B,cAAcF;QAChB;IACF,OAAO;QACLF,WAAWhB,KAAKgB,QAAQ;IAC1B;IAEA,IAAI,CAACA,UAAU;QACbA,WAAWtB;IACb;IAEA,MAAM2B,UAAUrB,KAAKqB,OAAO,IAAI5B,oBAAoB4B,OAAO;IAE3D,MAAMC,qBAAqB,MAAM3B,aAAa;QAC5CM,QAAQD,KAAKC,MAAM;QACnBK,QAAQN,KAAKM,MAAM,IAAI;QACvBJ,mBAAmBF,KAAKE,iBAAiB,IAAI;QAC7CqB,yBAAyB;YACvBP;YACAK;QACF;IACF;IAEA,OAAO;QACLL;QACAM;QACAX,iBAAiB;YACfK,UAAUpB,uBAAuB0B;YACjCD,SAASrB,KAAKqB,OAAO;YACrBC;QACF;IACF;AACF,EAAC"}

package/dist/utilities/fieldsDrawer/Drawer.js

@@ -1,6 +1,4 @@
 'use client';
-
-import { c as _c } from "react/compiler-runtime";
 import { jsx as _jsx } from "react/jsx-runtime";
 import { Drawer, EditDepthProvider, useModal } from '@payloadcms/ui';
 import React from 'react';
@@ -9,72 +7,37 @@ import { DrawerContent } from './DrawerContent.js';
  * This FieldsDrawer component can be used to easily create a Drawer that contains a form with fields within your feature.
  * The fields are taken directly from the schema map based on your `featureKey` and `schemaPathSuffix`. Thus, this can only
  * be used if you provide your field schema inside the `generateSchemaMap` prop of your feature.server.ts.
- */
-export const FieldsDrawer = t0 => {
-  const $ = _c(15);
-  const {
-    className,
-    data,
-    drawerSlug,
-    drawerTitle,
-    featureKey,
-    fieldMapOverride,
-    handleDrawerSubmit,
-    schemaFieldsPathOverride,
-    schemaPath,
-    schemaPathSuffix
-  } = t0;
-  const {
-    closeModal
-  } = useModal();
-  const t1 = drawerTitle ?? "";
-  let t2;
-  if ($[0] !== closeModal || $[1] !== drawerSlug || $[2] !== handleDrawerSubmit) {
-    t2 = (args, args2) => {
-      closeModal(drawerSlug);
-      setTimeout(() => {
-        handleDrawerSubmit(args, args2);
-      }, 1);
-    };
-    $[0] = closeModal;
-    $[1] = drawerSlug;
-    $[2] = handleDrawerSubmit;
-    $[3] = t2;
-  } else {
-    t2 = $[3];
-  }
-  let t3;
-  if ($[4] !== className || $[5] !== data || $[6] !== drawerSlug || $[7] !== featureKey || $[8] !== fieldMapOverride || $[9] !== schemaFieldsPathOverride || $[10] !== schemaPath || $[11] !== schemaPathSuffix || $[12] !== t1 || $[13] !== t2) {
-    t3 = _jsx(EditDepthProvider, {
-      children: _jsx(Drawer, {
-        className,
-        slug: drawerSlug,
-        title: t1,
-        children: _jsx(DrawerContent, {
-          data,
-          featureKey,
-          fieldMapOverride,
-          handleDrawerSubmit: t2,
-          schemaFieldsPathOverride,
-          schemaPath,
-          schemaPathSuffix
+ */ export const FieldsDrawer = ({ className, data, drawerSlug, drawerTitle, featureKey, fieldMapOverride, handleDrawerSubmit, schemaFieldsPathOverride, schemaPath, schemaPathSuffix })=>{
+    const { closeModal } = useModal();
+    // The Drawer only renders its children (and itself) if it's open. Thus, by extracting the main content
+    // to DrawerContent, this should be faster
+    return /*#__PURE__*/ _jsx(EditDepthProvider, {
+        children: /*#__PURE__*/ _jsx(Drawer, {
+            className: className,
+            slug: drawerSlug,
+            title: drawerTitle ?? '',
+            children: /*#__PURE__*/ _jsx(DrawerContent, {
+                data: data,
+                featureKey: featureKey,
+                fieldMapOverride: fieldMapOverride,
+                handleDrawerSubmit: (args, args2)=>{
+                    // Simply close drawer - no need for useLexicalDrawer here as at this point,
+                    // we don't need to restore the cursor position. This is handled by the useEffect in useLexicalDrawer.
+                    closeModal(drawerSlug);
+                    // Actual drawer submit logic needs to be triggered after the drawer is closed.
+                    // That's because the lexical selection / cursor restore logic that is striggerer by
+                    // `useLexicalDrawer` neeeds to be triggered before any editor.update calls that may happen
+                    // in the `handleDrawerSubmit` function.
+                    setTimeout(()=>{
+                        handleDrawerSubmit(args, args2);
+                    }, 1);
+                },
+                schemaFieldsPathOverride: schemaFieldsPathOverride,
+                schemaPath: schemaPath,
+                schemaPathSuffix: schemaPathSuffix
+            })
         })
-      })
     });
-    $[4] = className;
-    $[5] = data;
-    $[6] = drawerSlug;
-    $[7] = featureKey;
-    $[8] = fieldMapOverride;
-    $[9] = schemaFieldsPathOverride;
-    $[10] = schemaPath;
-    $[11] = schemaPathSuffix;
-    $[12] = t1;
-    $[13] = t2;
-    $[14] = t3;
-  } else {
-    t3 = $[14];
-  }
-  return t3;
 };
+
 //# sourceMappingURL=Drawer.js.map

package/dist/utilities/fieldsDrawer/Drawer.js.map

@@ -1 +1 @@
-{"version":3,"file":"Drawer.js","names":["c","_c","Drawer","EditDepthProvider","useModal","React","DrawerContent","FieldsDrawer","t0","$","className","data","drawerSlug","drawerTitle","featureKey","fieldMapOverride","handleDrawerSubmit","schemaFieldsPathOverride","schemaPath","schemaPathSuffix","closeModal","t1","t2","args","args2","setTimeout","t3","_jsx","children","slug","title"],"sources":["../../../src/utilities/fieldsDrawer/Drawer.tsx"],"sourcesContent":["'use client'\nimport type { ClientField, Data, FormState, JsonObject } from 'payload'\n\nimport { Drawer, EditDepthProvider, useModal } from '@payloadcms/ui'\nimport React from 'react'\n\nimport { DrawerContent } from './DrawerContent.js'\n\nexport type FieldsDrawerProps = {\n  readonly className?: string\n  readonly data?: Data\n  readonly drawerSlug: string\n  readonly drawerTitle?: string\n  readonly featureKey: string\n  readonly fieldMapOverride?: ClientField[]\n  readonly handleDrawerSubmit: (fields: FormState, data: JsonObject) => void\n  readonly schemaFieldsPathOverride?: string\n  readonly schemaPath: string\n  readonly schemaPathSuffix?: string\n}\n\n/**\n * This FieldsDrawer component can be used to easily create a Drawer that contains a form with fields within your feature.\n * The fields are taken directly from the schema map based on your `featureKey` and `schemaPathSuffix`. Thus, this can only\n * be used if you provide your field schema inside the `generateSchemaMap` prop of your feature.server.ts.\n */\nexport const FieldsDrawer: React.FC<FieldsDrawerProps> = ({\n  className,\n  data,\n  drawerSlug,\n  drawerTitle,\n  featureKey,\n  fieldMapOverride,\n  handleDrawerSubmit,\n  schemaFieldsPathOverride,\n  schemaPath,\n  schemaPathSuffix,\n}) => {\n  const { closeModal } = useModal()\n  // The Drawer only renders its children (and itself) if it's open. Thus, by extracting the main content\n  // to DrawerContent, this should be faster\n  return (\n    <EditDepthProvider>\n      <Drawer className={className} slug={drawerSlug} title={drawerTitle ?? ''}>\n        <DrawerContent\n          data={data}\n          featureKey={featureKey}\n          fieldMapOverride={fieldMapOverride}\n          handleDrawerSubmit={(args, args2) => {\n            // Simply close drawer - no need for useLexicalDrawer here as at this point,\n            // we don't need to restore the cursor position. This is handled by the useEffect in useLexicalDrawer.\n            closeModal(drawerSlug)\n\n            // Actual drawer submit logic needs to be triggered after the drawer is closed.\n            // That's because the lexical selection / cursor restore logic that is striggerer by\n            // `useLexicalDrawer` neeeds to be triggered before any editor.update calls that may happen\n            // in the `handleDrawerSubmit` function.\n            setTimeout(() => {\n              handleDrawerSubmit(args, args2)\n            }, 1)\n          }}\n          schemaFieldsPathOverride={schemaFieldsPathOverride}\n          schemaPath={schemaPath}\n          schemaPathSuffix={schemaPathSuffix}\n        />\n      </Drawer>\n    </EditDepthProvider>\n  )\n}\n"],"mappings":"AAAA;;AAAA,SAAAA,CAAA,IAAAC,EAAA;;AAGA,SAASC,MAAM,EAAEC,iBAAiB,EAAEC,QAAQ,QAAQ;AACpD,OAAOC,KAAA,MAAW;AAElB,SAASC,aAAa,QAAQ;AAe9B;;;;;AAKA,OAAO,MAAMC,YAAA,GAA4CC,EAAA;EAAA,MAAAC,CAAA,GAAAR,EAAA;EAAC;IAAAS,SAAA;IAAAC,IAAA;IAAAC,UAAA;IAAAC,WAAA;IAAAC,UAAA;IAAAC,gBAAA;IAAAC,kBAAA;IAAAC,wBAAA;IAAAC,UAAA;IAAAC;EAAA,IAAAX,EAWzD;EACC;IAAAY;EAAA,IAAuBhB,QAAA;EAKoC,MAAAiB,EAAA,GAAAR,WAAA,IAAe;EAAA,IAAAS,EAAA;EAAA,IAAAb,CAAA,QAAAW,UAAA,IAAAX,CAAA,QAAAG,UAAA,IAAAH,CAAA,QAAAO,kBAAA;IAK9CM,EAAA,GAAAA,CAAAC,IAAA,EAAAC,KAAA;MAGlBJ,UAAA,CAAWR,UAAA;MAMXa,UAAA;QACET,kBAAA,CAAmBO,IAAA,EAAMC,KAAA;MAAA,IACxB;IAAA;IACLf,CAAA,MAAAW,UAAA;IAAAX,CAAA,MAAAG,UAAA;IAAAH,CAAA,MAAAO,kBAAA;IAAAP,CAAA,MAAAa,EAAA;EAAA;IAAAA,EAAA,GAAAb,CAAA;EAAA;EAAA,IAAAiB,EAAA;EAAA,IAAAjB,CAAA,QAAAC,SAAA,IAAAD,CAAA,QAAAE,IAAA,IAAAF,CAAA,QAAAG,UAAA,IAAAH,CAAA,QAAAK,UAAA,IAAAL,CAAA,QAAAM,gBAAA,IAAAN,CAAA,QAAAQ,wBAAA,IAAAR,CAAA,SAAAS,UAAA,IAAAT,CAAA,SAAAU,gBAAA,IAAAV,CAAA,SAAAY,EAAA,IAAAZ,CAAA,SAAAa,EAAA;IAlBNI,EAAA,GAAAC,IAAA,CAAAxB,iBAAA;MAAAyB,QAAA,EACED,IAAA,CAAAzB,MAAA;QAAAQ,SAAA;QAAAmB,IAAA,EAAoCjB,UAAA;QAAAkB,KAAA,EAAmBT,EAAe;QAAAO,QAAA,EACpED,IAAA,CAAArB,aAAA;UAAAK,IAAA;UAAAG,UAAA;UAAAC,gBAAA;UAAAC,kBAAA,EAIsBM,EAYpB;UAAAL,wBAAA;UAAAC,UAAA;UAAAC;QAAA,C;;;;;;;;;;;;;;;;;SAlBNO,E;CA0BJ","ignoreList":[]}
+{"version":3,"sources":["../../../src/utilities/fieldsDrawer/Drawer.tsx"],"sourcesContent":["'use client'\nimport type { ClientField, Data, FormState, JsonObject } from 'payload'\n\nimport { Drawer, EditDepthProvider, useModal } from '@payloadcms/ui'\nimport React from 'react'\n\nimport { DrawerContent } from './DrawerContent.js'\n\nexport type FieldsDrawerProps = {\n  readonly className?: string\n  readonly data?: Data\n  readonly drawerSlug: string\n  readonly drawerTitle?: string\n  readonly featureKey: string\n  readonly fieldMapOverride?: ClientField[]\n  readonly handleDrawerSubmit: (fields: FormState, data: JsonObject) => void\n  readonly schemaFieldsPathOverride?: string\n  readonly schemaPath: string\n  readonly schemaPathSuffix?: string\n}\n\n/**\n * This FieldsDrawer component can be used to easily create a Drawer that contains a form with fields within your feature.\n * The fields are taken directly from the schema map based on your `featureKey` and `schemaPathSuffix`. Thus, this can only\n * be used if you provide your field schema inside the `generateSchemaMap` prop of your feature.server.ts.\n */\nexport const FieldsDrawer: React.FC<FieldsDrawerProps> = ({\n  className,\n  data,\n  drawerSlug,\n  drawerTitle,\n  featureKey,\n  fieldMapOverride,\n  handleDrawerSubmit,\n  schemaFieldsPathOverride,\n  schemaPath,\n  schemaPathSuffix,\n}) => {\n  const { closeModal } = useModal()\n  // The Drawer only renders its children (and itself) if it's open. Thus, by extracting the main content\n  // to DrawerContent, this should be faster\n  return (\n    <EditDepthProvider>\n      <Drawer className={className} slug={drawerSlug} title={drawerTitle ?? ''}>\n        <DrawerContent\n          data={data}\n          featureKey={featureKey}\n          fieldMapOverride={fieldMapOverride}\n          handleDrawerSubmit={(args, args2) => {\n            // Simply close drawer - no need for useLexicalDrawer here as at this point,\n            // we don't need to restore the cursor position. This is handled by the useEffect in useLexicalDrawer.\n            closeModal(drawerSlug)\n\n            // Actual drawer submit logic needs to be triggered after the drawer is closed.\n            // That's because the lexical selection / cursor restore logic that is striggerer by\n            // `useLexicalDrawer` neeeds to be triggered before any editor.update calls that may happen\n            // in the `handleDrawerSubmit` function.\n            setTimeout(() => {\n              handleDrawerSubmit(args, args2)\n            }, 1)\n          }}\n          schemaFieldsPathOverride={schemaFieldsPathOverride}\n          schemaPath={schemaPath}\n          schemaPathSuffix={schemaPathSuffix}\n        />\n      </Drawer>\n    </EditDepthProvider>\n  )\n}\n"],"names":["Drawer","EditDepthProvider","useModal","React","DrawerContent","FieldsDrawer","className","data","drawerSlug","drawerTitle","featureKey","fieldMapOverride","handleDrawerSubmit","schemaFieldsPathOverride","schemaPath","schemaPathSuffix","closeModal","slug","title","args","args2","setTimeout"],"mappings":"AAAA;;AAGA,SAASA,MAAM,EAAEC,iBAAiB,EAAEC,QAAQ,QAAQ,iBAAgB;AACpE,OAAOC,WAAW,QAAO;AAEzB,SAASC,aAAa,QAAQ,qBAAoB;AAelD;;;;CAIC,GACD,OAAO,MAAMC,eAA4C,CAAC,EACxDC,SAAS,EACTC,IAAI,EACJC,UAAU,EACVC,WAAW,EACXC,UAAU,EACVC,gBAAgB,EAChBC,kBAAkB,EAClBC,wBAAwB,EACxBC,UAAU,EACVC,gBAAgB,EACjB;IACC,MAAM,EAAEC,UAAU,EAAE,GAAGd;IACvB,uGAAuG;IACvG,0CAA0C;IAC1C,qBACE,KAACD;kBACC,cAAA,KAACD;YAAOM,WAAWA;YAAWW,MAAMT;YAAYU,OAAOT,eAAe;sBACpE,cAAA,KAACL;gBACCG,MAAMA;gBACNG,YAAYA;gBACZC,kBAAkBA;gBAClBC,oBAAoB,CAACO,MAAMC;oBACzB,4EAA4E;oBAC5E,sGAAsG;oBACtGJ,WAAWR;oBAEX,+EAA+E;oBAC/E,oFAAoF;oBACpF,2FAA2F;oBAC3F,wCAAwC;oBACxCa,WAAW;wBACTT,mBAAmBO,MAAMC;oBAC3B,GAAG;gBACL;gBACAP,0BAA0BA;gBAC1BC,YAAYA;gBACZC,kBAAkBA;;;;AAK5B,EAAC"}

package/dist/utilities/fieldsDrawer/DrawerContent.js

@@ -1,5 +1,4 @@
 'use client';
-
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useLexicalEditable } from '@lexical/react/useLexicalEditable';
 import { Form, FormSubmit, RenderFields, useDocumentForm, useDocumentInfo, useServerFunctions, useTranslation } from '@payloadcms/ui';
@@ -8,129 +7,126 @@ import { deepCopyObjectSimpleWithoutReactComponents } from 'payload/shared';
 import React, { useCallback, useEffect, useRef, useState } from 'react';
 import { v4 as uuid } from 'uuid';
 import { useEditorConfigContext } from '../../lexical/config/client/EditorConfigProvider.js';
-export const DrawerContent = ({
-  data,
-  featureKey,
-  fieldMapOverride,
-  handleDrawerSubmit,
-  schemaFieldsPathOverride,
-  schemaPath,
-  schemaPathSuffix
-}) => {
-  const {
-    t
-  } = useTranslation();
-  const {
-    id,
-    collectionSlug,
-    getDocPreferences,
-    globalSlug
-  } = useDocumentInfo();
-  const {
-    fields: parentDocumentFields
-  } = useDocumentForm();
-  const isEditable = useLexicalEditable();
-  const onChangeAbortControllerRef = useRef(new AbortController());
-  const [initialState, setInitialState] = useState(false);
-  const {
-    fieldProps: {
-      featureClientSchemaMap
-    }
-  } = useEditorConfigContext();
-  const {
-    getFormState
-  } = useServerFunctions();
-  const schemaFieldsPath = schemaFieldsPathOverride ?? `${schemaPath}.lexical_internal_feature.${featureKey}${schemaPathSuffix ? `.${schemaPathSuffix}` : ''}`;
-  const fields = fieldMapOverride ?? featureClientSchemaMap[featureKey]?.[schemaFieldsPath] // Field Schema
-  ;
-  useEffect(() => {
-    const controller = new AbortController();
-    const awaitInitialState = async () => {
-      const {
-        state
-      } = await getFormState({
+export const DrawerContent = ({ data, featureKey, fieldMapOverride, handleDrawerSubmit, schemaFieldsPathOverride, schemaPath, schemaPathSuffix })=>{
+    const { t } = useTranslation();
+    const { id, collectionSlug, getDocPreferences, globalSlug } = useDocumentInfo();
+    const { fields: parentDocumentFields } = useDocumentForm();
+    const isEditable = useLexicalEditable();
+    const onChangeAbortControllerRef = useRef(new AbortController());
+    const [initialState, setInitialState] = useState(false);
+    const { fieldProps: { featureClientSchemaMap } } = useEditorConfigContext();
+    const { getFormState } = useServerFunctions();
+    const schemaFieldsPath = schemaFieldsPathOverride ?? `${schemaPath}.lexical_internal_feature.${featureKey}${schemaPathSuffix ? `.${schemaPathSuffix}` : ''}`;
+    const fields = fieldMapOverride ?? featureClientSchemaMap[featureKey]?.[schemaFieldsPath];
+    // Field Schema
+    useEffect(()=>{
+        const controller = new AbortController();
+        const awaitInitialState = async ()=>{
+            const { state } = await getFormState({
+                id,
+                collectionSlug,
+                data: data ?? {},
+                docPermissions: {
+                    fields: true
+                },
+                docPreferences: await getDocPreferences(),
+                documentFormState: deepCopyObjectSimpleWithoutReactComponents(parentDocumentFields),
+                globalSlug,
+                initialBlockData: data,
+                operation: 'update',
+                readOnly: !isEditable,
+                renderAllFields: true,
+                schemaPath: schemaFieldsPath,
+                signal: controller.signal
+            });
+            setInitialState(state);
+        };
+        void awaitInitialState();
+        return ()=>{
+            abortAndIgnore(controller);
+        };
+    }, [
+        schemaFieldsPath,
         id,
+        data,
+        getFormState,
         collectionSlug,
-        data: data ?? {},
-        docPermissions: {
-          fields: true
-        },
-        docPreferences: await getDocPreferences(),
-        documentFormState: deepCopyObjectSimpleWithoutReactComponents(parentDocumentFields),
+        isEditable,
         globalSlug,
-        initialBlockData: data,
-        operation: 'update',
-        readOnly: !isEditable,
-        renderAllFields: true,
-        schemaPath: schemaFieldsPath,
-        signal: controller.signal
-      });
-      setInitialState(state);
-    };
-    void awaitInitialState();
-    return () => {
-      abortAndIgnore(controller);
-    };
-  }, [schemaFieldsPath, id, data, getFormState, collectionSlug, isEditable, globalSlug, getDocPreferences, parentDocumentFields]);
-  const onChange = useCallback(async ({
-    formState: prevFormState
-  }) => {
-    abortAndIgnore(onChangeAbortControllerRef.current);
-    const controller_0 = new AbortController();
-    onChangeAbortControllerRef.current = controller_0;
-    const {
-      state: state_0
-    } = await getFormState({
-      id,
-      collectionSlug,
-      docPermissions: {
-        fields: true
-      },
-      docPreferences: await getDocPreferences(),
-      documentFormState: deepCopyObjectSimpleWithoutReactComponents(parentDocumentFields),
-      formState: prevFormState,
-      globalSlug,
-      initialBlockFormState: prevFormState,
-      operation: 'update',
-      readOnly: !isEditable,
-      schemaPath: schemaFieldsPath,
-      signal: controller_0.signal
-    });
-    if (!state_0) {
-      return prevFormState;
+        getDocPreferences,
+        parentDocumentFields
+    ]);
+    const onChange = useCallback(async ({ formState: prevFormState })=>{
+        abortAndIgnore(onChangeAbortControllerRef.current);
+        const controller = new AbortController();
+        onChangeAbortControllerRef.current = controller;
+        const { state } = await getFormState({
+            id,
+            collectionSlug,
+            docPermissions: {
+                fields: true
+            },
+            docPreferences: await getDocPreferences(),
+            documentFormState: deepCopyObjectSimpleWithoutReactComponents(parentDocumentFields),
+            formState: prevFormState,
+            globalSlug,
+            initialBlockFormState: prevFormState,
+            operation: 'update',
+            readOnly: !isEditable,
+            schemaPath: schemaFieldsPath,
+            signal: controller.signal
+        });
+        if (!state) {
+            return prevFormState;
+        }
+        return state;
+    }, [
+        getFormState,
+        id,
+        isEditable,
+        collectionSlug,
+        getDocPreferences,
+        parentDocumentFields,
+        globalSlug,
+        schemaFieldsPath
+    ]);
+    // cleanup effect
+    useEffect(()=>{
+        return ()=>{
+            abortAndIgnore(onChangeAbortControllerRef.current);
+        };
+    }, []);
+    if (initialState === false) {
+        return null;
     }
-    return state_0;
-  }, [getFormState, id, isEditable, collectionSlug, getDocPreferences, parentDocumentFields, globalSlug, schemaFieldsPath]);
-  // cleanup effect
-  useEffect(() => {
-    return () => {
-      abortAndIgnore(onChangeAbortControllerRef.current);
-    };
-  }, []);
-  if (initialState === false) {
-    return null;
-  }
-  return /*#__PURE__*/_jsxs(Form, {
-    beforeSubmit: [onChange],
-    disableValidationOnSubmit: true,
-    fields: Array.isArray(fields) ? fields : [],
-    initialState: initialState,
-    onChange: [onChange],
-    onSubmit: handleDrawerSubmit,
-    uuid: uuid(),
-    children: [/*#__PURE__*/_jsx(RenderFields, {
-      fields: Array.isArray(fields) ? fields : [],
-      forceRender: true,
-      parentIndexPath: "",
-      parentPath: "" // See Blocks feature path for details as for why this is empty
-      ,
-
-      parentSchemaPath: schemaFieldsPath,
-      permissions: true,
-      readOnly: !isEditable
-    }), /*#__PURE__*/_jsx(FormSubmit, {
-      children: t('fields:saveChanges')
-    })]
-  });
+    return /*#__PURE__*/ _jsxs(Form, {
+        beforeSubmit: [
+            onChange
+        ],
+        disableValidationOnSubmit: true,
+        fields: Array.isArray(fields) ? fields : [],
+        initialState: initialState,
+        onChange: [
+            onChange
+        ],
+        onSubmit: handleDrawerSubmit,
+        uuid: uuid(),
+        children: [
+            /*#__PURE__*/ _jsx(RenderFields, {
+                fields: Array.isArray(fields) ? fields : [],
+                forceRender: true,
+                parentIndexPath: "",
+                parentPath: "",
+                // See Blocks feature path for details as for why this is empty
+                parentSchemaPath: schemaFieldsPath,
+                permissions: true,
+                readOnly: !isEditable
+            }),
+            /*#__PURE__*/ _jsx(FormSubmit, {
+                children: t('fields:saveChanges')
+            })
+        ]
+    });
 };
+
 //# sourceMappingURL=DrawerContent.js.map