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

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,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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,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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