@payloadcms/richtext-lexical 3.0.0-beta.85 → 3.0.0-beta.86

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

@@ -1,120 +1,120 @@
 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;
+  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);
-        }
+  const graph = createDependencyGraph(featureProviders);
+  const visited = {};
+  const stack = [];
+  for (const key in graph) {
+    if (!visited[key]) {
+      visit(graph, key, visited, stack);
     }
-    return stack.reverse();
+  }
+  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 (!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);
     }
-    if (visited[key]) {
-        return;
+  }
+  // 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);
     }
-    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);
     }
-    // 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();
+  }
+  stack.push(graph[key].featureProvider);
+  currentPath.pop();
 }
 export function sortFeaturesForOptimalLoading(featureProviders) {
-    return topologicallySortFeatures(featureProviders);
+  return topologicallySortFeatures(featureProviders);
 }
-export async function loadFeatures({ config, isRoot, 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.`);
-                }
-            }
+export async function loadFeatures({
+  config,
+  isRoot,
+  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.`);
-                    }
-                }
-            }
+      }
+    }
+    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 = typeof featureProvider.feature === 'function' ? await featureProvider.feature({
-            config,
-            featureProviderMap,
-            isRoot,
-            resolvedFeatures,
-            unSanitizedEditorConfig
-        }) : featureProvider.feature;
-        resolvedFeatures.set(featureProvider.key, {
-            ...feature,
-            dependencies: featureProvider.dependencies,
-            dependenciesPriority: featureProvider.dependenciesPriority,
-            dependenciesSoft: featureProvider.dependenciesSoft,
-            key: featureProvider.key,
-            order: loaded
-        });
-        loaded++;
+      }
     }
-    return resolvedFeatures;
+    const feature = typeof featureProvider.feature === 'function' ? await featureProvider.feature({
+      config,
+      featureProviderMap,
+      isRoot,
+      resolvedFeatures,
+      unSanitizedEditorConfig
+    }) : featureProvider.feature;
+    resolvedFeatures.set(featureProvider.key, {
+      ...feature,
+      dependencies: featureProvider.dependencies,
+      dependenciesPriority: featureProvider.dependenciesPriority,
+      dependenciesSoft: featureProvider.dependenciesSoft,
+      key: featureProvider.key,
+      order: loaded
+    });
+    loaded++;
+  }
+  return resolvedFeatures;
 }
-
 //# sourceMappingURL=loader.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lexical/config/server/loader.ts"],"sourcesContent":["import type { SanitizedConfig } from 'payload'\n\nimport type {\n  FeatureProviderServer,\n  ResolvedServerFeatureMap,\n  ServerFeatureProviderMap,\n} from '../../../features/typesServer.js'\nimport type { ServerEditorConfig } from '../types.js'\n\ntype DependencyGraph = {\n  [key: string]: {\n    dependencies: string[]\n    dependenciesPriority: string[]\n    dependenciesSoft: string[]\n    featureProvider: FeatureProviderServer<unknown, unknown, unknown>\n  }\n}\n\nfunction createDependencyGraph(\n  featureProviders: FeatureProviderServer<unknown, 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, unknown>[],\n): FeatureProviderServer<unknown, unknown, unknown>[] {\n  const graph = createDependencyGraph(featureProviders)\n  const visited: { [key: string]: boolean } = {}\n  const stack: FeatureProviderServer<unknown, 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, 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, unknown>[],\n): FeatureProviderServer<unknown, unknown, unknown>[] {\n  return topologicallySortFeatures(featureProviders)\n}\n\nexport async function loadFeatures({\n  config,\n  isRoot,\n  unSanitizedEditorConfig,\n}: {\n  config: SanitizedConfig\n  isRoot?: boolean\n  unSanitizedEditorConfig: ServerEditorConfig\n}): Promise<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, 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 =\n      typeof featureProvider.feature === 'function'\n        ? await featureProvider.feature({\n            config,\n            featureProviderMap,\n            isRoot,\n            resolvedFeatures,\n            unSanitizedEditorConfig,\n          })\n        : featureProvider.feature\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":["createDependencyGraph","featureProviders","graph","fp","key","dependencies","dependenciesPriority","dependenciesSoft","featureProvider","topologicallySortFeatures","visited","stack","visit","reverse","currentPath","Error","includes","join","push","dep","pop","sortFeaturesForOptimalLoading","loadFeatures","config","isRoot","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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"}
+{"version":3,"file":"loader.js","names":["createDependencyGraph","featureProviders","graph","fp","key","dependencies","dependenciesPriority","dependenciesSoft","featureProvider","topologicallySortFeatures","visited","stack","visit","reverse","currentPath","Error","includes","join","push","dep","pop","sortFeaturesForOptimalLoading","loadFeatures","config","isRoot","unSanitizedEditorConfig","features","filter","f","i","arr","firstIndex","findIndex","f2","featureProviderMap","Map","map","resolvedFeatures","loaded","length","dependencyKey","found","find","priorityDependencyKey","get","existsInEditorConfig","feature","set","order"],"sources":["../../../../src/lexical/config/server/loader.ts"],"sourcesContent":["import type { SanitizedConfig } from 'payload'\n\nimport type {\n  FeatureProviderServer,\n  ResolvedServerFeatureMap,\n  ServerFeatureProviderMap,\n} from '../../../features/typesServer.js'\nimport type { ServerEditorConfig } from '../types.js'\n\ntype DependencyGraph = {\n  [key: string]: {\n    dependencies: string[]\n    dependenciesPriority: string[]\n    dependenciesSoft: string[]\n    featureProvider: FeatureProviderServer<unknown, unknown, unknown>\n  }\n}\n\nfunction createDependencyGraph(\n  featureProviders: FeatureProviderServer<unknown, 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, unknown>[],\n): FeatureProviderServer<unknown, unknown, unknown>[] {\n  const graph = createDependencyGraph(featureProviders)\n  const visited: { [key: string]: boolean } = {}\n  const stack: FeatureProviderServer<unknown, 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, 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, unknown>[],\n): FeatureProviderServer<unknown, unknown, unknown>[] {\n  return topologicallySortFeatures(featureProviders)\n}\n\nexport async function loadFeatures({\n  config,\n  isRoot,\n  unSanitizedEditorConfig,\n}: {\n  config: SanitizedConfig\n  isRoot?: boolean\n  unSanitizedEditorConfig: ServerEditorConfig\n}): Promise<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, 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 =\n      typeof featureProvider.feature === 'function'\n        ? await featureProvider.feature({\n            config,\n            featureProviderMap,\n            isRoot,\n            resolvedFeatures,\n            unSanitizedEditorConfig,\n          })\n        : featureProvider.feature\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"],"mappings":"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","ignoreList":[]}

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

@@ -1,113 +1,112 @@
 import { loadFeatures } from './loader.js';
-export const sanitizeServerFeatures = (features)=>{
-    const sanitized = {
-        converters: {
-            html: []
-        },
-        enabledFeatures: [],
-        generatedTypes: {
-            modifyOutputSchemas: []
-        },
-        getSubFields: new Map(),
-        getSubFieldsData: new Map(),
-        graphQLPopulationPromises: new Map(),
-        hooks: {
-            afterChange: [],
-            afterRead: [],
-            beforeChange: [],
-            beforeValidate: []
-        },
-        i18n: {},
-        markdownTransformers: [],
-        nodeHooks: {
-            afterChange: new Map(),
-            afterRead: new Map(),
-            beforeChange: new Map(),
-            beforeValidate: new Map()
-        },
-        nodes: [],
-        validations: new Map()
-    };
-    if (!features?.size) {
-        return sanitized;
+export const sanitizeServerFeatures = features => {
+  const sanitized = {
+    converters: {
+      html: []
+    },
+    enabledFeatures: [],
+    generatedTypes: {
+      modifyOutputSchemas: []
+    },
+    getSubFields: new Map(),
+    getSubFieldsData: new Map(),
+    graphQLPopulationPromises: new Map(),
+    hooks: {
+      afterChange: [],
+      afterRead: [],
+      beforeChange: [],
+      beforeValidate: []
+    },
+    i18n: {},
+    markdownTransformers: [],
+    nodeHooks: {
+      afterChange: new Map(),
+      afterRead: new Map(),
+      beforeChange: new Map(),
+      beforeValidate: new Map()
+    },
+    nodes: [],
+    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?.beforeValidate?.length) {
+      sanitized.hooks.beforeValidate = sanitized.hooks.beforeValidate.concat(feature.hooks.beforeValidate);
+    }
+    if (feature?.hooks?.beforeChange?.length) {
+      sanitized.hooks.beforeChange = sanitized.hooks.beforeChange.concat(feature.hooks.beforeChange);
     }
-    features.forEach((feature)=>{
-        if (feature?.generatedTypes?.modifyOutputSchema) {
-            sanitized.generatedTypes.modifyOutputSchemas.push(feature.generatedTypes.modifyOutputSchema);
+    if (feature?.hooks?.afterRead?.length) {
+      sanitized.hooks.afterRead = sanitized.hooks.afterRead.concat(feature.hooks.afterRead);
+    }
+    if (feature?.hooks?.afterChange?.length) {
+      sanitized.hooks.afterChange = sanitized.hooks.afterChange.concat(feature.hooks.afterChange);
+    }
+    if (feature?.i18n) {
+      for (const lang in feature.i18n) {
+        if (!sanitized.i18n[lang]) {
+          sanitized.i18n[lang] = {
+            lexical: {}
+          };
         }
-        if (feature?.hooks?.beforeValidate?.length) {
-            sanitized.hooks.beforeValidate = sanitized.hooks.beforeValidate.concat(feature.hooks.beforeValidate);
+        sanitized.i18n[lang].lexical[feature.key] = feature.i18n[lang];
+      }
+    }
+    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?.graphQLPopulationPromises?.length) {
+          sanitized.graphQLPopulationPromises.set(nodeType, node.graphQLPopulationPromises);
         }
-        if (feature?.hooks?.beforeChange?.length) {
-            sanitized.hooks.beforeChange = sanitized.hooks.beforeChange.concat(feature.hooks.beforeChange);
+        if (node?.validations?.length) {
+          sanitized.validations.set(nodeType, node.validations);
         }
-        if (feature?.hooks?.afterRead?.length) {
-            sanitized.hooks.afterRead = sanitized.hooks.afterRead.concat(feature.hooks.afterRead);
+        if (node?.converters?.html) {
+          sanitized.converters.html.push(node.converters.html);
         }
-        if (feature?.hooks?.afterChange?.length) {
-            sanitized.hooks.afterChange = sanitized.hooks.afterChange.concat(feature.hooks.afterChange);
+        if (node?.hooks?.afterChange) {
+          sanitized.nodeHooks.afterChange.set(nodeType, node.hooks.afterChange);
         }
-        if (feature?.i18n) {
-            for(const lang in feature.i18n){
-                if (!sanitized.i18n[lang]) {
-                    sanitized.i18n[lang] = {
-                        lexical: {}
-                    };
-                }
-                sanitized.i18n[lang].lexical[feature.key] = feature.i18n[lang];
-            }
+        if (node?.hooks?.afterRead) {
+          sanitized.nodeHooks.afterRead.set(nodeType, node.hooks.afterRead);
         }
-        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?.graphQLPopulationPromises?.length) {
-                    sanitized.graphQLPopulationPromises.set(nodeType, node.graphQLPopulationPromises);
-                }
-                if (node?.validations?.length) {
-                    sanitized.validations.set(nodeType, node.validations);
-                }
-                if (node?.converters?.html) {
-                    sanitized.converters.html.push(node.converters.html);
-                }
-                if (node?.hooks?.afterChange) {
-                    sanitized.nodeHooks.afterChange.set(nodeType, node.hooks.afterChange);
-                }
-                if (node?.hooks?.afterRead) {
-                    sanitized.nodeHooks.afterRead.set(nodeType, node.hooks.afterRead);
-                }
-                if (node?.hooks?.beforeChange) {
-                    sanitized.nodeHooks.beforeChange.set(nodeType, node.hooks.beforeChange);
-                }
-                if (node?.hooks?.beforeValidate) {
-                    sanitized.nodeHooks.beforeValidate.set(nodeType, node.hooks.beforeValidate);
-                }
-                if (node?.getSubFields) {
-                    sanitized.getSubFields.set(nodeType, node.getSubFields);
-                }
-                if (node?.getSubFieldsData) {
-                    sanitized.getSubFieldsData.set(nodeType, node.getSubFieldsData);
-                }
-            });
+        if (node?.hooks?.beforeChange) {
+          sanitized.nodeHooks.beforeChange.set(nodeType, node.hooks.beforeChange);
         }
-        if (feature.markdownTransformers?.length) {
-            sanitized.markdownTransformers = sanitized.markdownTransformers.concat(feature.markdownTransformers);
+        if (node?.hooks?.beforeValidate) {
+          sanitized.nodeHooks.beforeValidate.set(nodeType, node.hooks.beforeValidate);
         }
-        sanitized.enabledFeatures.push(feature.key);
-    });
-    return sanitized;
+        if (node?.getSubFields) {
+          sanitized.getSubFields.set(nodeType, node.getSubFields);
+        }
+        if (node?.getSubFieldsData) {
+          sanitized.getSubFieldsData.set(nodeType, node.getSubFieldsData);
+        }
+      });
+    }
+    if (feature.markdownTransformers?.length) {
+      sanitized.markdownTransformers = sanitized.markdownTransformers.concat(feature.markdownTransformers);
+    }
+    sanitized.enabledFeatures.push(feature.key);
+  });
+  return sanitized;
 };
 export async function sanitizeServerEditorConfig(editorConfig, config) {
-    const resolvedFeatureMap = await loadFeatures({
-        config,
-        unSanitizedEditorConfig: editorConfig
-    });
-    return {
-        features: sanitizeServerFeatures(resolvedFeatureMap),
-        lexical: editorConfig.lexical,
-        resolvedFeatureMap
-    };
+  const resolvedFeatureMap = await loadFeatures({
+    config,
+    unSanitizedEditorConfig: editorConfig
+  });
+  return {
+    features: sanitizeServerFeatures(resolvedFeatureMap),
+    lexical: editorConfig.lexical,
+    resolvedFeatureMap
+  };
 }
-
 //# sourceMappingURL=sanitize.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lexical/config/server/sanitize.ts"],"sourcesContent":["import type { SanitizedConfig } from 'payload'\n\nimport type {\n  ResolvedServerFeatureMap,\n  SanitizedServerFeatures,\n} from '../../../features/typesServer.js'\nimport type { SanitizedServerEditorConfig, ServerEditorConfig } from '../types.js'\n\nimport { loadFeatures } from './loader.js'\n\nexport const sanitizeServerFeatures = (\n  features: ResolvedServerFeatureMap,\n): SanitizedServerFeatures => {\n  const sanitized: SanitizedServerFeatures = {\n    converters: {\n      html: [],\n    },\n    enabledFeatures: [],\n    generatedTypes: {\n      modifyOutputSchemas: [],\n    },\n    getSubFields: new Map(),\n    getSubFieldsData: new Map(),\n    graphQLPopulationPromises: new Map(),\n    hooks: {\n      afterChange: [],\n      afterRead: [],\n      beforeChange: [],\n      beforeValidate: [],\n    },\n    i18n: {},\n    markdownTransformers: [],\n    nodeHooks: {\n      afterChange: new Map(),\n      afterRead: new Map(),\n      beforeChange: new Map(),\n      beforeValidate: new Map(),\n    },\n    nodes: [],\n\n    validations: new Map(),\n  }\n\n  if (!features?.size) {\n    return sanitized\n  }\n\n  features.forEach((feature) => {\n    if (feature?.generatedTypes?.modifyOutputSchema) {\n      sanitized.generatedTypes.modifyOutputSchemas.push(feature.generatedTypes.modifyOutputSchema)\n    }\n\n    if (feature?.hooks?.beforeValidate?.length) {\n      sanitized.hooks.beforeValidate = sanitized.hooks.beforeValidate.concat(\n        feature.hooks.beforeValidate,\n      )\n    }\n    if (feature?.hooks?.beforeChange?.length) {\n      sanitized.hooks.beforeChange = sanitized.hooks.beforeChange.concat(feature.hooks.beforeChange)\n    }\n    if (feature?.hooks?.afterRead?.length) {\n      sanitized.hooks.afterRead = sanitized.hooks.afterRead.concat(feature.hooks.afterRead)\n    }\n    if (feature?.hooks?.afterChange?.length) {\n      sanitized.hooks.afterChange = sanitized.hooks.afterChange.concat(feature.hooks.afterChange)\n    }\n\n    if (feature?.i18n) {\n      for (const lang in feature.i18n) {\n        if (!sanitized.i18n[lang]) {\n          sanitized.i18n[lang] = {\n            lexical: {},\n          }\n        }\n        sanitized.i18n[lang].lexical[feature.key] = feature.i18n[lang]\n      }\n    }\n\n    if (feature.nodes?.length) {\n      sanitized.nodes = sanitized.nodes.concat(feature.nodes)\n      feature.nodes.forEach((node) => {\n        const nodeType = 'with' in node.node ? node.node.replace.getType() : node.node.getType() // TODO: Idk if this works for node replacements\n        if (node?.graphQLPopulationPromises?.length) {\n          sanitized.graphQLPopulationPromises.set(nodeType, node.graphQLPopulationPromises)\n        }\n        if (node?.validations?.length) {\n          sanitized.validations.set(nodeType, node.validations)\n        }\n        if (node?.converters?.html) {\n          sanitized.converters.html.push(node.converters.html)\n        }\n        if (node?.hooks?.afterChange) {\n          sanitized.nodeHooks.afterChange.set(nodeType, node.hooks.afterChange)\n        }\n        if (node?.hooks?.afterRead) {\n          sanitized.nodeHooks.afterRead.set(nodeType, node.hooks.afterRead)\n        }\n        if (node?.hooks?.beforeChange) {\n          sanitized.nodeHooks.beforeChange.set(nodeType, node.hooks.beforeChange)\n        }\n        if (node?.hooks?.beforeValidate) {\n          sanitized.nodeHooks.beforeValidate.set(nodeType, node.hooks.beforeValidate)\n        }\n        if (node?.getSubFields) {\n          sanitized.getSubFields.set(nodeType, node.getSubFields)\n        }\n        if (node?.getSubFieldsData) {\n          sanitized.getSubFieldsData.set(nodeType, node.getSubFieldsData)\n        }\n      })\n    }\n\n    if (feature.markdownTransformers?.length) {\n      sanitized.markdownTransformers = sanitized.markdownTransformers.concat(\n        feature.markdownTransformers,\n      )\n    }\n\n    sanitized.enabledFeatures.push(feature.key)\n  })\n\n  return sanitized\n}\n\nexport async function sanitizeServerEditorConfig(\n  editorConfig: ServerEditorConfig,\n  config: SanitizedConfig,\n): Promise<SanitizedServerEditorConfig> {\n  const resolvedFeatureMap = await loadFeatures({\n    config,\n    unSanitizedEditorConfig: editorConfig,\n  })\n\n  return {\n    features: sanitizeServerFeatures(resolvedFeatureMap),\n    lexical: editorConfig.lexical,\n    resolvedFeatureMap,\n  }\n}\n"],"names":["loadFeatures","sanitizeServerFeatures","features","sanitized","converters","html","enabledFeatures","generatedTypes","modifyOutputSchemas","getSubFields","Map","getSubFieldsData","graphQLPopulationPromises","hooks","afterChange","afterRead","beforeChange","beforeValidate","i18n","markdownTransformers","nodeHooks","nodes","validations","size","forEach","feature","modifyOutputSchema","push","length","concat","lang","lexical","key","node","nodeType","replace","getType","set","sanitizeServerEditorConfig","editorConfig","config","resolvedFeatureMap","unSanitizedEditorConfig"],"mappings":"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"}
+{"version":3,"file":"sanitize.js","names":["loadFeatures","sanitizeServerFeatures","features","sanitized","converters","html","enabledFeatures","generatedTypes","modifyOutputSchemas","getSubFields","Map","getSubFieldsData","graphQLPopulationPromises","hooks","afterChange","afterRead","beforeChange","beforeValidate","i18n","markdownTransformers","nodeHooks","nodes","validations","size","forEach","feature","modifyOutputSchema","push","length","concat","lang","lexical","key","node","nodeType","replace","getType","set","sanitizeServerEditorConfig","editorConfig","config","resolvedFeatureMap","unSanitizedEditorConfig"],"sources":["../../../../src/lexical/config/server/sanitize.ts"],"sourcesContent":["import type { SanitizedConfig } from 'payload'\n\nimport type {\n  ResolvedServerFeatureMap,\n  SanitizedServerFeatures,\n} from '../../../features/typesServer.js'\nimport type { SanitizedServerEditorConfig, ServerEditorConfig } from '../types.js'\n\nimport { loadFeatures } from './loader.js'\n\nexport const sanitizeServerFeatures = (\n  features: ResolvedServerFeatureMap,\n): SanitizedServerFeatures => {\n  const sanitized: SanitizedServerFeatures = {\n    converters: {\n      html: [],\n    },\n    enabledFeatures: [],\n    generatedTypes: {\n      modifyOutputSchemas: [],\n    },\n    getSubFields: new Map(),\n    getSubFieldsData: new Map(),\n    graphQLPopulationPromises: new Map(),\n    hooks: {\n      afterChange: [],\n      afterRead: [],\n      beforeChange: [],\n      beforeValidate: [],\n    },\n    i18n: {},\n    markdownTransformers: [],\n    nodeHooks: {\n      afterChange: new Map(),\n      afterRead: new Map(),\n      beforeChange: new Map(),\n      beforeValidate: new Map(),\n    },\n    nodes: [],\n\n    validations: new Map(),\n  }\n\n  if (!features?.size) {\n    return sanitized\n  }\n\n  features.forEach((feature) => {\n    if (feature?.generatedTypes?.modifyOutputSchema) {\n      sanitized.generatedTypes.modifyOutputSchemas.push(feature.generatedTypes.modifyOutputSchema)\n    }\n\n    if (feature?.hooks?.beforeValidate?.length) {\n      sanitized.hooks.beforeValidate = sanitized.hooks.beforeValidate.concat(\n        feature.hooks.beforeValidate,\n      )\n    }\n    if (feature?.hooks?.beforeChange?.length) {\n      sanitized.hooks.beforeChange = sanitized.hooks.beforeChange.concat(feature.hooks.beforeChange)\n    }\n    if (feature?.hooks?.afterRead?.length) {\n      sanitized.hooks.afterRead = sanitized.hooks.afterRead.concat(feature.hooks.afterRead)\n    }\n    if (feature?.hooks?.afterChange?.length) {\n      sanitized.hooks.afterChange = sanitized.hooks.afterChange.concat(feature.hooks.afterChange)\n    }\n\n    if (feature?.i18n) {\n      for (const lang in feature.i18n) {\n        if (!sanitized.i18n[lang]) {\n          sanitized.i18n[lang] = {\n            lexical: {},\n          }\n        }\n        sanitized.i18n[lang].lexical[feature.key] = feature.i18n[lang]\n      }\n    }\n\n    if (feature.nodes?.length) {\n      sanitized.nodes = sanitized.nodes.concat(feature.nodes)\n      feature.nodes.forEach((node) => {\n        const nodeType = 'with' in node.node ? node.node.replace.getType() : node.node.getType() // TODO: Idk if this works for node replacements\n        if (node?.graphQLPopulationPromises?.length) {\n          sanitized.graphQLPopulationPromises.set(nodeType, node.graphQLPopulationPromises)\n        }\n        if (node?.validations?.length) {\n          sanitized.validations.set(nodeType, node.validations)\n        }\n        if (node?.converters?.html) {\n          sanitized.converters.html.push(node.converters.html)\n        }\n        if (node?.hooks?.afterChange) {\n          sanitized.nodeHooks.afterChange.set(nodeType, node.hooks.afterChange)\n        }\n        if (node?.hooks?.afterRead) {\n          sanitized.nodeHooks.afterRead.set(nodeType, node.hooks.afterRead)\n        }\n        if (node?.hooks?.beforeChange) {\n          sanitized.nodeHooks.beforeChange.set(nodeType, node.hooks.beforeChange)\n        }\n        if (node?.hooks?.beforeValidate) {\n          sanitized.nodeHooks.beforeValidate.set(nodeType, node.hooks.beforeValidate)\n        }\n        if (node?.getSubFields) {\n          sanitized.getSubFields.set(nodeType, node.getSubFields)\n        }\n        if (node?.getSubFieldsData) {\n          sanitized.getSubFieldsData.set(nodeType, node.getSubFieldsData)\n        }\n      })\n    }\n\n    if (feature.markdownTransformers?.length) {\n      sanitized.markdownTransformers = sanitized.markdownTransformers.concat(\n        feature.markdownTransformers,\n      )\n    }\n\n    sanitized.enabledFeatures.push(feature.key)\n  })\n\n  return sanitized\n}\n\nexport async function sanitizeServerEditorConfig(\n  editorConfig: ServerEditorConfig,\n  config: SanitizedConfig,\n): Promise<SanitizedServerEditorConfig> {\n  const resolvedFeatureMap = await loadFeatures({\n    config,\n    unSanitizedEditorConfig: editorConfig,\n  })\n\n  return {\n    features: sanitizeServerFeatures(resolvedFeatureMap),\n    lexical: editorConfig.lexical,\n    resolvedFeatureMap,\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/lexical/config/types.js

@@ -1,3 +1,2 @@
-export { };
-
+export {};
 //# sourceMappingURL=types.js.map

package/dist/lexical/config/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lexical/config/types.ts"],"sourcesContent":["import type { EditorConfig as LexicalEditorConfig } from 'lexical'\n\nimport type {\n  FeatureProviderClient,\n  ResolvedClientFeatureMap,\n  SanitizedClientFeatures,\n} from '../../features/typesClient.js'\nimport type {\n  FeatureProviderServer,\n  ResolvedServerFeatureMap,\n  SanitizedServerFeatures,\n} from '../../features/typesServer.js'\nimport type { LexicalFieldAdminProps } from '../../types.js'\n\nexport type ServerEditorConfig = {\n  features: FeatureProviderServer<any, any, any>[]\n  lexical?: LexicalEditorConfig\n}\n\nexport type SanitizedServerEditorConfig = {\n  features: SanitizedServerFeatures\n  lexical: LexicalEditorConfig\n  resolvedFeatureMap: ResolvedServerFeatureMap\n}\n\nexport type ClientEditorConfig = {\n  features: FeatureProviderClient<any, any>[]\n  lexical?: LexicalEditorConfig\n}\n\nexport type SanitizedClientEditorConfig = {\n  admin?: LexicalFieldAdminProps\n  features: SanitizedClientFeatures\n  lexical: LexicalEditorConfig\n  resolvedFeatureMap: ResolvedClientFeatureMap\n}\n"],"names":[],"mappings":"AA8BA,WAKC"}
+{"version":3,"file":"types.js","names":[],"sources":["../../../src/lexical/config/types.ts"],"sourcesContent":["import type { EditorConfig as LexicalEditorConfig } from 'lexical'\n\nimport type {\n  FeatureProviderClient,\n  ResolvedClientFeatureMap,\n  SanitizedClientFeatures,\n} from '../../features/typesClient.js'\nimport type {\n  FeatureProviderServer,\n  ResolvedServerFeatureMap,\n  SanitizedServerFeatures,\n} from '../../features/typesServer.js'\nimport type { LexicalFieldAdminProps } from '../../types.js'\n\nexport type ServerEditorConfig = {\n  features: FeatureProviderServer<any, any, any>[]\n  lexical?: LexicalEditorConfig\n}\n\nexport type SanitizedServerEditorConfig = {\n  features: SanitizedServerFeatures\n  lexical: LexicalEditorConfig\n  resolvedFeatureMap: ResolvedServerFeatureMap\n}\n\nexport type ClientEditorConfig = {\n  features: FeatureProviderClient<any, any>[]\n  lexical?: LexicalEditorConfig\n}\n\nexport type SanitizedClientEditorConfig = {\n  admin?: LexicalFieldAdminProps\n  features: SanitizedClientFeatures\n  lexical: LexicalEditorConfig\n  resolvedFeatureMap: ResolvedClientFeatureMap\n}\n"],"mappings":"AA8BA","ignoreList":[]}

package/dist/lexical/nodes/index.js

@@ -1,10 +1,11 @@
-export function getEnabledNodes({ editorConfig }) {
-    return editorConfig.features.nodes.map((node)=>{
-        if ('node' in node) {
-            return node.node;
-        }
-        return node;
-    });
+export function getEnabledNodes({
+  editorConfig
+}) {
+  return editorConfig.features.nodes.map(node => {
+    if ('node' in node) {
+      return node.node;
+    }
+    return node;
+  });
 }
-
 //# sourceMappingURL=index.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lexical/nodes/index.ts"],"sourcesContent":["import type { Klass, LexicalNode, LexicalNodeReplacement } from 'lexical'\n\nimport type { SanitizedClientEditorConfig, SanitizedServerEditorConfig } from '../config/types.js'\n\nexport function getEnabledNodes({\n  editorConfig,\n}: {\n  editorConfig: SanitizedClientEditorConfig | SanitizedServerEditorConfig\n}): Array<Klass<LexicalNode> | LexicalNodeReplacement> {\n  return editorConfig.features.nodes.map((node) => {\n    if ('node' in node) {\n      return node.node\n    }\n    return node\n  })\n}\n"],"names":["getEnabledNodes","editorConfig","features","nodes","map","node"],"mappings":"AAIA,OAAO,SAASA,gBAAgB,EAC9BC,YAAY,EAGb;IACC,OAAOA,aAAaC,QAAQ,CAACC,KAAK,CAACC,GAAG,CAAC,CAACC;QACtC,IAAI,UAAUA,MAAM;YAClB,OAAOA,KAAKA,IAAI;QAClB;QACA,OAAOA;IACT;AACF"}
+{"version":3,"file":"index.js","names":["getEnabledNodes","editorConfig","features","nodes","map","node"],"sources":["../../../src/lexical/nodes/index.ts"],"sourcesContent":["import type { Klass, LexicalNode, LexicalNodeReplacement } from 'lexical'\n\nimport type { SanitizedClientEditorConfig, SanitizedServerEditorConfig } from '../config/types.js'\n\nexport function getEnabledNodes({\n  editorConfig,\n}: {\n  editorConfig: SanitizedClientEditorConfig | SanitizedServerEditorConfig\n}): Array<Klass<LexicalNode> | LexicalNodeReplacement> {\n  return editorConfig.features.nodes.map((node) => {\n    if ('node' in node) {\n      return node.node\n    }\n    return node\n  })\n}\n"],"mappings":"AAIA,OAAO,SAASA,gBAAgB;EAC9BC;AAAY,CAGb;EACC,OAAOA,YAAA,CAAaC,QAAQ,CAACC,KAAK,CAACC,GAAG,CAAEC,IAAA;IACtC,IAAI,UAAUA,IAAA,EAAM;MAClB,OAAOA,IAAA,CAAKA,IAAI;IAClB;IACA,OAAOA,IAAA;EACT;AACF","ignoreList":[]}

package/dist/lexical/plugins/MarkdownShortcut/index.js

@@ -1,13 +1,25 @@
 'use client';
+
+import { c as _c } from "react/compiler-runtime";
 import { jsx as _jsx } from "react/jsx-runtime";
 import { MarkdownShortcutPlugin as LexicalMarkdownShortcutPlugin } from '@lexical/react/LexicalMarkdownShortcutPlugin.js';
 import * as React from 'react';
 import { useEditorConfigContext } from '../../config/client/EditorConfigProvider.js';
-export const MarkdownShortcutPlugin = ()=>{
-    const { editorConfig } = useEditorConfigContext();
-    return /*#__PURE__*/ _jsx(LexicalMarkdownShortcutPlugin, {
-        transformers: editorConfig.features.markdownTransformers
+export const MarkdownShortcutPlugin = () => {
+  const $ = _c(2);
+  const {
+    editorConfig
+  } = useEditorConfigContext();
+  let t0;
+  if ($[0] !== editorConfig.features.markdownTransformers) {
+    t0 = _jsx(LexicalMarkdownShortcutPlugin, {
+      transformers: editorConfig.features.markdownTransformers
     });
+    $[0] = editorConfig.features.markdownTransformers;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  return t0;
 };
-
 //# sourceMappingURL=index.js.map