@payloadcms/richtext-lexical 0.7.0 → 3.0.0-alpha.18

package/dist/field/index.js

@@ -9,8 +9,13 @@ Object.defineProperty(exports, "RichTextField", {
         return RichTextField;
     }
 });
-const _components = require("payload/components");
+const _ui = require("@payloadcms/ui");
+const _forms = require("@payloadcms/ui/forms");
+const _providers = require("@payloadcms/ui/providers");
 const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _default = require("./lexical/config/client/default");
+const _loader = require("./lexical/config/client/loader");
+const _sanitize = require("./lexical/config/client/sanitize");
 function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
     var cacheBabelInterop = new WeakMap();
@@ -52,14 +57,81 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
-// @ts-expect-error Just TypeScript being broken // TODO: Open TypeScript issue
+// @ts-expect-error-next-line Just TypeScript being broken // TODO: Open TypeScript issue
 const RichTextEditor = /*#__PURE__*/ (0, _react.lazy)(()=>Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("./Field"))));
 const RichTextField = (props)=>{
+    const { lexicalEditorConfig, richTextComponentMap } = props;
+    const { schemaPath } = (0, _forms.useFieldPath)();
+    const clientFunctions = (0, _providers.useClientFunctions)();
+    const [hasLoadedFeatures, setHasLoadedFeatures] = (0, _react.useState)(false);
+    const [featureProviders, setFeatureProviders] = (0, _react.useState)([]);
+    const [finalSanitizedEditorConfig, setFinalSanitizedEditorConfig] = (0, _react.useState)(null);
+    let featureProviderComponents = richTextComponentMap.get('features')// TODO: Type better
+    ;
+    // order by order
+    featureProviderComponents = featureProviderComponents.sort((a, b)=>a.order - b.order);
+    const featureComponentsWithFeaturesLength = Array.from(richTextComponentMap.keys()).filter((key)=>key.startsWith(`feature.`) && !key.includes('.fields.')).length + featureProviderComponents.length;
+    (0, _react.useEffect)(()=>{
+        if (!hasLoadedFeatures) {
+            const featureProvidersLocal = [];
+            let featureProvidersAndComponentsLoaded = 0;
+            Object.entries(clientFunctions).forEach(([key, plugin])=>{
+                if (key.startsWith(`lexicalFeature.${schemaPath}.`)) {
+                    if (!key.includes('.components.')) {
+                        featureProvidersLocal.push(plugin);
+                    }
+                    featureProvidersAndComponentsLoaded++;
+                }
+            });
+            if (featureProvidersAndComponentsLoaded === featureComponentsWithFeaturesLength) {
+                setFeatureProviders(featureProvidersLocal);
+                setHasLoadedFeatures(true);
+                /**
+         * Loaded feature provided => create the final sanitized editor config
+         */ const resolvedClientFeatures = (0, _loader.loadClientFeatures)({
+                    clientFunctions,
+                    schemaPath,
+                    unSanitizedEditorConfig: {
+                        features: featureProvidersLocal,
+                        lexical: lexicalEditorConfig
+                    }
+                });
+                setFinalSanitizedEditorConfig((0, _sanitize.sanitizeClientEditorConfig)(lexicalEditorConfig ? lexicalEditorConfig : _default.defaultEditorLexicalConfig, resolvedClientFeatures));
+            }
+        }
+    }, [
+        hasLoadedFeatures,
+        clientFunctions,
+        schemaPath,
+        featureProviderComponents.length,
+        featureProviders,
+        finalSanitizedEditorConfig,
+        lexicalEditorConfig,
+        featureComponentsWithFeaturesLength
+    ]);
+    if (!hasLoadedFeatures) {
+        return /*#__PURE__*/ _react.default.createElement(_react.default.Fragment, null, Array.isArray(featureProviderComponents) && featureProviderComponents.map((featureProvider)=>{
+            // get all components starting with key feature.${FeatureProvider.key}.components.{featureComponentKey}
+            const featureComponentKeys = Array.from(richTextComponentMap.keys()).filter((key)=>key.startsWith(`feature.${featureProvider.key}.components.`));
+            const featureComponents = featureComponentKeys.map((key)=>{
+                return richTextComponentMap.get(key);
+            })// TODO: Type better
+            ;
+            return /*#__PURE__*/ _react.default.createElement(_react.default.Fragment, {
+                key: featureProvider.key
+            }, featureComponents?.length ? featureComponents.map((FeatureComponent)=>{
+                return FeatureComponent;
+            }) : null, featureProvider.ClientComponent);
+        }));
+    }
     return /*#__PURE__*/ _react.default.createElement(_react.Suspense, {
-        fallback: /*#__PURE__*/ _react.default.createElement(_components.ShimmerEffect, {
+        fallback: /*#__PURE__*/ _react.default.createElement(_ui.ShimmerEffect, {
             height: "35vh"
         })
-    }, /*#__PURE__*/ _react.default.createElement(RichTextEditor, props));
+    }, finalSanitizedEditorConfig && /*#__PURE__*/ _react.default.createElement(RichTextEditor, {
+        ...props,
+        editorConfig: finalSanitizedEditorConfig
+    }));
 };
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9maWVsZC9pbmRleC50c3giXSwic291cmNlc0NvbnRlbnQiOlsiJ3VzZSBjbGllbnQnXG5pbXBvcnQgeyBTaGltbWVyRWZmZWN0IH0gZnJvbSAncGF5bG9hZC9jb21wb25lbnRzJ1xuaW1wb3J0IFJlYWN0LCB7IFN1c3BlbnNlLCBsYXp5IH0gZnJvbSAncmVhY3QnXG5cbmltcG9ydCB0eXBlIHsgRmllbGRQcm9wcyB9IGZyb20gJy4uL3R5cGVzJ1xuXG4vLyBAdHMtZXhwZWN0LWVycm9yIEp1c3QgVHlwZVNjcmlwdCBiZWluZyBicm9rZW4gLy8gVE9ETzogT3BlbiBUeXBlU2NyaXB0IGlzc3VlXG5jb25zdCBSaWNoVGV4dEVkaXRvciA9IGxhenkoKCkgPT4gaW1wb3J0KCcuL0ZpZWxkJykpXG5cbmV4cG9ydCBjb25zdCBSaWNoVGV4dEZpZWxkOiBSZWFjdC5GQzxGaWVsZFByb3BzPiA9IChwcm9wcykgPT4ge1xuICByZXR1cm4gKFxuICAgIDxTdXNwZW5zZSBmYWxsYmFjaz17PFNoaW1tZXJFZmZlY3QgaGVpZ2h0PVwiMzV2aFwiIC8+fT5cbiAgICAgIDxSaWNoVGV4dEVkaXRvciB7Li4ucHJvcHN9IC8+XG4gICAgPC9TdXNwZW5zZT5cbiAgKVxufVxuIl0sIm5hbWVzIjpbIlJpY2hUZXh0RmllbGQiLCJSaWNoVGV4dEVkaXRvciIsImxhenkiLCJwcm9wcyIsIlN1c3BlbnNlIiwiZmFsbGJhY2siLCJTaGltbWVyRWZmZWN0IiwiaGVpZ2h0Il0sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7K0JBU2FBOzs7ZUFBQUE7Ozs0QkFSaUI7K0RBQ1E7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUl0QywrRUFBK0U7QUFDL0UsTUFBTUMsK0JBQWlCQyxJQUFBQSxXQUFJLEVBQUMsSUFBTSxtRUFBQSxRQUFPO0FBRWxDLE1BQU1GLGdCQUFzQyxDQUFDRztJQUNsRCxxQkFDRSw2QkFBQ0MsZUFBUTtRQUFDQyx3QkFBVSw2QkFBQ0MseUJBQWE7WUFBQ0MsUUFBTzs7cUJBQ3hDLDZCQUFDTixnQkFBbUJFO0FBRzFCIn0=
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/field/index.tsx"],"sourcesContent":["'use client'\nimport type { EditorConfig as LexicalEditorConfig } from 'lexical/LexicalEditor'\n\nimport { type FormFieldBase, ShimmerEffect } from '@payloadcms/ui'\nimport { useFieldPath } from '@payloadcms/ui/forms'\nimport { useClientFunctions } from '@payloadcms/ui/providers'\nimport React, { Suspense, lazy, useEffect, useState } from 'react'\n\nimport type { GeneratedFeatureProviderComponent } from '../types'\nimport type { FeatureProviderClient } from './features/types'\nimport type { SanitizedClientEditorConfig } from './lexical/config/types'\n\nimport { defaultEditorLexicalConfig } from './lexical/config/client/default'\nimport { loadClientFeatures } from './lexical/config/client/loader'\nimport { sanitizeClientEditorConfig } from './lexical/config/client/sanitize'\n\n// @ts-expect-error-next-line Just TypeScript being broken // TODO: Open TypeScript issue\nconst RichTextEditor = lazy(() => import('./Field'))\n\nexport const RichTextField: React.FC<\n  FormFieldBase & {\n    lexicalEditorConfig: LexicalEditorConfig\n    name: string\n    richTextComponentMap: Map<string, React.ReactNode>\n  }\n> = (props) => {\n  const { lexicalEditorConfig, richTextComponentMap } = props\n  const { schemaPath } = useFieldPath()\n  const clientFunctions = useClientFunctions()\n  const [hasLoadedFeatures, setHasLoadedFeatures] = useState(false)\n\n  const [featureProviders, setFeatureProviders] = useState<FeatureProviderClient<unknown>[]>([])\n\n  const [finalSanitizedEditorConfig, setFinalSanitizedEditorConfig] =\n    useState<SanitizedClientEditorConfig>(null)\n\n  let featureProviderComponents: GeneratedFeatureProviderComponent[] = richTextComponentMap.get(\n    'features',\n  ) as GeneratedFeatureProviderComponent[] // TODO: Type better\n  // order by order\n  featureProviderComponents = featureProviderComponents.sort((a, b) => a.order - b.order)\n\n  const featureComponentsWithFeaturesLength =\n    Array.from(richTextComponentMap.keys()).filter(\n      (key) => key.startsWith(`feature.`) && !key.includes('.fields.'),\n    ).length + featureProviderComponents.length\n\n  useEffect(() => {\n    if (!hasLoadedFeatures) {\n      const featureProvidersLocal: FeatureProviderClient<unknown>[] = []\n      let featureProvidersAndComponentsLoaded = 0\n\n      Object.entries(clientFunctions).forEach(([key, plugin]) => {\n        if (key.startsWith(`lexicalFeature.${schemaPath}.`)) {\n          if (!key.includes('.components.')) {\n            featureProvidersLocal.push(plugin)\n          }\n          featureProvidersAndComponentsLoaded++\n        }\n      })\n\n      if (featureProvidersAndComponentsLoaded === featureComponentsWithFeaturesLength) {\n        setFeatureProviders(featureProvidersLocal)\n        setHasLoadedFeatures(true)\n\n        /**\n         * Loaded feature provided => create the final sanitized editor config\n         */\n\n        const resolvedClientFeatures = loadClientFeatures({\n          clientFunctions,\n          schemaPath,\n          unSanitizedEditorConfig: {\n            features: featureProvidersLocal,\n            lexical: lexicalEditorConfig,\n          },\n        })\n\n        setFinalSanitizedEditorConfig(\n          sanitizeClientEditorConfig(\n            lexicalEditorConfig ? lexicalEditorConfig : defaultEditorLexicalConfig,\n            resolvedClientFeatures,\n          ),\n        )\n      }\n    }\n  }, [\n    hasLoadedFeatures,\n    clientFunctions,\n    schemaPath,\n    featureProviderComponents.length,\n    featureProviders,\n    finalSanitizedEditorConfig,\n    lexicalEditorConfig,\n    featureComponentsWithFeaturesLength,\n  ])\n\n  if (!hasLoadedFeatures) {\n    return (\n      <React.Fragment>\n        {Array.isArray(featureProviderComponents) &&\n          featureProviderComponents.map((featureProvider) => {\n            // get all components starting with key feature.${FeatureProvider.key}.components.{featureComponentKey}\n            const featureComponentKeys = Array.from(richTextComponentMap.keys()).filter((key) =>\n              key.startsWith(`feature.${featureProvider.key}.components.`),\n            )\n            const featureComponents: React.ReactNode[] = featureComponentKeys.map((key) => {\n              return richTextComponentMap.get(key)\n            }) as React.ReactNode[] // TODO: Type better\n\n            return (\n              <React.Fragment key={featureProvider.key}>\n                {featureComponents?.length\n                  ? featureComponents.map((FeatureComponent) => {\n                      return FeatureComponent\n                    })\n                  : null}\n                {featureProvider.ClientComponent}\n              </React.Fragment>\n            )\n          })}\n      </React.Fragment>\n    )\n  }\n\n  return (\n    <Suspense fallback={<ShimmerEffect height=\"35vh\" />}>\n      {finalSanitizedEditorConfig && (\n        <RichTextEditor {...props} editorConfig={finalSanitizedEditorConfig} />\n      )}\n    </Suspense>\n  )\n}\n"],"names":["RichTextField","RichTextEditor","lazy","props","lexicalEditorConfig","richTextComponentMap","schemaPath","useFieldPath","clientFunctions","useClientFunctions","hasLoadedFeatures","setHasLoadedFeatures","useState","featureProviders","setFeatureProviders","finalSanitizedEditorConfig","setFinalSanitizedEditorConfig","featureProviderComponents","get","sort","a","b","order","featureComponentsWithFeaturesLength","Array","from","keys","filter","key","startsWith","includes","length","useEffect","featureProvidersLocal","featureProvidersAndComponentsLoaded","Object","entries","forEach","plugin","push","resolvedClientFeatures","loadClientFeatures","unSanitizedEditorConfig","features","lexical","sanitizeClientEditorConfig","defaultEditorLexicalConfig","React","Fragment","isArray","map","featureProvider","featureComponentKeys","featureComponents","FeatureComponent","ClientComponent","Suspense","fallback","ShimmerEffect","height","editorConfig"],"mappings":"AAAA;;;;;+BAmBaA;;;eAAAA;;;oBAhBqC;uBACrB;2BACM;+DACwB;yBAMhB;wBACR;0BACQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE3C,yFAAyF;AACzF,MAAMC,+BAAiBC,IAAAA,WAAI,EAAC,IAAM,mEAAA,QAAO;AAElC,MAAMF,gBAMT,CAACG;IACH,MAAM,EAAEC,mBAAmB,EAAEC,oBAAoB,EAAE,GAAGF;IACtD,MAAM,EAAEG,UAAU,EAAE,GAAGC,IAAAA,mBAAY;IACnC,MAAMC,kBAAkBC,IAAAA,6BAAkB;IAC1C,MAAM,CAACC,mBAAmBC,qBAAqB,GAAGC,IAAAA,eAAQ,EAAC;IAE3D,MAAM,CAACC,kBAAkBC,oBAAoB,GAAGF,IAAAA,eAAQ,EAAmC,EAAE;IAE7F,MAAM,CAACG,4BAA4BC,8BAA8B,GAC/DJ,IAAAA,eAAQ,EAA8B;IAExC,IAAIK,4BAAiEZ,qBAAqBa,GAAG,CAC3F,WACuC,oBAAoB;;IAC7D,iBAAiB;IACjBD,4BAA4BA,0BAA0BE,IAAI,CAAC,CAACC,GAAGC,IAAMD,EAAEE,KAAK,GAAGD,EAAEC,KAAK;IAEtF,MAAMC,sCACJC,MAAMC,IAAI,CAACpB,qBAAqBqB,IAAI,IAAIC,MAAM,CAC5C,CAACC,MAAQA,IAAIC,UAAU,CAAC,CAAC,QAAQ,CAAC,KAAK,CAACD,IAAIE,QAAQ,CAAC,aACrDC,MAAM,GAAGd,0BAA0Bc,MAAM;IAE7CC,IAAAA,gBAAS,EAAC;QACR,IAAI,CAACtB,mBAAmB;YACtB,MAAMuB,wBAA0D,EAAE;YAClE,IAAIC,sCAAsC;YAE1CC,OAAOC,OAAO,CAAC5B,iBAAiB6B,OAAO,CAAC,CAAC,CAACT,KAAKU,OAAO;gBACpD,IAAIV,IAAIC,UAAU,CAAC,CAAC,eAAe,EAAEvB,WAAW,CAAC,CAAC,GAAG;oBACnD,IAAI,CAACsB,IAAIE,QAAQ,CAAC,iBAAiB;wBACjCG,sBAAsBM,IAAI,CAACD;oBAC7B;oBACAJ;gBACF;YACF;YAEA,IAAIA,wCAAwCX,qCAAqC;gBAC/ET,oBAAoBmB;gBACpBtB,qBAAqB;gBAErB;;SAEC,GAED,MAAM6B,yBAAyBC,IAAAA,0BAAkB,EAAC;oBAChDjC;oBACAF;oBACAoC,yBAAyB;wBACvBC,UAAUV;wBACVW,SAASxC;oBACX;gBACF;gBAEAY,8BACE6B,IAAAA,oCAA0B,EACxBzC,sBAAsBA,sBAAsB0C,mCAA0B,EACtEN;YAGN;QACF;IACF,GAAG;QACD9B;QACAF;QACAF;QACAW,0BAA0Bc,MAAM;QAChClB;QACAE;QACAX;QACAmB;KACD;IAED,IAAI,CAACb,mBAAmB;QACtB,qBACE,6BAACqC,cAAK,CAACC,QAAQ,QACZxB,MAAMyB,OAAO,CAAChC,8BACbA,0BAA0BiC,GAAG,CAAC,CAACC;YAC7B,uGAAuG;YACvG,MAAMC,uBAAuB5B,MAAMC,IAAI,CAACpB,qBAAqBqB,IAAI,IAAIC,MAAM,CAAC,CAACC,MAC3EA,IAAIC,UAAU,CAAC,CAAC,QAAQ,EAAEsB,gBAAgBvB,GAAG,CAAC,YAAY,CAAC;YAE7D,MAAMyB,oBAAuCD,qBAAqBF,GAAG,CAAC,CAACtB;gBACrE,OAAOvB,qBAAqBa,GAAG,CAACU;YAClC,EAAwB,oBAAoB;;YAE5C,qBACE,6BAACmB,cAAK,CAACC,QAAQ;gBAACpB,KAAKuB,gBAAgBvB,GAAG;eACrCyB,mBAAmBtB,SAChBsB,kBAAkBH,GAAG,CAAC,CAACI;gBACrB,OAAOA;YACT,KACA,MACHH,gBAAgBI,eAAe;QAGtC;IAGR;IAEA,qBACE,6BAACC,eAAQ;QAACC,wBAAU,6BAACC,iBAAa;YAACC,QAAO;;OACvC5C,4CACC,6BAACd;QAAgB,GAAGE,KAAK;QAAEyD,cAAc7C;;AAIjD"}

package/dist/field/index.scss

@@ -1,4 +1,4 @@
-@import 'payload/scss';
+@import '../scss/styles.scss';
 
 .rich-text-lexical {
   display: flex;
@@ -19,7 +19,7 @@
       .editor {
         background: var(--theme-elevation-200);
         color: var(--theme-elevation-450);
-        padding: base(0.5);
+        padding: calc(var(--base) * 0.5);
       }
     }
   }

package/dist/field/lexical/EditorPlugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EditorPlugin.d.ts","sourceRoot":"","sources":["../../../src/field/lexical/EditorPlugin.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAExD,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC;IAClC,UAAU,CAAC,EAAE,cAAc,CAAA;IAC3B,MAAM,EAAE,eAAe,CAAA;CACxB,CA4BA,CAAA"}
+{"version":3,"file":"EditorPlugin.d.ts","sourceRoot":"","sources":["../../../src/field/lexical/EditorPlugin.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAExD,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC;IAClC,UAAU,CAAC,EAAE,cAAc,CAAA;IAC3B,MAAM,EAAE,eAAe,CAAA;CACxB,CAMA,CAAA"}

package/dist/field/lexical/EditorPlugin.js

@@ -51,20 +51,12 @@ function _interop_require_wildcard(obj, nodeInterop) {
     return newObj;
 }
 const EditorPlugin = ({ anchorElem, plugin })=>{
-    const Component = (0, _react.useMemo)(()=>{
-        return plugin?.Component ? /*#__PURE__*/ _react.lazy(()=>plugin.Component().then((resolvedComponent)=>({
-                    default: resolvedComponent
-                }))) : null;
-    }, [
-        plugin
-    ]) // Dependency array ensures this is only recomputed if entry changes
-    ;
     if (plugin.position === 'floatingAnchorElem') {
-        return Component && /*#__PURE__*/ _react.createElement(_react.Suspense, null, /*#__PURE__*/ _react.createElement(Component, {
+        return plugin.Component && /*#__PURE__*/ _react.createElement(plugin.Component, {
             anchorElem: anchorElem
-        }));
+        });
     }
-    return Component && /*#__PURE__*/ _react.createElement(_react.Suspense, null, /*#__PURE__*/ _react.createElement(Component, null));
+    return plugin.Component && /*#__PURE__*/ _react.createElement(plugin.Component, null);
 };
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9maWVsZC9sZXhpY2FsL0VkaXRvclBsdWdpbi50c3giXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0ICogYXMgUmVhY3QgZnJvbSAncmVhY3QnXG5cbmltcG9ydCB0eXBlIHsgU2FuaXRpemVkUGx1Z2luIH0gZnJvbSAnLi4vZmVhdHVyZXMvdHlwZXMnXG5cbmV4cG9ydCBjb25zdCBFZGl0b3JQbHVnaW46IFJlYWN0LkZDPHtcbiAgYW5jaG9yRWxlbT86IEhUTUxEaXZFbGVtZW50XG4gIHBsdWdpbjogU2FuaXRpemVkUGx1Z2luXG59PiA9ICh7IGFuY2hvckVsZW0sIHBsdWdpbiB9KSA9PiB7XG4gIGlmIChwbHVnaW4ucG9zaXRpb24gPT09ICdmbG9hdGluZ0FuY2hvckVsZW0nKSB7XG4gICAgcmV0dXJuIHBsdWdpbi5Db21wb25lbnQgJiYgPHBsdWdpbi5Db21wb25lbnQgYW5jaG9yRWxlbT17YW5jaG9yRWxlbX0gLz5cbiAgfVxuXG4gIHJldHVybiBwbHVnaW4uQ29tcG9uZW50ICYmIDxwbHVnaW4uQ29tcG9uZW50IC8+XG59XG4iXSwibmFtZXMiOlsiRWRpdG9yUGx1Z2luIiwiYW5jaG9yRWxlbSIsInBsdWdpbiIsInBvc2l0aW9uIiwiQ29tcG9uZW50Il0sIm1hcHBpbmdzIjoiOzs7OytCQUlhQTs7O2VBQUFBOzs7K0RBSlU7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUloQixNQUFNQSxlQUdSLENBQUMsRUFBRUMsVUFBVSxFQUFFQyxNQUFNLEVBQUU7SUFDMUIsSUFBSUEsT0FBT0MsUUFBUSxLQUFLLHNCQUFzQjtRQUM1QyxPQUFPRCxPQUFPRSxTQUFTLGtCQUFJLHFCQUFDRixPQUFPRSxTQUFTO1lBQUNILFlBQVlBOztJQUMzRDtJQUVBLE9BQU9DLE9BQU9FLFNBQVMsa0JBQUkscUJBQUNGLE9BQU9FLFNBQVM7QUFDOUMifQ==

package/dist/field/lexical/LexicalEditor.js

@@ -140,7 +140,7 @@ const LexicalEditor = (props)=>{
         anchorElem: floatingAnchorElem
     }), /*#__PURE__*/ _react.createElement(_SlashMenu.SlashMenuPlugin, {
         anchorElem: floatingAnchorElem
-    }))), editor.isEditable() && /*#__PURE__*/ _react.createElement(_react.Fragment, null, /*#__PURE__*/ _react.createElement(_LexicalHistoryPlugin.HistoryPlugin, null), /*#__PURE__*/ _react.createElement(_MarkdownShortcut.MarkdownShortcutPlugin, null)), /*#__PURE__*/ _react.createElement(_LexicalTabIndentationPlugin.TabIndentationPlugin, null), editorConfig.features.plugins.map((plugin)=>{
+    }))), editor.isEditable() && /*#__PURE__*/ _react.createElement(_react.Fragment, null, /*#__PURE__*/ _react.createElement(_LexicalHistoryPlugin.HistoryPlugin, null), editorConfig?.features?.markdownTransformers?.length > 0 && /*#__PURE__*/ _react.createElement(_MarkdownShortcut.MarkdownShortcutPlugin, null)), /*#__PURE__*/ _react.createElement(_LexicalTabIndentationPlugin.TabIndentationPlugin, null), editorConfig.features.plugins.map((plugin)=>{
         if (plugin.position === 'normal') {
             return /*#__PURE__*/ _react.createElement(_EditorPlugin.EditorPlugin, {
                 key: plugin.key,
@@ -157,4 +157,4 @@ const LexicalEditor = (props)=>{
     }));
 };
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/field/lexical/LexicalEditor.tsx"],"sourcesContent":["'use client'\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext'\nimport LexicalErrorBoundary from '@lexical/react/LexicalErrorBoundary'\nimport { HistoryPlugin } from '@lexical/react/LexicalHistoryPlugin'\nimport { OnChangePlugin } from '@lexical/react/LexicalOnChangePlugin'\nimport { RichTextPlugin } from '@lexical/react/LexicalRichTextPlugin'\nimport { TabIndentationPlugin } from '@lexical/react/LexicalTabIndentationPlugin'\nimport * as React from 'react'\nimport { useEffect, useState } from 'react'\n\nimport type { LexicalProviderProps } from './LexicalProvider'\n\nimport { EditorPlugin } from './EditorPlugin'\nimport './LexicalEditor.scss'\nimport { FloatingSelectToolbarPlugin } from './plugins/FloatingSelectToolbar'\nimport { MarkdownShortcutPlugin } from './plugins/MarkdownShortcut'\nimport { SlashMenuPlugin } from './plugins/SlashMenu'\nimport { AddBlockHandlePlugin } from './plugins/handles/AddBlockHandlePlugin'\nimport { DraggableBlockPlugin } from './plugins/handles/DraggableBlockPlugin'\nimport { LexicalContentEditable } from './ui/ContentEditable'\n\nexport const LexicalEditor: React.FC<Pick<LexicalProviderProps, 'editorConfig' | 'onChange'>> = (\n  props,\n) => {\n  const { editorConfig, onChange } = props\n  const [editor] = useLexicalComposerContext()\n\n  const [floatingAnchorElem, setFloatingAnchorElem] = useState<HTMLDivElement | null>(null)\n  const onRef = (_floatingAnchorElem: HTMLDivElement) => {\n    if (_floatingAnchorElem !== null) {\n      setFloatingAnchorElem(_floatingAnchorElem)\n    }\n  }\n\n  const [isSmallWidthViewport, setIsSmallWidthViewport] = useState<boolean>(false)\n\n  useEffect(() => {\n    const updateViewPortWidth = () => {\n      const isNextSmallWidthViewport = window.matchMedia('(max-width: 1025px)').matches\n\n      if (isNextSmallWidthViewport !== isSmallWidthViewport) {\n        setIsSmallWidthViewport(isNextSmallWidthViewport)\n      }\n    }\n    updateViewPortWidth()\n    window.addEventListener('resize', updateViewPortWidth)\n\n    return () => {\n      window.removeEventListener('resize', updateViewPortWidth)\n    }\n  }, [isSmallWidthViewport])\n\n  return (\n    <React.Fragment>\n      {editorConfig.features.plugins.map((plugin) => {\n        if (plugin.position === 'top') {\n          return <EditorPlugin key={plugin.key} plugin={plugin} />\n        }\n      })}\n      <RichTextPlugin\n        ErrorBoundary={LexicalErrorBoundary}\n        contentEditable={\n          <div className=\"editor-scroller\">\n            <div className=\"editor\" ref={onRef}>\n              <LexicalContentEditable />\n            </div>\n          </div>\n        }\n        placeholder={\n          <p className=\"editor-placeholder\">Start typing, or press '/' for commands...</p>\n        }\n      />\n      <OnChangePlugin\n        // Selection changes can be ignored here, reducing the\n        // frequency that the FieldComponent and Payload receive updates.\n        // Selection changes are only needed if you are saving selection state\n        ignoreSelectionChange\n        onChange={(editorState, editor, tags) => {\n          // Ignore any onChange event triggered by focus only\n          if (!tags.has('focus') || tags.size > 1) {\n            if (onChange != null) onChange(editorState, editor, tags)\n          }\n        }}\n      />\n      {floatingAnchorElem && (\n        <React.Fragment>\n          {!isSmallWidthViewport && editor.isEditable() && (\n            <React.Fragment>\n              <DraggableBlockPlugin anchorElem={floatingAnchorElem} />\n              <AddBlockHandlePlugin anchorElem={floatingAnchorElem} />\n            </React.Fragment>\n          )}\n          {editorConfig.features.plugins.map((plugin) => {\n            if (\n              plugin.position === 'floatingAnchorElem' &&\n              !(plugin.desktopOnly === true && isSmallWidthViewport)\n            ) {\n              return (\n                <EditorPlugin anchorElem={floatingAnchorElem} key={plugin.key} plugin={plugin} />\n              )\n            }\n          })}\n          {editor.isEditable() && (\n            <React.Fragment>\n              <FloatingSelectToolbarPlugin anchorElem={floatingAnchorElem} />\n              <SlashMenuPlugin anchorElem={floatingAnchorElem} />\n            </React.Fragment>\n          )}\n        </React.Fragment>\n      )}\n      {editor.isEditable() && (\n        <React.Fragment>\n          <HistoryPlugin />\n          <MarkdownShortcutPlugin />\n        </React.Fragment>\n      )}\n\n      <TabIndentationPlugin />\n      {editorConfig.features.plugins.map((plugin) => {\n        if (plugin.position === 'normal') {\n          return <EditorPlugin key={plugin.key} plugin={plugin} />\n        }\n      })}\n      {editorConfig.features.plugins.map((plugin) => {\n        if (plugin.position === 'bottom') {\n          return <EditorPlugin key={plugin.key} plugin={plugin} />\n        }\n      })}\n    </React.Fragment>\n  )\n}\n"],"names":["LexicalEditor","props","editorConfig","onChange","editor","useLexicalComposerContext","floatingAnchorElem","setFloatingAnchorElem","useState","onRef","_floatingAnchorElem","isSmallWidthViewport","setIsSmallWidthViewport","useEffect","updateViewPortWidth","isNextSmallWidthViewport","window","matchMedia","matches","addEventListener","removeEventListener","React","Fragment","features","plugins","map","plugin","position","EditorPlugin","key","RichTextPlugin","ErrorBoundary","LexicalErrorBoundary","contentEditable","div","className","ref","LexicalContentEditable","placeholder","p","OnChangePlugin","ignoreSelectionChange","editorState","tags","has","size","isEditable","DraggableBlockPlugin","anchorElem","AddBlockHandlePlugin","desktopOnly","FloatingSelectToolbarPlugin","SlashMenuPlugin","HistoryPlugin","MarkdownShortcutPlugin","TabIndentationPlugin"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/field/lexical/LexicalEditor.tsx"],"sourcesContent":["'use client'\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext'\nimport LexicalErrorBoundary from '@lexical/react/LexicalErrorBoundary'\nimport { HistoryPlugin } from '@lexical/react/LexicalHistoryPlugin'\nimport { OnChangePlugin } from '@lexical/react/LexicalOnChangePlugin'\nimport { RichTextPlugin } from '@lexical/react/LexicalRichTextPlugin'\nimport { TabIndentationPlugin } from '@lexical/react/LexicalTabIndentationPlugin'\nimport * as React from 'react'\nimport { useEffect, useState } from 'react'\n\nimport type { LexicalProviderProps } from './LexicalProvider'\n\nimport { EditorPlugin } from './EditorPlugin'\nimport './LexicalEditor.scss'\nimport { FloatingSelectToolbarPlugin } from './plugins/FloatingSelectToolbar'\nimport { MarkdownShortcutPlugin } from './plugins/MarkdownShortcut'\nimport { SlashMenuPlugin } from './plugins/SlashMenu'\nimport { AddBlockHandlePlugin } from './plugins/handles/AddBlockHandlePlugin'\nimport { DraggableBlockPlugin } from './plugins/handles/DraggableBlockPlugin'\nimport { LexicalContentEditable } from './ui/ContentEditable'\n\nexport const LexicalEditor: React.FC<Pick<LexicalProviderProps, 'editorConfig' | 'onChange'>> = (\n  props,\n) => {\n  const { editorConfig, onChange } = props\n  const [editor] = useLexicalComposerContext()\n\n  const [floatingAnchorElem, setFloatingAnchorElem] = useState<HTMLDivElement | null>(null)\n  const onRef = (_floatingAnchorElem: HTMLDivElement) => {\n    if (_floatingAnchorElem !== null) {\n      setFloatingAnchorElem(_floatingAnchorElem)\n    }\n  }\n\n  const [isSmallWidthViewport, setIsSmallWidthViewport] = useState<boolean>(false)\n\n  useEffect(() => {\n    const updateViewPortWidth = () => {\n      const isNextSmallWidthViewport = window.matchMedia('(max-width: 1025px)').matches\n\n      if (isNextSmallWidthViewport !== isSmallWidthViewport) {\n        setIsSmallWidthViewport(isNextSmallWidthViewport)\n      }\n    }\n    updateViewPortWidth()\n    window.addEventListener('resize', updateViewPortWidth)\n\n    return () => {\n      window.removeEventListener('resize', updateViewPortWidth)\n    }\n  }, [isSmallWidthViewport])\n\n  return (\n    <React.Fragment>\n      {editorConfig.features.plugins.map((plugin) => {\n        if (plugin.position === 'top') {\n          return <EditorPlugin key={plugin.key} plugin={plugin} />\n        }\n      })}\n      <RichTextPlugin\n        ErrorBoundary={LexicalErrorBoundary}\n        contentEditable={\n          <div className=\"editor-scroller\">\n            <div className=\"editor\" ref={onRef}>\n              <LexicalContentEditable />\n            </div>\n          </div>\n        }\n        placeholder={\n          <p className=\"editor-placeholder\">Start typing, or press '/' for commands...</p>\n        }\n      />\n      <OnChangePlugin\n        // Selection changes can be ignored here, reducing the\n        // frequency that the FieldComponent and Payload receive updates.\n        // Selection changes are only needed if you are saving selection state\n        ignoreSelectionChange\n        onChange={(editorState, editor, tags) => {\n          // Ignore any onChange event triggered by focus only\n          if (!tags.has('focus') || tags.size > 1) {\n            if (onChange != null) onChange(editorState, editor, tags)\n          }\n        }}\n      />\n      {floatingAnchorElem && (\n        <React.Fragment>\n          {!isSmallWidthViewport && editor.isEditable() && (\n            <React.Fragment>\n              <DraggableBlockPlugin anchorElem={floatingAnchorElem} />\n              <AddBlockHandlePlugin anchorElem={floatingAnchorElem} />\n            </React.Fragment>\n          )}\n          {editorConfig.features.plugins.map((plugin) => {\n            if (\n              plugin.position === 'floatingAnchorElem' &&\n              !(plugin.desktopOnly === true && isSmallWidthViewport)\n            ) {\n              return (\n                <EditorPlugin anchorElem={floatingAnchorElem} key={plugin.key} plugin={plugin} />\n              )\n            }\n          })}\n          {editor.isEditable() && (\n            <React.Fragment>\n              <FloatingSelectToolbarPlugin anchorElem={floatingAnchorElem} />\n              <SlashMenuPlugin anchorElem={floatingAnchorElem} />\n            </React.Fragment>\n          )}\n        </React.Fragment>\n      )}\n      {editor.isEditable() && (\n        <React.Fragment>\n          <HistoryPlugin />\n          {editorConfig?.features?.markdownTransformers?.length > 0 && <MarkdownShortcutPlugin />}\n        </React.Fragment>\n      )}\n\n      <TabIndentationPlugin />\n      {editorConfig.features.plugins.map((plugin) => {\n        if (plugin.position === 'normal') {\n          return <EditorPlugin key={plugin.key} plugin={plugin} />\n        }\n      })}\n      {editorConfig.features.plugins.map((plugin) => {\n        if (plugin.position === 'bottom') {\n          return <EditorPlugin key={plugin.key} plugin={plugin} />\n        }\n      })}\n    </React.Fragment>\n  )\n}\n"],"names":["LexicalEditor","props","editorConfig","onChange","editor","useLexicalComposerContext","floatingAnchorElem","setFloatingAnchorElem","useState","onRef","_floatingAnchorElem","isSmallWidthViewport","setIsSmallWidthViewport","useEffect","updateViewPortWidth","isNextSmallWidthViewport","window","matchMedia","matches","addEventListener","removeEventListener","React","Fragment","features","plugins","map","plugin","position","EditorPlugin","key","RichTextPlugin","ErrorBoundary","LexicalErrorBoundary","contentEditable","div","className","ref","LexicalContentEditable","placeholder","p","OnChangePlugin","ignoreSelectionChange","editorState","tags","has","size","isEditable","DraggableBlockPlugin","anchorElem","AddBlockHandlePlugin","desktopOnly","FloatingSelectToolbarPlugin","SlashMenuPlugin","HistoryPlugin","markdownTransformers","length","MarkdownShortcutPlugin","TabIndentationPlugin"],"mappings":"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"}

package/dist/field/lexical/LexicalEditor.scss

@@ -1,5 +1,3 @@
-@import 'payload/scss';
-
 .rich-text-lexical {
   .editor {
     position: relative;
@@ -9,7 +7,7 @@
     position: relative;
 
     font-family: var(--font-serif);
-    font-size: base(0.625);
+    font-size: calc(var(--base) * 0.625);
 
     h1,
     h2,

package/dist/field/lexical/LexicalProvider.d.ts

@@ -1,11 +1,15 @@
+import type { FormFieldBase } from '@payloadcms/ui';
 import type { EditorState, SerializedEditorState } from 'lexical';
 import type { LexicalEditor } from 'lexical';
 import * as React from 'react';
-import type { FieldProps } from '../../types';
-import type { SanitizedEditorConfig } from './config/types';
+import type { SanitizedClientEditorConfig } from './config/types';
 export type LexicalProviderProps = {
-    editorConfig: SanitizedEditorConfig;
-    fieldProps: FieldProps;
+    editorConfig: SanitizedClientEditorConfig;
+    fieldProps: FormFieldBase & {
+        editorConfig: SanitizedClientEditorConfig;
+        name: string;
+        richTextComponentMap: Map<string, React.ReactNode>;
+    };
     onChange: (editorState: EditorState, editor: LexicalEditor, tags: Set<string>) => void;
     path: string;
     readOnly: boolean;

package/dist/field/lexical/LexicalProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LexicalProvider.d.ts","sourceRoot":"","sources":["../../../src/field/lexical/LexicalProvider.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AACjE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAI5C,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAC7C,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAA;AAK3D,MAAM,MAAM,oBAAoB,GAAG;IACjC,YAAY,EAAE,qBAAqB,CAAA;IACnC,UAAU,EAAE,UAAU,CAAA;IACtB,QAAQ,EAAE,CAAC,WAAW,EAAE,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,KAAK,IAAI,CAAA;IACtF,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,OAAO,CAAA;IACjB,KAAK,EAAE,qBAAqB,CAAA;CAC7B,CAAA;AACD,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC,oBAAoB,CA6D1D,CAAA"}
+{"version":3,"file":"LexicalProvider.d.ts","sourceRoot":"","sources":["../../../src/field/lexical/LexicalProvider.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AACnD,OAAO,KAAK,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AACjE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAG5C,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,gBAAgB,CAAA;AAMjE,MAAM,MAAM,oBAAoB,GAAG;IACjC,YAAY,EAAE,2BAA2B,CAAA;IACzC,UAAU,EAAE,aAAa,GAAG;QAC1B,YAAY,EAAE,2BAA2B,CAAA;QACzC,IAAI,EAAE,MAAM,CAAA;QACZ,oBAAoB,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,SAAS,CAAC,CAAA;KACnD,CAAA;IACD,QAAQ,EAAE,CAAC,WAAW,EAAE,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,KAAK,IAAI,CAAA;IACtF,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,OAAO,CAAA;IACjB,KAAK,EAAE,qBAAqB,CAAA;CAC7B,CAAA;AACD,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC,oBAAoB,CA2D1D,CAAA"}

package/dist/field/lexical/LexicalProvider.js

@@ -12,7 +12,7 @@ Object.defineProperty(exports, "LexicalProvider", {
 const _LexicalComposer = require("@lexical/react/LexicalComposer");
 const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
 const _LexicalEditor = require("./LexicalEditor");
-const _EditorConfigProvider = require("./config/EditorConfigProvider");
+const _EditorConfigProvider = require("./config/client/EditorConfigProvider");
 const _nodes = require("./nodes");
 function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
@@ -59,25 +59,23 @@ const LexicalProvider = (props)=>{
     const { editorConfig, fieldProps, onChange, path, readOnly } = props;
     let { value } = props;
     const [initialConfig, setInitialConfig] = _react.useState(null);
-    // set lexical config in useffect async:
+    // set lexical config in useEffect: // TODO: Is this the most performant way to do this? Prob not
     _react.useEffect(()=>{
-        void editorConfig.lexical().then((lexicalConfig)=>{
-            const newInitialConfig = {
-                editable: readOnly !== true,
-                editorState: value != null ? JSON.stringify(value) : undefined,
-                namespace: lexicalConfig.namespace,
-                nodes: [
-                    ...(0, _nodes.getEnabledNodes)({
-                        editorConfig
-                    })
-                ],
-                onError: (error)=>{
-                    throw error;
-                },
-                theme: lexicalConfig.theme
-            };
-            setInitialConfig(newInitialConfig);
-        });
+        const newInitialConfig = {
+            editable: readOnly !== true,
+            editorState: value != null ? JSON.stringify(value) : undefined,
+            namespace: editorConfig.lexical.namespace,
+            nodes: [
+                ...(0, _nodes.getEnabledNodes)({
+                    editorConfig
+                })
+            ],
+            onError: (error)=>{
+                throw error;
+            },
+            theme: editorConfig.lexical.theme
+        };
+        setInitialConfig(newInitialConfig);
     }, [
         editorConfig,
         readOnly,
@@ -116,4 +114,4 @@ const LexicalProvider = (props)=>{
     }))));
 };
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9maWVsZC9sZXhpY2FsL0xleGljYWxQcm92aWRlci50c3giXSwic291cmNlc0NvbnRlbnQiOlsiJ3VzZSBjbGllbnQnXG5pbXBvcnQgdHlwZSB7IEluaXRpYWxDb25maWdUeXBlIH0gZnJvbSAnQGxleGljYWwvcmVhY3QvTGV4aWNhbENvbXBvc2VyJ1xuaW1wb3J0IHR5cGUgeyBGb3JtRmllbGRCYXNlIH0gZnJvbSAnQHBheWxvYWRjbXMvdWknXG5pbXBvcnQgdHlwZSB7IEVkaXRvclN0YXRlLCBTZXJpYWxpemVkRWRpdG9yU3RhdGUgfSBmcm9tICdsZXhpY2FsJ1xuaW1wb3J0IHR5cGUgeyBMZXhpY2FsRWRpdG9yIH0gZnJvbSAnbGV4aWNhbCdcblxuaW1wb3J0IHsgTGV4aWNhbENvbXBvc2VyIH0gZnJvbSAnQGxleGljYWwvcmVhY3QvTGV4aWNhbENvbXBvc2VyJ1xuaW1wb3J0ICogYXMgUmVhY3QgZnJvbSAncmVhY3QnXG5cbmltcG9ydCB0eXBlIHsgU2FuaXRpemVkQ2xpZW50RWRpdG9yQ29uZmlnIH0gZnJvbSAnLi9jb25maWcvdHlwZXMnXG5cbmltcG9ydCB7IExleGljYWxFZGl0b3IgYXMgTGV4aWNhbEVkaXRvckNvbXBvbmVudCB9IGZyb20gJy4vTGV4aWNhbEVkaXRvcidcbmltcG9ydCB7IEVkaXRvckNvbmZpZ1Byb3ZpZGVyIH0gZnJvbSAnLi9jb25maWcvY2xpZW50L0VkaXRvckNvbmZpZ1Byb3ZpZGVyJ1xuaW1wb3J0IHsgZ2V0RW5hYmxlZE5vZGVzIH0gZnJvbSAnLi9ub2RlcydcblxuZXhwb3J0IHR5cGUgTGV4aWNhbFByb3ZpZGVyUHJvcHMgPSB7XG4gIGVkaXRvckNvbmZpZzogU2FuaXRpemVkQ2xpZW50RWRpdG9yQ29uZmlnXG4gIGZpZWxkUHJvcHM6IEZvcm1GaWVsZEJhc2UgJiB7XG4gICAgZWRpdG9yQ29uZmlnOiBTYW5pdGl6ZWRDbGllbnRFZGl0b3JDb25maWcgLy8gV2l0aCByZW5kZXJlZCBmZWF0dXJlcyBuIHN0dWZmXG4gICAgbmFtZTogc3RyaW5nXG4gICAgcmljaFRleHRDb21wb25lbnRNYXA6IE1hcDxzdHJpbmcsIFJlYWN0LlJlYWN0Tm9kZT5cbiAgfVxuICBvbkNoYW5nZTogKGVkaXRvclN0YXRlOiBFZGl0b3JTdGF0ZSwgZWRpdG9yOiBMZXhpY2FsRWRpdG9yLCB0YWdzOiBTZXQ8c3RyaW5nPikgPT4gdm9pZFxuICBwYXRoOiBzdHJpbmdcbiAgcmVhZE9ubHk6IGJvb2xlYW5cbiAgdmFsdWU6IFNlcmlhbGl6ZWRFZGl0b3JTdGF0ZVxufVxuZXhwb3J0IGNvbnN0IExleGljYWxQcm92aWRlcjogUmVhY3QuRkM8TGV4aWNhbFByb3ZpZGVyUHJvcHM+ID0gKHByb3BzKSA9PiB7XG4gIGNvbnN0IHsgZWRpdG9yQ29uZmlnLCBmaWVsZFByb3BzLCBvbkNoYW5nZSwgcGF0aCwgcmVhZE9ubHkgfSA9IHByb3BzXG4gIGxldCB7IHZhbHVlIH0gPSBwcm9wc1xuXG4gIGNvbnN0IFtpbml0aWFsQ29uZmlnLCBzZXRJbml0aWFsQ29uZmlnXSA9IFJlYWN0LnVzZVN0YXRlPEluaXRpYWxDb25maWdUeXBlIHwgbnVsbD4obnVsbClcblxuICAvLyBzZXQgbGV4aWNhbCBjb25maWcgaW4gdXNlRWZmZWN0OiAvLyBUT0RPOiBJcyB0aGlzIHRoZSBtb3N0IHBlcmZvcm1hbnQgd2F5IHRvIGRvIHRoaXM/IFByb2Igbm90XG4gIFJlYWN0LnVzZUVmZmVjdCgoKSA9PiB7XG4gICAgY29uc3QgbmV3SW5pdGlhbENvbmZpZzogSW5pdGlhbENvbmZpZ1R5cGUgPSB7XG4gICAgICBlZGl0YWJsZTogcmVhZE9ubHkgIT09IHRydWUsXG4gICAgICBlZGl0b3JTdGF0ZTogdmFsdWUgIT0gbnVsbCA/IEpTT04uc3RyaW5naWZ5KHZhbHVlKSA6IHVuZGVmaW5lZCxcbiAgICAgIG5hbWVzcGFjZTogZWRpdG9yQ29uZmlnLmxleGljYWwubmFtZXNwYWNlLFxuICAgICAgbm9kZXM6IFsuLi5nZXRFbmFibGVkTm9kZXMoeyBlZGl0b3JDb25maWcgfSldLFxuICAgICAgb25FcnJvcjogKGVycm9yOiBFcnJvcikgPT4ge1xuICAgICAgICB0aHJvdyBlcnJvclxuICAgICAgfSxcbiAgICAgIHRoZW1lOiBlZGl0b3JDb25maWcubGV4aWNhbC50aGVtZSxcbiAgICB9XG4gICAgc2V0SW5pdGlhbENvbmZpZyhuZXdJbml0aWFsQ29uZmlnKVxuICB9LCBbZWRpdG9yQ29uZmlnLCByZWFkT25seSwgdmFsdWVdKVxuXG4gIGlmIChlZGl0b3JDb25maWc/LmZlYXR1cmVzPy5ob29rcz8ubG9hZD8ubGVuZ3RoKSB7XG4gICAgZWRpdG9yQ29uZmlnLmZlYXR1cmVzLmhvb2tzLmxvYWQuZm9yRWFjaCgoaG9vaykgPT4ge1xuICAgICAgdmFsdWUgPSBob29rKHsgaW5jb21pbmdFZGl0b3JTdGF0ZTogdmFsdWUgfSlcbiAgICB9KVxuICB9XG5cbiAgaWYgKHZhbHVlICYmIHR5cGVvZiB2YWx1ZSAhPT0gJ29iamVjdCcpIHtcbiAgICB0aHJvdyBuZXcgRXJyb3IoXG4gICAgICAnVGhlIHZhbHVlIHBhc3NlZCB0byB0aGUgTGV4aWNhbCBlZGl0b3IgaXMgbm90IGFuIG9iamVjdC4gVGhpcyBpcyBub3Qgc3VwcG9ydGVkLiBQbGVhc2UgcmVtb3ZlIHRoZSBkYXRhIGZyb20gdGhlIGZpZWxkIGFuZCBzdGFydCBhZ2Fpbi4gVGhpcyBpcyB0aGUgdmFsdWUgdGhhdCB3YXMgcGFzc2VkIGluOiAnICtcbiAgICAgICAgSlNPTi5zdHJpbmdpZnkodmFsdWUpLFxuICAgIClcbiAgfVxuXG4gIGlmICh2YWx1ZSAmJiBBcnJheS5pc0FycmF5KHZhbHVlKSAmJiAhKCdyb290JyBpbiB2YWx1ZSkpIHtcbiAgICB0aHJvdyBuZXcgRXJyb3IoXG4gICAgICAnWW91IGhhdmUgdHJpZWQgdG8gcGFzcyBpbiBkYXRhIGZyb20gdGhlIG9sZCwgU2xhdGUgZWRpdG9yLCB0byB0aGUgbmV3LCBMZXhpY2FsIGVkaXRvci4gVGhpcyBpcyBub3Qgc3VwcG9ydGVkLiBUaGVyZSBpcyBubyBhdXRvbWF0aWMgY29udmVyc2lvbiBmcm9tIFNsYXRlIHRvIExleGljYWwgZGF0YSBhdmFpbGFibGUgeWV0IChjb21pbmcgc29vbikuIFBsZWFzZSByZW1vdmUgdGhlIGRhdGEgZnJvbSB0aGUgZmllbGQgYW5kIHN0YXJ0IGFnYWluLicsXG4gICAgKVxuICB9XG5cbiAgaWYgKHZhbHVlICYmICdqc29uQ29udGVudCcgaW4gdmFsdWUpIHtcbiAgICB0aHJvdyBuZXcgRXJyb3IoXG4gICAgICAnWW91IGhhdmUgdHJpZWQgdG8gcGFzcyBpbiBkYXRhIGZyb20gcGF5bG9hZC1wbHVnaW4tbGV4aWNhbC4gVGhpcyBpcyBub3Qgc3VwcG9ydGVkLiBUaGUgZGF0YSBzdHJ1Y3R1cmUgaGFzIGNoYW5nZWQgaW4gdGhpcyBlZGl0b3IsIGNvbXBhcmVkIHRvIHRoZSBwbHVnaW4sIGFuZCB0aGVyZSBpcyBubyBhdXRvbWF0aWMgY29udmVyc2lvbiBhdmFpbGFibGUgeWV0IChjb21pbmcgc29vbikuIFBsZWFzZSByZW1vdmUgdGhlIGRhdGEgZnJvbSB0aGUgZmllbGQgYW5kIHN0YXJ0IGFnYWluLicsXG4gICAgKVxuICB9XG5cbiAgaWYgKCFpbml0aWFsQ29uZmlnKSB7XG4gICAgcmV0dXJuIDxwPkxvYWRpbmcuLi48L3A+XG4gIH1cblxuICByZXR1cm4gKFxuICAgIDxMZXhpY2FsQ29tcG9zZXIgaW5pdGlhbENvbmZpZz17aW5pdGlhbENvbmZpZ30ga2V5PXtwYXRofT5cbiAgICAgIDxFZGl0b3JDb25maWdQcm92aWRlciBlZGl0b3JDb25maWc9e2VkaXRvckNvbmZpZ30gZmllbGRQcm9wcz17ZmllbGRQcm9wc30+XG4gICAgICAgIDxkaXYgY2xhc3NOYW1lPVwiZWRpdG9yLXNoZWxsXCI+XG4gICAgICAgICAgPExleGljYWxFZGl0b3JDb21wb25lbnQgZWRpdG9yQ29uZmlnPXtlZGl0b3JDb25maWd9IG9uQ2hhbmdlPXtvbkNoYW5nZX0gLz5cbiAgICAgICAgPC9kaXY+XG4gICAgICA8L0VkaXRvckNvbmZpZ1Byb3ZpZGVyPlxuICAgIDwvTGV4aWNhbENvbXBvc2VyPlxuICApXG59XG4iXSwibmFtZXMiOlsiTGV4aWNhbFByb3ZpZGVyIiwicHJvcHMiLCJlZGl0b3JDb25maWciLCJmaWVsZFByb3BzIiwib25DaGFuZ2UiLCJwYXRoIiwicmVhZE9ubHkiLCJ2YWx1ZSIsImluaXRpYWxDb25maWciLCJzZXRJbml0aWFsQ29uZmlnIiwiUmVhY3QiLCJ1c2VTdGF0ZSIsInVzZUVmZmVjdCIsIm5ld0luaXRpYWxDb25maWciLCJlZGl0YWJsZSIsImVkaXRvclN0YXRlIiwiSlNPTiIsInN0cmluZ2lmeSIsInVuZGVmaW5lZCIsIm5hbWVzcGFjZSIsImxleGljYWwiLCJub2RlcyIsImdldEVuYWJsZWROb2RlcyIsIm9uRXJyb3IiLCJlcnJvciIsInRoZW1lIiwiZmVhdHVyZXMiLCJob29rcyIsImxvYWQiLCJsZW5ndGgiLCJmb3JFYWNoIiwiaG9vayIsImluY29taW5nRWRpdG9yU3RhdGUiLCJFcnJvciIsIkFycmF5IiwiaXNBcnJheSIsInAiLCJMZXhpY2FsQ29tcG9zZXIiLCJrZXkiLCJFZGl0b3JDb25maWdQcm92aWRlciIsImRpdiIsImNsYXNzTmFtZSIsIkxleGljYWxFZGl0b3JDb21wb25lbnQiXSwibWFwcGluZ3MiOiJBQUFBOzs7OzsrQkEyQmFBOzs7ZUFBQUE7OztpQ0FyQm1COytEQUNUOytCQUlpQztzQ0FDbkI7dUJBQ0w7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQWN6QixNQUFNQSxrQkFBa0QsQ0FBQ0M7SUFDOUQsTUFBTSxFQUFFQyxZQUFZLEVBQUVDLFVBQVUsRUFBRUMsUUFBUSxFQUFFQyxJQUFJLEVBQUVDLFFBQVEsRUFBRSxHQUFHTDtJQUMvRCxJQUFJLEVBQUVNLEtBQUssRUFBRSxHQUFHTjtJQUVoQixNQUFNLENBQUNPLGVBQWVDLGlCQUFpQixHQUFHQyxPQUFNQyxRQUFRLENBQTJCO0lBRW5GLGlHQUFpRztJQUNqR0QsT0FBTUUsU0FBUyxDQUFDO1FBQ2QsTUFBTUMsbUJBQXNDO1lBQzFDQyxVQUFVUixhQUFhO1lBQ3ZCUyxhQUFhUixTQUFTLE9BQU9TLEtBQUtDLFNBQVMsQ0FBQ1YsU0FBU1c7WUFDckRDLFdBQVdqQixhQUFha0IsT0FBTyxDQUFDRCxTQUFTO1lBQ3pDRSxPQUFPO21CQUFJQyxJQUFBQSxzQkFBZSxFQUFDO29CQUFFcEI7Z0JBQWE7YUFBRztZQUM3Q3FCLFNBQVMsQ0FBQ0M7Z0JBQ1IsTUFBTUE7WUFDUjtZQUNBQyxPQUFPdkIsYUFBYWtCLE9BQU8sQ0FBQ0ssS0FBSztRQUNuQztRQUNBaEIsaUJBQWlCSTtJQUNuQixHQUFHO1FBQUNYO1FBQWNJO1FBQVVDO0tBQU07SUFFbEMsSUFBSUwsY0FBY3dCLFVBQVVDLE9BQU9DLE1BQU1DLFFBQVE7UUFDL0MzQixhQUFhd0IsUUFBUSxDQUFDQyxLQUFLLENBQUNDLElBQUksQ0FBQ0UsT0FBTyxDQUFDLENBQUNDO1lBQ3hDeEIsUUFBUXdCLEtBQUs7Z0JBQUVDLHFCQUFxQnpCO1lBQU07UUFDNUM7SUFDRjtJQUVBLElBQUlBLFNBQVMsT0FBT0EsVUFBVSxVQUFVO1FBQ3RDLE1BQU0sSUFBSTBCLE1BQ1Isa0xBQ0VqQixLQUFLQyxTQUFTLENBQUNWO0lBRXJCO0lBRUEsSUFBSUEsU0FBUzJCLE1BQU1DLE9BQU8sQ0FBQzVCLFVBQVUsQ0FBRSxDQUFBLFVBQVVBLEtBQUksR0FBSTtRQUN2RCxNQUFNLElBQUkwQixNQUNSO0lBRUo7SUFFQSxJQUFJMUIsU0FBUyxpQkFBaUJBLE9BQU87UUFDbkMsTUFBTSxJQUFJMEIsTUFDUjtJQUVKO0lBRUEsSUFBSSxDQUFDekIsZUFBZTtRQUNsQixxQkFBTyxxQkFBQzRCLFdBQUU7SUFDWjtJQUVBLHFCQUNFLHFCQUFDQyxnQ0FBZTtRQUFDN0IsZUFBZUE7UUFBZThCLEtBQUtqQztxQkFDbEQscUJBQUNrQywwQ0FBb0I7UUFBQ3JDLGNBQWNBO1FBQWNDLFlBQVlBO3FCQUM1RCxxQkFBQ3FDO1FBQUlDLFdBQVU7cUJBQ2IscUJBQUNDLDRCQUFzQjtRQUFDeEMsY0FBY0E7UUFBY0UsVUFBVUE7O0FBS3hFIn0=

package/dist/field/lexical/config/client/EditorConfigProvider.d.ts

@@ -0,0 +1,24 @@
+import type { FormFieldBase } from '@payloadcms/ui';
+import * as React from 'react';
+import type { SanitizedClientEditorConfig } from '../types';
+interface ContextType {
+    editorConfig: SanitizedClientEditorConfig;
+    field: FormFieldBase & {
+        editorConfig: SanitizedClientEditorConfig;
+        name: string;
+        richTextComponentMap: Map<string, React.ReactNode>;
+    };
+    uuid: string;
+}
+export declare const EditorConfigProvider: ({ children, editorConfig, fieldProps, }: {
+    children: React.ReactNode;
+    editorConfig: SanitizedClientEditorConfig;
+    fieldProps: FormFieldBase & {
+        editorConfig: SanitizedClientEditorConfig;
+        name: string;
+        richTextComponentMap: Map<string, React.ReactNode>;
+    };
+}) => React.ReactNode;
+export declare const useEditorConfigContext: () => ContextType;
+export {};
+//# sourceMappingURL=EditorConfigProvider.d.ts.map

package/dist/field/lexical/config/client/EditorConfigProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EditorConfigProvider.d.ts","sourceRoot":"","sources":["../../../../../src/field/lexical/config/client/EditorConfigProvider.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAEnD,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAI9B,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,UAAU,CAAA;AAM3D,UAAU,WAAW;IACnB,YAAY,EAAE,2BAA2B,CAAA;IACzC,KAAK,EAAE,aAAa,GAAG;QACrB,YAAY,EAAE,2BAA2B,CAAA;QACzC,IAAI,EAAE,MAAM,CAAA;QACZ,oBAAoB,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,SAAS,CAAC,CAAA;KACnD,CAAA;IACD,IAAI,EAAE,MAAM,CAAA;CACb;AAQD,eAAO,MAAM,oBAAoB;cAKrB,MAAM,SAAS;kBACX,2BAA2B;;sBAEzB,2BAA2B;cACnC,MAAM;8BACU,IAAI,MAAM,EAAE,MAAM,SAAS,CAAC;;MAElD,MAAM,SAeT,CAAA;AAED,eAAO,MAAM,sBAAsB,QAAO,WAMzC,CAAA"}

package/dist/field/lexical/config/client/EditorConfigProvider.js

@@ -0,0 +1,99 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    EditorConfigProvider: function() {
+        return EditorConfigProvider;
+    },
+    useEditorConfigContext: function() {
+        return useEditorConfigContext;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+// Should always produce a 20 character pseudo-random string
+function generateQuickGuid() {
+    return Math.random().toString(36).substring(2, 12) + Math.random().toString(36).substring(2, 12);
+}
+const Context = /*#__PURE__*/ (0, _react.createContext)({
+    editorConfig: null,
+    field: null,
+    uuid: generateQuickGuid()
+});
+const EditorConfigProvider = ({ children, editorConfig, fieldProps })=>{
+    // State to store the UUID
+    const [uuid, setUuid] = (0, _react.useState)(generateQuickGuid());
+    // When the component mounts, generate a new UUID only once
+    (0, _react.useEffect)(()=>{
+        setUuid(generateQuickGuid());
+    }, []);
+    const editorContext = (0, _react.useMemo)(()=>({
+            editorConfig,
+            field: fieldProps,
+            uuid
+        }), [
+        editorConfig,
+        fieldProps,
+        uuid
+    ]);
+    return /*#__PURE__*/ _react.createElement(Context.Provider, {
+        value: editorContext
+    }, children);
+};
+const useEditorConfigContext = ()=>{
+    const context = (0, _react.useContext)(Context);
+    if (context === undefined) {
+        throw new Error('useEditorConfigContext must be used within an EditorConfigProvider');
+    }
+    return context;
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/lexical/config/client/default.d.ts

@@ -0,0 +1,3 @@
+import type { EditorConfig as LexicalEditorConfig } from 'lexical/LexicalEditor';
+export declare const defaultEditorLexicalConfig: LexicalEditorConfig;
+//# sourceMappingURL=default.d.ts.map

package/dist/field/lexical/config/client/default.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default.d.ts","sourceRoot":"","sources":["../../../../../src/field/lexical/config/client/default.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,IAAI,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAIhF,eAAO,MAAM,0BAA0B,EAAE,mBAGxC,CAAA"}

package/dist/field/lexical/config/client/default.js

@@ -0,0 +1,18 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "defaultEditorLexicalConfig", {
+    enumerable: true,
+    get: function() {
+        return defaultEditorLexicalConfig;
+    }
+});
+const _EditorTheme = require("../../theme/EditorTheme");
+const defaultEditorLexicalConfig = {
+    namespace: 'lexical',
+    theme: _EditorTheme.LexicalEditorTheme
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9sZXhpY2FsL2NvbmZpZy9jbGllbnQvZGVmYXVsdC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIndXNlIGNsaWVudCdcbmltcG9ydCB0eXBlIHsgRWRpdG9yQ29uZmlnIGFzIExleGljYWxFZGl0b3JDb25maWcgfSBmcm9tICdsZXhpY2FsL0xleGljYWxFZGl0b3InXG5cbmltcG9ydCB7IExleGljYWxFZGl0b3JUaGVtZSB9IGZyb20gJy4uLy4uL3RoZW1lL0VkaXRvclRoZW1lJ1xuXG5leHBvcnQgY29uc3QgZGVmYXVsdEVkaXRvckxleGljYWxDb25maWc6IExleGljYWxFZGl0b3JDb25maWcgPSB7XG4gIG5hbWVzcGFjZTogJ2xleGljYWwnLFxuICB0aGVtZTogTGV4aWNhbEVkaXRvclRoZW1lLFxufVxuIl0sIm5hbWVzIjpbImRlZmF1bHRFZGl0b3JMZXhpY2FsQ29uZmlnIiwibmFtZXNwYWNlIiwidGhlbWUiLCJMZXhpY2FsRWRpdG9yVGhlbWUiXSwibWFwcGluZ3MiOiJBQUFBOzs7OzsrQkFLYUE7OztlQUFBQTs7OzZCQUZzQjtBQUU1QixNQUFNQSw2QkFBa0Q7SUFDN0RDLFdBQVc7SUFDWEMsT0FBT0MsK0JBQWtCO0FBQzNCIn0=

package/dist/field/lexical/config/client/loader.d.ts

@@ -0,0 +1,11 @@
+import type { ClientEditorConfig, ResolvedClientFeatureMap } from '@payloadcms/richtext-lexical';
+/**
+ * This function expects client functions to ALREADY be ordered & dependencies checked on the server
+ * @param unSanitizedEditorConfig
+ */
+export declare function loadClientFeatures({ clientFunctions, schemaPath, unSanitizedEditorConfig, }: {
+    clientFunctions?: Record<string, any>;
+    schemaPath: string;
+    unSanitizedEditorConfig: ClientEditorConfig;
+}): ResolvedClientFeatureMap;
+//# sourceMappingURL=loader.d.ts.map

package/dist/field/lexical/config/client/loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../../../../src/field/lexical/config/client/loader.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,kBAAkB,EAGlB,wBAAwB,EACzB,MAAM,8BAA8B,CAAA;AAErC;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,EACjC,eAAe,EACf,UAAU,EACV,uBAAuB,GACxB,EAAE;IACD,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IACrC,UAAU,EAAE,MAAM,CAAA;IAClB,uBAAuB,EAAE,kBAAkB,CAAA;CAC5C,GAAG,wBAAwB,CA8D3B"}

package/dist/field/lexical/config/client/loader.js

@@ -0,0 +1,53 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "loadClientFeatures", {
+    enumerable: true,
+    get: function() {
+        return loadClientFeatures;
+    }
+});
+function loadClientFeatures({ clientFunctions, schemaPath, unSanitizedEditorConfig }) {
+    for (const featureProvider of unSanitizedEditorConfig.features){
+        if (!featureProvider?.clientFeatureProps?.featureKey || featureProvider?.clientFeatureProps?.order === undefined || featureProvider?.clientFeatureProps?.order === null) {
+            throw new Error('A Feature you have installed does not return the client props as clientFeatureProps. Please make sure to always return those props, even if they are null, as other important props like order and featureKey are later on injected.');
+        }
+    }
+    // sort unSanitizedEditorConfig.features by order
+    unSanitizedEditorConfig.features = unSanitizedEditorConfig.features.sort((a, b)=>a.clientFeatureProps.order - b.clientFeatureProps.order);
+    const featureProviderMap = new Map(unSanitizedEditorConfig.features.map((f)=>[
+            f.clientFeatureProps.featureKey,
+            f
+        ]));
+    const resolvedFeatures = new Map();
+    // Make sure all dependencies declared in the respective features exist
+    let loaded = 0;
+    for (const featureProvider of unSanitizedEditorConfig.features){
+        /**
+     * Load relevant clientFunctions scoped to this feature and then pass them to the client feature
+     */ const relevantClientFunctions = {};
+        Object.entries(clientFunctions).forEach(([key, plugin])=>{
+            if (key.startsWith(`lexicalFeature.${schemaPath}.${featureProvider.clientFeatureProps.featureKey}.components.`)) {
+                const featureComponentKey = key.split(`${schemaPath}.${featureProvider.clientFeatureProps.featureKey}.components.`)[1];
+                relevantClientFunctions[featureComponentKey] = plugin;
+            }
+        });
+        const feature = featureProvider.feature({
+            clientFunctions: relevantClientFunctions,
+            featureProviderMap,
+            resolvedFeatures,
+            unSanitizedEditorConfig
+        });
+        resolvedFeatures.set(featureProvider.clientFeatureProps.featureKey, {
+            ...feature,
+            key: featureProvider.clientFeatureProps.featureKey,
+            order: loaded
+        });
+        loaded++;
+    }
+    return resolvedFeatures;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9sZXhpY2FsL2NvbmZpZy9jbGllbnQvbG9hZGVyLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIid1c2UgY2xpZW50J1xuXG5pbXBvcnQgdHlwZSB7XG4gIENsaWVudEVkaXRvckNvbmZpZyxcbiAgQ2xpZW50RmVhdHVyZVByb3ZpZGVyTWFwLFxuICBGZWF0dXJlUHJvdmlkZXJDbGllbnQsXG4gIFJlc29sdmVkQ2xpZW50RmVhdHVyZU1hcCxcbn0gZnJvbSAnQHBheWxvYWRjbXMvcmljaHRleHQtbGV4aWNhbCdcblxuLyoqXG4gKiBUaGlzIGZ1bmN0aW9uIGV4cGVjdHMgY2xpZW50IGZ1bmN0aW9ucyB0byBBTFJFQURZIGJlIG9yZGVyZWQgJiBkZXBlbmRlbmNpZXMgY2hlY2tlZCBvbiB0aGUgc2VydmVyXG4gKiBAcGFyYW0gdW5TYW5pdGl6ZWRFZGl0b3JDb25maWdcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGxvYWRDbGllbnRGZWF0dXJlcyh7XG4gIGNsaWVudEZ1bmN0aW9ucyxcbiAgc2NoZW1hUGF0aCxcbiAgdW5TYW5pdGl6ZWRFZGl0b3JDb25maWcsXG59OiB7XG4gIGNsaWVudEZ1bmN0aW9ucz86IFJlY29yZDxzdHJpbmcsIGFueT5cbiAgc2NoZW1hUGF0aDogc3RyaW5nXG4gIHVuU2FuaXRpemVkRWRpdG9yQ29uZmlnOiBDbGllbnRFZGl0b3JDb25maWdcbn0pOiBSZXNvbHZlZENsaWVudEZlYXR1cmVNYXAge1xuICBmb3IgKGNvbnN0IGZlYXR1cmVQcm92aWRlciBvZiB1blNhbml0aXplZEVkaXRvckNvbmZpZy5mZWF0dXJlcykge1xuICAgIGlmIChcbiAgICAgICFmZWF0dXJlUHJvdmlkZXI/LmNsaWVudEZlYXR1cmVQcm9wcz8uZmVhdHVyZUtleSB8fFxuICAgICAgZmVhdHVyZVByb3ZpZGVyPy5jbGllbnRGZWF0dXJlUHJvcHM/Lm9yZGVyID09PSB1bmRlZmluZWQgfHxcbiAgICAgIGZlYXR1cmVQcm92aWRlcj8uY2xpZW50RmVhdHVyZVByb3BzPy5vcmRlciA9PT0gbnVsbFxuICAgICkge1xuICAgICAgdGhyb3cgbmV3IEVycm9yKFxuICAgICAgICAnQSBGZWF0dXJlIHlvdSBoYXZlIGluc3RhbGxlZCBkb2VzIG5vdCByZXR1cm4gdGhlIGNsaWVudCBwcm9wcyBhcyBjbGllbnRGZWF0dXJlUHJvcHMuIFBsZWFzZSBtYWtlIHN1cmUgdG8gYWx3YXlzIHJldHVybiB0aG9zZSBwcm9wcywgZXZlbiBpZiB0aGV5IGFyZSBudWxsLCBhcyBvdGhlciBpbXBvcnRhbnQgcHJvcHMgbGlrZSBvcmRlciBhbmQgZmVhdHVyZUtleSBhcmUgbGF0ZXIgb24gaW5qZWN0ZWQuJyxcbiAgICAgIClcbiAgICB9XG4gIH1cblxuICAvLyBzb3J0IHVuU2FuaXRpemVkRWRpdG9yQ29uZmlnLmZlYXR1cmVzIGJ5IG9yZGVyXG4gIHVuU2FuaXRpemVkRWRpdG9yQ29uZmlnLmZlYXR1cmVzID0gdW5TYW5pdGl6ZWRFZGl0b3JDb25maWcuZmVhdHVyZXMuc29ydChcbiAgICAoYSwgYikgPT4gYS5jbGllbnRGZWF0dXJlUHJvcHMub3JkZXIgLSBiLmNsaWVudEZlYXR1cmVQcm9wcy5vcmRlcixcbiAgKVxuXG4gIGNvbnN0IGZlYXR1cmVQcm92aWRlck1hcDogQ2xpZW50RmVhdHVyZVByb3ZpZGVyTWFwID0gbmV3IE1hcChcbiAgICB1blNhbml0aXplZEVkaXRvckNvbmZpZy5mZWF0dXJlcy5tYXAoXG4gICAgICAoZikgPT4gW2YuY2xpZW50RmVhdHVyZVByb3BzLmZlYXR1cmVLZXksIGZdIGFzIFtzdHJpbmcsIEZlYXR1cmVQcm92aWRlckNsaWVudDx1bmtub3duPl0sXG4gICAgKSxcbiAgKVxuXG4gIGNvbnN0IHJlc29sdmVkRmVhdHVyZXM6IFJlc29sdmVkQ2xpZW50RmVhdHVyZU1hcCA9IG5ldyBNYXAoKVxuXG4gIC8vIE1ha2Ugc3VyZSBhbGwgZGVwZW5kZW5jaWVzIGRlY2xhcmVkIGluIHRoZSByZXNwZWN0aXZlIGZlYXR1cmVzIGV4aXN0XG4gIGxldCBsb2FkZWQgPSAwXG4gIGZvciAoY29uc3QgZmVhdHVyZVByb3ZpZGVyIG9mIHVuU2FuaXRpemVkRWRpdG9yQ29uZmlnLmZlYXR1cmVzKSB7XG4gICAgLyoqXG4gICAgICogTG9hZCByZWxldmFudCBjbGllbnRGdW5jdGlvbnMgc2NvcGVkIHRvIHRoaXMgZmVhdHVyZSBhbmQgdGhlbiBwYXNzIHRoZW0gdG8gdGhlIGNsaWVudCBmZWF0dXJlXG4gICAgICovXG4gICAgY29uc3QgcmVsZXZhbnRDbGllbnRGdW5jdGlvbnM6IFJlY29yZDxzdHJpbmcsIGFueT4gPSB7fVxuICAgIE9iamVjdC5lbnRyaWVzKGNsaWVudEZ1bmN0aW9ucykuZm9yRWFjaCgoW2tleSwgcGx1Z2luXSkgPT4ge1xuICAgICAgaWYgKFxuICAgICAgICBrZXkuc3RhcnRzV2l0aChcbiAgICAgICAgICBgbGV4aWNhbEZlYXR1cmUuJHtzY2hlbWFQYXRofS4ke2ZlYXR1cmVQcm92aWRlci5jbGllbnRGZWF0dXJlUHJvcHMuZmVhdHVyZUtleX0uY29tcG9uZW50cy5gLFxuICAgICAgICApXG4gICAgICApIHtcbiAgICAgICAgY29uc3QgZmVhdHVyZUNvbXBvbmVudEtleSA9IGtleS5zcGxpdChcbiAgICAgICAgICBgJHtzY2hlbWFQYXRofS4ke2ZlYXR1cmVQcm92aWRlci5jbGllbnRGZWF0dXJlUHJvcHMuZmVhdHVyZUtleX0uY29tcG9uZW50cy5gLFxuICAgICAgICApWzFdXG4gICAgICAgIHJlbGV2YW50Q2xpZW50RnVuY3Rpb25zW2ZlYXR1cmVDb21wb25lbnRLZXldID0gcGx1Z2luXG4gICAgICB9XG4gICAgfSlcblxuICAgIGNvbnN0IGZlYXR1cmUgPSBmZWF0dXJlUHJvdmlkZXIuZmVhdHVyZSh7XG4gICAgICBjbGllbnRGdW5jdGlvbnM6IHJlbGV2YW50Q2xpZW50RnVuY3Rpb25zLFxuICAgICAgZmVhdHVyZVByb3ZpZGVyTWFwLFxuICAgICAgcmVzb2x2ZWRGZWF0dXJlcyxcbiAgICAgIHVuU2FuaXRpemVkRWRpdG9yQ29uZmlnLFxuICAgIH0pXG4gICAgcmVzb2x2ZWRGZWF0dXJlcy5zZXQoZmVhdHVyZVByb3ZpZGVyLmNsaWVudEZlYXR1cmVQcm9wcy5mZWF0dXJlS2V5LCB7XG4gICAgICAuLi5mZWF0dXJlLFxuICAgICAga2V5OiBmZWF0dXJlUHJvdmlkZXIuY2xpZW50RmVhdHVyZVByb3BzLmZlYXR1cmVLZXksXG4gICAgICBvcmRlcjogbG9hZGVkLFxuICAgIH0pXG5cbiAgICBsb2FkZWQrK1xuICB9XG5cbiAgcmV0dXJuIHJlc29sdmVkRmVhdHVyZXNcbn1cbiJdLCJuYW1lcyI6WyJsb2FkQ2xpZW50RmVhdHVyZXMiLCJjbGllbnRGdW5jdGlvbnMiLCJzY2hlbWFQYXRoIiwidW5TYW5pdGl6ZWRFZGl0b3JDb25maWciLCJmZWF0dXJlUHJvdmlkZXIiLCJmZWF0dXJlcyIsImNsaWVudEZlYXR1cmVQcm9wcyIsImZlYXR1cmVLZXkiLCJvcmRlciIsInVuZGVmaW5lZCIsIkVycm9yIiwic29ydCIsImEiLCJiIiwiZmVhdHVyZVByb3ZpZGVyTWFwIiwiTWFwIiwibWFwIiwiZiIsInJlc29sdmVkRmVhdHVyZXMiLCJsb2FkZWQiLCJyZWxldmFudENsaWVudEZ1bmN0aW9ucyIsIk9iamVjdCIsImVudHJpZXMiLCJmb3JFYWNoIiwia2V5IiwicGx1Z2luIiwic3RhcnRzV2l0aCIsImZlYXR1cmVDb21wb25lbnRLZXkiLCJzcGxpdCIsImZlYXR1cmUiLCJzZXQiXSwibWFwcGluZ3MiOiJBQUFBOzs7OzsrQkFhZ0JBOzs7ZUFBQUE7OztBQUFULFNBQVNBLG1CQUFtQixFQUNqQ0MsZUFBZSxFQUNmQyxVQUFVLEVBQ1ZDLHVCQUF1QixFQUt4QjtJQUNDLEtBQUssTUFBTUMsbUJBQW1CRCx3QkFBd0JFLFFBQVEsQ0FBRTtRQUM5RCxJQUNFLENBQUNELGlCQUFpQkUsb0JBQW9CQyxjQUN0Q0gsaUJBQWlCRSxvQkFBb0JFLFVBQVVDLGFBQy9DTCxpQkFBaUJFLG9CQUFvQkUsVUFBVSxNQUMvQztZQUNBLE1BQU0sSUFBSUUsTUFDUjtRQUVKO0lBQ0Y7SUFFQSxpREFBaUQ7SUFDakRQLHdCQUF3QkUsUUFBUSxHQUFHRix3QkFBd0JFLFFBQVEsQ0FBQ00sSUFBSSxDQUN0RSxDQUFDQyxHQUFHQyxJQUFNRCxFQUFFTixrQkFBa0IsQ0FBQ0UsS0FBSyxHQUFHSyxFQUFFUCxrQkFBa0IsQ0FBQ0UsS0FBSztJQUduRSxNQUFNTSxxQkFBK0MsSUFBSUMsSUFDdkRaLHdCQUF3QkUsUUFBUSxDQUFDVyxHQUFHLENBQ2xDLENBQUNDLElBQU07WUFBQ0EsRUFBRVgsa0JBQWtCLENBQUNDLFVBQVU7WUFBRVU7U0FBRTtJQUkvQyxNQUFNQyxtQkFBNkMsSUFBSUg7SUFFdkQsdUVBQXVFO0lBQ3ZFLElBQUlJLFNBQVM7SUFDYixLQUFLLE1BQU1mLG1CQUFtQkQsd0JBQXdCRSxRQUFRLENBQUU7UUFDOUQ7O0tBRUMsR0FDRCxNQUFNZSwwQkFBK0MsQ0FBQztRQUN0REMsT0FBT0MsT0FBTyxDQUFDckIsaUJBQWlCc0IsT0FBTyxDQUFDLENBQUMsQ0FBQ0MsS0FBS0MsT0FBTztZQUNwRCxJQUNFRCxJQUFJRSxVQUFVLENBQ1osQ0FBQyxlQUFlLEVBQUV4QixXQUFXLENBQUMsRUFBRUUsZ0JBQWdCRSxrQkFBa0IsQ0FBQ0MsVUFBVSxDQUFDLFlBQVksQ0FBQyxHQUU3RjtnQkFDQSxNQUFNb0Isc0JBQXNCSCxJQUFJSSxLQUFLLENBQ25DLENBQUMsRUFBRTFCLFdBQVcsQ0FBQyxFQUFFRSxnQkFBZ0JFLGtCQUFrQixDQUFDQyxVQUFVLENBQUMsWUFBWSxDQUFDLENBQzdFLENBQUMsRUFBRTtnQkFDSmEsdUJBQXVCLENBQUNPLG9CQUFvQixHQUFHRjtZQUNqRDtRQUNGO1FBRUEsTUFBTUksVUFBVXpCLGdCQUFnQnlCLE9BQU8sQ0FBQztZQUN0QzVCLGlCQUFpQm1CO1lBQ2pCTjtZQUNBSTtZQUNBZjtRQUNGO1FBQ0FlLGlCQUFpQlksR0FBRyxDQUFDMUIsZ0JBQWdCRSxrQkFBa0IsQ0FBQ0MsVUFBVSxFQUFFO1lBQ2xFLEdBQUdzQixPQUFPO1lBQ1ZMLEtBQUtwQixnQkFBZ0JFLGtCQUFrQixDQUFDQyxVQUFVO1lBQ2xEQyxPQUFPVztRQUNUO1FBRUFBO0lBQ0Y7SUFFQSxPQUFPRDtBQUNUIn0=