@payloadcms/richtext-lexical 0.1.0-beta.0

package/dist/field/lexical/LexicalProvider.js

@@ -0,0 +1,89 @@
+"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 = {};
+    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)=>{
+    const { editorConfig, fieldProps, initialState, onChange, readOnly, setValue, value } = props;
+    const initialConfig = {
+        editable: readOnly === true ? false : true,
+        editorState: initialState != null ? JSON.stringify(initialState) : undefined,
+        namespace: editorConfig.lexical.namespace,
+        nodes: [
+            ...(0, _nodes.getEnabledNodes)({
+                editorConfig
+            })
+        ],
+        onError: (error)=>{
+            throw error;
+        },
+        theme: editorConfig.lexical.theme
+    };
+    return /*#__PURE__*/ _react.createElement(_LexicalComposer.LexicalComposer, {
+        initialConfig: initialConfig
+    }, /*#__PURE__*/ _react.createElement(_EditorConfigProvider.EditorConfigProvider, {
+        editorConfig: editorConfig,
+        fieldProps: fieldProps
+    }, /*#__PURE__*/ _react.createElement("div", {
+        className: "editor-shell"
+    }, /*#__PURE__*/ _react.createElement(_LexicalEditor.LexicalEditor, {
+        editorConfig: editorConfig,
+        fieldProps: fieldProps,
+        initialState: initialState,
+        onChange: onChange,
+        readOnly: readOnly,
+        setValue: setValue,
+        value: value
+    }))));
+};
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import type { FieldProps } from '../../../types';
+import type { SanitizedEditorConfig } from './types';
+interface ContextType {
+    editorConfig: SanitizedEditorConfig;
+    field: FieldProps;
+    uuid: string;
+}
+export declare const EditorConfigProvider: ({ children, editorConfig, fieldProps, }: {
+    children: React.ReactNode;
+    editorConfig: SanitizedEditorConfig;
+    fieldProps: FieldProps;
+}) => JSX.Element;
+export declare const useEditorConfigContext: () => ContextType;
+export {};
+//# sourceMappingURL=EditorConfigProvider.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EditorConfigProvider.d.ts","sourceRoot":"","sources":["../../../../src/field/lexical/config/EditorConfigProvider.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAChD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAMpD,UAAU,WAAW;IACnB,YAAY,EAAE,qBAAqB,CAAA;IACnC,KAAK,EAAE,UAAU,CAAA;IACjB,IAAI,EAAE,MAAM,CAAA;CACb;AAQD,eAAO,MAAM,oBAAoB;cAKrB,MAAM,SAAS;kBACX,qBAAqB;gBACvB,UAAU;MACpB,WAeH,CAAA;AAED,eAAO,MAAM,sBAAsB,QAAO,WAMzC,CAAA"}

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

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

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

@@ -0,0 +1,4 @@
+import type { EditorConfig, SanitizedEditorConfig } from './types';
+export declare const defaultEditorConfig: EditorConfig;
+export declare const defaultSanitizedEditorConfig: SanitizedEditorConfig;
+//# sourceMappingURL=default.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"default.d.ts","sourceRoot":"","sources":["../../../../src/field/lexical/config/default.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAwBlE,eAAO,MAAM,mBAAmB,EAAE,YA0BjC,CAAA;AAED,eAAO,MAAM,4BAA4B,EAAE,qBACA,CAAA"}

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

@@ -0,0 +1,67 @@
+"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;
+    },
+    defaultSanitizedEditorConfig: function() {
+        return defaultSanitizedEditorConfig;
+    }
+});
+const _BlockQuote = require("../../features/BlockQuote");
+const _Heading = require("../../features/Heading");
+const _Link = require("../../features/Link");
+const _Paragraph = require("../../features/Paragraph");
+const _Relationship = require("../../features/Relationship");
+const _Upload = require("../../features/Upload");
+const _align = require("../../features/align");
+const _Bold = require("../../features/format/Bold");
+const _InlineCode = require("../../features/format/InlineCode");
+const _Italic = require("../../features/format/Italic");
+const _strikethrough = require("../../features/format/strikethrough");
+const _subscript = require("../../features/format/subscript");
+const _superscript = require("../../features/format/superscript");
+const _underline = require("../../features/format/underline");
+const _indent = require("../../features/indent");
+const _CheckList = require("../../features/lists/CheckList");
+const _OrderedList = require("../../features/lists/OrderedList");
+const _UnorderedList = require("../../features/lists/UnorderedList");
+const _EditorTheme = require("../theme/EditorTheme");
+const _sanitize = require("./sanitize");
+const defaultEditorConfig = {
+    features: [
+        (0, _Bold.BoldTextFeature)(),
+        (0, _Italic.ItalicTextFeature)(),
+        (0, _underline.UnderlineTextFeature)(),
+        (0, _strikethrough.StrikethroughTextFeature)(),
+        (0, _subscript.SubscriptTextFeature)(),
+        (0, _superscript.SuperscriptTextFeature)(),
+        (0, _InlineCode.InlineCodeTextFeature)(),
+        (0, _Paragraph.ParagraphFeature)(),
+        (0, _Heading.HeadingFeature)({}),
+        (0, _align.AlignFeature)(),
+        (0, _indent.IndentFeature)(),
+        (0, _UnorderedList.UnoderedListFeature)(),
+        (0, _OrderedList.OrderedListFeature)(),
+        (0, _CheckList.CheckListFeature)(),
+        (0, _Link.LinkFeature)({}),
+        (0, _Relationship.RelationshipFeature)(),
+        (0, _BlockQuote.BlockQuoteFeature)(),
+        (0, _Upload.UploadFeature)()
+    ],
+    lexical: {
+        namespace: 'lexical',
+        theme: _EditorTheme.LexicalEditorTheme
+    }
+};
+const defaultSanitizedEditorConfig = (0, _sanitize.sanitizeEditorConfig)(defaultEditorConfig);
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,7 @@
+import type { FeatureProvider, ResolvedFeatureMap } from '../../features/types';
+import type { EditorConfig } from './types';
+export declare function sortFeaturesForOptimalLoading(featureProviders: FeatureProvider[]): FeatureProvider[];
+export declare function loadFeatures({ unsanitizedEditorConfig, }: {
+    unsanitizedEditorConfig: EditorConfig;
+}): ResolvedFeatureMap;
+//# sourceMappingURL=loader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../../../src/field/lexical/config/loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAsB,kBAAkB,EAAE,MAAM,sBAAsB,CAAA;AACnG,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AA0F3C,wBAAgB,6BAA6B,CAC3C,gBAAgB,EAAE,eAAe,EAAE,GAClC,eAAe,EAAE,CAEnB;AAED,wBAAgB,YAAY,CAAC,EAC3B,uBAAuB,GACxB,EAAE;IACD,uBAAuB,EAAE,YAAY,CAAA;CACtC,GAAG,kBAAkB,CAwErB"}

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

@@ -0,0 +1,133 @@
+"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, {
+    sortFeaturesForOptimalLoading: function() {
+        return sortFeaturesForOptimalLoading;
+    },
+    loadFeatures: function() {
+        return loadFeatures;
+    }
+});
+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();
+    const featureProviderMap = new Map(unsanitizedEditorConfig.features.map((f)=>[
+            f.key,
+            f
+        ]));
+    unsanitizedEditorConfig.features = sortFeaturesForOptimalLoading(unsanitizedEditorConfig.features);
+    const resolvedFeatures = new Map();
+    // Make sure all dependencies declared in the respective features exist
+    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
+        });
+    }
+    return resolvedFeatures;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/field/lexical/config/loader.ts"],"sourcesContent":["import type { FeatureProvider, FeatureProviderMap, ResolvedFeatureMap } from '../../features/types'\nimport type { EditorConfig } from './types'\n\ntype DependencyGraph = {\n  [key: string]: {\n    dependencies: string[]\n    dependenciesPriority: string[]\n    dependenciesSoft: string[]\n    featureProvider: FeatureProvider\n  }\n}\n\nfunction createDependencyGraph(featureProviders: FeatureProvider[]): 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(featureProviders: FeatureProvider[]): FeatureProvider[] {\n  const graph = createDependencyGraph(featureProviders)\n  const visited: { [key: string]: boolean } = {}\n  const stack: FeatureProvider[] = []\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: FeatureProvider[],\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: FeatureProvider[],\n): FeatureProvider[] {\n  return topologicallySortFeatures(featureProviders)\n}\n\nexport function loadFeatures({\n  unsanitizedEditorConfig,\n}: {\n  unsanitizedEditorConfig: EditorConfig\n}): ResolvedFeatureMap {\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  const featureProviderMap: FeatureProviderMap = new Map(\n    unsanitizedEditorConfig.features.map((f) => [f.key, f] as [string, FeatureProvider]),\n  )\n\n  unsanitizedEditorConfig.features = sortFeaturesForOptimalLoading(unsanitizedEditorConfig.features)\n\n  const resolvedFeatures: ResolvedFeatureMap = new Map()\n\n  // Make sure all dependencies declared in the respective features exist\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    })\n  }\n\n  return resolvedFeatures\n}\n"],"names":["sortFeaturesForOptimalLoading","loadFeatures","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","length","dependencyKey","found","find","priorityDependencyKey","get","existsInEditorConfig","feature","set"],"mappings":"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"}

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

@@ -0,0 +1,5 @@
+import type { ResolvedFeatureMap, SanitizedFeatures } from '../../features/types';
+import type { EditorConfig, SanitizedEditorConfig } from './types';
+export declare const sanitizeFeatures: (features: ResolvedFeatureMap) => SanitizedFeatures;
+export declare function sanitizeEditorConfig(editorConfig: EditorConfig): SanitizedEditorConfig;
+//# sourceMappingURL=sanitize.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sanitize.d.ts","sourceRoot":"","sources":["../../../../src/field/lexical/config/sanitize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAA;AACjF,OAAO,KAAK,EAAE,YAAY,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAIlE,eAAO,MAAM,gBAAgB,oCAAmC,iBAiI/D,CAAA;AAED,wBAAgB,oBAAoB,CAAC,YAAY,EAAE,YAAY,GAAG,qBAAqB,CAUtF"}

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

@@ -0,0 +1,138 @@
+"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, {
+    sanitizeFeatures: function() {
+        return sanitizeFeatures;
+    },
+    sanitizeEditorConfig: function() {
+        return sanitizeEditorConfig;
+    }
+});
+const _loader = require("./loader");
+const sanitizeFeatures = (features)=>{
+    const sanitized = {
+        afterReadPromises: new Map(),
+        enabledFeatures: [],
+        floatingSelectToolbar: {
+            sections: []
+        },
+        markdownTransformers: [],
+        nodes: [],
+        plugins: [],
+        slashMenu: {
+            dynamicOptions: [],
+            groupsWithOptions: []
+        }
+    };
+    features.forEach((feature)=>{
+        if (feature.nodes?.length) {
+            sanitized.nodes = sanitized.nodes.concat(feature.nodes);
+            feature.nodes.forEach((node)=>{
+                if (node?.afterReadPromises?.length) {
+                    sanitized.afterReadPromises.set(node.type, node.afterReadPromises);
+                }
+            });
+        }
+        if (feature.plugins?.length) {
+            feature.plugins.forEach((plugin, i)=>{
+                sanitized.plugins.push({
+                    Component: plugin.Component,
+                    key: feature.key + i,
+                    position: plugin.position
+                });
+            });
+        }
+        if (feature.markdownTransformers?.length) {
+            sanitized.markdownTransformers = sanitized.markdownTransformers.concat(feature.markdownTransformers);
+        }
+        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.title === optionGroup.title);
+                if (!group) {
+                    group = {
+                        ...optionGroup,
+                        options: []
+                    };
+                } else {
+                    sanitized.slashMenu.groupsWithOptions = sanitized.slashMenu.groupsWithOptions.filter((group)=>group.title !== optionGroup.title);
+                }
+                // 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);
+            }
+        }
+        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 sanitizeEditorConfig(editorConfig) {
+    const resolvedFeatureMap = (0, _loader.loadFeatures)({
+        unsanitizedEditorConfig: editorConfig
+    });
+    return {
+        features: sanitizeFeatures(resolvedFeatureMap),
+        lexical: editorConfig.lexical,
+        resolvedFeatureMap: resolvedFeatureMap
+    };
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/field/lexical/config/sanitize.ts"],"sourcesContent":["import type { ResolvedFeatureMap, SanitizedFeatures } from '../../features/types'\nimport type { EditorConfig, SanitizedEditorConfig } from './types'\n\nimport { loadFeatures } from './loader'\n\nexport const sanitizeFeatures = (features: ResolvedFeatureMap): SanitizedFeatures => {\n  const sanitized: SanitizedFeatures = {\n    afterReadPromises: new Map(),\n    enabledFeatures: [],\n    floatingSelectToolbar: {\n      sections: [],\n    },\n    markdownTransformers: [],\n    nodes: [],\n    plugins: [],\n    slashMenu: {\n      dynamicOptions: [],\n      groupsWithOptions: [],\n    },\n  }\n\n  features.forEach((feature) => {\n    if (feature.nodes?.length) {\n      sanitized.nodes = sanitized.nodes.concat(feature.nodes)\n      feature.nodes.forEach((node) => {\n        if (node?.afterReadPromises?.length) {\n          sanitized.afterReadPromises.set(node.type, node.afterReadPromises)\n        }\n      })\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    if (feature.markdownTransformers?.length) {\n      sanitized.markdownTransformers = sanitized.markdownTransformers.concat(\n        feature.markdownTransformers,\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.title === optionGroup.title,\n        )\n        if (!group) {\n          group = {\n            ...optionGroup,\n            options: [],\n          }\n        } else {\n          sanitized.slashMenu.groupsWithOptions = sanitized.slashMenu.groupsWithOptions.filter(\n            (group) => group.title !== optionGroup.title,\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    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 sanitizeEditorConfig(editorConfig: EditorConfig): SanitizedEditorConfig {\n  const resolvedFeatureMap = loadFeatures({\n    unsanitizedEditorConfig: editorConfig,\n  })\n\n  return {\n    features: sanitizeFeatures(resolvedFeatureMap),\n    lexical: editorConfig.lexical,\n    resolvedFeatureMap: resolvedFeatureMap,\n  }\n}\n"],"names":["sanitizeFeatures","sanitizeEditorConfig","features","sanitized","afterReadPromises","Map","enabledFeatures","floatingSelectToolbar","sections","markdownTransformers","nodes","plugins","slashMenu","dynamicOptions","groupsWithOptions","forEach","feature","length","concat","node","set","type","plugin","i","push","Component","key","position","section","foundSection","find","sanitizedSection","entries","filter","options","optionGroup","group","title","sort","a","b","order","editorConfig","resolvedFeatureMap","loadFeatures","unsanitizedEditorConfig","lexical"],"mappings":"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"}