@payloadcms/richtext-lexical 3.55.0-internal.f8c92b5 → 3.56.0-canary.0

package/dist/field/RenderLexical/renderLexical.js

@@ -1,96 +0,0 @@
-import { RenderServerComponent } from '@payloadcms/ui/elements/RenderServerComponent';
-import { getClientConfig } from '@payloadcms/ui/utilities/getClientConfig';
-import { getClientSchemaMap } from '@payloadcms/ui/utilities/getClientSchemaMap';
-import { getSchemaMap } from '@payloadcms/ui/utilities/getSchemaMap';
-import { createClientField } from 'payload';
-/**
- * @experimental - may break in minor releases
- */
-export const _internal_renderLexical = async ({
-  name,
-  admin,
-  editorTarget,
-  importMap,
-  initialValue,
-  path,
-  req,
-  schemaPath
-}) => {
-  if (!req.user) {
-    throw new Error('Unauthorized');
-  }
-  const [entityType, entitySlug, ...fieldPath] = editorTarget.split('.');
-  const schemaMap = getSchemaMap({
-    collectionSlug: entityType === 'collection' ? entitySlug : undefined,
-    config: req.payload.config,
-    globalSlug: entityType === 'global' ? entitySlug : undefined,
-    i18n: req.i18n
-  });
-  const targetField = schemaMap.get(`${entitySlug}.${fieldPath.join('.')}`);
-  if (!targetField?.editor || typeof targetField.editor === 'function') {
-    throw new Error(`No editor found for target: ${editorTarget}`);
-  }
-  const sanitizedEditor = targetField.editor;
-  if (!sanitizedEditor) {
-    throw new Error(`No editor found for target: ${editorTarget}`);
-  }
-  const field = {
-    name,
-    type: 'richText',
-    editor: sanitizedEditor
-  };
-  // Provide client schema map as it would have been provided if the target editor field would have been rendered.
-  // Only then will it contain all the lexical-internal entries
-  const clientSchemaMap = getClientSchemaMap({
-    collectionSlug: entityType === 'collection' ? entitySlug : undefined,
-    config: getClientConfig({
-      config: req.payload.config,
-      i18n: req.i18n,
-      importMap: req.payload.importMap
-    }),
-    globalSlug: entityType === 'global' ? entitySlug : undefined,
-    i18n: req.i18n,
-    payload: req.payload,
-    schemaMap
-  });
-  const FieldComponent = RenderServerComponent({
-    Component: sanitizedEditor.FieldComponent,
-    importMap,
-    serverProps: {
-      admin: admin ?? {},
-      clientField: createClientField({
-        defaultIDType: req.payload.db.defaultIDType,
-        field,
-        i18n: req.i18n,
-        importMap
-      }),
-      clientFieldSchemaMap: clientSchemaMap,
-      // collectionSlug is typed incorrectly - @todo make it accept undefined in 4.0
-      collectionSlug: entityType === 'collection' && entitySlug ? entitySlug : '-',
-      data: {},
-      field,
-      fieldSchemaMap: schemaMap,
-      forceRender: true,
-      formState: {},
-      i18n: req.i18n,
-      operation: 'create',
-      path: path ?? name,
-      payload: req.payload,
-      permissions: true,
-      preferences: {
-        fields: {}
-      },
-      req,
-      sanitizedEditorConfig: sanitizedEditor.editorConfig,
-      schemaPath: schemaPath ?? name,
-      siblingData: initialValue ? {
-        [name]: initialValue
-      } : {},
-      user: req.user
-    }
-  });
-  return {
-    Component: FieldComponent
-  };
-};
-//# sourceMappingURL=renderLexical.js.map

package/dist/field/RenderLexical/renderLexical.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"renderLexical.js","names":["RenderServerComponent","getClientConfig","getClientSchemaMap","getSchemaMap","createClientField","_internal_renderLexical","name","admin","editorTarget","importMap","initialValue","path","req","schemaPath","user","Error","entityType","entitySlug","fieldPath","split","schemaMap","collectionSlug","undefined","config","payload","globalSlug","i18n","targetField","get","join","editor","sanitizedEditor","field","type","clientSchemaMap","FieldComponent","Component","serverProps","clientField","defaultIDType","db","clientFieldSchemaMap","data","fieldSchemaMap","forceRender","formState","operation","permissions","preferences","fields","sanitizedEditorConfig","editorConfig","siblingData"],"sources":["../../../src/field/RenderLexical/renderLexical.tsx"],"sourcesContent":["import { RenderServerComponent } from '@payloadcms/ui/elements/RenderServerComponent'\nimport { getClientConfig } from '@payloadcms/ui/utilities/getClientConfig'\nimport { getClientSchemaMap } from '@payloadcms/ui/utilities/getClientSchemaMap'\nimport { getSchemaMap } from '@payloadcms/ui/utilities/getSchemaMap'\nimport {\n  createClientField,\n  type RichTextField,\n  type RichTextFieldClient,\n  type RichTextFieldServerProps,\n  type ServerFunction,\n} from 'payload'\n\nimport {\n  type DefaultTypedEditorState,\n  type LexicalFieldAdminProps,\n  type LexicalRichTextAdapter,\n  type SanitizedServerEditorConfig,\n} from '../../index.js'\n\nexport type RenderLexicalServerFunctionArgs = {\n  admin?: LexicalFieldAdminProps\n  /**\n   * {global|collection}.entitySlug.fieldSchemaPath\n   *\n   * @example collection.posts.richText\n   */\n  editorTarget: string\n  /**\n   * Pass the value this richtext field will receive when rendering it on the server.\n   * This helps provide initial state for sub-fields that are immediately rendered (like blocks)\n   * so that we can avoid multiple waterfall requests for each block that renders on the client.\n   */\n  initialValue?: DefaultTypedEditorState\n  /**\n   * Name of the field to render\n   */\n  name: string\n  /**\n   * Path to the field to render\n   * @default field name\n   */\n  path?: string\n  /**\n   * Schema path to the field to render.\n   */\n  schemaPath: string\n}\nexport type RenderLexicalServerFunctionReturnType = { Component: React.ReactNode }\n\n/**\n * @experimental - may break in minor releases\n */\nexport const _internal_renderLexical: ServerFunction<\n  RenderLexicalServerFunctionArgs,\n  Promise<RenderLexicalServerFunctionReturnType>\n  // eslint-disable-next-line @typescript-eslint/require-await\n> = async ({ name, admin, editorTarget, importMap, initialValue, path, req, schemaPath }) => {\n  if (!req.user) {\n    throw new Error('Unauthorized')\n  }\n\n  const [entityType, entitySlug, ...fieldPath] = editorTarget.split('.')\n\n  const schemaMap = getSchemaMap({\n    collectionSlug: entityType === 'collection' ? entitySlug : undefined,\n    config: req.payload.config,\n    globalSlug: entityType === 'global' ? entitySlug : undefined,\n    i18n: req.i18n,\n  })\n\n  const targetField = schemaMap.get(`${entitySlug}.${fieldPath.join('.')}`) as\n    | RichTextField\n    | undefined\n\n  if (!targetField?.editor || typeof targetField.editor === 'function') {\n    throw new Error(`No editor found for target: ${editorTarget}`)\n  }\n\n  const sanitizedEditor = targetField.editor as LexicalRichTextAdapter\n\n  if (!sanitizedEditor) {\n    throw new Error(`No editor found for target: ${editorTarget}`)\n  }\n\n  const field: RichTextField = {\n    name,\n    type: 'richText',\n    editor: sanitizedEditor,\n  }\n\n  // Provide client schema map as it would have been provided if the target editor field would have been rendered.\n  // Only then will it contain all the lexical-internal entries\n  const clientSchemaMap = getClientSchemaMap({\n    collectionSlug: entityType === 'collection' ? entitySlug : undefined,\n    config: getClientConfig({\n      config: req.payload.config,\n      i18n: req.i18n,\n      importMap: req.payload.importMap,\n    }),\n    globalSlug: entityType === 'global' ? entitySlug : undefined,\n    i18n: req.i18n,\n    payload: req.payload,\n    schemaMap,\n  })\n\n  const FieldComponent = RenderServerComponent({\n    Component: sanitizedEditor.FieldComponent,\n    importMap,\n    serverProps: {\n      admin: admin ?? {},\n      clientField: createClientField({\n        defaultIDType: req.payload.db.defaultIDType,\n        field,\n        i18n: req.i18n,\n        importMap,\n      }) as RichTextFieldClient,\n      clientFieldSchemaMap: clientSchemaMap,\n      // collectionSlug is typed incorrectly - @todo make it accept undefined in 4.0\n      collectionSlug: entityType === 'collection' && entitySlug ? entitySlug : '-',\n      data: {},\n      field,\n      fieldSchemaMap: schemaMap,\n      forceRender: true,\n      formState: {},\n      i18n: req.i18n,\n      operation: 'create',\n      path: path ?? name,\n      payload: req.payload,\n      permissions: true,\n      preferences: {\n        fields: {},\n      },\n      req,\n      sanitizedEditorConfig: sanitizedEditor.editorConfig,\n      schemaPath: schemaPath ?? name,\n      siblingData: initialValue\n        ? {\n            [name]: initialValue,\n          }\n        : {},\n      user: req.user,\n    } satisfies {\n      admin: LexicalFieldAdminProps // <= new in 3.26.0\n      sanitizedEditorConfig: SanitizedServerEditorConfig\n    } & RichTextFieldServerProps,\n  })\n\n  return {\n    Component: FieldComponent,\n  }\n}\n"],"mappings":"AAAA,SAASA,qBAAqB,QAAQ;AACtC,SAASC,eAAe,QAAQ;AAChC,SAASC,kBAAkB,QAAQ;AACnC,SAASC,YAAY,QAAQ;AAC7B,SACEC,iBAAiB,QAKZ;AAuCP;;;AAGA,OAAO,MAAMC,uBAAA,GAIT,MAAAA,CAAO;EAAEC,IAAI;EAAEC,KAAK;EAAEC,YAAY;EAAEC,SAAS;EAAEC,YAAY;EAAEC,IAAI;EAAEC,GAAG;EAAEC;AAAU,CAAE;EACtF,IAAI,CAACD,GAAA,CAAIE,IAAI,EAAE;IACb,MAAM,IAAIC,KAAA,CAAM;EAClB;EAEA,MAAM,CAACC,UAAA,EAAYC,UAAA,EAAY,GAAGC,SAAA,CAAU,GAAGV,YAAA,CAAaW,KAAK,CAAC;EAElE,MAAMC,SAAA,GAAYjB,YAAA,CAAa;IAC7BkB,cAAA,EAAgBL,UAAA,KAAe,eAAeC,UAAA,GAAaK,SAAA;IAC3DC,MAAA,EAAQX,GAAA,CAAIY,OAAO,CAACD,MAAM;IAC1BE,UAAA,EAAYT,UAAA,KAAe,WAAWC,UAAA,GAAaK,SAAA;IACnDI,IAAA,EAAMd,GAAA,CAAIc;EACZ;EAEA,MAAMC,WAAA,GAAcP,SAAA,CAAUQ,GAAG,CAAC,GAAGX,UAAA,IAAcC,SAAA,CAAUW,IAAI,CAAC,MAAM;EAIxE,IAAI,CAACF,WAAA,EAAaG,MAAA,IAAU,OAAOH,WAAA,CAAYG,MAAM,KAAK,YAAY;IACpE,MAAM,IAAIf,KAAA,CAAM,+BAA+BP,YAAA,EAAc;EAC/D;EAEA,MAAMuB,eAAA,GAAkBJ,WAAA,CAAYG,MAAM;EAE1C,IAAI,CAACC,eAAA,EAAiB;IACpB,MAAM,IAAIhB,KAAA,CAAM,+BAA+BP,YAAA,EAAc;EAC/D;EAEA,MAAMwB,KAAA,GAAuB;IAC3B1B,IAAA;IACA2B,IAAA,EAAM;IACNH,MAAA,EAAQC;EACV;EAEA;EACA;EACA,MAAMG,eAAA,GAAkBhC,kBAAA,CAAmB;IACzCmB,cAAA,EAAgBL,UAAA,KAAe,eAAeC,UAAA,GAAaK,SAAA;IAC3DC,MAAA,EAAQtB,eAAA,CAAgB;MACtBsB,MAAA,EAAQX,GAAA,CAAIY,OAAO,CAACD,MAAM;MAC1BG,IAAA,EAAMd,GAAA,CAAIc,IAAI;MACdjB,SAAA,EAAWG,GAAA,CAAIY,OAAO,CAACf;IACzB;IACAgB,UAAA,EAAYT,UAAA,KAAe,WAAWC,UAAA,GAAaK,SAAA;IACnDI,IAAA,EAAMd,GAAA,CAAIc,IAAI;IACdF,OAAA,EAASZ,GAAA,CAAIY,OAAO;IACpBJ;EACF;EAEA,MAAMe,cAAA,GAAiBnC,qBAAA,CAAsB;IAC3CoC,SAAA,EAAWL,eAAA,CAAgBI,cAAc;IACzC1B,SAAA;IACA4B,WAAA,EAAa;MACX9B,KAAA,EAAOA,KAAA,IAAS,CAAC;MACjB+B,WAAA,EAAalC,iBAAA,CAAkB;QAC7BmC,aAAA,EAAe3B,GAAA,CAAIY,OAAO,CAACgB,EAAE,CAACD,aAAa;QAC3CP,KAAA;QACAN,IAAA,EAAMd,GAAA,CAAIc,IAAI;QACdjB;MACF;MACAgC,oBAAA,EAAsBP,eAAA;MACtB;MACAb,cAAA,EAAgBL,UAAA,KAAe,gBAAgBC,UAAA,GAAaA,UAAA,GAAa;MACzEyB,IAAA,EAAM,CAAC;MACPV,KAAA;MACAW,cAAA,EAAgBvB,SAAA;MAChBwB,WAAA,EAAa;MACbC,SAAA,EAAW,CAAC;MACZnB,IAAA,EAAMd,GAAA,CAAIc,IAAI;MACdoB,SAAA,EAAW;MACXnC,IAAA,EAAMA,IAAA,IAAQL,IAAA;MACdkB,OAAA,EAASZ,GAAA,CAAIY,OAAO;MACpBuB,WAAA,EAAa;MACbC,WAAA,EAAa;QACXC,MAAA,EAAQ,CAAC;MACX;MACArC,GAAA;MACAsC,qBAAA,EAAuBnB,eAAA,CAAgBoB,YAAY;MACnDtC,UAAA,EAAYA,UAAA,IAAcP,IAAA;MAC1B8C,WAAA,EAAa1C,YAAA,GACT;QACE,CAACJ,IAAA,GAAOI;MACV,IACA,CAAC;MACLI,IAAA,EAAMF,GAAA,CAAIE;IACZ;EAIF;EAEA,OAAO;IACLsB,SAAA,EAAWD;EACb;AACF","ignoreList":[]}

package/dist/field/RenderLexical/useRenderEditor.d.ts

@@ -1,15 +0,0 @@
-import { type FieldType } from '@payloadcms/ui';
-import React from 'react';
-import type { DefaultTypedEditorState } from '../../nodeTypes.js';
-import type { RenderLexicalServerFunctionArgs } from './renderLexical.js';
-/**
- * @experimental - may break in minor releases
- */
-export declare const useRenderEditor_internal_: (args: Omit<RenderLexicalServerFunctionArgs, "initialValue" | "schemaPath">) => {
-    Component: ({ setValue, value, }: {
-        setValue?: FieldType<DefaultTypedEditorState | undefined>["setValue"];
-        value?: FieldType<DefaultTypedEditorState | undefined>["value"];
-    }) => React.JSX.Element | null;
-    renderLexical: (args?: Pick<RenderLexicalServerFunctionArgs, "initialValue">) => void;
-};
-//# sourceMappingURL=useRenderEditor.d.ts.map

package/dist/field/RenderLexical/useRenderEditor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useRenderEditor.d.ts","sourceRoot":"","sources":["../../../src/field/RenderLexical/useRenderEditor.tsx"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,SAAS,EAIf,MAAM,gBAAgB,CAAA;AACvB,OAAO,KAAsB,MAAM,OAAO,CAAA;AAE1C,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAA;AACjE,OAAO,KAAK,EACV,+BAA+B,EAEhC,MAAM,oBAAoB,CAAA;AAE3B;;GAEG;AACH,eAAO,MAAM,yBAAyB,SAC9B,IAAI,CAAC,+BAA+B,EAAE,cAAc,GAAG,YAAY,CAAC;sCAuCxE;QACE,QAAQ,CAAC,EAAE,SAAS,CAAC,uBAAuB,GAAG,SAAS,CAAC,CAAC,UAAU,CAAC,CAAA;QAErE,KAAK,CAAC,EAAE,SAAS,CAAC,uBAAuB,GAAG,SAAS,CAAC,CAAC,OAAO,CAAC,CAAA;KAChE;2BAjCO,IAAI,CAAC,+BAA+B,EAAE,cAAc,CAAC;CA2FhE,CAAA"}

package/dist/field/RenderLexical/useRenderEditor.js

@@ -1,159 +0,0 @@
-'use client';
-
-import { c as _c } from "react/compiler-runtime";
-import { jsx as _jsx } from "react/jsx-runtime";
-import { FieldContext, FieldPathContext, ServerFunctionsContext, useServerFunctions } from '@payloadcms/ui';
-import React, { useCallback } from 'react';
-/**
- * @experimental - may break in minor releases
- */
-export const useRenderEditor_internal_ = args => {
-  const $ = _c(24);
-  const {
-    name,
-    admin,
-    editorTarget,
-    path
-  } = args;
-  const [Component, setComponent] = React.useState(null);
-  const serverFunctionContext = useServerFunctions();
-  const {
-    serverFunction
-  } = serverFunctionContext;
-  let t0;
-  if ($[0] !== editorTarget) {
-    t0 = editorTarget.split(".");
-    $[0] = editorTarget;
-    $[1] = t0;
-  } else {
-    t0 = $[1];
-  }
-  let entitySlug;
-  let entityType;
-  let fieldPath;
-  if ($[2] !== t0) {
-    [entityType, entitySlug, ...fieldPath] = t0;
-    $[2] = t0;
-    $[3] = entitySlug;
-    $[4] = entityType;
-    $[5] = fieldPath;
-  } else {
-    entitySlug = $[3];
-    entityType = $[4];
-    fieldPath = $[5];
-  }
-  let t1;
-  if ($[6] !== admin || $[7] !== editorTarget || $[8] !== entitySlug || $[9] !== fieldPath || $[10] !== name || $[11] !== path || $[12] !== serverFunction) {
-    t1 = args_0 => {
-      const render = async function render() {
-        const {
-          Component: Component_0
-        } = await serverFunction({
-          name: "render-lexical",
-          args: {
-            name,
-            admin,
-            editorTarget,
-            initialValue: args_0?.initialValue ?? undefined,
-            path,
-            schemaPath: `${entitySlug}.${fieldPath.join(".")}`
-          }
-        });
-        setComponent(Component_0);
-      };
-      render();
-    };
-    $[6] = admin;
-    $[7] = editorTarget;
-    $[8] = entitySlug;
-    $[9] = fieldPath;
-    $[10] = name;
-    $[11] = path;
-    $[12] = serverFunction;
-    $[13] = t1;
-  } else {
-    t1 = $[13];
-  }
-  const renderLexical = t1;
-  let t2;
-  if ($[14] !== Component || $[15] !== entitySlug || $[16] !== entityType || $[17] !== name || $[18] !== path || $[19] !== serverFunctionContext) {
-    t2 = function Memoized(t3) {
-      const {
-        setValue,
-        value
-      } = t3;
-      if (!Component) {
-        return null;
-      }
-      const adjustedServerFunctionContext = {
-        ...serverFunctionContext,
-        getFormState: async getFormStateArgs => serverFunctionContext.getFormState({
-          ...getFormStateArgs,
-          collectionSlug: entityType === "collection" ? entitySlug : undefined,
-          globalSlug: entityType === "global" ? entitySlug : undefined
-        })
-      };
-      const fieldPath_0 = path ?? name;
-      if (typeof value === "undefined" && !setValue) {
-        return _jsx(ServerFunctionsContext, {
-          value: {
-            ...adjustedServerFunctionContext
-          },
-          children: _jsx(FieldPathContext, {
-            value: fieldPath_0,
-            children: Component
-          }, fieldPath_0)
-        });
-      }
-      const fieldValue = {
-        disabled: false,
-        formInitializing: false,
-        formProcessing: false,
-        formSubmitted: false,
-        initialValue: value,
-        path: fieldPath_0,
-        setValue: setValue ?? _temp,
-        showError: false,
-        value
-      };
-      return _jsx(ServerFunctionsContext, {
-        value: {
-          ...adjustedServerFunctionContext
-        },
-        children: _jsx(FieldPathContext, {
-          value: fieldPath_0,
-          children: _jsx(FieldContext, {
-            value: fieldValue,
-            children: Component
-          })
-        }, fieldPath_0)
-      });
-    };
-    $[14] = Component;
-    $[15] = entitySlug;
-    $[16] = entityType;
-    $[17] = name;
-    $[18] = path;
-    $[19] = serverFunctionContext;
-    $[20] = t2;
-  } else {
-    t2 = $[20];
-  }
-  const Memoized = t2;
-  const WrappedComponent = Memoized;
-  let t3;
-  if ($[21] !== WrappedComponent || $[22] !== renderLexical) {
-    t3 = {
-      Component: WrappedComponent,
-      renderLexical
-    };
-    $[21] = WrappedComponent;
-    $[22] = renderLexical;
-    $[23] = t3;
-  } else {
-    t3 = $[23];
-  }
-  return t3;
-};
-function _temp() {}
-//# sourceMappingURL=useRenderEditor.js.map

package/dist/field/RenderLexical/useRenderEditor.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useRenderEditor.js","names":["c","_c","FieldContext","FieldPathContext","ServerFunctionsContext","useServerFunctions","React","useCallback","useRenderEditor_internal_","args","$","name","admin","editorTarget","path","Component","setComponent","useState","serverFunctionContext","serverFunction","t0","split","entitySlug","entityType","fieldPath","t1","args_0","render","Component_0","initialValue","undefined","schemaPath","join","renderLexical","t2","Memoized","t3","setValue","value","adjustedServerFunctionContext","getFormState","getFormStateArgs","collectionSlug","globalSlug","fieldPath_0","_jsx","children","fieldValue","disabled","formInitializing","formProcessing","formSubmitted","_temp","showError","WrappedComponent"],"sources":["../../../src/field/RenderLexical/useRenderEditor.tsx"],"sourcesContent":["'use client'\nimport {\n  FieldContext,\n  FieldPathContext,\n  type FieldType,\n  ServerFunctionsContext,\n  type ServerFunctionsContextType,\n  useServerFunctions,\n} from '@payloadcms/ui'\nimport React, { useCallback } from 'react'\n\nimport type { DefaultTypedEditorState } from '../../nodeTypes.js'\nimport type {\n  RenderLexicalServerFunctionArgs,\n  RenderLexicalServerFunctionReturnType,\n} from './renderLexical.js'\n\n/**\n * @experimental - may break in minor releases\n */\nexport const useRenderEditor_internal_ = (\n  args: Omit<RenderLexicalServerFunctionArgs, 'initialValue' | 'schemaPath'>,\n) => {\n  const { name, admin, editorTarget, path } = args\n  const [Component, setComponent] = React.useState<null | React.ReactNode>(null)\n  const serverFunctionContext = useServerFunctions()\n  const { serverFunction } = serverFunctionContext\n\n  const [entityType, entitySlug, ...fieldPath] = editorTarget.split('.')\n\n  const renderLexical = useCallback(\n    (args?: Pick<RenderLexicalServerFunctionArgs, 'initialValue'>) => {\n      async function render() {\n        const { Component } = (await serverFunction({\n          name: 'render-lexical',\n          args: {\n            name,\n            admin,\n            editorTarget,\n            initialValue: args?.initialValue ?? undefined,\n            path,\n            schemaPath: `${entitySlug}.${fieldPath.join('.')}`,\n          } satisfies RenderLexicalServerFunctionArgs,\n        })) as RenderLexicalServerFunctionReturnType\n\n        setComponent(Component)\n      }\n      void render()\n    },\n    [serverFunction, name, admin, editorTarget, path, entitySlug, fieldPath],\n  )\n\n  const WrappedComponent = React.useMemo(() => {\n    function Memoized({\n      setValue,\n      value,\n    }: /**\n     * If value or setValue, or both, is provided, this component will manage its own value.\n     * If neither is passed, it will rely on the parent form to manage the value.\n     */\n    {\n      setValue?: FieldType<DefaultTypedEditorState | undefined>['setValue']\n\n      value?: FieldType<DefaultTypedEditorState | undefined>['value']\n    }) {\n      if (!Component) {\n        return null\n      }\n\n      /**\n       * By default, the lexical will make form state requests (e.g. to get drawer fields), passing in the arguments\n       * of the current field. However, we need to override those arguments to get it to make requests based on the\n       * *target* field. The server only knows the schema map of the target field.\n       */\n      const adjustedServerFunctionContext: ServerFunctionsContextType = {\n        ...serverFunctionContext,\n        getFormState: async (getFormStateArgs) => {\n          return serverFunctionContext.getFormState({\n            ...getFormStateArgs,\n            collectionSlug: entityType === 'collection' ? entitySlug : undefined,\n            globalSlug: entityType === 'global' ? entitySlug : undefined,\n          })\n        },\n      }\n\n      const fieldPath = path ?? name\n\n      if (typeof value === 'undefined' && !setValue) {\n        return (\n          <ServerFunctionsContext value={{ ...adjustedServerFunctionContext }}>\n            <FieldPathContext key={fieldPath} value={fieldPath}>\n              {Component}\n            </FieldPathContext>\n          </ServerFunctionsContext>\n        )\n      }\n\n      const fieldValue: FieldType<DefaultTypedEditorState | undefined> = {\n        disabled: false,\n        formInitializing: false,\n        formProcessing: false,\n        formSubmitted: false,\n        initialValue: value,\n        path: fieldPath,\n        setValue: setValue ?? (() => undefined),\n        showError: false,\n        value,\n      }\n\n      return (\n        <ServerFunctionsContext value={{ ...adjustedServerFunctionContext }}>\n          <FieldPathContext key={fieldPath} value={fieldPath}>\n            <FieldContext value={fieldValue}>{Component}</FieldContext>\n          </FieldPathContext>\n        </ServerFunctionsContext>\n      )\n    }\n\n    return Memoized\n  }, [Component, serverFunctionContext, path, name, entityType, entitySlug])\n\n  return { Component: WrappedComponent, renderLexical }\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/utilities/buildEditorState.d.ts

@@ -1,11 +0,0 @@
-import type { SerializedLexicalNode } from 'lexical';
-import type { DefaultTypedEditorState, TypedEditorState } from '../nodeTypes.js';
-export declare function buildEditorState(args: {
-    nodes?: DefaultTypedEditorState['root']['children'];
-    text?: string;
-}): DefaultTypedEditorState;
-export declare function buildEditorState<T extends SerializedLexicalNode>(args: {
-    nodes?: TypedEditorState<T>['root']['children'];
-    text?: string;
-}): TypedEditorState<T>;
-//# sourceMappingURL=buildEditorState.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"buildEditorState.d.ts","sourceRoot":"","sources":["../../src/utilities/buildEditorState.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAEpD,OAAO,KAAK,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AAEhF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE;IACrC,KAAK,CAAC,EAAE,uBAAuB,CAAC,MAAM,CAAC,CAAC,UAAU,CAAC,CAAA;IACnD,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,GAAG,uBAAuB,CAAA;AAE3B,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,qBAAqB,EAAE,IAAI,EAAE;IAEtE,KAAK,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,UAAU,CAAC,CAAA;IAC/C,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAAA"}

package/dist/utilities/buildEditorState.js

@@ -1,76 +0,0 @@
-/**
- * Helper to build lexical editor state JSON from text and/or nodes.
- *
- * @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.
- * @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.
- * @returns The constructed editor state JSON.
- *
- * @example
- *
- * just passing text:
- *
- * ```ts
- * const editorState = buildEditorState({ text: 'Hello world' }) // result typed as DefaultTypedEditorState
- * ```
- *
- * @example
- *
- * passing nodes:
- *
- * ```ts
- * const editorState = // result typed as TypedEditorState<DefaultNodeTypes | SerializedBlockNode> (or TypedEditorState<SerializedBlockNode>)
- * buildEditorState<DefaultNodeTypes | SerializedBlockNode>({ // or just buildEditorState<SerializedBlockNode> if you *only* want to allow block nodes
- *   nodes: [
- *     {
- *       type: 'block',
- *        fields: {
- *          id: 'id',
- *          blockName: 'Cool block',
- *          blockType: 'myBlock',
- *        },
- *        format: 'left',
- *        version: 1,
- *      }
- *   ],
- * })
- * ```
- */export function buildEditorState({
-  nodes,
-  text
-}) {
-  const editorJSON = {
-    root: {
-      type: 'root',
-      children: [],
-      direction: 'ltr',
-      format: '',
-      indent: 0,
-      version: 1
-    }
-  };
-  if (text) {
-    editorJSON.root.children.push({
-      type: 'paragraph',
-      children: [{
-        type: 'text',
-        detail: 0,
-        format: 0,
-        mode: 'normal',
-        style: '',
-        text,
-        version: 1
-      }],
-      direction: 'ltr',
-      format: '',
-      indent: 0,
-      textFormat: 0,
-      textStyle: '',
-      version: 1
-    });
-  }
-  if (nodes?.length) {
-    editorJSON.root.children.push(...nodes);
-  }
-  return editorJSON;
-}
-//# sourceMappingURL=buildEditorState.js.map

package/dist/utilities/buildEditorState.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"buildEditorState.js","names":["buildEditorState","nodes","text","editorJSON","root","type","children","direction","format","indent","version","push","detail","mode","style","textFormat","textStyle","length"],"sources":["../../src/utilities/buildEditorState.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\n\nimport type { DefaultTypedEditorState, TypedEditorState } from '../nodeTypes.js'\n\nexport function buildEditorState(args: {\n  nodes?: DefaultTypedEditorState['root']['children']\n  text?: string\n}): DefaultTypedEditorState\n\nexport function buildEditorState<T extends SerializedLexicalNode>(args: {\n  // If you pass children typed for a specific schema T, the return is TypedEditorState<T>\n  nodes?: TypedEditorState<T>['root']['children']\n  text?: string\n}): TypedEditorState<T>\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({ 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?: DefaultTypedEditorState['root']['children'] | TypedEditorState<T>['root']['children']\n  text?: string\n}): DefaultTypedEditorState | 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    editorJSON.root.children.push(...(nodes as any))\n  }\n\n  return editorJSON\n}\n"],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;IACjBd,UAAA,CAAWC,IAAI,CAACE,QAAQ,CAACK,IAAI,IAAKV,KAAA;EACpC;EAEA,OAAOE,UAAA;AACT","ignoreList":[]}