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

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,144 @@
+'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, {
+    sanitizeClientEditorConfig: function() {
+        return sanitizeClientEditorConfig;
+    },
+    sanitizeClientFeatures: function() {
+        return sanitizeClientFeatures;
+    }
+});
+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;
+};
+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":["sanitizeClientEditorConfig","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","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,75 @@
+"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, {
+    defaultEditorConfig: function() {
+        return defaultEditorConfig;
+    },
+    defaultEditorFeatures: function() {
+        return defaultEditorFeatures;
+    },
+    defaultEditorLexicalConfig: function() {
+        return defaultEditorLexicalConfig;
+    },
+    defaultSanitizedServerEditorConfig: function() {
+        return defaultSanitizedServerEditorConfig;
+    }
+});
+const _featureserver = require("../../../features/align/feature.server");
+const _featureserver1 = require("../../../features/blockquote/feature.server");
+const _featureserver2 = require("../../../features/format/bold/feature.server");
+const _featureserver3 = require("../../../features/format/inlinecode/feature.server");
+const _featureserver4 = require("../../../features/format/italic/feature.server");
+const _featureserver5 = require("../../../features/format/strikethrough/feature.server");
+const _featureserver6 = require("../../../features/format/subscript/feature.server");
+const _featureserver7 = require("../../../features/format/superscript/feature.server");
+const _featureserver8 = require("../../../features/format/underline/feature.server");
+const _featureserver9 = require("../../../features/heading/feature.server");
+const _featureserver10 = require("../../../features/indent/feature.server");
+const _featureserver11 = require("../../../features/link/feature.server");
+const _featureserver12 = require("../../../features/lists/checklist/feature.server");
+const _featureserver13 = require("../../../features/lists/orderedlist/feature.server");
+const _featureserver14 = require("../../../features/lists/unorderedlist/feature.server");
+const _featureserver15 = require("../../../features/paragraph/feature.server");
+const _featureserver16 = require("../../../features/relationship/feature.server");
+const _featureserver17 = require("../../../features/upload/feature.server");
+const _EditorTheme = require("../../theme/EditorTheme");
+const _sanitize = require("./sanitize");
+const defaultEditorLexicalConfig = {
+    namespace: 'lexical',
+    theme: _EditorTheme.LexicalEditorTheme
+};
+const defaultEditorFeatures = [
+    (0, _featureserver2.BoldFeature)(),
+    (0, _featureserver4.ItalicFeature)(),
+    (0, _featureserver8.UnderlineFeature)(),
+    (0, _featureserver5.StrikethroughFeature)(),
+    (0, _featureserver6.SubscriptFeature)(),
+    (0, _featureserver7.SuperscriptFeature)(),
+    (0, _featureserver3.InlineCodeFeature)(),
+    (0, _featureserver15.ParagraphFeature)(),
+    (0, _featureserver9.HeadingFeature)(),
+    (0, _featureserver.AlignFeature)(),
+    (0, _featureserver10.IndentFeature)(),
+    (0, _featureserver14.UnorderedListFeature)(),
+    (0, _featureserver13.OrderedListFeature)(),
+    (0, _featureserver12.CheckListFeature)(),
+    (0, _featureserver11.LinkFeature)(),
+    (0, _featureserver16.RelationshipFeature)(),
+    (0, _featureserver1.BlockQuoteFeature)(),
+    (0, _featureserver17.UploadFeature)()
+];
+const defaultEditorConfig = {
+    features: defaultEditorFeatures,
+    lexical: defaultEditorLexicalConfig
+};
+const defaultSanitizedServerEditorConfig = (0, _sanitize.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"}

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

@@ -0,0 +1,136 @@
+"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, {
+    loadFeatures: function() {
+        return loadFeatures;
+    },
+    sortFeaturesForOptimalLoading: function() {
+        return sortFeaturesForOptimalLoading;
+    }
+});
+function createDependencyGraph(featureProviders) {
+    const graph = {};
+    for (const fp of featureProviders){
+        graph[fp.key] = {
+            dependencies: fp.dependencies || [],
+            dependenciesPriority: fp.dependenciesPriority || [],
+            dependenciesSoft: fp.dependenciesSoft || [],
+            featureProvider: fp
+        };
+    }
+    return graph;
+}
+function topologicallySortFeatures(featureProviders) {
+    const graph = createDependencyGraph(featureProviders);
+    const visited = {};
+    const stack = [];
+    for(const key in graph){
+        if (!visited[key]) {
+            visit(graph, key, visited, stack);
+        }
+    }
+    return stack.reverse();
+}
+function visit(graph, key, visited, stack, currentPath = []) {
+    if (!graph[key]) {
+        throw new Error(`Feature key ${key} is not present in the dependency graph.`);
+    }
+    if (currentPath.includes(key)) {
+        throw new Error(`Circular dependency detected: ${currentPath.join(' -> ')} -> ${key}`);
+    }
+    if (visited[key]) {
+        return;
+    }
+    visited[key] = true;
+    currentPath.push(key);
+    // First process the hard priority dependencies
+    for (const dep of graph[key].dependenciesPriority){
+        if (!visited[dep]) {
+            visit(graph, dep, visited, stack, currentPath);
+        }
+    }
+    // Then process the normal dependencies, but make sure to not violate hard dependencies
+    for (const dep of graph[key].dependencies){
+        if (!visited[dep] && !graph[key].dependenciesPriority.includes(dep)) {
+            visit(graph, dep, visited, stack, currentPath);
+        }
+    }
+    // Then process the soft dependencies. Make sure to not violate hard and normal dependencies.
+    for (const dep of graph[key].dependenciesSoft){
+        if (graph[dep] && !visited[dep] && !graph[key].dependenciesPriority.includes(dep) && !graph[key].dependencies.includes(dep)) {
+            visit(graph, dep, visited, stack, currentPath);
+        }
+    }
+    stack.push(graph[key].featureProvider);
+    currentPath.pop();
+}
+function sortFeaturesForOptimalLoading(featureProviders) {
+    return topologicallySortFeatures(featureProviders);
+}
+function loadFeatures({ unSanitizedEditorConfig }) {
+    // First remove all duplicate features. The LAST feature with a given key wins.
+    unSanitizedEditorConfig.features = unSanitizedEditorConfig.features.reverse().filter((f, i, arr)=>{
+        const firstIndex = arr.findIndex((f2)=>f2.key === f.key);
+        return firstIndex === i;
+    }).reverse();
+    unSanitizedEditorConfig.features = sortFeaturesForOptimalLoading(unSanitizedEditorConfig.features);
+    const featureProviderMap = new Map(unSanitizedEditorConfig.features.map((f)=>[
+            f.key,
+            f
+        ]));
+    const resolvedFeatures = new Map();
+    // Make sure all dependencies declared in the respective features exist
+    let loaded = 0;
+    for (const featureProvider of unSanitizedEditorConfig.features){
+        if (!featureProvider.key) {
+            throw new Error(`A Feature you've added does not have a key. Please add a key to the feature. This is used to uniquely identify the feature.`);
+        }
+        if (featureProvider.dependencies?.length) {
+            for (const dependencyKey of featureProvider.dependencies){
+                const found = unSanitizedEditorConfig.features.find((f)=>f.key === dependencyKey);
+                if (!found) {
+                    throw new Error(`Feature ${featureProvider.key} has a dependency ${dependencyKey} which does not exist.`);
+                }
+            }
+        }
+        if (featureProvider.dependenciesPriority?.length) {
+            for (const priorityDependencyKey of featureProvider.dependenciesPriority){
+                // look in the resolved features instead of the editorConfig.features, as a dependency requires the feature to be loaded before it, contrary to a soft-dependency
+                const found = resolvedFeatures.get(priorityDependencyKey);
+                if (!found) {
+                    const existsInEditorConfig = unSanitizedEditorConfig.features.find((f)=>f.key === priorityDependencyKey);
+                    if (!existsInEditorConfig) {
+                        throw new Error(`Feature ${featureProvider.key} has a priority dependency ${priorityDependencyKey} which does not exist.`);
+                    } else {
+                        throw new Error(`Feature ${featureProvider.key} has a priority dependency ${priorityDependencyKey} which is not loaded before it.`);
+                    }
+                }
+            }
+        }
+        const feature = featureProvider.feature({
+            featureProviderMap,
+            resolvedFeatures,
+            unSanitizedEditorConfig
+        });
+        resolvedFeatures.set(featureProvider.key, {
+            ...feature,
+            dependencies: featureProvider.dependencies,
+            dependenciesPriority: featureProvider.dependenciesPriority,
+            dependenciesSoft: featureProvider.dependenciesSoft,
+            key: featureProvider.key,
+            order: loaded
+        });
+        loaded++;
+    }
+    return resolvedFeatures;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../src/field/lexical/config/server/loader.ts"],"sourcesContent":["import type {\n  FeatureProviderServer,\n  ResolvedServerFeatureMap,\n  ServerFeatureProviderMap,\n} from '../../../features/types'\nimport type { ServerEditorConfig } from '../types'\n\ntype DependencyGraph = {\n  [key: string]: {\n    dependencies: string[]\n    dependenciesPriority: string[]\n    dependenciesSoft: string[]\n    featureProvider: FeatureProviderServer<unknown, unknown>\n  }\n}\n\nfunction createDependencyGraph(\n  featureProviders: FeatureProviderServer<unknown, unknown>[],\n): DependencyGraph {\n  const graph: DependencyGraph = {}\n  for (const fp of featureProviders) {\n    graph[fp.key] = {\n      dependencies: fp.dependencies || [],\n      dependenciesPriority: fp.dependenciesPriority || [],\n      dependenciesSoft: fp.dependenciesSoft || [],\n      featureProvider: fp,\n    }\n  }\n  return graph\n}\n\nfunction topologicallySortFeatures(\n  featureProviders: FeatureProviderServer<unknown, unknown>[],\n): FeatureProviderServer<unknown, unknown>[] {\n  const graph = createDependencyGraph(featureProviders)\n  const visited: { [key: string]: boolean } = {}\n  const stack: FeatureProviderServer<unknown, unknown>[] = []\n\n  for (const key in graph) {\n    if (!visited[key]) {\n      visit(graph, key, visited, stack)\n    }\n  }\n\n  return stack.reverse()\n}\n\nfunction visit(\n  graph: DependencyGraph,\n  key: string,\n  visited: { [key: string]: boolean },\n  stack: FeatureProviderServer<unknown, unknown>[],\n  currentPath: string[] = [],\n) {\n  if (!graph[key]) {\n    throw new Error(`Feature key ${key} is not present in the dependency graph.`)\n  }\n\n  if (currentPath.includes(key)) {\n    throw new Error(`Circular dependency detected: ${currentPath.join(' -> ')} -> ${key}`)\n  }\n\n  if (visited[key]) {\n    return\n  }\n\n  visited[key] = true\n  currentPath.push(key)\n\n  // First process the hard priority dependencies\n  for (const dep of graph[key].dependenciesPriority) {\n    if (!visited[dep]) {\n      visit(graph, dep, visited, stack, currentPath)\n    }\n  }\n\n  // Then process the normal dependencies, but make sure to not violate hard dependencies\n  for (const dep of graph[key].dependencies) {\n    if (!visited[dep] && !graph[key].dependenciesPriority.includes(dep)) {\n      visit(graph, dep, visited, stack, currentPath)\n    }\n  }\n\n  // Then process the soft dependencies. Make sure to not violate hard and normal dependencies.\n  for (const dep of graph[key].dependenciesSoft) {\n    if (\n      graph[dep] &&\n      !visited[dep] &&\n      !graph[key].dependenciesPriority.includes(dep) &&\n      !graph[key].dependencies.includes(dep)\n    ) {\n      visit(graph, dep, visited, stack, currentPath)\n    }\n  }\n\n  stack.push(graph[key].featureProvider)\n  currentPath.pop()\n}\n\nexport function sortFeaturesForOptimalLoading(\n  featureProviders: FeatureProviderServer<unknown, unknown>[],\n): FeatureProviderServer<unknown, unknown>[] {\n  return topologicallySortFeatures(featureProviders)\n}\n\nexport function loadFeatures({\n  unSanitizedEditorConfig,\n}: {\n  unSanitizedEditorConfig: ServerEditorConfig\n}): ResolvedServerFeatureMap {\n  // First remove all duplicate features. The LAST feature with a given key wins.\n  unSanitizedEditorConfig.features = unSanitizedEditorConfig.features\n    .reverse()\n    .filter((f, i, arr) => {\n      const firstIndex = arr.findIndex((f2) => f2.key === f.key)\n      return firstIndex === i\n    })\n    .reverse()\n\n  unSanitizedEditorConfig.features = sortFeaturesForOptimalLoading(unSanitizedEditorConfig.features)\n\n  const featureProviderMap: ServerFeatureProviderMap = new Map(\n    unSanitizedEditorConfig.features.map(\n      (f) => [f.key, f] as [string, FeatureProviderServer<unknown, unknown>],\n    ),\n  )\n\n  const resolvedFeatures: ResolvedServerFeatureMap = new Map()\n\n  // Make sure all dependencies declared in the respective features exist\n  let loaded = 0\n  for (const featureProvider of unSanitizedEditorConfig.features) {\n    if (!featureProvider.key) {\n      throw new Error(\n        `A Feature you've added does not have a key. Please add a key to the feature. This is used to uniquely identify the feature.`,\n      )\n    }\n    if (featureProvider.dependencies?.length) {\n      for (const dependencyKey of featureProvider.dependencies) {\n        const found = unSanitizedEditorConfig.features.find((f) => f.key === dependencyKey)\n        if (!found) {\n          throw new Error(\n            `Feature ${featureProvider.key} has a dependency ${dependencyKey} which does not exist.`,\n          )\n        }\n      }\n    }\n\n    if (featureProvider.dependenciesPriority?.length) {\n      for (const priorityDependencyKey of featureProvider.dependenciesPriority) {\n        // look in the resolved features instead of the editorConfig.features, as a dependency requires the feature to be loaded before it, contrary to a soft-dependency\n        const found = resolvedFeatures.get(priorityDependencyKey)\n        if (!found) {\n          const existsInEditorConfig = unSanitizedEditorConfig.features.find(\n            (f) => f.key === priorityDependencyKey,\n          )\n          if (!existsInEditorConfig) {\n            throw new Error(\n              `Feature ${featureProvider.key} has a priority dependency ${priorityDependencyKey} which does not exist.`,\n            )\n          } else {\n            throw new Error(\n              `Feature ${featureProvider.key} has a priority dependency ${priorityDependencyKey} which is not loaded before it.`,\n            )\n          }\n        }\n      }\n    }\n\n    const feature = featureProvider.feature({\n      featureProviderMap,\n      resolvedFeatures,\n      unSanitizedEditorConfig,\n    })\n    resolvedFeatures.set(featureProvider.key, {\n      ...feature,\n      dependencies: featureProvider.dependencies,\n      dependenciesPriority: featureProvider.dependenciesPriority,\n      dependenciesSoft: featureProvider.dependenciesSoft,\n      key: featureProvider.key,\n      order: loaded,\n    })\n\n    loaded++\n  }\n\n  return resolvedFeatures\n}\n"],"names":["loadFeatures","sortFeaturesForOptimalLoading","createDependencyGraph","featureProviders","graph","fp","key","dependencies","dependenciesPriority","dependenciesSoft","featureProvider","topologicallySortFeatures","visited","stack","visit","reverse","currentPath","Error","includes","join","push","dep","pop","unSanitizedEditorConfig","features","filter","f","i","arr","firstIndex","findIndex","f2","featureProviderMap","Map","map","resolvedFeatures","loaded","length","dependencyKey","found","find","priorityDependencyKey","get","existsInEditorConfig","feature","set","order"],"mappings":"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"}

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

@@ -0,0 +1,5 @@
+import type { ResolvedServerFeatureMap, SanitizedServerFeatures } from '../../../features/types';
+import type { SanitizedServerEditorConfig, ServerEditorConfig } from '../types';
+export declare const sanitizeServerFeatures: (features: ResolvedServerFeatureMap) => SanitizedServerFeatures;
+export declare function sanitizeServerEditorConfig(editorConfig: ServerEditorConfig): SanitizedServerEditorConfig;
+//# sourceMappingURL=sanitize.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sanitize.d.ts","sourceRoot":"","sources":["../../../../../src/field/lexical/config/server/sanitize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAA;AAChG,OAAO,KAAK,EAAE,2BAA2B,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAI/E,eAAO,MAAM,sBAAsB,0CAEhC,uBA8DF,CAAA;AAED,wBAAgB,0BAA0B,CACxC,YAAY,EAAE,kBAAkB,GAC/B,2BAA2B,CAU7B"}

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

@@ -0,0 +1,83 @@
+"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, {
+    sanitizeServerEditorConfig: function() {
+        return sanitizeServerEditorConfig;
+    },
+    sanitizeServerFeatures: function() {
+        return sanitizeServerFeatures;
+    }
+});
+const _loader = require("./loader");
+const sanitizeServerFeatures = (features)=>{
+    const sanitized = {
+        converters: {
+            html: []
+        },
+        enabledFeatures: [],
+        generatedTypes: {
+            modifyOutputSchemas: []
+        },
+        hooks: {
+            afterReadPromises: []
+        },
+        markdownTransformers: [],
+        nodes: [],
+        populationPromises: new Map(),
+        validations: new Map()
+    };
+    if (!features?.size) {
+        return sanitized;
+    }
+    features.forEach((feature)=>{
+        if (feature?.generatedTypes?.modifyOutputSchema) {
+            sanitized.generatedTypes.modifyOutputSchemas.push(feature.generatedTypes.modifyOutputSchema);
+        }
+        if (feature.hooks) {
+            if (feature.hooks.afterReadPromise) {
+                sanitized.hooks.afterReadPromises = sanitized.hooks.afterReadPromises.concat(feature.hooks.afterReadPromise);
+            }
+        }
+        if (feature.nodes?.length) {
+            sanitized.nodes = sanitized.nodes.concat(feature.nodes);
+            feature.nodes.forEach((node)=>{
+                const nodeType = 'with' in node.node ? node.node.replace.getType() : node.node.getType() // TODO: Idk if this works for node replacements
+                ;
+                if (node?.populationPromises?.length) {
+                    sanitized.populationPromises.set(nodeType, node.populationPromises);
+                }
+                if (node?.validations?.length) {
+                    sanitized.validations.set(nodeType, node.validations);
+                }
+                if (node?.converters?.html) {
+                    sanitized.converters.html.push(node.converters.html);
+                }
+            });
+        }
+        if (feature.markdownTransformers?.length) {
+            sanitized.markdownTransformers = sanitized.markdownTransformers.concat(feature.markdownTransformers);
+        }
+        sanitized.enabledFeatures.push(feature.key);
+    });
+    return sanitized;
+};
+function sanitizeServerEditorConfig(editorConfig) {
+    const resolvedFeatureMap = (0, _loader.loadFeatures)({
+        unSanitizedEditorConfig: editorConfig
+    });
+    return {
+        features: sanitizeServerFeatures(resolvedFeatureMap),
+        lexical: editorConfig.lexical,
+        resolvedFeatureMap
+    };
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/lexical/config/types.d.ts

@@ -1,12 +1,21 @@
 import type { EditorConfig as LexicalEditorConfig } from 'lexical/LexicalEditor';
-import type { FeatureProvider, ResolvedFeatureMap, SanitizedFeatures } from '../../features/types';
-export type EditorConfig = {
-    features: FeatureProvider[];
-    lexical?: () => Promise<LexicalEditorConfig>;
-};
-export type SanitizedEditorConfig = {
-    features: SanitizedFeatures;
-    lexical: () => Promise<LexicalEditorConfig>;
-    resolvedFeatureMap: ResolvedFeatureMap;
+import type { FeatureProviderClient, FeatureProviderServer, ResolvedClientFeatureMap, ResolvedServerFeatureMap, SanitizedClientFeatures, SanitizedServerFeatures } from '../../features/types';
+export type ServerEditorConfig = {
+    features: FeatureProviderServer<unknown, unknown>[];
+    lexical?: LexicalEditorConfig;
+};
+export type SanitizedServerEditorConfig = {
+    features: SanitizedServerFeatures;
+    lexical: LexicalEditorConfig;
+    resolvedFeatureMap: ResolvedServerFeatureMap;
+};
+export type ClientEditorConfig = {
+    features: FeatureProviderClient<unknown>[];
+    lexical?: LexicalEditorConfig;
+};
+export type SanitizedClientEditorConfig = {
+    features: SanitizedClientFeatures;
+    lexical: LexicalEditorConfig;
+    resolvedFeatureMap: ResolvedClientFeatureMap;
 };
 //# sourceMappingURL=types.d.ts.map

package/dist/field/lexical/config/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/field/lexical/config/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,IAAI,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAEhF,OAAO,KAAK,EAAE,eAAe,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAA;AAElG,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,EAAE,eAAe,EAAE,CAAA;IAC3B,OAAO,CAAC,EAAE,MAAM,OAAO,CAAC,mBAAmB,CAAC,CAAA;CAC7C,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,EAAE,iBAAiB,CAAA;IAC3B,OAAO,EAAE,MAAM,OAAO,CAAC,mBAAmB,CAAC,CAAA;IAC3C,kBAAkB,EAAE,kBAAkB,CAAA;CACvC,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/field/lexical/config/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,IAAI,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAEhF,OAAO,KAAK,EACV,qBAAqB,EACrB,qBAAqB,EACrB,wBAAwB,EACxB,wBAAwB,EACxB,uBAAuB,EACvB,uBAAuB,EACxB,MAAM,sBAAsB,CAAA;AAE7B,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,EAAE,qBAAqB,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,CAAA;IACnD,OAAO,CAAC,EAAE,mBAAmB,CAAA;CAC9B,CAAA;AAED,MAAM,MAAM,2BAA2B,GAAG;IACxC,QAAQ,EAAE,uBAAuB,CAAA;IACjC,OAAO,EAAE,mBAAmB,CAAA;IAC5B,kBAAkB,EAAE,wBAAwB,CAAA;CAC7C,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,EAAE,qBAAqB,CAAC,OAAO,CAAC,EAAE,CAAA;IAC1C,OAAO,CAAC,EAAE,mBAAmB,CAAA;CAC9B,CAAA;AAED,MAAM,MAAM,2BAA2B,GAAG;IACxC,QAAQ,EAAE,uBAAuB,CAAA;IACjC,OAAO,EAAE,mBAAmB,CAAA;IAC5B,kBAAkB,EAAE,wBAAwB,CAAA;CAC7C,CAAA"}

package/dist/field/lexical/nodes/index.d.ts

@@ -1,7 +1,7 @@
 import type { Klass, LexicalNode } from 'lexical';
 import type { LexicalNodeReplacement } from 'lexical';
-import type { SanitizedEditorConfig } from '../config/types';
+import type { SanitizedClientEditorConfig, SanitizedServerEditorConfig } from '../config/types';
 export declare function getEnabledNodes({ editorConfig, }: {
-    editorConfig: SanitizedEditorConfig;
+    editorConfig: SanitizedClientEditorConfig | SanitizedServerEditorConfig;
 }): Array<Klass<LexicalNode> | LexicalNodeReplacement>;
 //# sourceMappingURL=index.d.ts.map

package/dist/field/lexical/nodes/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/field/lexical/nodes/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AACjD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAA;AAErD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAA;AAE5D,wBAAgB,eAAe,CAAC,EAC9B,YAAY,GACb,EAAE;IACD,YAAY,EAAE,qBAAqB,CAAA;CACpC,GAAG,KAAK,CAAC,KAAK,CAAC,WAAW,CAAC,GAAG,sBAAsB,CAAC,CAErD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/field/lexical/nodes/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AACjD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAA;AAErD,OAAO,KAAK,EAAE,2BAA2B,EAAE,2BAA2B,EAAE,MAAM,iBAAiB,CAAA;AAE/F,wBAAgB,eAAe,CAAC,EAC9B,YAAY,GACb,EAAE;IACD,YAAY,EAAE,2BAA2B,GAAG,2BAA2B,CAAA;CACxE,GAAG,KAAK,CAAC,KAAK,CAAC,WAAW,CAAC,GAAG,sBAAsB,CAAC,CAOrD"}

package/dist/field/lexical/nodes/index.js

@@ -9,7 +9,12 @@ Object.defineProperty(exports, "getEnabledNodes", {
     }
 });
 function getEnabledNodes({ editorConfig }) {
-    return editorConfig.features.nodes.map((node)=>node.node);
+    return editorConfig.features.nodes.map((node)=>{
+        if ('node' in node) {
+            return node.node;
+        }
+        return node;
+    });
 }
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9maWVsZC9sZXhpY2FsL25vZGVzL2luZGV4LnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgS2xhc3MsIExleGljYWxOb2RlIH0gZnJvbSAnbGV4aWNhbCdcbmltcG9ydCB0eXBlIHsgTGV4aWNhbE5vZGVSZXBsYWNlbWVudCB9IGZyb20gJ2xleGljYWwnXG5cbmltcG9ydCB0eXBlIHsgU2FuaXRpemVkRWRpdG9yQ29uZmlnIH0gZnJvbSAnLi4vY29uZmlnL3R5cGVzJ1xuXG5leHBvcnQgZnVuY3Rpb24gZ2V0RW5hYmxlZE5vZGVzKHtcbiAgZWRpdG9yQ29uZmlnLFxufToge1xuICBlZGl0b3JDb25maWc6IFNhbml0aXplZEVkaXRvckNvbmZpZ1xufSk6IEFycmF5PEtsYXNzPExleGljYWxOb2RlPiB8IExleGljYWxOb2RlUmVwbGFjZW1lbnQ+IHtcbiAgcmV0dXJuIGVkaXRvckNvbmZpZy5mZWF0dXJlcy5ub2Rlcy5tYXAoKG5vZGUpID0+IG5vZGUubm9kZSlcbn1cbiJdLCJuYW1lcyI6WyJnZXRFbmFibGVkTm9kZXMiLCJlZGl0b3JDb25maWciLCJmZWF0dXJlcyIsIm5vZGVzIiwibWFwIiwibm9kZSJdLCJtYXBwaW5ncyI6Ijs7OzsrQkFLZ0JBOzs7ZUFBQUE7OztBQUFULFNBQVNBLGdCQUFnQixFQUM5QkMsWUFBWSxFQUdiO0lBQ0MsT0FBT0EsYUFBYUMsUUFBUSxDQUFDQyxLQUFLLENBQUNDLEdBQUcsQ0FBQyxDQUFDQyxPQUFTQSxLQUFLQSxJQUFJO0FBQzVEIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9maWVsZC9sZXhpY2FsL25vZGVzL2luZGV4LnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgS2xhc3MsIExleGljYWxOb2RlIH0gZnJvbSAnbGV4aWNhbCdcbmltcG9ydCB0eXBlIHsgTGV4aWNhbE5vZGVSZXBsYWNlbWVudCB9IGZyb20gJ2xleGljYWwnXG5cbmltcG9ydCB0eXBlIHsgU2FuaXRpemVkQ2xpZW50RWRpdG9yQ29uZmlnLCBTYW5pdGl6ZWRTZXJ2ZXJFZGl0b3JDb25maWcgfSBmcm9tICcuLi9jb25maWcvdHlwZXMnXG5cbmV4cG9ydCBmdW5jdGlvbiBnZXRFbmFibGVkTm9kZXMoe1xuICBlZGl0b3JDb25maWcsXG59OiB7XG4gIGVkaXRvckNvbmZpZzogU2FuaXRpemVkQ2xpZW50RWRpdG9yQ29uZmlnIHwgU2FuaXRpemVkU2VydmVyRWRpdG9yQ29uZmlnXG59KTogQXJyYXk8S2xhc3M8TGV4aWNhbE5vZGU+IHwgTGV4aWNhbE5vZGVSZXBsYWNlbWVudD4ge1xuICByZXR1cm4gZWRpdG9yQ29uZmlnLmZlYXR1cmVzLm5vZGVzLm1hcCgobm9kZSkgPT4ge1xuICAgIGlmICgnbm9kZScgaW4gbm9kZSkge1xuICAgICAgcmV0dXJuIG5vZGUubm9kZVxuICAgIH1cbiAgICByZXR1cm4gbm9kZVxuICB9KVxufVxuIl0sIm5hbWVzIjpbImdldEVuYWJsZWROb2RlcyIsImVkaXRvckNvbmZpZyIsImZlYXR1cmVzIiwibm9kZXMiLCJtYXAiLCJub2RlIl0sIm1hcHBpbmdzIjoiOzs7OytCQUtnQkE7OztlQUFBQTs7O0FBQVQsU0FBU0EsZ0JBQWdCLEVBQzlCQyxZQUFZLEVBR2I7SUFDQyxPQUFPQSxhQUFhQyxRQUFRLENBQUNDLEtBQUssQ0FBQ0MsR0FBRyxDQUFDLENBQUNDO1FBQ3RDLElBQUksVUFBVUEsTUFBTTtZQUNsQixPQUFPQSxLQUFLQSxJQUFJO1FBQ2xCO1FBQ0EsT0FBT0E7SUFDVDtBQUNGIn0=