@payloadcms/richtext-lexical 3.68.0-internal-debug.e9b66ee → 3.68.0-internal.10bf491

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

@@ -1,122 +1,123 @@
 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, parentIsLocalized, 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,
+  parentIsLocalized,
+  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,
-            parentIsLocalized,
-            resolvedFeatures,
-            unSanitizedEditorConfig
-        }) : featureProvider.feature;
-        const resolvedFeature = feature;
-        // All these new properties would be added to the feature, as it's mutated. However, this does not cause any damage and allows
-        // us to prevent an unnecessary spread operation.
-        resolvedFeature.key = featureProvider.key;
-        resolvedFeature.order = loaded;
-        resolvedFeature.dependencies = featureProvider.dependencies;
-        resolvedFeature.dependenciesPriority = featureProvider.dependenciesPriority;
-        resolvedFeature.dependenciesSoft = featureProvider.dependenciesSoft;
-        resolvedFeatures.set(featureProvider.key, resolvedFeature);
-        loaded++;
+      }
     }
-    return resolvedFeatures;
+    const feature = typeof featureProvider.feature === 'function' ? await featureProvider.feature({
+      config,
+      featureProviderMap,
+      isRoot,
+      parentIsLocalized,
+      resolvedFeatures,
+      unSanitizedEditorConfig
+    }) : featureProvider.feature;
+    const resolvedFeature = feature;
+    // All these new properties would be added to the feature, as it's mutated. However, this does not cause any damage and allows
+    // us to prevent an unnecessary spread operation.
+    resolvedFeature.key = featureProvider.key;
+    resolvedFeature.order = loaded;
+    resolvedFeature.dependencies = featureProvider.dependencies;
+    resolvedFeature.dependenciesPriority = featureProvider.dependenciesPriority;
+    resolvedFeature.dependenciesSoft = featureProvider.dependenciesSoft;
+    resolvedFeatures.set(featureProvider.key, resolvedFeature);
+    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  ResolvedServerFeature,\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  parentIsLocalized,\n  unSanitizedEditorConfig,\n}: {\n  config: SanitizedConfig\n  isRoot?: boolean\n  parentIsLocalized: 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            parentIsLocalized,\n            resolvedFeatures,\n            unSanitizedEditorConfig,\n          })\n        : featureProvider.feature\n\n    const resolvedFeature: ResolvedServerFeature<any, any> = feature as ResolvedServerFeature<\n      any,\n      any\n    >\n\n    // All these new properties would be added to the feature, as it's mutated. However, this does not cause any damage and allows\n    // us to prevent an unnecessary spread operation.\n    resolvedFeature.key = featureProvider.key\n    resolvedFeature.order = loaded\n    resolvedFeature.dependencies = featureProvider.dependencies!\n    resolvedFeature.dependenciesPriority = featureProvider.dependenciesPriority!\n    resolvedFeature.dependenciesSoft = featureProvider.dependenciesSoft!\n\n    resolvedFeatures.set(featureProvider.key, resolvedFeature)\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","parentIsLocalized","unSanitizedEditorConfig","features","filter","f","i","arr","firstIndex","findIndex","f2","featureProviderMap","Map","map","resolvedFeatures","loaded","length","dependencyKey","found","find","priorityDependencyKey","get","existsInEditorConfig","feature","resolvedFeature","order","set"],"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","parentIsLocalized","unSanitizedEditorConfig","features","filter","f","i","arr","firstIndex","findIndex","f2","featureProviderMap","Map","map","resolvedFeatures","loaded","length","dependencyKey","found","find","priorityDependencyKey","get","existsInEditorConfig","feature","resolvedFeature","order","set"],"sources":["../../../../src/lexical/config/server/loader.ts"],"sourcesContent":["import type { SanitizedConfig } from 'payload'\n\nimport type {\n  FeatureProviderServer,\n  ResolvedServerFeature,\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  parentIsLocalized,\n  unSanitizedEditorConfig,\n}: {\n  config: SanitizedConfig\n  isRoot?: boolean\n  parentIsLocalized: 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            parentIsLocalized,\n            resolvedFeatures,\n            unSanitizedEditorConfig,\n          })\n        : featureProvider.feature\n\n    const resolvedFeature: ResolvedServerFeature<any, any> = feature as ResolvedServerFeature<\n      any,\n      any\n    >\n\n    // All these new properties would be added to the feature, as it's mutated. However, this does not cause any damage and allows\n    // us to prevent an unnecessary spread operation.\n    resolvedFeature.key = featureProvider.key\n    resolvedFeature.order = loaded\n    resolvedFeature.dependencies = featureProvider.dependencies!\n    resolvedFeature.dependenciesPriority = featureProvider.dependenciesPriority!\n    resolvedFeature.dependenciesSoft = featureProvider.dependenciesSoft!\n\n    resolvedFeatures.set(featureProvider.key, resolvedFeature)\n\n    loaded++\n  }\n\n  return resolvedFeatures\n}\n"],"mappings":"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","ignoreList":[]}

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

@@ -1,128 +1,127 @@
 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);
+    }
+    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: {}
+          };
+        }
+        // @ts-expect-error - vestiges of when tsconfig was not strict. Feel free to improve
+        sanitized.i18n[lang].lexical[feature.key] = feature.i18n[lang];
+      }
     }
-    features.forEach((feature)=>{
-        if (feature?.generatedTypes?.modifyOutputSchema) {
-            sanitized.generatedTypes.modifyOutputSchemas.push(feature.generatedTypes.modifyOutputSchema);
+    if (feature.nodes?.length) {
+      // Do not concat here. We need to keep the object reference of sanitized.nodes so that function markdown transformers of features automatically get the updated nodes
+      for (const node of feature.nodes) {
+        sanitized.nodes.push(node);
+      }
+      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?.beforeValidate?.length) {
-            sanitized.hooks.beforeValidate = sanitized.hooks.beforeValidate?.concat(feature.hooks.beforeValidate);
+        if (node?.validations?.length) {
+          sanitized.validations.set(nodeType, node.validations);
         }
-        if (feature?.hooks?.beforeChange?.length) {
-            sanitized.hooks.beforeChange = sanitized.hooks.beforeChange?.concat(feature.hooks.beforeChange);
+        if (node?.converters?.html) {
+          sanitized.converters.html.push(node.converters.html);
         }
-        if (feature?.hooks?.afterRead?.length) {
-            sanitized.hooks.afterRead = sanitized.hooks.afterRead?.concat(feature.hooks.afterRead);
+        if (node?.hooks?.afterChange) {
+          sanitized.nodeHooks?.afterChange?.set(nodeType, node.hooks.afterChange);
         }
-        if (feature?.hooks?.afterChange?.length) {
-            sanitized.hooks.afterChange = sanitized.hooks.afterChange?.concat(feature.hooks.afterChange);
+        if (node?.hooks?.afterRead) {
+          sanitized.nodeHooks?.afterRead?.set(nodeType, node.hooks.afterRead);
         }
-        if (feature?.i18n) {
-            for(const lang in feature.i18n){
-                if (!sanitized.i18n[lang]) {
-                    sanitized.i18n[lang] = {
-                        lexical: {}
-                    };
-                }
-                // @ts-expect-error - vestiges of when tsconfig was not strict. Feel free to improve
-                sanitized.i18n[lang].lexical[feature.key] = feature.i18n[lang];
-            }
+        if (node?.hooks?.beforeChange) {
+          sanitized.nodeHooks?.beforeChange?.set(nodeType, node.hooks.beforeChange);
         }
-        if (feature.nodes?.length) {
-            // Do not concat here. We need to keep the object reference of sanitized.nodes so that function markdown transformers of features automatically get the updated nodes
-            for (const node of feature.nodes){
-                sanitized.nodes.push(node);
-            }
-            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?.beforeValidate) {
+          sanitized.nodeHooks?.beforeValidate?.set(nodeType, node.hooks.beforeValidate);
         }
-        if (feature.markdownTransformers?.length) {
-            // Do not concat here. We need to keep the object reference of feature.markdownTransformers
-            for (const transformer of feature.markdownTransformers){
-                if (typeof transformer === 'function') {
-                    sanitized.markdownTransformers.push(transformer({
-                        allNodes: sanitized.nodes,
-                        allTransformers: sanitized.markdownTransformers
-                    }));
-                } else {
-                    sanitized.markdownTransformers.push(transformer);
-                }
-            }
+        if (node?.getSubFields) {
+          sanitized.getSubFields?.set(nodeType, node.getSubFields);
         }
-        sanitized.enabledFeatures.push(feature.key);
-    });
-    return sanitized;
+        if (node?.getSubFieldsData) {
+          sanitized.getSubFieldsData?.set(nodeType, node.getSubFieldsData);
+        }
+      });
+    }
+    if (feature.markdownTransformers?.length) {
+      // Do not concat here. We need to keep the object reference of feature.markdownTransformers
+      for (const transformer of feature.markdownTransformers) {
+        if (typeof transformer === 'function') {
+          sanitized.markdownTransformers.push(transformer({
+            allNodes: sanitized.nodes,
+            allTransformers: sanitized.markdownTransformers
+          }));
+        } else {
+          sanitized.markdownTransformers.push(transformer);
+        }
+      }
+    }
+    sanitized.enabledFeatures.push(feature.key);
+  });
+  return sanitized;
 };
 export async function sanitizeServerEditorConfig(editorConfig, config, parentIsLocalized) {
-    const resolvedFeatureMap = await loadFeatures({
-        config,
-        parentIsLocalized: parentIsLocalized,
-        unSanitizedEditorConfig: editorConfig
-    });
-    return {
-        features: sanitizeServerFeatures(resolvedFeatureMap),
-        lexical: editorConfig.lexical,
-        resolvedFeatureMap
-    };
+  const resolvedFeatureMap = await loadFeatures({
+    config,
+    parentIsLocalized: parentIsLocalized,
+    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(\n        feature.hooks.beforeChange,\n      )\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 as keyof typeof sanitized.i18n]) {\n          sanitized.i18n[lang as keyof typeof sanitized.i18n] = {\n            lexical: {},\n          }\n        }\n        // @ts-expect-error - vestiges of when tsconfig was not strict. Feel free to improve\n        sanitized.i18n[lang].lexical[feature.key] = feature.i18n[lang]\n      }\n    }\n\n    if (feature.nodes?.length) {\n      // Do not concat here. We need to keep the object reference of sanitized.nodes so that function markdown transformers of features automatically get the updated nodes\n      for (const node of feature.nodes) {\n        sanitized.nodes.push(node)\n      }\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      // Do not concat here. We need to keep the object reference of feature.markdownTransformers\n\n      for (const transformer of feature.markdownTransformers) {\n        if (typeof transformer === 'function') {\n          sanitized.markdownTransformers.push(\n            transformer({\n              allNodes: sanitized.nodes,\n              allTransformers: sanitized.markdownTransformers,\n            }),\n          )\n        } else {\n          sanitized.markdownTransformers.push(transformer)\n        }\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  parentIsLocalized?: boolean,\n): Promise<SanitizedServerEditorConfig> {\n  const resolvedFeatureMap = await loadFeatures({\n    config,\n    parentIsLocalized: parentIsLocalized!,\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","transformer","allNodes","allTransformers","sanitizeServerEditorConfig","editorConfig","config","parentIsLocalized","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","transformer","allNodes","allTransformers","sanitizeServerEditorConfig","editorConfig","config","parentIsLocalized","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(\n        feature.hooks.beforeChange,\n      )\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 as keyof typeof sanitized.i18n]) {\n          sanitized.i18n[lang as keyof typeof sanitized.i18n] = {\n            lexical: {},\n          }\n        }\n        // @ts-expect-error - vestiges of when tsconfig was not strict. Feel free to improve\n        sanitized.i18n[lang].lexical[feature.key] = feature.i18n[lang]\n      }\n    }\n\n    if (feature.nodes?.length) {\n      // Do not concat here. We need to keep the object reference of sanitized.nodes so that function markdown transformers of features automatically get the updated nodes\n      for (const node of feature.nodes) {\n        sanitized.nodes.push(node)\n      }\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      // Do not concat here. We need to keep the object reference of feature.markdownTransformers\n\n      for (const transformer of feature.markdownTransformers) {\n        if (typeof transformer === 'function') {\n          sanitized.markdownTransformers.push(\n            transformer({\n              allNodes: sanitized.nodes,\n              allTransformers: sanitized.markdownTransformers,\n            }),\n          )\n        } else {\n          sanitized.markdownTransformers.push(transformer)\n        }\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  parentIsLocalized?: boolean,\n): Promise<SanitizedServerEditorConfig> {\n  const resolvedFeatureMap = await loadFeatures({\n    config,\n    parentIsLocalized: parentIsLocalized!,\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,5 +1,2 @@
-// If undefined, the default lexical editor config will be used. This can be undefined so that we do not send the default lexical editor config to the client.
-// If undefined, the default lexical editor config will be used. This can be undefined so that we do not send the default lexical editor config to the client.
-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 { LexicalFieldAdminClientProps } from '../../types.js'\n\nexport type ServerEditorConfig = {\n  features: FeatureProviderServer<any, any, any>[]\n  lexical?: LexicalEditorConfig | undefined // If undefined, the default lexical editor config will be used. This can be undefined so that we do not send the default lexical editor config to the client.\n}\n\nexport type SanitizedServerEditorConfig = {\n  features: SanitizedServerFeatures\n  lexical: LexicalEditorConfig | undefined // If undefined, the default lexical editor config will be used. This can be undefined so that we do not send the default lexical editor config to the client.\n  resolvedFeatureMap: ResolvedServerFeatureMap\n}\n\nexport type ClientEditorConfig = {\n  features: FeatureProviderClient<any, any>[]\n  lexical?: LexicalEditorConfig\n}\n\nexport type SanitizedClientEditorConfig = {\n  admin?: LexicalFieldAdminClientProps\n  features: SanitizedClientFeatures\n  lexical: LexicalEditorConfig\n  resolvedFeatureMap: ResolvedClientFeatureMap\n}\n"],"names":[],"mappings":"AAgB4C,8JAA8J;AAK/J,8JAA8J;AASzM,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 { LexicalFieldAdminClientProps } from '../../types.js'\n\nexport type ServerEditorConfig = {\n  features: FeatureProviderServer<any, any, any>[]\n  lexical?: LexicalEditorConfig | undefined // If undefined, the default lexical editor config will be used. This can be undefined so that we do not send the default lexical editor config to the client.\n}\n\nexport type SanitizedServerEditorConfig = {\n  features: SanitizedServerFeatures\n  lexical: LexicalEditorConfig | undefined // If undefined, the default lexical editor config will be used. This can be undefined so that we do not send the default lexical editor config to the client.\n  resolvedFeatureMap: ResolvedServerFeatureMap\n}\n\nexport type ClientEditorConfig = {\n  features: FeatureProviderClient<any, any>[]\n  lexical?: LexicalEditorConfig\n}\n\nexport type SanitizedClientEditorConfig = {\n  admin?: LexicalFieldAdminClientProps\n  features: SanitizedClientFeatures\n  lexical: LexicalEditorConfig\n  resolvedFeatureMap: ResolvedClientFeatureMap\n}\n"],"mappings":"AA8BA","ignoreList":[]}

package/dist/lexical/nodes/index.js

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