@payloadcms/richtext-lexical 3.0.0-beta.13 → 3.0.0-beta.130

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

@@ -0,0 +1,11 @@
+import type { SanitizedConfig } from 'payload';
+import type { FeatureProviderServer, ResolvedServerFeatureMap } from '../../../features/typesServer.js';
+import type { ServerEditorConfig } from '../types.js';
+export declare function sortFeaturesForOptimalLoading(featureProviders: FeatureProviderServer<unknown, unknown, unknown>[]): FeatureProviderServer<unknown, unknown, unknown>[];
+export declare function loadFeatures({ config, isRoot, parentIsLocalized, unSanitizedEditorConfig, }: {
+    config: SanitizedConfig;
+    isRoot?: boolean;
+    parentIsLocalized: boolean;
+    unSanitizedEditorConfig: ServerEditorConfig;
+}): Promise<ResolvedServerFeatureMap>;
+//# sourceMappingURL=loader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../../../src/lexical/config/server/loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAE9C,OAAO,KAAK,EACV,qBAAqB,EACrB,wBAAwB,EAEzB,MAAM,kCAAkC,CAAA;AACzC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AA8FrD,wBAAgB,6BAA6B,CAC3C,gBAAgB,EAAE,qBAAqB,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,GACnE,qBAAqB,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,CAEpD;AAED,wBAAsB,YAAY,CAAC,EACjC,MAAM,EACN,MAAM,EACN,iBAAiB,EACjB,uBAAuB,GACxB,EAAE;IACD,MAAM,EAAE,eAAe,CAAA;IACvB,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,iBAAiB,EAAE,OAAO,CAAA;IAC1B,uBAAuB,EAAE,kBAAkB,CAAA;CAC5C,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAoFpC"}

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

@@ -0,0 +1,122 @@
+function createDependencyGraph(featureProviders) {
+  const graph = {};
+  for (const fp of featureProviders) {
+    graph[fp.key] = {
+      dependencies: fp.dependencies || [],
+      dependenciesPriority: fp.dependenciesPriority || [],
+      dependenciesSoft: fp.dependenciesSoft || [],
+      featureProvider: fp
+    };
+  }
+  return graph;
+}
+function topologicallySortFeatures(featureProviders) {
+  const graph = createDependencyGraph(featureProviders);
+  const visited = {};
+  const stack = [];
+  for (const key in graph) {
+    if (!visited[key]) {
+      visit(graph, key, visited, stack);
+    }
+  }
+  return stack.reverse();
+}
+function visit(graph, key, visited, stack, currentPath = []) {
+  if (!graph[key]) {
+    throw new Error(`Feature key ${key} is not present in the dependency graph.`);
+  }
+  if (currentPath.includes(key)) {
+    throw new Error(`Circular dependency detected: ${currentPath.join(' -> ')} -> ${key}`);
+  }
+  if (visited[key]) {
+    return;
+  }
+  visited[key] = true;
+  currentPath.push(key);
+  // First process the hard priority dependencies
+  for (const dep of graph[key].dependenciesPriority) {
+    if (!visited[dep]) {
+      visit(graph, dep, visited, stack, currentPath);
+    }
+  }
+  // Then process the normal dependencies, but make sure to not violate hard dependencies
+  for (const dep of graph[key].dependencies) {
+    if (!visited[dep] && !graph[key].dependenciesPriority.includes(dep)) {
+      visit(graph, dep, visited, stack, currentPath);
+    }
+  }
+  // Then process the soft dependencies. Make sure to not violate hard and normal dependencies.
+  for (const dep of graph[key].dependenciesSoft) {
+    if (graph[dep] && !visited[dep] && !graph[key].dependenciesPriority.includes(dep) && !graph[key].dependencies.includes(dep)) {
+      visit(graph, dep, visited, stack, currentPath);
+    }
+  }
+  stack.push(graph[key].featureProvider);
+  currentPath.pop();
+}
+export function sortFeaturesForOptimalLoading(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.`);
+        }
+      }
+    }
+    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;
+    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

@@ -0,0 +1 @@
+{"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","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  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    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.d.ts

@@ -0,0 +1,6 @@
+import type { SanitizedConfig } from 'payload';
+import type { ResolvedServerFeatureMap, SanitizedServerFeatures } from '../../../features/typesServer.js';
+import type { SanitizedServerEditorConfig, ServerEditorConfig } from '../types.js';
+export declare const sanitizeServerFeatures: (features: ResolvedServerFeatureMap) => SanitizedServerFeatures;
+export declare function sanitizeServerEditorConfig(editorConfig: ServerEditorConfig, config: SanitizedConfig, parentIsLocalized?: boolean): Promise<SanitizedServerEditorConfig>;
+//# sourceMappingURL=sanitize.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sanitize.d.ts","sourceRoot":"","sources":["../../../../src/lexical/config/server/sanitize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAE9C,OAAO,KAAK,EACV,wBAAwB,EACxB,uBAAuB,EACxB,MAAM,kCAAkC,CAAA;AACzC,OAAO,KAAK,EAAE,2BAA2B,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAIlF,eAAO,MAAM,sBAAsB,aACvB,wBAAwB,KACjC,uBAgHF,CAAA;AAED,wBAAsB,0BAA0B,CAC9C,YAAY,EAAE,kBAAkB,EAChC,MAAM,EAAE,eAAe,EACvB,iBAAiB,CAAC,EAAE,OAAO,GAC1B,OAAO,CAAC,2BAA2B,CAAC,CAYtC"}

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

@@ -0,0 +1,113 @@
+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;
+  }
+  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: {}
+          };
+        }
+        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 (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 (feature.markdownTransformers?.length) {
+      sanitized.markdownTransformers = sanitized.markdownTransformers.concat(feature.markdownTransformers);
+    }
+    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
+  };
+}
+//# sourceMappingURL=sanitize.js.map

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

@@ -0,0 +1 @@
+{"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","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]) {\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  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.d.ts

@@ -0,0 +1,24 @@
+import type { EditorConfig as LexicalEditorConfig } from 'lexical';
+import type { FeatureProviderClient, ResolvedClientFeatureMap, SanitizedClientFeatures } from '../../features/typesClient.js';
+import type { FeatureProviderServer, ResolvedServerFeatureMap, SanitizedServerFeatures } from '../../features/typesServer.js';
+import type { LexicalFieldAdminProps } from '../../types.js';
+export type ServerEditorConfig = {
+    features: FeatureProviderServer<any, any, any>[];
+    lexical?: LexicalEditorConfig;
+};
+export type SanitizedServerEditorConfig = {
+    features: SanitizedServerFeatures;
+    lexical: LexicalEditorConfig;
+    resolvedFeatureMap: ResolvedServerFeatureMap;
+};
+export type ClientEditorConfig = {
+    features: FeatureProviderClient<any, any>[];
+    lexical?: LexicalEditorConfig;
+};
+export type SanitizedClientEditorConfig = {
+    admin?: LexicalFieldAdminProps;
+    features: SanitizedClientFeatures;
+    lexical: LexicalEditorConfig;
+    resolvedFeatureMap: ResolvedClientFeatureMap;
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/lexical/config/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,IAAI,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAElE,OAAO,KAAK,EACV,qBAAqB,EACrB,wBAAwB,EACxB,uBAAuB,EACxB,MAAM,+BAA+B,CAAA;AACtC,OAAO,KAAK,EACV,qBAAqB,EACrB,wBAAwB,EACxB,uBAAuB,EACxB,MAAM,+BAA+B,CAAA;AACtC,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAA;AAE5D,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,EAAE,qBAAqB,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,CAAA;IAChD,OAAO,CAAC,EAAE,mBAAmB,CAAA;CAC9B,CAAA;AAED,MAAM,MAAM,2BAA2B,GAAG;IACxC,QAAQ,EAAE,uBAAuB,CAAA;IACjC,OAAO,EAAE,mBAAmB,CAAA;IAC5B,kBAAkB,EAAE,wBAAwB,CAAA;CAC7C,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,EAAE,qBAAqB,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAA;IAC3C,OAAO,CAAC,EAAE,mBAAmB,CAAA;CAC9B,CAAA;AAED,MAAM,MAAM,2BAA2B,GAAG;IACxC,KAAK,CAAC,EAAE,sBAAsB,CAAA;IAC9B,QAAQ,EAAE,uBAAuB,CAAA;IACjC,OAAO,EAAE,mBAAmB,CAAA;IAC5B,kBAAkB,EAAE,wBAAwB,CAAA;CAC7C,CAAA"}

package/dist/lexical/config/types.js

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

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

@@ -0,0 +1 @@
+{"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.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lexical/nodes/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAA;AAEzE,OAAO,KAAK,EAAE,2BAA2B,EAAE,2BAA2B,EAAE,MAAM,oBAAoB,CAAA;AAElG,wBAAgB,eAAe,CAAC,EAC9B,YAAY,GACb,EAAE;IACD,YAAY,EAAE,2BAA2B,GAAG,2BAA2B,CAAA;CACxE,GAAG,KAAK,CAAC,KAAK,CAAC,WAAW,CAAC,GAAG,sBAAsB,CAAC,CAOrD"}

package/dist/lexical/nodes/index.js

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1 @@
+{"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.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lexical/plugins/MarkdownShortcut/index.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAI9B,eAAO,MAAM,sBAAsB,EAAE,KAAK,CAAC,EAI1C,CAAA"}

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

@@ -0,0 +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 $ = _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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["c","_c","MarkdownShortcutPlugin","LexicalMarkdownShortcutPlugin","React","useEditorConfigContext","$","editorConfig","t0","features","markdownTransformers","_jsx","transformers"],"sources":["../../../../src/lexical/plugins/MarkdownShortcut/index.tsx"],"sourcesContent":["'use client'\n\nimport { MarkdownShortcutPlugin as LexicalMarkdownShortcutPlugin } from '@lexical/react/LexicalMarkdownShortcutPlugin.js'\nimport * as React from 'react'\n\nimport { useEditorConfigContext } from '../../config/client/EditorConfigProvider.js'\n\nexport const MarkdownShortcutPlugin: React.FC = () => {\n  const { editorConfig } = useEditorConfigContext()\n\n  return <LexicalMarkdownShortcutPlugin transformers={editorConfig.features.markdownTransformers} />\n}\n"],"mappings":"AAAA;;AAAA,SAAAA,CAAA,IAAAC,EAAA;;AAEA,SAASC,sBAAA,IAA0BC,6BAA6B,QAAQ;AACxE,YAAYC,KAAA,MAAW;AAEvB,SAASC,sBAAsB,QAAQ;AAEvC,OAAO,MAAMH,sBAAA,GAAmCA,CAAA;EAAA,MAAAI,CAAA,GAAAL,EAAA;EAC9C;IAAAM;EAAA,IAAyBF,sBAAA;EAAA,IAAAG,EAAA;EAAA,IAAAF,CAAA,QAAAC,YAAA,CAAAE,QAAA,CAAAC,oBAAA;IAElBF,EAAA,GAAAG,IAAA,CAAAR,6BAAA;MAAAS,YAAA,EAA6CL,YAAA,CAAAE,QAAA,CAAAC;IAAA,C;;;;;;SAA7CF,E;CACT","ignoreList":[]}

package/dist/lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/LexicalMenu.d.ts

@@ -0,0 +1,32 @@
+import type { LexicalCommand, LexicalEditor } from 'lexical';
+import type { JSX, ReactPortal, RefObject } from 'react';
+import type { MenuTextMatch } from '../useMenuTriggerMatch.js';
+import type { SlashMenuGroupInternal, SlashMenuItem, SlashMenuItemInternal } from './types.js';
+export type MenuResolution = {
+    getRect: () => DOMRect;
+    match?: MenuTextMatch;
+};
+export type MenuRenderFn = (anchorElementRef: RefObject<HTMLElement | null>, itemProps: {
+    groups: Array<SlashMenuGroupInternal>;
+    selectedItemKey: null | string;
+    selectItemAndCleanUp: (selectedItem: SlashMenuItem) => void;
+    setSelectedItemKey: (itemKey: string) => void;
+}, matchingString: null | string) => JSX.Element | null | ReactPortal;
+export declare function getScrollParent(element: HTMLElement, includeHidden: boolean): HTMLBodyElement | HTMLElement;
+export declare function useDynamicPositioning(resolution: MenuResolution | null, targetElement: HTMLElement | null, onReposition: () => void, onVisibilityChange?: (isInView: boolean) => void): void;
+export declare const SCROLL_TYPEAHEAD_OPTION_INTO_VIEW_COMMAND: LexicalCommand<{
+    index: number;
+    item: SlashMenuItemInternal;
+}>;
+export declare function LexicalMenu({ anchorElementRef, close, editor, groups, menuRenderFn, onSelectItem, resolution, shouldSplitNodeWithQuery, }: {
+    anchorElementRef: RefObject<HTMLElement | null>;
+    close: () => void;
+    editor: LexicalEditor;
+    groups: Array<SlashMenuGroupInternal>;
+    menuRenderFn: MenuRenderFn;
+    onSelectItem: (item: SlashMenuItem, closeMenu: () => void, matchingString: string) => void;
+    resolution: MenuResolution;
+    shouldSplitNodeWithQuery?: boolean;
+}): JSX.Element | null;
+export declare function useMenuAnchorRef(anchorElem: HTMLElement, resolution: MenuResolution | null, setResolution: (r: MenuResolution | null) => void, className?: string): RefObject<HTMLElement | null>;
+//# sourceMappingURL=LexicalMenu.d.ts.map

package/dist/lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/LexicalMenu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LexicalMenu.d.ts","sourceRoot":"","sources":["../../../../../src/lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/LexicalMenu.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAY,MAAM,SAAS,CAAA;AACtE,OAAO,KAAK,EAAE,GAAG,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAiBxD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA;AAC9D,OAAO,KAAK,EAAE,sBAAsB,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAA;AAI9F,MAAM,MAAM,cAAc,GAAG;IAC3B,OAAO,EAAE,MAAM,OAAO,CAAA;IACtB,KAAK,CAAC,EAAE,aAAa,CAAA;CACtB,CAAA;AAID,MAAM,MAAM,YAAY,GAAG,CACzB,gBAAgB,EAAE,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,EAC/C,SAAS,EAAE;IACT,MAAM,EAAE,KAAK,CAAC,sBAAsB,CAAC,CAAA;IACrC,eAAe,EAAE,IAAI,GAAG,MAAM,CAAA;IAC9B,oBAAoB,EAAE,CAAC,YAAY,EAAE,aAAa,KAAK,IAAI,CAAA;IAC3D,kBAAkB,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;CAC9C,EACD,cAAc,EAAE,IAAI,GAAG,MAAM,KAC1B,GAAG,CAAC,OAAO,GAAG,IAAI,GAAG,WAAW,CAAA;AA2ErC,wBAAgB,eAAe,CAC7B,OAAO,EAAE,WAAW,EACpB,aAAa,EAAE,OAAO,GACrB,eAAe,GAAG,WAAW,CAiB/B;AAYD,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,cAAc,GAAG,IAAI,EACjC,aAAa,EAAE,WAAW,GAAG,IAAI,EACjC,YAAY,EAAE,MAAM,IAAI,EACxB,kBAAkB,CAAC,EAAE,CAAC,QAAQ,EAAE,OAAO,KAAK,IAAI,QA2CjD;AAED,eAAO,MAAM,yCAAyC,EAAE,cAAc,CAAC;IACrE,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,qBAAqB,CAAA;CAC5B,CAA8D,CAAA;AAE/D,wBAAgB,WAAW,CAAC,EAC1B,gBAAgB,EAChB,KAAK,EACL,MAAM,EAEN,MAAM,EACN,YAAY,EACZ,YAAY,EACZ,UAAU,EACV,wBAAgC,GACjC,EAAE;IACD,gBAAgB,EAAE,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,CAAA;IAC/C,KAAK,EAAE,MAAM,IAAI,CAAA;IACjB,MAAM,EAAE,aAAa,CAAA;IACrB,MAAM,EAAE,KAAK,CAAC,sBAAsB,CAAC,CAAA;IACrC,YAAY,EAAE,YAAY,CAAA;IAC1B,YAAY,EAAE,CAAC,IAAI,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,IAAI,EAAE,cAAc,EAAE,MAAM,KAAK,IAAI,CAAA;IAC1F,UAAU,EAAE,cAAc,CAAA;IAC1B,wBAAwB,CAAC,EAAE,OAAO,CAAA;CACnC,GAAG,GAAG,CAAC,OAAO,GAAG,IAAI,CAiNrB;AAED,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,WAAW,EACvB,UAAU,EAAE,cAAc,GAAG,IAAI,EACjC,aAAa,EAAE,CAAC,CAAC,EAAE,cAAc,GAAG,IAAI,KAAK,IAAI,EACjD,SAAS,CAAC,EAAE,MAAM,GACjB,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,CAkG/B"}