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

package/dist/field/lexical/LexicalProvider.js

@@ -1,83 +1,30 @@
 'use client';
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "LexicalProvider", {
-    enumerable: true,
-    get: function() {
-        return 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 _nodes = require("./nodes");
-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;
-}
-const LexicalProvider = (props)=>{
+import { LexicalComposer } from '@lexical/react/LexicalComposer';
+import * as React from 'react';
+import { LexicalEditor as LexicalEditorComponent } from './LexicalEditor';
+import { EditorConfigProvider } from './config/client/EditorConfigProvider';
+import { getEnabledNodes } from './nodes';
+export 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:
-    _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 [initialConfig, setInitialConfig] = React.useState(null);
+    // set lexical config in useEffect: // TODO: Is this the most performant way to do this? Prob not
+    React.useEffect(()=>{
+        const newInitialConfig = {
+            editable: readOnly !== true,
+            editorState: value != null ? JSON.stringify(value) : undefined,
+            namespace: editorConfig.lexical.namespace,
+            nodes: [
+                ...getEnabledNodes({
+                    editorConfig
+                })
+            ],
+            onError: (error)=>{
+                throw error;
+            },
+            theme: editorConfig.lexical.theme
+        };
+        setInitialConfig(newInitialConfig);
     }, [
         editorConfig,
         readOnly,
@@ -100,20 +47,20 @@ const LexicalProvider = (props)=>{
         throw new Error('You have tried to pass in data from payload-plugin-lexical. This is not supported. The data structure has changed in this editor, compared to the plugin, and there is no automatic conversion available yet (coming soon). Please remove the data from the field and start again.');
     }
     if (!initialConfig) {
-        return /*#__PURE__*/ _react.createElement("p", null, "Loading...");
+        return /*#__PURE__*/ React.createElement("p", null, "Loading...");
     }
-    return /*#__PURE__*/ _react.createElement(_LexicalComposer.LexicalComposer, {
+    return /*#__PURE__*/ React.createElement(LexicalComposer, {
         initialConfig: initialConfig,
         key: path
-    }, /*#__PURE__*/ _react.createElement(_EditorConfigProvider.EditorConfigProvider, {
+    }, /*#__PURE__*/ React.createElement(EditorConfigProvider, {
         editorConfig: editorConfig,
         fieldProps: fieldProps
-    }, /*#__PURE__*/ _react.createElement("div", {
+    }, /*#__PURE__*/ React.createElement("div", {
         className: "editor-shell"
-    }, /*#__PURE__*/ _react.createElement(_LexicalEditor.LexicalEditor, {
+    }, /*#__PURE__*/ React.createElement(LexicalEditorComponent, {
         editorConfig: editorConfig,
         onChange: onChange
     }))));
 };
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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,41 @@
+'use client';
+import * as React from 'react';
+import { createContext, useContext, useEffect, useMemo, useState } from 'react';
+// 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__*/ createContext({
+    editorConfig: null,
+    field: null,
+    uuid: generateQuickGuid()
+});
+export const EditorConfigProvider = ({ children, editorConfig, fieldProps })=>{
+    // State to store the UUID
+    const [uuid, setUuid] = useState(generateQuickGuid());
+    // When the component mounts, generate a new UUID only once
+    useEffect(()=>{
+        setUuid(generateQuickGuid());
+    }, []);
+    const editorContext = useMemo(()=>({
+            editorConfig,
+            field: fieldProps,
+            uuid
+        }), [
+        editorConfig,
+        fieldProps,
+        uuid
+    ]);
+    return /*#__PURE__*/ React.createElement(Context.Provider, {
+        value: editorContext
+    }, children);
+};
+export const useEditorConfigContext = ()=>{
+    const context = 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,8 @@
+'use client';
+import { LexicalEditorTheme } from '../../theme/EditorTheme';
+export const defaultEditorLexicalConfig = {
+    namespace: 'lexical',
+    theme: LexicalEditorTheme
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9sZXhpY2FsL2NvbmZpZy9jbGllbnQvZGVmYXVsdC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIndXNlIGNsaWVudCdcbmltcG9ydCB0eXBlIHsgRWRpdG9yQ29uZmlnIGFzIExleGljYWxFZGl0b3JDb25maWcgfSBmcm9tICdsZXhpY2FsL0xleGljYWxFZGl0b3InXG5cbmltcG9ydCB7IExleGljYWxFZGl0b3JUaGVtZSB9IGZyb20gJy4uLy4uL3RoZW1lL0VkaXRvclRoZW1lJ1xuXG5leHBvcnQgY29uc3QgZGVmYXVsdEVkaXRvckxleGljYWxDb25maWc6IExleGljYWxFZGl0b3JDb25maWcgPSB7XG4gIG5hbWVzcGFjZTogJ2xleGljYWwnLFxuICB0aGVtZTogTGV4aWNhbEVkaXRvclRoZW1lLFxufVxuIl0sIm5hbWVzIjpbIkxleGljYWxFZGl0b3JUaGVtZSIsImRlZmF1bHRFZGl0b3JMZXhpY2FsQ29uZmlnIiwibmFtZXNwYWNlIiwidGhlbWUiXSwibWFwcGluZ3MiOiJBQUFBO0FBR0EsU0FBU0Esa0JBQWtCLFFBQVEsMEJBQXlCO0FBRTVELE9BQU8sTUFBTUMsNkJBQWtEO0lBQzdEQyxXQUFXO0lBQ1hDLE9BQU9IO0FBQ1QsRUFBQyJ9

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,46 @@
+'use client';
+/**
+ * This function expects client functions to ALREADY be ordered & dependencies checked on the server
+ * @param unSanitizedEditorConfig
+ */ export 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,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

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

@@ -0,0 +1,6 @@
+import type { EditorConfig as LexicalEditorConfig } from 'lexical/LexicalEditor';
+import type { ResolvedClientFeatureMap, SanitizedClientFeatures } from '../../../features/types';
+import type { SanitizedClientEditorConfig } from '../types';
+export declare const sanitizeClientFeatures: (features: ResolvedClientFeatureMap) => SanitizedClientFeatures;
+export declare function sanitizeClientEditorConfig(lexical: LexicalEditorConfig, resolvedClientFeatureMap: ResolvedClientFeatureMap): SanitizedClientEditorConfig;
+//# sourceMappingURL=sanitize.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sanitize.d.ts","sourceRoot":"","sources":["../../../../../src/field/lexical/config/client/sanitize.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,IAAI,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAEhF,OAAO,KAAK,EAAE,wBAAwB,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAA;AAChG,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,UAAU,CAAA;AAE3D,eAAO,MAAM,sBAAsB,0CAEhC,uBA4IF,CAAA;AAED,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,mBAAmB,EAC5B,wBAAwB,EAAE,wBAAwB,GACjD,2BAA2B,CAM7B"}

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

@@ -0,0 +1,126 @@
+'use client';
+export const sanitizeClientFeatures = (features)=>{
+    const sanitized = {
+        enabledFeatures: [],
+        floatingSelectToolbar: {
+            sections: []
+        },
+        hooks: {
+            load: [],
+            save: []
+        },
+        markdownTransformers: [],
+        nodes: [],
+        plugins: [],
+        slashMenu: {
+            dynamicOptions: [],
+            groupsWithOptions: []
+        }
+    };
+    if (!features?.size) {
+        return sanitized;
+    }
+    features.forEach((feature)=>{
+        if (feature.hooks) {
+            if (feature.hooks?.load?.length) {
+                sanitized.hooks.load = sanitized.hooks.load.concat(feature.hooks.load);
+            }
+            if (feature.hooks?.save?.length) {
+                sanitized.hooks.save = sanitized.hooks.save.concat(feature.hooks.save);
+            }
+        }
+        if (feature.nodes?.length) {
+            sanitized.nodes = sanitized.nodes.concat(feature.nodes);
+        }
+        if (feature.plugins?.length) {
+            feature.plugins.forEach((plugin, i)=>{
+                sanitized.plugins.push({
+                    Component: plugin.Component,
+                    key: feature.key + i,
+                    position: plugin.position
+                });
+            });
+        }
+        if (feature.floatingSelectToolbar?.sections?.length) {
+            for (const section of feature.floatingSelectToolbar.sections){
+                // 1. find the section with the same key or create new one
+                let foundSection = sanitized.floatingSelectToolbar.sections.find((sanitizedSection)=>sanitizedSection.key === section.key);
+                if (!foundSection) {
+                    foundSection = {
+                        ...section,
+                        entries: []
+                    };
+                } else {
+                    sanitized.floatingSelectToolbar.sections = sanitized.floatingSelectToolbar.sections.filter((sanitizedSection)=>sanitizedSection.key !== section.key);
+                }
+                // 2. Add options to group options array and add to sanitized.slashMenu.groupsWithOptions
+                if (section?.entries?.length) {
+                    foundSection.entries = foundSection.entries.concat(section.entries);
+                }
+                sanitized.floatingSelectToolbar?.sections.push(foundSection);
+            }
+        }
+        if (feature.slashMenu?.options) {
+            if (feature.slashMenu.dynamicOptions?.length) {
+                sanitized.slashMenu.dynamicOptions = sanitized.slashMenu.dynamicOptions.concat(feature.slashMenu.dynamicOptions);
+            }
+            for (const optionGroup of feature.slashMenu.options){
+                // 1. find the group with the same name or create new one
+                let group = sanitized.slashMenu.groupsWithOptions.find((group)=>group.key === optionGroup.key);
+                if (!group) {
+                    group = {
+                        ...optionGroup,
+                        options: []
+                    };
+                } else {
+                    sanitized.slashMenu.groupsWithOptions = sanitized.slashMenu.groupsWithOptions.filter((group)=>group.key !== optionGroup.key);
+                }
+                // 2. Add options to group options array and add to sanitized.slashMenu.groupsWithOptions
+                if (optionGroup?.options?.length) {
+                    group.options = group.options.concat(optionGroup.options);
+                }
+                sanitized.slashMenu.groupsWithOptions.push(group);
+            }
+        }
+        if (feature.markdownTransformers?.length) {
+            sanitized.markdownTransformers = sanitized.markdownTransformers.concat(feature.markdownTransformers);
+        }
+        sanitized.enabledFeatures.push(feature.key);
+    });
+    // Sort sanitized.floatingSelectToolbar.sections by order property
+    sanitized.floatingSelectToolbar.sections.sort((a, b)=>{
+        if (a.order && b.order) {
+            return a.order - b.order;
+        } else if (a.order) {
+            return -1;
+        } else if (b.order) {
+            return 1;
+        } else {
+            return 0;
+        }
+    });
+    // Sort sanitized.floatingSelectToolbar.sections.[section].entries by order property
+    for (const section of sanitized.floatingSelectToolbar.sections){
+        section.entries.sort((a, b)=>{
+            if (a.order && b.order) {
+                return a.order - b.order;
+            } else if (a.order) {
+                return -1;
+            } else if (b.order) {
+                return 1;
+            } else {
+                return 0;
+            }
+        });
+    }
+    return sanitized;
+};
+export function sanitizeClientEditorConfig(lexical, resolvedClientFeatureMap) {
+    return {
+        features: sanitizeClientFeatures(resolvedClientFeatureMap),
+        lexical,
+        resolvedFeatureMap: resolvedClientFeatureMap
+    };
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../src/field/lexical/config/client/sanitize.ts"],"sourcesContent":["'use client'\n\nimport type { EditorConfig as LexicalEditorConfig } from 'lexical/LexicalEditor'\n\nimport type { ResolvedClientFeatureMap, SanitizedClientFeatures } from '../../../features/types'\nimport type { SanitizedClientEditorConfig } from '../types'\n\nexport const sanitizeClientFeatures = (\n  features: ResolvedClientFeatureMap,\n): SanitizedClientFeatures => {\n  const sanitized: SanitizedClientFeatures = {\n    enabledFeatures: [],\n    floatingSelectToolbar: {\n      sections: [],\n    },\n    hooks: {\n      load: [],\n      save: [],\n    },\n    markdownTransformers: [],\n    nodes: [],\n    plugins: [],\n    slashMenu: {\n      dynamicOptions: [],\n      groupsWithOptions: [],\n    },\n  }\n\n  if (!features?.size) {\n    return sanitized\n  }\n\n  features.forEach((feature) => {\n    if (feature.hooks) {\n      if (feature.hooks?.load?.length) {\n        sanitized.hooks.load = sanitized.hooks.load.concat(feature.hooks.load)\n      }\n      if (feature.hooks?.save?.length) {\n        sanitized.hooks.save = sanitized.hooks.save.concat(feature.hooks.save)\n      }\n    }\n\n    if (feature.nodes?.length) {\n      sanitized.nodes = sanitized.nodes.concat(feature.nodes)\n    }\n    if (feature.plugins?.length) {\n      feature.plugins.forEach((plugin, i) => {\n        sanitized.plugins.push({\n          Component: plugin.Component,\n          key: feature.key + i,\n          position: plugin.position,\n        })\n      })\n    }\n\n    if (feature.floatingSelectToolbar?.sections?.length) {\n      for (const section of feature.floatingSelectToolbar.sections) {\n        // 1. find the section with the same key or create new one\n        let foundSection = sanitized.floatingSelectToolbar.sections.find(\n          (sanitizedSection) => sanitizedSection.key === section.key,\n        )\n        if (!foundSection) {\n          foundSection = {\n            ...section,\n            entries: [],\n          }\n        } else {\n          sanitized.floatingSelectToolbar.sections =\n            sanitized.floatingSelectToolbar.sections.filter(\n              (sanitizedSection) => sanitizedSection.key !== section.key,\n            )\n        }\n\n        // 2. Add options to group options array and add to sanitized.slashMenu.groupsWithOptions\n        if (section?.entries?.length) {\n          foundSection.entries = foundSection.entries.concat(section.entries)\n        }\n        sanitized.floatingSelectToolbar?.sections.push(foundSection)\n      }\n    }\n\n    if (feature.slashMenu?.options) {\n      if (feature.slashMenu.dynamicOptions?.length) {\n        sanitized.slashMenu.dynamicOptions = sanitized.slashMenu.dynamicOptions.concat(\n          feature.slashMenu.dynamicOptions,\n        )\n      }\n\n      for (const optionGroup of feature.slashMenu.options) {\n        // 1. find the group with the same name or create new one\n        let group = sanitized.slashMenu.groupsWithOptions.find(\n          (group) => group.key === optionGroup.key,\n        )\n        if (!group) {\n          group = {\n            ...optionGroup,\n            options: [],\n          }\n        } else {\n          sanitized.slashMenu.groupsWithOptions = sanitized.slashMenu.groupsWithOptions.filter(\n            (group) => group.key !== optionGroup.key,\n          )\n        }\n\n        // 2. Add options to group options array and add to sanitized.slashMenu.groupsWithOptions\n        if (optionGroup?.options?.length) {\n          group.options = group.options.concat(optionGroup.options)\n        }\n        sanitized.slashMenu.groupsWithOptions.push(group)\n      }\n    }\n\n    if (feature.markdownTransformers?.length) {\n      sanitized.markdownTransformers = sanitized.markdownTransformers.concat(\n        feature.markdownTransformers,\n      )\n    }\n    sanitized.enabledFeatures.push(feature.key)\n  })\n\n  // Sort sanitized.floatingSelectToolbar.sections by order property\n  sanitized.floatingSelectToolbar.sections.sort((a, b) => {\n    if (a.order && b.order) {\n      return a.order - b.order\n    } else if (a.order) {\n      return -1\n    } else if (b.order) {\n      return 1\n    } else {\n      return 0\n    }\n  })\n\n  // Sort sanitized.floatingSelectToolbar.sections.[section].entries by order property\n  for (const section of sanitized.floatingSelectToolbar.sections) {\n    section.entries.sort((a, b) => {\n      if (a.order && b.order) {\n        return a.order - b.order\n      } else if (a.order) {\n        return -1\n      } else if (b.order) {\n        return 1\n      } else {\n        return 0\n      }\n    })\n  }\n\n  return sanitized\n}\n\nexport function sanitizeClientEditorConfig(\n  lexical: LexicalEditorConfig,\n  resolvedClientFeatureMap: ResolvedClientFeatureMap,\n): SanitizedClientEditorConfig {\n  return {\n    features: sanitizeClientFeatures(resolvedClientFeatureMap),\n    lexical,\n    resolvedFeatureMap: resolvedClientFeatureMap,\n  }\n}\n"],"names":["sanitizeClientFeatures","features","sanitized","enabledFeatures","floatingSelectToolbar","sections","hooks","load","save","markdownTransformers","nodes","plugins","slashMenu","dynamicOptions","groupsWithOptions","size","forEach","feature","length","concat","plugin","i","push","Component","key","position","section","foundSection","find","sanitizedSection","entries","filter","options","optionGroup","group","sort","a","b","order","sanitizeClientEditorConfig","lexical","resolvedClientFeatureMap","resolvedFeatureMap"],"mappings":"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"}

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

@@ -0,0 +1,8 @@
+import type { EditorConfig as LexicalEditorConfig } from 'lexical/LexicalEditor';
+import type { FeatureProviderServer } from '../../../features/types';
+import type { SanitizedServerEditorConfig, ServerEditorConfig } from '../types';
+export declare const defaultEditorLexicalConfig: LexicalEditorConfig;
+export declare const defaultEditorFeatures: FeatureProviderServer<unknown, unknown>[];
+export declare const defaultEditorConfig: ServerEditorConfig;
+export declare const defaultSanitizedServerEditorConfig: SanitizedServerEditorConfig;
+//# sourceMappingURL=default.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"default.d.ts","sourceRoot":"","sources":["../../../../../src/field/lexical/config/server/default.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,IAAI,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAEhF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAA;AACpE,OAAO,KAAK,EAAE,2BAA2B,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAuB/E,eAAO,MAAM,0BAA0B,EAAE,mBAGxC,CAAA;AAED,eAAO,MAAM,qBAAqB,EAAE,qBAAqB,CAAC,OAAO,EAAE,OAAO,CAAC,EAmB1E,CAAA;AAED,eAAO,MAAM,mBAAmB,EAAE,kBAGjC,CAAA;AAED,eAAO,MAAM,kCAAkC,EAAE,2BACA,CAAA"}

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

@@ -0,0 +1,51 @@
+import { AlignFeature } from '../../../features/align/feature.server';
+import { BlockQuoteFeature } from '../../../features/blockquote/feature.server';
+import { BoldFeature } from '../../../features/format/bold/feature.server';
+import { InlineCodeFeature } from '../../../features/format/inlinecode/feature.server';
+import { ItalicFeature } from '../../../features/format/italic/feature.server';
+import { StrikethroughFeature } from '../../../features/format/strikethrough/feature.server';
+import { SubscriptFeature } from '../../../features/format/subscript/feature.server';
+import { SuperscriptFeature } from '../../../features/format/superscript/feature.server';
+import { UnderlineFeature } from '../../../features/format/underline/feature.server';
+import { HeadingFeature } from '../../../features/heading/feature.server';
+import { IndentFeature } from '../../../features/indent/feature.server';
+import { LinkFeature } from '../../../features/link/feature.server';
+import { CheckListFeature } from '../../../features/lists/checklist/feature.server';
+import { OrderedListFeature } from '../../../features/lists/orderedlist/feature.server';
+import { UnorderedListFeature } from '../../../features/lists/unorderedlist/feature.server';
+import { ParagraphFeature } from '../../../features/paragraph/feature.server';
+import { RelationshipFeature } from '../../../features/relationship/feature.server';
+import { UploadFeature } from '../../../features/upload/feature.server';
+import { LexicalEditorTheme } from '../../theme/EditorTheme';
+import { sanitizeServerEditorConfig } from './sanitize';
+export const defaultEditorLexicalConfig = {
+    namespace: 'lexical',
+    theme: LexicalEditorTheme
+};
+export const defaultEditorFeatures = [
+    BoldFeature(),
+    ItalicFeature(),
+    UnderlineFeature(),
+    StrikethroughFeature(),
+    SubscriptFeature(),
+    SuperscriptFeature(),
+    InlineCodeFeature(),
+    ParagraphFeature(),
+    HeadingFeature(),
+    AlignFeature(),
+    IndentFeature(),
+    UnorderedListFeature(),
+    OrderedListFeature(),
+    CheckListFeature(),
+    LinkFeature(),
+    RelationshipFeature(),
+    BlockQuoteFeature(),
+    UploadFeature()
+];
+export const defaultEditorConfig = {
+    features: defaultEditorFeatures,
+    lexical: defaultEditorLexicalConfig
+};
+export const defaultSanitizedServerEditorConfig = sanitizeServerEditorConfig(defaultEditorConfig);
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,7 @@
+import type { FeatureProviderServer, ResolvedServerFeatureMap } from '../../../features/types';
+import type { ServerEditorConfig } from '../types';
+export declare function sortFeaturesForOptimalLoading(featureProviders: FeatureProviderServer<unknown, unknown>[]): FeatureProviderServer<unknown, unknown>[];
+export declare function loadFeatures({ unSanitizedEditorConfig, }: {
+    unSanitizedEditorConfig: ServerEditorConfig;
+}): ResolvedServerFeatureMap;
+//# sourceMappingURL=loader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../../../../src/field/lexical/config/server/loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,qBAAqB,EACrB,wBAAwB,EAEzB,MAAM,yBAAyB,CAAA;AAChC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AA8FlD,wBAAgB,6BAA6B,CAC3C,gBAAgB,EAAE,qBAAqB,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,GAC1D,qBAAqB,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,CAE3C;AAED,wBAAgB,YAAY,CAAC,EAC3B,uBAAuB,GACxB,EAAE;IACD,uBAAuB,EAAE,kBAAkB,CAAA;CAC5C,GAAG,wBAAwB,CA8E3B"}