@payloadcms/richtext-lexical 3.0.0-canary.f1db24e → 3.0.0-canary.f1f97ff

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

@@ -1,46 +0,0 @@
-'use client';
-/**
- * This function expects client functions to ALREADY be ordered & dependencies checked on the server
- * @param unSanitizedEditorConfig
- */ export function loadClientFeatures({ clientFunctions, schemaPath, unSanitizedEditorConfig }) {
-    for (const featureProvider of unSanitizedEditorConfig.features){
-        if (!featureProvider?.clientFeatureProps?.featureKey || featureProvider?.clientFeatureProps?.order === undefined || featureProvider?.clientFeatureProps?.order === null) {
-            throw new Error('A Feature you have installed does not return the client props as clientFeatureProps. Please make sure to always return those props, even if they are null, as other important props like order and featureKey are later on injected.');
-        }
-    }
-    // sort unSanitizedEditorConfig.features by order
-    unSanitizedEditorConfig.features = unSanitizedEditorConfig.features.sort((a, b)=>a.clientFeatureProps.order - b.clientFeatureProps.order);
-    const featureProviderMap = new Map(unSanitizedEditorConfig.features.map((f)=>[
-            f.clientFeatureProps.featureKey,
-            f
-        ]));
-    const resolvedFeatures = new Map();
-    // Make sure all dependencies declared in the respective features exist
-    let loaded = 0;
-    for (const featureProvider of unSanitizedEditorConfig.features){
-        /**
-     * Load relevant clientFunctions scoped to this feature and then pass them to the client feature
-     */ const relevantClientFunctions = {};
-        Object.entries(clientFunctions).forEach(([key, plugin])=>{
-            if (key.startsWith(`lexicalFeature.${schemaPath}.${featureProvider.clientFeatureProps.featureKey}.components.`)) {
-                const featureComponentKey = key.split(`${schemaPath}.${featureProvider.clientFeatureProps.featureKey}.components.`)[1];
-                relevantClientFunctions[featureComponentKey] = plugin;
-            }
-        });
-        const feature = featureProvider.feature({
-            clientFunctions: relevantClientFunctions,
-            featureProviderMap,
-            resolvedFeatures,
-            unSanitizedEditorConfig
-        });
-        resolvedFeatures.set(featureProvider.clientFeatureProps.featureKey, {
-            ...feature,
-            key: featureProvider.clientFeatureProps.featureKey,
-            order: loaded
-        });
-        loaded++;
-    }
-    return resolvedFeatures;
-}
-
-//# sourceMappingURL=loader.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../src/field/lexical/config/client/loader.ts"],"sourcesContent":["'use client'\n\nimport type {\n  ClientFeatureProviderMap,\n  FeatureProviderClient,\n  ResolvedClientFeatureMap,\n} from '../../../features/types.js'\nimport type { ClientEditorConfig } from '../types.js'\n\n/**\n * This function expects client functions to ALREADY be ordered & dependencies checked on the server\n * @param unSanitizedEditorConfig\n */\nexport function loadClientFeatures({\n  clientFunctions,\n  schemaPath,\n  unSanitizedEditorConfig,\n}: {\n  clientFunctions?: Record<string, any>\n  schemaPath: string\n  unSanitizedEditorConfig: ClientEditorConfig\n}): ResolvedClientFeatureMap {\n  for (const featureProvider of unSanitizedEditorConfig.features) {\n    if (\n      !featureProvider?.clientFeatureProps?.featureKey ||\n      featureProvider?.clientFeatureProps?.order === undefined ||\n      featureProvider?.clientFeatureProps?.order === null\n    ) {\n      throw new Error(\n        'A Feature you have installed does not return the client props as clientFeatureProps. Please make sure to always return those props, even if they are null, as other important props like order and featureKey are later on injected.',\n      )\n    }\n  }\n\n  // sort unSanitizedEditorConfig.features by order\n  unSanitizedEditorConfig.features = unSanitizedEditorConfig.features.sort(\n    (a, b) => a.clientFeatureProps.order - b.clientFeatureProps.order,\n  )\n\n  const featureProviderMap: ClientFeatureProviderMap = new Map(\n    unSanitizedEditorConfig.features.map(\n      (f) => [f.clientFeatureProps.featureKey, f] as [string, FeatureProviderClient<unknown>],\n    ),\n  )\n\n  const resolvedFeatures: ResolvedClientFeatureMap = 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    /**\n     * Load relevant clientFunctions scoped to this feature and then pass them to the client feature\n     */\n    const relevantClientFunctions: Record<string, any> = {}\n    Object.entries(clientFunctions).forEach(([key, plugin]) => {\n      if (\n        key.startsWith(\n          `lexicalFeature.${schemaPath}.${featureProvider.clientFeatureProps.featureKey}.components.`,\n        )\n      ) {\n        const featureComponentKey = key.split(\n          `${schemaPath}.${featureProvider.clientFeatureProps.featureKey}.components.`,\n        )[1]\n        relevantClientFunctions[featureComponentKey] = plugin\n      }\n    })\n\n    const feature = featureProvider.feature({\n      clientFunctions: relevantClientFunctions,\n      featureProviderMap,\n      resolvedFeatures,\n      unSanitizedEditorConfig,\n    })\n    resolvedFeatures.set(featureProvider.clientFeatureProps.featureKey, {\n      ...feature,\n      key: featureProvider.clientFeatureProps.featureKey,\n      order: loaded,\n    })\n\n    loaded++\n  }\n\n  return resolvedFeatures\n}\n"],"names":["loadClientFeatures","clientFunctions","schemaPath","unSanitizedEditorConfig","featureProvider","features","clientFeatureProps","featureKey","order","undefined","Error","sort","a","b","featureProviderMap","Map","map","f","resolvedFeatures","loaded","relevantClientFunctions","Object","entries","forEach","key","plugin","startsWith","featureComponentKey","split","feature","set"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;AASA;;;CAGC,GACD,OAAO,SAASA,mBAAmB,EACjCC,eAAe,EACfC,UAAU,EACVC,uBAAuB,EAKxB;IACC,KAAK,MAAMC,mBAAmBD,wBAAwBE,QAAQ,CAAE;QAC9D,IACE,CAACD,iBAAiBE,oBAAoBC,cACtCH,iBAAiBE,oBAAoBE,UAAUC,aAC/CL,iBAAiBE,oBAAoBE,UAAU,MAC/C;YACA,MAAM,IAAIE,MACR;QAEJ;IACF;IAEA,iDAAiD;IACjDP,wBAAwBE,QAAQ,GAAGF,wBAAwBE,QAAQ,CAACM,IAAI,CACtE,CAACC,GAAGC,IAAMD,EAAEN,kBAAkB,CAACE,KAAK,GAAGK,EAAEP,kBAAkB,CAACE,KAAK;IAGnE,MAAMM,qBAA+C,IAAIC,IACvDZ,wBAAwBE,QAAQ,CAACW,GAAG,CAClC,CAACC,IAAM;YAACA,EAAEX,kBAAkB,CAACC,UAAU;YAAEU;SAAE;IAI/C,MAAMC,mBAA6C,IAAIH;IAEvD,uEAAuE;IACvE,IAAII,SAAS;IACb,KAAK,MAAMf,mBAAmBD,wBAAwBE,QAAQ,CAAE;QAC9D;;KAEC,GACD,MAAMe,0BAA+C,CAAC;QACtDC,OAAOC,OAAO,CAACrB,iBAAiBsB,OAAO,CAAC,CAAC,CAACC,KAAKC,OAAO;YACpD,IACED,IAAIE,UAAU,CACZ,CAAC,eAAe,EAAExB,WAAW,CAAC,EAAEE,gBAAgBE,kBAAkB,CAACC,UAAU,CAAC,YAAY,CAAC,GAE7F;gBACA,MAAMoB,sBAAsBH,IAAII,KAAK,CACnC,CAAC,EAAE1B,WAAW,CAAC,EAAEE,gBAAgBE,kBAAkB,CAACC,UAAU,CAAC,YAAY,CAAC,CAC7E,CAAC,EAAE;gBACJa,uBAAuB,CAACO,oBAAoB,GAAGF;YACjD;QACF;QAEA,MAAMI,UAAUzB,gBAAgByB,OAAO,CAAC;YACtC5B,iBAAiBmB;YACjBN;YACAI;YACAf;QACF;QACAe,iBAAiBY,GAAG,CAAC1B,gBAAgBE,kBAAkB,CAACC,UAAU,EAAE;YAClE,GAAGsB,OAAO;YACVL,KAAKpB,gBAAgBE,kBAAkB,CAACC,UAAU;YAClDC,OAAOW;QACT;QAEAA;IACF;IAEA,OAAOD;AACT"}

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

@@ -1,7 +0,0 @@
-import type { EditorConfig as LexicalEditorConfig } from 'lexical';
-import type { LexicalFieldAdminProps } from '../../../../types.js';
-import type { ResolvedClientFeatureMap, SanitizedClientFeatures } from '../../../features/types.js';
-import type { SanitizedClientEditorConfig } from '../types.js';
-export declare const sanitizeClientFeatures: (features: ResolvedClientFeatureMap) => SanitizedClientFeatures;
-export declare function sanitizeClientEditorConfig(lexical: LexicalEditorConfig, resolvedClientFeatureMap: ResolvedClientFeatureMap, admin?: LexicalFieldAdminProps): SanitizedClientEditorConfig;
-//# sourceMappingURL=sanitize.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"sanitize.d.ts","sourceRoot":"","sources":["../../../../../src/field/lexical/config/client/sanitize.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,IAAI,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAElE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAA;AAClE,OAAO,KAAK,EAAE,wBAAwB,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAA;AACnG,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,aAAa,CAAA;AAE9D,eAAO,MAAM,sBAAsB,0CAEhC,uBAiMF,CAAA;AAED,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,mBAAmB,EAC5B,wBAAwB,EAAE,wBAAwB,EAClD,KAAK,CAAC,EAAE,sBAAsB,GAC7B,2BAA2B,CAO7B"}

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

@@ -1,176 +0,0 @@
-'use client';
-export const sanitizeClientFeatures = (features)=>{
-    const sanitized = {
-        enabledFeatures: [],
-        hooks: {
-            load: [],
-            save: []
-        },
-        markdownTransformers: [],
-        nodes: [],
-        plugins: [],
-        slashMenu: {
-            dynamicGroups: [],
-            groups: []
-        },
-        toolbarFixed: {
-            groups: []
-        },
-        toolbarInline: {
-            groups: []
-        }
-    };
-    if (!features?.size) {
-        return sanitized;
-    }
-    features.forEach((feature)=>{
-        if (feature.hooks) {
-            if (feature.hooks?.load?.length) {
-                sanitized.hooks.load = sanitized.hooks.load.concat(feature.hooks.load);
-            }
-            if (feature.hooks?.save?.length) {
-                sanitized.hooks.save = sanitized.hooks.save.concat(feature.hooks.save);
-            }
-        }
-        if (feature.nodes?.length) {
-            sanitized.nodes = sanitized.nodes.concat(feature.nodes);
-        }
-        if (feature.plugins?.length) {
-            feature.plugins.forEach((plugin, i)=>{
-                sanitized.plugins.push({
-                    Component: plugin.Component,
-                    clientProps: feature.clientFeatureProps,
-                    key: feature.key + i,
-                    position: plugin.position
-                });
-            });
-        }
-        if (feature.toolbarInline?.groups?.length) {
-            for (const group of feature.toolbarInline.groups){
-                // 1. find the group with the same key or create new one
-                let foundGroup = sanitized.toolbarInline.groups.find((sanitizedGroup)=>sanitizedGroup.key === group.key);
-                if (!foundGroup) {
-                    foundGroup = {
-                        ...group,
-                        items: []
-                    };
-                } else {
-                    sanitized.toolbarInline.groups = sanitized.toolbarInline.groups.filter((sanitizedGroup)=>sanitizedGroup.key !== group.key);
-                }
-                // 2. Add options to group options array and add to sanitized.slashMenu.groupsWithOptions
-                if (group?.items?.length) {
-                    foundGroup.items = foundGroup.items.concat(group.items);
-                }
-                sanitized.toolbarInline?.groups.push(foundGroup);
-            }
-        }
-        if (feature.toolbarFixed?.groups?.length) {
-            for (const group of feature.toolbarFixed.groups){
-                // 1. find the group with the same key or create new one
-                let foundGroup = sanitized.toolbarFixed.groups.find((sanitizedGroup)=>sanitizedGroup.key === group.key);
-                if (!foundGroup) {
-                    foundGroup = {
-                        ...group,
-                        items: []
-                    };
-                } else {
-                    sanitized.toolbarFixed.groups = sanitized.toolbarFixed.groups.filter((sanitizedGroup)=>sanitizedGroup.key !== group.key);
-                }
-                // 2. Add options to group options array and add to sanitized.slashMenu.groupsWithOptions
-                if (group?.items?.length) {
-                    foundGroup.items = foundGroup.items.concat(group.items);
-                }
-                sanitized.toolbarFixed?.groups.push(foundGroup);
-            }
-        }
-        if (feature.slashMenu?.groups) {
-            if (feature.slashMenu.dynamicGroups?.length) {
-                sanitized.slashMenu.dynamicGroups = sanitized.slashMenu.dynamicGroups.concat(feature.slashMenu.dynamicGroups);
-            }
-            for (const optionGroup of feature.slashMenu.groups){
-                // 1. find the group with the same name or create new one
-                let group = sanitized.slashMenu.groups.find((group)=>group.key === optionGroup.key);
-                if (!group) {
-                    group = {
-                        ...optionGroup,
-                        items: []
-                    };
-                } else {
-                    sanitized.slashMenu.groups = sanitized.slashMenu.groups.filter((group)=>group.key !== optionGroup.key);
-                }
-                // 2. Add options to group options array and add to sanitized.slashMenu.groupsWithOptions
-                if (optionGroup?.items?.length) {
-                    group.items = group.items.concat(optionGroup.items);
-                }
-                sanitized.slashMenu.groups.push(group);
-            }
-        }
-        if (feature.markdownTransformers?.length) {
-            sanitized.markdownTransformers = sanitized.markdownTransformers.concat(feature.markdownTransformers);
-        }
-        sanitized.enabledFeatures.push(feature.key);
-    });
-    // Sort sanitized.toolbarInline.groups by order property
-    sanitized.toolbarInline.groups.sort((a, b)=>{
-        if (a.order && b.order) {
-            return a.order - b.order;
-        } else if (a.order) {
-            return -1;
-        } else if (b.order) {
-            return 1;
-        } else {
-            return 0;
-        }
-    });
-    // Sort sanitized.toolbarFixed.groups by order property
-    sanitized.toolbarFixed.groups.sort((a, b)=>{
-        if (a.order && b.order) {
-            return a.order - b.order;
-        } else if (a.order) {
-            return -1;
-        } else if (b.order) {
-            return 1;
-        } else {
-            return 0;
-        }
-    });
-    // Sort sanitized.toolbarInline.groups.[group].entries by order property
-    for (const group of sanitized.toolbarInline.groups){
-        group.items.sort((a, b)=>{
-            if (a.order && b.order) {
-                return a.order - b.order;
-            } else if (a.order) {
-                return -1;
-            } else if (b.order) {
-                return 1;
-            } else {
-                return 0;
-            }
-        });
-    }
-    // Sort sanitized.toolbarFixed.groups.[group].entries by order property
-    for (const group of sanitized.toolbarFixed.groups){
-        group.items.sort((a, b)=>{
-            if (a.order && b.order) {
-                return a.order - b.order;
-            } else if (a.order) {
-                return -1;
-            } else if (b.order) {
-                return 1;
-            } else {
-                return 0;
-            }
-        });
-    }
-    return sanitized;
-};
-export function sanitizeClientEditorConfig(lexical, resolvedClientFeatureMap, admin) {
-    return {
-        admin,
-        features: sanitizeClientFeatures(resolvedClientFeatureMap),
-        lexical,
-        resolvedFeatureMap: resolvedClientFeatureMap
-    };
-}
-
-//# sourceMappingURL=sanitize.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../src/field/lexical/config/client/sanitize.ts"],"sourcesContent":["'use client'\n\nimport type { EditorConfig as LexicalEditorConfig } from 'lexical'\n\nimport type { LexicalFieldAdminProps } from '../../../../types.js'\nimport type { ResolvedClientFeatureMap, SanitizedClientFeatures } from '../../../features/types.js'\nimport type { SanitizedClientEditorConfig } from '../types.js'\n\nexport const sanitizeClientFeatures = (\n  features: ResolvedClientFeatureMap,\n): SanitizedClientFeatures => {\n  const sanitized: SanitizedClientFeatures = {\n    enabledFeatures: [],\n    hooks: {\n      load: [],\n      save: [],\n    },\n    markdownTransformers: [],\n    nodes: [],\n    plugins: [],\n    slashMenu: {\n      dynamicGroups: [],\n      groups: [],\n    },\n    toolbarFixed: {\n      groups: [],\n    },\n    toolbarInline: {\n      groups: [],\n    },\n  }\n\n  if (!features?.size) {\n    return sanitized\n  }\n\n  features.forEach((feature) => {\n    if (feature.hooks) {\n      if (feature.hooks?.load?.length) {\n        sanitized.hooks.load = sanitized.hooks.load.concat(feature.hooks.load)\n      }\n      if (feature.hooks?.save?.length) {\n        sanitized.hooks.save = sanitized.hooks.save.concat(feature.hooks.save)\n      }\n    }\n\n    if (feature.nodes?.length) {\n      sanitized.nodes = sanitized.nodes.concat(feature.nodes)\n    }\n    if (feature.plugins?.length) {\n      feature.plugins.forEach((plugin, i) => {\n        sanitized.plugins.push({\n          Component: plugin.Component,\n          clientProps: feature.clientFeatureProps,\n          key: feature.key + i,\n          position: plugin.position,\n        })\n      })\n    }\n\n    if (feature.toolbarInline?.groups?.length) {\n      for (const group of feature.toolbarInline.groups) {\n        // 1. find the group with the same key or create new one\n        let foundGroup = sanitized.toolbarInline.groups.find(\n          (sanitizedGroup) => sanitizedGroup.key === group.key,\n        )\n        if (!foundGroup) {\n          foundGroup = {\n            ...group,\n            items: [],\n          }\n        } else {\n          sanitized.toolbarInline.groups = sanitized.toolbarInline.groups.filter(\n            (sanitizedGroup) => sanitizedGroup.key !== group.key,\n          )\n        }\n\n        // 2. Add options to group options array and add to sanitized.slashMenu.groupsWithOptions\n        if (group?.items?.length) {\n          foundGroup.items = foundGroup.items.concat(group.items)\n        }\n        sanitized.toolbarInline?.groups.push(foundGroup)\n      }\n    }\n\n    if (feature.toolbarFixed?.groups?.length) {\n      for (const group of feature.toolbarFixed.groups) {\n        // 1. find the group with the same key or create new one\n        let foundGroup = sanitized.toolbarFixed.groups.find(\n          (sanitizedGroup) => sanitizedGroup.key === group.key,\n        )\n        if (!foundGroup) {\n          foundGroup = {\n            ...group,\n            items: [],\n          }\n        } else {\n          sanitized.toolbarFixed.groups = sanitized.toolbarFixed.groups.filter(\n            (sanitizedGroup) => sanitizedGroup.key !== group.key,\n          )\n        }\n\n        // 2. Add options to group options array and add to sanitized.slashMenu.groupsWithOptions\n        if (group?.items?.length) {\n          foundGroup.items = foundGroup.items.concat(group.items)\n        }\n        sanitized.toolbarFixed?.groups.push(foundGroup)\n      }\n    }\n\n    if (feature.slashMenu?.groups) {\n      if (feature.slashMenu.dynamicGroups?.length) {\n        sanitized.slashMenu.dynamicGroups = sanitized.slashMenu.dynamicGroups.concat(\n          feature.slashMenu.dynamicGroups,\n        )\n      }\n\n      for (const optionGroup of feature.slashMenu.groups) {\n        // 1. find the group with the same name or create new one\n        let group = sanitized.slashMenu.groups.find((group) => group.key === optionGroup.key)\n        if (!group) {\n          group = {\n            ...optionGroup,\n            items: [],\n          }\n        } else {\n          sanitized.slashMenu.groups = sanitized.slashMenu.groups.filter(\n            (group) => group.key !== optionGroup.key,\n          )\n        }\n\n        // 2. Add options to group options array and add to sanitized.slashMenu.groupsWithOptions\n        if (optionGroup?.items?.length) {\n          group.items = group.items.concat(optionGroup.items)\n        }\n        sanitized.slashMenu.groups.push(group)\n      }\n    }\n\n    if (feature.markdownTransformers?.length) {\n      sanitized.markdownTransformers = sanitized.markdownTransformers.concat(\n        feature.markdownTransformers,\n      )\n    }\n    sanitized.enabledFeatures.push(feature.key)\n  })\n\n  // Sort sanitized.toolbarInline.groups by order property\n  sanitized.toolbarInline.groups.sort((a, b) => {\n    if (a.order && b.order) {\n      return a.order - b.order\n    } else if (a.order) {\n      return -1\n    } else if (b.order) {\n      return 1\n    } else {\n      return 0\n    }\n  })\n  // Sort sanitized.toolbarFixed.groups by order property\n  sanitized.toolbarFixed.groups.sort((a, b) => {\n    if (a.order && b.order) {\n      return a.order - b.order\n    } else if (a.order) {\n      return -1\n    } else if (b.order) {\n      return 1\n    } else {\n      return 0\n    }\n  })\n\n  // Sort sanitized.toolbarInline.groups.[group].entries by order property\n  for (const group of sanitized.toolbarInline.groups) {\n    group.items.sort((a, b) => {\n      if (a.order && b.order) {\n        return a.order - b.order\n      } else if (a.order) {\n        return -1\n      } else if (b.order) {\n        return 1\n      } else {\n        return 0\n      }\n    })\n  }\n\n  // Sort sanitized.toolbarFixed.groups.[group].entries by order property\n  for (const group of sanitized.toolbarFixed.groups) {\n    group.items.sort((a, b) => {\n      if (a.order && b.order) {\n        return a.order - b.order\n      } else if (a.order) {\n        return -1\n      } else if (b.order) {\n        return 1\n      } else {\n        return 0\n      }\n    })\n  }\n\n  return sanitized\n}\n\nexport function sanitizeClientEditorConfig(\n  lexical: LexicalEditorConfig,\n  resolvedClientFeatureMap: ResolvedClientFeatureMap,\n  admin?: LexicalFieldAdminProps,\n): SanitizedClientEditorConfig {\n  return {\n    admin,\n    features: sanitizeClientFeatures(resolvedClientFeatureMap),\n    lexical,\n    resolvedFeatureMap: resolvedClientFeatureMap,\n  }\n}\n"],"names":["sanitizeClientFeatures","features","sanitized","enabledFeatures","hooks","load","save","markdownTransformers","nodes","plugins","slashMenu","dynamicGroups","groups","toolbarFixed","toolbarInline","size","forEach","feature","length","concat","plugin","i","push","Component","clientProps","clientFeatureProps","key","position","group","foundGroup","find","sanitizedGroup","items","filter","optionGroup","sort","a","b","order","sanitizeClientEditorConfig","lexical","resolvedClientFeatureMap","admin","resolvedFeatureMap"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

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

@@ -1,7 +0,0 @@
-import type { EditorConfig as LexicalEditorConfig } from 'lexical';
-import type { FeatureProviderServer } from '../../../features/types.js';
-import type { ServerEditorConfig } from '../types.js';
-export declare const defaultEditorLexicalConfig: LexicalEditorConfig;
-export declare const defaultEditorFeatures: FeatureProviderServer<unknown, unknown>[];
-export declare const defaultEditorConfig: ServerEditorConfig;
-//# sourceMappingURL=default.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"default.d.ts","sourceRoot":"","sources":["../../../../../src/field/lexical/config/server/default.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,IAAI,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAElE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAA;AACvE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAwBrD,eAAO,MAAM,0BAA0B,EAAE,mBAGxC,CAAA;AAED,eAAO,MAAM,qBAAqB,EAAE,qBAAqB,CAAC,OAAO,EAAE,OAAO,CAAC,EAqB1E,CAAA;AAED,eAAO,MAAM,mBAAmB,EAAE,kBAGjC,CAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../src/field/lexical/config/server/default.ts"],"sourcesContent":["import type { EditorConfig as LexicalEditorConfig } from 'lexical'\n\nimport type { FeatureProviderServer } from '../../../features/types.js'\nimport type { ServerEditorConfig } from '../types.js'\n\nimport { AlignFeature } from '../../../features/align/feature.server.js'\nimport { BlockquoteFeature } from '../../../features/blockquote/feature.server.js'\nimport { BoldFeature } from '../../../features/format/bold/feature.server.js'\nimport { InlineCodeFeature } from '../../../features/format/inlineCode/feature.server.js'\nimport { ItalicFeature } from '../../../features/format/italic/feature.server.js'\nimport { StrikethroughFeature } from '../../../features/format/strikethrough/feature.server.js'\nimport { SubscriptFeature } from '../../../features/format/subscript/feature.server.js'\nimport { SuperscriptFeature } from '../../../features/format/superscript/feature.server.js'\nimport { UnderlineFeature } from '../../../features/format/underline/feature.server.js'\nimport { HeadingFeature } from '../../../features/heading/feature.server.js'\nimport { HorizontalRuleFeature } from '../../../features/horizontalRule/feature.server.js'\nimport { IndentFeature } from '../../../features/indent/feature.server.js'\nimport { LinkFeature } from '../../../features/link/feature.server.js'\nimport { ChecklistFeature } from '../../../features/lists/checklist/feature.server.js'\nimport { OrderedListFeature } from '../../../features/lists/orderedList/feature.server.js'\nimport { UnorderedListFeature } from '../../../features/lists/unorderedList/feature.server.js'\nimport { ParagraphFeature } from '../../../features/paragraph/feature.server.js'\nimport { RelationshipFeature } from '../../../features/relationship/feature.server.js'\nimport { InlineToolbarFeature } from '../../../features/toolbars/inline/feature.server.js'\nimport { UploadFeature } from '../../../features/upload/feature.server.js'\nimport { LexicalEditorTheme } from '../../theme/EditorTheme.js'\n\nexport const defaultEditorLexicalConfig: LexicalEditorConfig = {\n  namespace: 'lexical',\n  theme: LexicalEditorTheme,\n}\n\nexport const defaultEditorFeatures: FeatureProviderServer<unknown, unknown>[] = [\n  BoldFeature(),\n  ItalicFeature(),\n  UnderlineFeature(),\n  StrikethroughFeature(),\n  SubscriptFeature(),\n  SuperscriptFeature(),\n  InlineCodeFeature(),\n  ParagraphFeature(),\n  HeadingFeature(),\n  AlignFeature(),\n  IndentFeature(),\n  UnorderedListFeature(),\n  OrderedListFeature(),\n  ChecklistFeature(),\n  LinkFeature(),\n  RelationshipFeature(),\n  BlockquoteFeature(),\n  UploadFeature(),\n  HorizontalRuleFeature(),\n  InlineToolbarFeature(),\n]\n\nexport const defaultEditorConfig: ServerEditorConfig = {\n  features: defaultEditorFeatures,\n  lexical: defaultEditorLexicalConfig,\n}\n"],"names":["AlignFeature","BlockquoteFeature","BoldFeature","InlineCodeFeature","ItalicFeature","StrikethroughFeature","SubscriptFeature","SuperscriptFeature","UnderlineFeature","HeadingFeature","HorizontalRuleFeature","IndentFeature","LinkFeature","ChecklistFeature","OrderedListFeature","UnorderedListFeature","ParagraphFeature","RelationshipFeature","InlineToolbarFeature","UploadFeature","LexicalEditorTheme","defaultEditorLexicalConfig","namespace","theme","defaultEditorFeatures","defaultEditorConfig","features","lexical"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAKA,SAASA,YAAY,QAAQ,4CAA2C;AACxE,SAASC,iBAAiB,QAAQ,iDAAgD;AAClF,SAASC,WAAW,QAAQ,kDAAiD;AAC7E,SAASC,iBAAiB,QAAQ,wDAAuD;AACzF,SAASC,aAAa,QAAQ,oDAAmD;AACjF,SAASC,oBAAoB,QAAQ,2DAA0D;AAC/F,SAASC,gBAAgB,QAAQ,uDAAsD;AACvF,SAASC,kBAAkB,QAAQ,yDAAwD;AAC3F,SAASC,gBAAgB,QAAQ,uDAAsD;AACvF,SAASC,cAAc,QAAQ,8CAA6C;AAC5E,SAASC,qBAAqB,QAAQ,qDAAoD;AAC1F,SAASC,aAAa,QAAQ,6CAA4C;AAC1E,SAASC,WAAW,QAAQ,2CAA0C;AACtE,SAASC,gBAAgB,QAAQ,sDAAqD;AACtF,SAASC,kBAAkB,QAAQ,wDAAuD;AAC1F,SAASC,oBAAoB,QAAQ,0DAAyD;AAC9F,SAASC,gBAAgB,QAAQ,gDAA+C;AAChF,SAASC,mBAAmB,QAAQ,mDAAkD;AACtF,SAASC,oBAAoB,QAAQ,sDAAqD;AAC1F,SAASC,aAAa,QAAQ,6CAA4C;AAC1E,SAASC,kBAAkB,QAAQ,6BAA4B;AAE/D,OAAO,MAAMC,6BAAkD;IAC7DC,WAAW;IACXC,OAAOH;AACT,EAAC;AAED,OAAO,MAAMI,wBAAmE;IAC9EtB;IACAE;IACAI;IACAH;IACAC;IACAC;IACAJ;IACAa;IACAP;IACAT;IACAW;IACAI;IACAD;IACAD;IACAD;IACAK;IACAhB;IACAkB;IACAT;IACAQ;CACD,CAAA;AAED,OAAO,MAAMO,sBAA0C;IACrDC,UAAUF;IACVG,SAASN;AACX,EAAC"}

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../../../../src/field/lexical/config/server/loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAU,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAE7D,OAAO,KAAK,EACV,qBAAqB,EACrB,wBAAwB,EAEzB,MAAM,4BAA4B,CAAA;AACnC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AA8FrD,wBAAgB,6BAA6B,CAC3C,gBAAgB,EAAE,qBAAqB,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,GAC1D,qBAAqB,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,CAE3C;AAED,wBAAsB,YAAY,CAAC,EACjC,MAAM,EACN,MAAM,EACN,uBAAuB,GACxB,EAAE;IACD,MAAM,EAAE,eAAe,CAAA;IACvB,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,uBAAuB,EAAE,kBAAkB,CAAA;CAC5C,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAgFpC"}

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

@@ -1,120 +0,0 @@
-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, 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 = await featureProvider.feature({
-            config,
-            featureProviderMap,
-            isRoot,
-            resolvedFeatures,
-            unSanitizedEditorConfig
-        });
-        resolvedFeatures.set(featureProvider.key, {
-            ...feature,
-            dependencies: featureProvider.dependencies,
-            dependenciesPriority: featureProvider.dependenciesPriority,
-            dependenciesSoft: featureProvider.dependenciesSoft,
-            key: featureProvider.key,
-            order: loaded
-        });
-        loaded++;
-    }
-    return resolvedFeatures;
-}
-
-//# sourceMappingURL=loader.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../src/field/lexical/config/server/loader.ts"],"sourcesContent":["import type { Config, SanitizedConfig } from 'payload/config'\n\nimport type {\n  FeatureProviderServer,\n  ResolvedServerFeatureMap,\n  ServerFeatureProviderMap,\n} from '../../../features/types.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>\n  }\n}\n\nfunction createDependencyGraph(\n  featureProviders: FeatureProviderServer<unknown, unknown>[],\n): DependencyGraph {\n  const graph: DependencyGraph = {}\n  for (const fp of featureProviders) {\n    graph[fp.key] = {\n      dependencies: fp.dependencies || [],\n      dependenciesPriority: fp.dependenciesPriority || [],\n      dependenciesSoft: fp.dependenciesSoft || [],\n      featureProvider: fp,\n    }\n  }\n  return graph\n}\n\nfunction topologicallySortFeatures(\n  featureProviders: FeatureProviderServer<unknown, unknown>[],\n): FeatureProviderServer<unknown, unknown>[] {\n  const graph = createDependencyGraph(featureProviders)\n  const visited: { [key: string]: boolean } = {}\n  const stack: FeatureProviderServer<unknown, unknown>[] = []\n\n  for (const key in graph) {\n    if (!visited[key]) {\n      visit(graph, key, visited, stack)\n    }\n  }\n\n  return stack.reverse()\n}\n\nfunction visit(\n  graph: DependencyGraph,\n  key: string,\n  visited: { [key: string]: boolean },\n  stack: FeatureProviderServer<unknown, unknown>[],\n  currentPath: string[] = [],\n) {\n  if (!graph[key]) {\n    throw new Error(`Feature key ${key} is not present in the dependency graph.`)\n  }\n\n  if (currentPath.includes(key)) {\n    throw new Error(`Circular dependency detected: ${currentPath.join(' -> ')} -> ${key}`)\n  }\n\n  if (visited[key]) {\n    return\n  }\n\n  visited[key] = true\n  currentPath.push(key)\n\n  // First process the hard priority dependencies\n  for (const dep of graph[key].dependenciesPriority) {\n    if (!visited[dep]) {\n      visit(graph, dep, visited, stack, currentPath)\n    }\n  }\n\n  // Then process the normal dependencies, but make sure to not violate hard dependencies\n  for (const dep of graph[key].dependencies) {\n    if (!visited[dep] && !graph[key].dependenciesPriority.includes(dep)) {\n      visit(graph, dep, visited, stack, currentPath)\n    }\n  }\n\n  // Then process the soft dependencies. Make sure to not violate hard and normal dependencies.\n  for (const dep of graph[key].dependenciesSoft) {\n    if (\n      graph[dep] &&\n      !visited[dep] &&\n      !graph[key].dependenciesPriority.includes(dep) &&\n      !graph[key].dependencies.includes(dep)\n    ) {\n      visit(graph, dep, visited, stack, currentPath)\n    }\n  }\n\n  stack.push(graph[key].featureProvider)\n  currentPath.pop()\n}\n\nexport function sortFeaturesForOptimalLoading(\n  featureProviders: FeatureProviderServer<unknown, unknown>[],\n): FeatureProviderServer<unknown, unknown>[] {\n  return topologicallySortFeatures(featureProviders)\n}\n\nexport 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>],\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 = await featureProvider.feature({\n      config,\n      featureProviderMap,\n      isRoot,\n      resolvedFeatures,\n      unSanitizedEditorConfig,\n    })\n    resolvedFeatures.set(featureProvider.key, {\n      ...feature,\n      dependencies: featureProvider.dependencies,\n      dependenciesPriority: featureProvider.dependenciesPriority,\n      dependenciesSoft: featureProvider.dependenciesSoft,\n      key: featureProvider.key,\n      order: loaded,\n    })\n\n    loaded++\n  }\n\n  return resolvedFeatures\n}\n"],"names":["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"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"sanitize.d.ts","sourceRoot":"","sources":["../../../../../src/field/lexical/config/server/sanitize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAU,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAE7D,OAAO,KAAK,EAAE,wBAAwB,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAA;AACnG,OAAO,KAAK,EAAE,2BAA2B,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAIlF,eAAO,MAAM,sBAAsB,0CAEhC,uBAsFF,CAAA;AAED,wBAAsB,0BAA0B,CAC9C,YAAY,EAAE,kBAAkB,EAChC,MAAM,EAAE,eAAe,GACtB,OAAO,CAAC,2BAA2B,CAAC,CAWtC"}

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

@@ -1,91 +0,0 @@
-import { loadFeatures } from './loader.js';
-export const sanitizeServerFeatures = (features)=>{
-    const sanitized = {
-        converters: {
-            html: []
-        },
-        enabledFeatures: [],
-        generatedTypes: {
-            modifyOutputSchemas: []
-        },
-        hooks: {
-            afterChange: new Map(),
-            afterRead: new Map(),
-            beforeChange: new Map(),
-            beforeDuplicate: new Map(),
-            beforeValidate: new Map()
-        },
-        i18n: {},
-        markdownTransformers: [],
-        nodes: [],
-        populationPromises: new Map(),
-        validations: new Map()
-    };
-    if (!features?.size) {
-        return sanitized;
-    }
-    features.forEach((feature)=>{
-        if (feature?.generatedTypes?.modifyOutputSchema) {
-            sanitized.generatedTypes.modifyOutputSchemas.push(feature.generatedTypes.modifyOutputSchema);
-        }
-        if (feature?.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?.populationPromises?.length) {
-                    sanitized.populationPromises.set(nodeType, node.populationPromises);
-                }
-                if (node?.validations?.length) {
-                    sanitized.validations.set(nodeType, node.validations);
-                }
-                if (node?.converters?.html) {
-                    sanitized.converters.html.push(node.converters.html);
-                }
-                if (node?.hooks?.afterChange) {
-                    sanitized.hooks.afterChange.set(nodeType, node.hooks.afterChange);
-                }
-                if (node?.hooks?.afterRead) {
-                    sanitized.hooks.afterRead.set(nodeType, node.hooks.afterRead);
-                }
-                if (node?.hooks?.beforeChange) {
-                    sanitized.hooks.beforeChange.set(nodeType, node.hooks.beforeChange);
-                }
-                if (node?.hooks?.beforeDuplicate) {
-                    sanitized.hooks.beforeDuplicate.set(nodeType, node.hooks.beforeDuplicate);
-                }
-                if (node?.hooks?.beforeValidate) {
-                    sanitized.hooks.beforeValidate.set(nodeType, node.hooks.beforeValidate);
-                }
-            });
-        }
-        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
-    };
-}
-
-//# sourceMappingURL=sanitize.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../src/field/lexical/config/server/sanitize.ts"],"sourcesContent":["import type { Config, SanitizedConfig } from 'payload/config'\n\nimport type { ResolvedServerFeatureMap, SanitizedServerFeatures } from '../../../features/types.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\n    hooks: {\n      afterChange: new Map(),\n      afterRead: new Map(),\n      beforeChange: new Map(),\n      beforeDuplicate: new Map(),\n      beforeValidate: new Map(),\n    },\n    i18n: {},\n    markdownTransformers: [],\n    nodes: [],\n    populationPromises: new Map(),\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?.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?.populationPromises?.length) {\n          sanitized.populationPromises.set(nodeType, node.populationPromises)\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.hooks.afterChange.set(nodeType, node.hooks.afterChange)\n        }\n        if (node?.hooks?.afterRead) {\n          sanitized.hooks.afterRead.set(nodeType, node.hooks.afterRead)\n        }\n        if (node?.hooks?.beforeChange) {\n          sanitized.hooks.beforeChange.set(nodeType, node.hooks.beforeChange)\n        }\n        if (node?.hooks?.beforeDuplicate) {\n          sanitized.hooks.beforeDuplicate.set(nodeType, node.hooks.beforeDuplicate)\n        }\n        if (node?.hooks?.beforeValidate) {\n          sanitized.hooks.beforeValidate.set(nodeType, node.hooks.beforeValidate)\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","hooks","afterChange","Map","afterRead","beforeChange","beforeDuplicate","beforeValidate","i18n","markdownTransformers","nodes","populationPromises","validations","size","forEach","feature","modifyOutputSchema","push","lang","lexical","key","length","concat","node","nodeType","replace","getType","set","sanitizeServerEditorConfig","editorConfig","config","resolvedFeatureMap","unSanitizedEditorConfig"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/field/lexical/config/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,IAAI,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAElE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAA;AAC/D,OAAO,KAAK,EACV,qBAAqB,EACrB,qBAAqB,EACrB,wBAAwB,EACxB,wBAAwB,EACxB,uBAAuB,EACvB,uBAAuB,EACxB,MAAM,yBAAyB,CAAA;AAEhC,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,EAAE,qBAAqB,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,CAAA;IACnD,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,OAAO,CAAC,EAAE,CAAA;IAC1C,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/field/lexical/config/types.js

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

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/field/lexical/config/types.ts"],"sourcesContent":["import type { EditorConfig as LexicalEditorConfig } from 'lexical'\n\nimport type { LexicalFieldAdminProps } from '../../../types.js'\nimport type {\n  FeatureProviderClient,\n  FeatureProviderServer,\n  ResolvedClientFeatureMap,\n  ResolvedServerFeatureMap,\n  SanitizedClientFeatures,\n  SanitizedServerFeatures,\n} from '../../features/types.js'\n\nexport type ServerEditorConfig = {\n  features: FeatureProviderServer<unknown, unknown>[]\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<unknown>[]\n  lexical?: LexicalEditorConfig\n}\n\nexport type SanitizedClientEditorConfig = {\n  admin?: LexicalFieldAdminProps\n  features: SanitizedClientFeatures\n  lexical: LexicalEditorConfig\n  resolvedFeatureMap: ResolvedClientFeatureMap\n}\n"],"names":[],"rangeMappings":"","mappings":"AA4BA,WAKC"}

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

@@ -1,7 +0,0 @@
-import type { Klass, LexicalNode } from 'lexical';
-import type { 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