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

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

@@ -1,18 +1,8 @@
-import type { Klass, LexicalEditor, LexicalNode, LexicalNodeReplacement } from 'lexical';
+import type { Klass, LexicalNode, LexicalNodeReplacement } from 'lexical';
 import type { NodeWithHooks } from '../../features/typesServer.js';
-import type { LexicalEditorNodeMap } from '../../types.js';
 import type { SanitizedClientEditorConfig, SanitizedServerEditorConfig } from '../config/types.js';
-/**
- * Register view definitions for an editor
- */
-export declare function registerEditorNodeViews(editor: LexicalEditor, nodeViews: LexicalEditorNodeMap): void;
-/**
- * Clear all view overrides for an editor (restores default rendering)
- */
-export declare function clearEditorNodeViews(editor: LexicalEditor): void;
-export declare function getEnabledNodes({ editorConfig, nodeViews, }: {
+export declare function getEnabledNodes({ editorConfig, }: {
     editorConfig: SanitizedClientEditorConfig | SanitizedServerEditorConfig;
-    nodeViews?: LexicalEditorNodeMap;
 }): Array<Klass<LexicalNode> | LexicalNodeReplacement>;
 export declare function getEnabledNodesFromServerNodes({ nodes, }: {
     nodes: Array<Klass<LexicalNode> | LexicalNodeReplacement> | Array<NodeWithHooks>;

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lexical/nodes/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,KAAK,EACL,aAAa,EACb,WAAW,EACX,sBAAsB,EACvB,MAAM,SAAS,CAAA;AAIhB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAA;AAClE,OAAO,KAAK,EAAE,oBAAoB,EAAgB,MAAM,gBAAgB,CAAA;AACxE,OAAO,KAAK,EAAE,2BAA2B,EAAE,2BAA2B,EAAE,MAAM,oBAAoB,CAAA;AAMlG;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,aAAa,EACrB,SAAS,EAAE,oBAAoB,GAC9B,IAAI,CAsCN;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI,CAEhE;AAoID,wBAAgB,eAAe,CAAC,EAC9B,YAAY,EACZ,SAAS,GACV,EAAE;IACD,YAAY,EAAE,2BAA2B,GAAG,2BAA2B,CAAA;IACvE,SAAS,CAAC,EAAE,oBAAoB,CAAA;CACjC,GAAG,KAAK,CAAC,KAAK,CAAC,WAAW,CAAC,GAAG,sBAAsB,CAAC,CAyCrD;AAED,wBAAgB,8BAA8B,CAAC,EAC7C,KAAK,GACN,EAAE;IACD,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,WAAW,CAAC,GAAG,sBAAsB,CAAC,GAAG,KAAK,CAAC,aAAa,CAAC,CAAA;CACjF,GAAG,KAAK,CAAC,KAAK,CAAC,WAAW,CAAC,GAAG,sBAAsB,CAAC,CAOrD"}
+{"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,aAAa,EAAE,MAAM,+BAA+B,CAAA;AAClE,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,CAIrD;AAED,wBAAgB,8BAA8B,CAAC,EAC7C,KAAK,GACN,EAAE;IACD,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,WAAW,CAAC,GAAG,sBAAsB,CAAC,GAAG,KAAK,CAAC,aAAa,CAAC,CAAA;CACjF,GAAG,KAAK,CAAC,KAAK,CAAC,WAAW,CAAC,GAAG,sBAAsB,CAAC,CAOrD"}

package/dist/lexical/nodes/index.js

@@ -1,200 +1,18 @@
-import React from 'react';
-// Store view definitions for each editor and node type
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const editorNodeViews = new WeakMap();
-/**
- * Register view definitions for an editor
- */ export function registerEditorNodeViews(editor, nodeViews) {
-    if (!editorNodeViews.has(editor)) {
-        editorNodeViews.set(editor, new Map());
-    }
-    const editorViews = editorNodeViews.get(editor);
-    // Register each node type's view
-    for (const [nodeType, value] of Object.entries(nodeViews)){
-        if (!value || typeof value !== 'object') {
-            continue;
-        }
-        // Handle blocks specially - store each block type with key 'block:blockType'
-        if (nodeType === 'blocks') {
-            for (const [blockType, viewDef] of Object.entries(// eslint-disable-next-line @typescript-eslint/no-explicit-any
-            value)){
-                editorViews.set(`block:${blockType}`, viewDef);
-            }
-            continue;
-        }
-        // Handle inlineBlocks specially - store each block type with key 'inlineBlock:blockType'
-        if (nodeType === 'inlineBlocks') {
-            for (const [blockType, viewDef] of Object.entries(// eslint-disable-next-line @typescript-eslint/no-explicit-any
-            value)){
-                editorViews.set(`inlineBlock:${blockType}`, viewDef);
-            }
-            continue;
-        }
-        // Regular node types
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        editorViews.set(nodeType, value);
-    }
-}
-/**
- * Clear all view overrides for an editor (restores default rendering)
- */ export function clearEditorNodeViews(editor) {
-    editorNodeViews.delete(editor);
-}
-/**
- * Get the view definition for a specific editor and node
- */ function getEditorNodeView(editor, nodeType, // eslint-disable-next-line @typescript-eslint/no-explicit-any
-node) // eslint-disable-next-line @typescript-eslint/no-explicit-any
-{
-    const editorViews = editorNodeViews.get(editor);
-    // For block nodes, look up by blockType
-    if (nodeType === 'block' && node?.['__fields']?.blockType) {
-        const blockType = node['__fields'].blockType;
-        return editorViews?.get(`block:${blockType}`);
-    }
-    // For inlineBlock nodes, look up by blockType
-    if (nodeType === 'inlineBlock' && node?.['__fields']?.blockType) {
-        const blockType = node['__fields'].blockType;
-        return editorViews?.get(`inlineBlock:${blockType}`);
-    }
-    // Regular node types
-    return editorViews?.get(nodeType);
-}
-/**
- * Apply view overrides to a specific node type by modifying its prototype
- * Uses WeakMap to check per-editor at runtime
- */ function applyNodeOverride({ node, nodeType }) {
-    if (!('getType' in node) || node.getType() !== nodeType) {
-        return;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const NodeClass = node;
-    // Store original methods if not already stored
-    if (!NodeClass.prototype._originalDecorate) {
-        NodeClass.prototype._originalDecorate = NodeClass.prototype.decorate;
-    }
-    if (!NodeClass.prototype._originalCreateDOM) {
-        NodeClass.prototype._originalCreateDOM = NodeClass.prototype.createDOM;
-    }
-    // Override decorate method (for DecoratorNodes)
-    if (NodeClass.prototype.decorate && !NodeClass.prototype._decorateOverridden) {
-        NodeClass.prototype._decorateOverridden = true;
-        const hasCreateDOM = !!NodeClass.prototype.createDOM;
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        NodeClass.prototype.decorate = function(editor, config) {
-            const viewDef = getEditorNodeView(editor, nodeType, this);
-            if (viewDef) {
-                // Priority 1: If Component is provided, use it
-                if (viewDef.Component) {
-                    return viewDef.Component({
-                        config,
-                        editor,
-                        isEditor: true,
-                        isJSXConverter: false,
-                        node: this
-                    });
-                }
-                // Priority 2: If custom createDOM is provided, use html in decorate
-                if (viewDef.createDOM && viewDef.html) {
-                    const htmlContent = typeof viewDef.html === 'function' ? viewDef.html({
-                        config,
-                        editor,
-                        isEditor: true,
-                        isJSXConverter: false,
-                        node: this
-                    }) : viewDef.html;
-                    return React.createElement('span', {
-                        dangerouslySetInnerHTML: {
-                            __html: htmlContent
-                        }
-                    });
-                }
-                // Priority 3: If only html is provided (no custom createDOM),
-                // createDOM will handle it, so decorate returns empty fragment
-                if (viewDef.html && hasCreateDOM && !viewDef.createDOM) {
-                    return React.createElement(React.Fragment);
-                }
-            }
-            // Otherwise use original
-            return NodeClass.prototype._originalDecorate.call(this, editor, config);
-        };
-    }
-    // Override createDOM method (for ElementNodes)
-    if (NodeClass.prototype.createDOM && !NodeClass.prototype._createDOMOverridden) {
-        NodeClass.prototype._createDOMOverridden = true;
-        NodeClass.prototype.createDOM = function(config, editor) {
-            const viewDef = getEditorNodeView(editor, nodeType, this);
-            if (viewDef) {
-                // If createDOM is provided, use it
-                if (viewDef.createDOM) {
-                    return viewDef.createDOM({
-                        config,
-                        editor,
-                        node: this
-                    });
-                }
-                // If html is provided (as a function or string), create element from it
-                if (viewDef.html) {
-                    const htmlContent = typeof viewDef.html === 'function' ? viewDef.html({
-                        config,
-                        editor,
-                        isEditor: true,
-                        isJSXConverter: false,
-                        node: this
-                    }) : viewDef.html;
-                    const tempDiv = document.createElement('div');
-                    tempDiv.innerHTML = htmlContent;
-                    return tempDiv.firstElementChild || tempDiv;
-                }
-            }
-            // Otherwise use original
-            return NodeClass.prototype._originalCreateDOM.call(this, config, editor);
-        };
-    }
-}
-export function getEnabledNodes({ editorConfig, nodeViews }) {
-    const nodes = getEnabledNodesFromServerNodes({
-        nodes: editorConfig.features.nodes
-    });
-    if (nodeViews) {
-        // Apply node overrides by modifying prototypes (once globally)
-        // The overrides check per-editor at runtime using WeakMap
-        const nodeTypesToOverride = new Set();
-        for (const [key, value] of Object.entries(nodeViews)){
-            if (!value || typeof value !== 'object') {
-                continue;
-            }
-            // If 'blocks' key exists with content, we need to override 'block' nodes
-            if (key === 'blocks' && Object.keys(value).length > 0) {
-                nodeTypesToOverride.add('block');
-            } else // If 'inlineBlocks' key exists with content, we need to override 'inlineBlock' nodes
-            if (key === 'inlineBlocks' && Object.keys(value).length > 0) {
-                nodeTypesToOverride.add('inlineBlock');
-            } else // Regular node types
-            {
-                nodeTypesToOverride.add(key);
-            }
-        }
-        for (const node of nodes){
-            if ('getType' in node) {
-                const nodeType = node.getType();
-                if (nodeTypesToOverride.has(nodeType)) {
-                    applyNodeOverride({
-                        node,
-                        nodeType
-                    });
-                }
-            }
-        }
-    }
-    return nodes;
+export function getEnabledNodes({
+  editorConfig
+}) {
+  return getEnabledNodesFromServerNodes({
+    nodes: editorConfig.features.nodes
+  });
 }
-export function getEnabledNodesFromServerNodes({ nodes }) {
-    return nodes.map((node)=>{
-        if ('node' in node) {
-            return node.node;
-        }
-        return node;
-    });
+export function getEnabledNodesFromServerNodes({
+  nodes
+}) {
+  return nodes.map(node => {
+    if ('node' in node) {
+      return node.node;
+    }
+    return node;
+  });
 }
-
 //# sourceMappingURL=index.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lexical/nodes/index.ts"],"sourcesContent":["import type {\n  EditorConfig,\n  Klass,\n  LexicalEditor,\n  LexicalNode,\n  LexicalNodeReplacement,\n} from 'lexical'\n\nimport React from 'react'\n\nimport type { NodeWithHooks } from '../../features/typesServer.js'\nimport type { LexicalEditorNodeMap, NodeMapValue } from '../../types.js'\nimport type { SanitizedClientEditorConfig, SanitizedServerEditorConfig } from '../config/types.js'\n\n// Store view definitions for each editor and node type\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nconst editorNodeViews = new WeakMap<LexicalEditor, Map<string, NodeMapValue<any>>>()\n\n/**\n * Register view definitions for an editor\n */\nexport function registerEditorNodeViews(\n  editor: LexicalEditor,\n  nodeViews: LexicalEditorNodeMap,\n): void {\n  if (!editorNodeViews.has(editor)) {\n    editorNodeViews.set(editor, new Map())\n  }\n  const editorViews = editorNodeViews.get(editor)!\n\n  // Register each node type's view\n  for (const [nodeType, value] of Object.entries(nodeViews)) {\n    if (!value || typeof value !== 'object') {\n      continue\n    }\n\n    // Handle blocks specially - store each block type with key 'block:blockType'\n    if (nodeType === 'blocks') {\n      for (const [blockType, viewDef] of Object.entries(\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        value as Record<string, NodeMapValue<any>>,\n      )) {\n        editorViews.set(`block:${blockType}`, viewDef)\n      }\n      continue\n    }\n\n    // Handle inlineBlocks specially - store each block type with key 'inlineBlock:blockType'\n    if (nodeType === 'inlineBlocks') {\n      for (const [blockType, viewDef] of Object.entries(\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        value as Record<string, NodeMapValue<any>>,\n      )) {\n        editorViews.set(`inlineBlock:${blockType}`, viewDef)\n      }\n      continue\n    }\n\n    // Regular node types\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    editorViews.set(nodeType, value as NodeMapValue<any>)\n  }\n}\n\n/**\n * Clear all view overrides for an editor (restores default rendering)\n */\nexport function clearEditorNodeViews(editor: LexicalEditor): void {\n  editorNodeViews.delete(editor)\n}\n\n/**\n * Get the view definition for a specific editor and node\n */\nfunction getEditorNodeView(\n  editor: LexicalEditor,\n  nodeType: string,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  node?: any,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n): NodeMapValue<any> | undefined {\n  const editorViews = editorNodeViews.get(editor)\n\n  // For block nodes, look up by blockType\n  if (nodeType === 'block' && node?.['__fields']?.blockType) {\n    const blockType = node['__fields'].blockType\n    return editorViews?.get(`block:${blockType}`)\n  }\n\n  // For inlineBlock nodes, look up by blockType\n  if (nodeType === 'inlineBlock' && node?.['__fields']?.blockType) {\n    const blockType = node['__fields'].blockType\n    return editorViews?.get(`inlineBlock:${blockType}`)\n  }\n\n  // Regular node types\n  return editorViews?.get(nodeType)\n}\n\n/**\n * Apply view overrides to a specific node type by modifying its prototype\n * Uses WeakMap to check per-editor at runtime\n */\nfunction applyNodeOverride({\n  node,\n  nodeType,\n}: {\n  node: Klass<LexicalNode>\n  nodeType: string\n}): void {\n  if (!('getType' in node) || node.getType() !== nodeType) {\n    return\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const NodeClass = node as any\n\n  // Store original methods if not already stored\n  if (!NodeClass.prototype._originalDecorate) {\n    NodeClass.prototype._originalDecorate = NodeClass.prototype.decorate\n  }\n  if (!NodeClass.prototype._originalCreateDOM) {\n    NodeClass.prototype._originalCreateDOM = NodeClass.prototype.createDOM\n  }\n\n  // Override decorate method (for DecoratorNodes)\n  if (NodeClass.prototype.decorate && !NodeClass.prototype._decorateOverridden) {\n    NodeClass.prototype._decorateOverridden = true\n    const hasCreateDOM = !!NodeClass.prototype.createDOM\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    NodeClass.prototype.decorate = function (editor: LexicalEditor, config: EditorConfig): any {\n      const viewDef = getEditorNodeView(editor, nodeType, this)\n\n      if (viewDef) {\n        // Priority 1: If Component is provided, use it\n        if (viewDef.Component) {\n          return viewDef.Component({\n            config,\n            editor,\n            isEditor: true,\n            isJSXConverter: false,\n            node: this,\n          })\n        }\n\n        // Priority 2: If custom createDOM is provided, use html in decorate\n        if (viewDef.createDOM && viewDef.html) {\n          const htmlContent =\n            typeof viewDef.html === 'function'\n              ? viewDef.html({ config, editor, isEditor: true, isJSXConverter: false, node: this })\n              : viewDef.html\n          return React.createElement('span', {\n            dangerouslySetInnerHTML: { __html: htmlContent },\n          })\n        }\n\n        // Priority 3: If only html is provided (no custom createDOM),\n        // createDOM will handle it, so decorate returns empty fragment\n        if (viewDef.html && hasCreateDOM && !viewDef.createDOM) {\n          return React.createElement(React.Fragment)\n        }\n      }\n\n      // Otherwise use original\n      return NodeClass.prototype._originalDecorate.call(this, editor, config)\n    }\n  }\n\n  // Override createDOM method (for ElementNodes)\n  if (NodeClass.prototype.createDOM && !NodeClass.prototype._createDOMOverridden) {\n    NodeClass.prototype._createDOMOverridden = true\n    NodeClass.prototype.createDOM = function (\n      config: EditorConfig,\n      editor: LexicalEditor,\n    ): HTMLElement {\n      const viewDef = getEditorNodeView(editor, nodeType, this)\n\n      if (viewDef) {\n        // If createDOM is provided, use it\n        if (viewDef.createDOM) {\n          return viewDef.createDOM({ config, editor, node: this })\n        }\n\n        // If html is provided (as a function or string), create element from it\n        if (viewDef.html) {\n          const htmlContent =\n            typeof viewDef.html === 'function'\n              ? viewDef.html({ config, editor, isEditor: true, isJSXConverter: false, node: this })\n              : viewDef.html\n          const tempDiv = document.createElement('div')\n          tempDiv.innerHTML = htmlContent\n          return (tempDiv.firstElementChild as HTMLElement) || tempDiv\n        }\n      }\n\n      // Otherwise use original\n      return NodeClass.prototype._originalCreateDOM.call(this, config, editor)\n    }\n  }\n}\n\nexport function getEnabledNodes({\n  editorConfig,\n  nodeViews,\n}: {\n  editorConfig: SanitizedClientEditorConfig | SanitizedServerEditorConfig\n  nodeViews?: LexicalEditorNodeMap\n}): Array<Klass<LexicalNode> | LexicalNodeReplacement> {\n  const nodes = getEnabledNodesFromServerNodes({\n    nodes: editorConfig.features.nodes,\n  })\n\n  if (nodeViews) {\n    // Apply node overrides by modifying prototypes (once globally)\n    // The overrides check per-editor at runtime using WeakMap\n    const nodeTypesToOverride = new Set<string>()\n\n    for (const [key, value] of Object.entries(nodeViews)) {\n      if (!value || typeof value !== 'object') {\n        continue\n      }\n\n      // If 'blocks' key exists with content, we need to override 'block' nodes\n      if (key === 'blocks' && Object.keys(value).length > 0) {\n        nodeTypesToOverride.add('block')\n      }\n      // If 'inlineBlocks' key exists with content, we need to override 'inlineBlock' nodes\n      else if (key === 'inlineBlocks' && Object.keys(value).length > 0) {\n        nodeTypesToOverride.add('inlineBlock')\n      }\n      // Regular node types\n      else {\n        nodeTypesToOverride.add(key)\n      }\n    }\n\n    for (const node of nodes) {\n      if ('getType' in node) {\n        const nodeType = node.getType()\n\n        if (nodeTypesToOverride.has(nodeType)) {\n          applyNodeOverride({ node, nodeType })\n        }\n      }\n    }\n  }\n\n  return nodes\n}\n\nexport function getEnabledNodesFromServerNodes({\n  nodes,\n}: {\n  nodes: Array<Klass<LexicalNode> | LexicalNodeReplacement> | Array<NodeWithHooks>\n}): Array<Klass<LexicalNode> | LexicalNodeReplacement> {\n  return nodes.map((node) => {\n    if ('node' in node) {\n      return node.node\n    }\n    return node\n  })\n}\n"],"names":["React","editorNodeViews","WeakMap","registerEditorNodeViews","editor","nodeViews","has","set","Map","editorViews","get","nodeType","value","Object","entries","blockType","viewDef","clearEditorNodeViews","delete","getEditorNodeView","node","applyNodeOverride","getType","NodeClass","prototype","_originalDecorate","decorate","_originalCreateDOM","createDOM","_decorateOverridden","hasCreateDOM","config","Component","isEditor","isJSXConverter","html","htmlContent","createElement","dangerouslySetInnerHTML","__html","Fragment","call","_createDOMOverridden","tempDiv","document","innerHTML","firstElementChild","getEnabledNodes","editorConfig","nodes","getEnabledNodesFromServerNodes","features","nodeTypesToOverride","Set","key","keys","length","add","map"],"mappings":"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"}
+{"version":3,"file":"index.js","names":["getEnabledNodes","editorConfig","getEnabledNodesFromServerNodes","nodes","features","map","node"],"sources":["../../../src/lexical/nodes/index.ts"],"sourcesContent":["import type { Klass, LexicalNode, LexicalNodeReplacement } from 'lexical'\n\nimport type { NodeWithHooks } from '../../features/typesServer.js'\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 getEnabledNodesFromServerNodes({\n    nodes: editorConfig.features.nodes,\n  })\n}\n\nexport function getEnabledNodesFromServerNodes({\n  nodes,\n}: {\n  nodes: Array<Klass<LexicalNode> | LexicalNodeReplacement> | Array<NodeWithHooks>\n}): Array<Klass<LexicalNode> | LexicalNodeReplacement> {\n  return nodes.map((node) => {\n    if ('node' in node) {\n      return node.node\n    }\n    return node\n  })\n}\n"],"mappings":"AAKA,OAAO,SAASA,gBAAgB;EAC9BC;AAAY,CAGb;EACC,OAAOC,8BAAA,CAA+B;IACpCC,KAAA,EAAOF,YAAA,CAAaG,QAAQ,CAACD;EAC/B;AACF;AAEA,OAAO,SAASD,+BAA+B;EAC7CC;AAAK,CAGN;EACC,OAAOA,KAAA,CAAME,GAAG,CAAEC,IAAA;IAChB,IAAI,UAAUA,IAAA,EAAM;MAClB,OAAOA,IAAA,CAAKA,IAAI;IAClB;IACA,OAAOA,IAAA;EACT;AACF","ignoreList":[]}

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

@@ -1,78 +1,82 @@
 'use client';
+
+import { c as _c } from "react/compiler-runtime";
 import { copyToClipboard } from '@lexical/clipboard';
 import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js';
 import { objectKlassEquals } from '@lexical/utils';
 import ObjectID from 'bson-objectid';
 import { $getSelection, $isNodeSelection, COMMAND_PRIORITY_LOW, COPY_COMMAND } from 'lexical';
 import { useEffect } from 'react';
-const changeIds = (node)=>{
-    if ('fields' in node && typeof node.fields === 'object' && node.fields !== null && 'id' in node.fields) {
-        node.fields.id = new ObjectID.default().toHexString();
-    } else if ('id' in node) {
-        node.id = new ObjectID.default().toHexString();
-    }
-    if (node.children) {
-        for (const child of node.children){
-            changeIds(child);
-        }
+const changeIds = node => {
+  if ('fields' in node && typeof node.fields === 'object' && node.fields !== null && 'id' in node.fields) {
+    node.fields.id = new ObjectID.default().toHexString();
+  } else if ('id' in node) {
+    node.id = new ObjectID.default().toHexString();
+  }
+  if (node.children) {
+    for (const child of node.children) {
+      changeIds(child);
     }
+  }
 };
 export function ClipboardPlugin() {
-    const [editor] = useLexicalComposerContext();
-    useEffect(()=>{
-        // Remove duplicated ids from clipboard. We do it here because:
-        // 1. Browsers do not allow setting the clipboardData in paste event for security reasons.
-        // 2. If you cut instead of paste, the id will be kept, which is a good thing.
-        return editor.registerCommand(COPY_COMMAND, (event)=>{
-            // Handle decorator node case
-            const selection = $getSelection();
-            if ($isNodeSelection(selection)) {
-                const node = selection.getNodes()[0];
-                const serializedNode = node?.exportJSON();
-                const deepCloneSerializedNode = JSON.parse(JSON.stringify(serializedNode));
-                changeIds(deepCloneSerializedNode);
-                const lexicalClipboardData = {
-                    namespace: editor._config.namespace,
-                    nodes: [
-                        deepCloneSerializedNode
-                    ]
-                };
-                const stringifiedLexicalClipboardData = JSON.stringify(lexicalClipboardData);
-                copyToClipboard(editor, null, {
-                    'application/x-lexical-editor': stringifiedLexicalClipboardData,
-                    'text/plain': ''
-                }).catch((error)=>{
-                    throw error;
-                });
-                return true;
-            }
-            // Handle range selection case
-            copyToClipboard(editor, objectKlassEquals(event, ClipboardEvent) ? event : null).then(()=>{
-                if (!(event instanceof ClipboardEvent) || !event.clipboardData) {
-                    throw new Error('No clipboard event');
-                }
-                const lexicalStringified = event.clipboardData.getData('application/x-lexical-editor');
-                if (!lexicalStringified) {
-                    return true;
-                }
-                const lexical = JSON.parse(lexicalStringified);
-                for (const node of lexical.nodes){
-                    changeIds(node);
-                }
-                const stringified = JSON.stringify(lexical);
-                event.clipboardData.setData('application/x-lexical-editor', stringified);
-            }).catch((error)=>{
-                if (event instanceof ClipboardEvent) {
-                    event.clipboardData?.setData('application/x-lexical-editor', '');
-                }
-                throw error;
-            });
-            return true;
-        }, COMMAND_PRIORITY_LOW);
-    }, [
-        editor
-    ]);
-    return null;
+  const $ = _c(3);
+  const [editor] = useLexicalComposerContext();
+  let t0;
+  let t1;
+  if ($[0] !== editor) {
+    t0 = () => editor.registerCommand(COPY_COMMAND, event => {
+      const selection = $getSelection();
+      if ($isNodeSelection(selection)) {
+        const node = selection.getNodes()[0];
+        const serializedNode = node?.exportJSON();
+        const deepCloneSerializedNode = JSON.parse(JSON.stringify(serializedNode));
+        changeIds(deepCloneSerializedNode);
+        const lexicalClipboardData = {
+          namespace: editor._config.namespace,
+          nodes: [deepCloneSerializedNode]
+        };
+        const stringifiedLexicalClipboardData = JSON.stringify(lexicalClipboardData);
+        copyToClipboard(editor, null, {
+          "application/x-lexical-editor": stringifiedLexicalClipboardData,
+          "text/plain": ""
+        }).catch(_temp);
+        return true;
+      }
+      copyToClipboard(editor, objectKlassEquals(event, ClipboardEvent) ? event : null).then(() => {
+        if (!(event instanceof ClipboardEvent) || !event.clipboardData) {
+          throw new Error("No clipboard event");
+        }
+        const lexicalStringified = event.clipboardData.getData("application/x-lexical-editor");
+        if (!lexicalStringified) {
+          return true;
+        }
+        const lexical = JSON.parse(lexicalStringified);
+        for (const node_0 of lexical.nodes) {
+          changeIds(node_0);
+        }
+        const stringified = JSON.stringify(lexical);
+        event.clipboardData.setData("application/x-lexical-editor", stringified);
+      }).catch(error_0 => {
+        if (event instanceof ClipboardEvent) {
+          event.clipboardData?.setData("application/x-lexical-editor", "");
+        }
+        throw error_0;
+      });
+      return true;
+    }, COMMAND_PRIORITY_LOW);
+    t1 = [editor];
+    $[0] = editor;
+    $[1] = t0;
+    $[2] = t1;
+  } else {
+    t0 = $[1];
+    t1 = $[2];
+  }
+  useEffect(t0, t1);
+  return null;
+}
+function _temp(error) {
+  throw error;
 }
-
 //# sourceMappingURL=index.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lexical/plugins/ClipboardPlugin/index.tsx"],"sourcesContent":["'use client'\n\nimport { copyToClipboard } from '@lexical/clipboard'\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js'\nimport { objectKlassEquals } from '@lexical/utils'\nimport ObjectID from 'bson-objectid'\nimport { $getSelection, $isNodeSelection, COMMAND_PRIORITY_LOW, COPY_COMMAND } from 'lexical'\nimport { useEffect } from 'react'\n\ntype SerializedUnknownLexicalNode = {\n  children?: SerializedUnknownLexicalNode[]\n  type: string\n}\n\ntype LexicalClipboardData = {\n  namespace: string\n  nodes: SerializedUnknownLexicalNode[]\n}\n\nconst changeIds = (node: SerializedUnknownLexicalNode) => {\n  if (\n    'fields' in node &&\n    typeof node.fields === 'object' &&\n    node.fields !== null &&\n    'id' in node.fields\n  ) {\n    node.fields.id = new ObjectID.default().toHexString()\n  } else if ('id' in node) {\n    node.id = new ObjectID.default().toHexString()\n  }\n\n  if (node.children) {\n    for (const child of node.children) {\n      changeIds(child)\n    }\n  }\n}\n\nexport function ClipboardPlugin() {\n  const [editor] = useLexicalComposerContext()\n\n  useEffect(() => {\n    // Remove duplicated ids from clipboard. We do it here because:\n    // 1. Browsers do not allow setting the clipboardData in paste event for security reasons.\n    // 2. If you cut instead of paste, the id will be kept, which is a good thing.\n    return editor.registerCommand(\n      COPY_COMMAND,\n      (event) => {\n        // Handle decorator node case\n        const selection = $getSelection()\n        if ($isNodeSelection(selection)) {\n          const node = selection.getNodes()[0]\n\n          const serializedNode = node?.exportJSON() as SerializedUnknownLexicalNode\n          const deepCloneSerializedNode = JSON.parse(JSON.stringify(serializedNode))\n          changeIds(deepCloneSerializedNode)\n\n          const lexicalClipboardData: LexicalClipboardData = {\n            namespace: editor._config.namespace,\n            nodes: [deepCloneSerializedNode],\n          }\n\n          const stringifiedLexicalClipboardData = JSON.stringify(lexicalClipboardData)\n\n          copyToClipboard(editor, null, {\n            'application/x-lexical-editor': stringifiedLexicalClipboardData,\n            'text/plain': '',\n          }).catch((error) => {\n            throw error\n          })\n          return true\n        }\n\n        // Handle range selection case\n        copyToClipboard(editor, objectKlassEquals(event, ClipboardEvent) ? event : null)\n          .then(() => {\n            if (!(event instanceof ClipboardEvent) || !event.clipboardData) {\n              throw new Error('No clipboard event')\n            }\n            const lexicalStringified = event.clipboardData.getData('application/x-lexical-editor')\n            if (!lexicalStringified) {\n              return true\n            }\n\n            const lexical = JSON.parse(lexicalStringified) as {\n              nodes: SerializedUnknownLexicalNode[]\n            }\n\n            for (const node of lexical.nodes) {\n              changeIds(node)\n            }\n            const stringified = JSON.stringify(lexical)\n            event.clipboardData.setData('application/x-lexical-editor', stringified)\n          })\n          .catch((error) => {\n            if (event instanceof ClipboardEvent) {\n              event.clipboardData?.setData('application/x-lexical-editor', '')\n            }\n            throw error\n          })\n        return true\n      },\n      COMMAND_PRIORITY_LOW,\n    )\n  }, [editor])\n\n  return null\n}\n"],"names":["copyToClipboard","useLexicalComposerContext","objectKlassEquals","ObjectID","$getSelection","$isNodeSelection","COMMAND_PRIORITY_LOW","COPY_COMMAND","useEffect","changeIds","node","fields","id","default","toHexString","children","child","ClipboardPlugin","editor","registerCommand","event","selection","getNodes","serializedNode","exportJSON","deepCloneSerializedNode","JSON","parse","stringify","lexicalClipboardData","namespace","_config","nodes","stringifiedLexicalClipboardData","catch","error","ClipboardEvent","then","clipboardData","Error","lexicalStringified","getData","lexical","stringified","setData"],"mappings":"AAAA;AAEA,SAASA,eAAe,QAAQ,qBAAoB;AACpD,SAASC,yBAAyB,QAAQ,2CAA0C;AACpF,SAASC,iBAAiB,QAAQ,iBAAgB;AAClD,OAAOC,cAAc,gBAAe;AACpC,SAASC,aAAa,EAAEC,gBAAgB,EAAEC,oBAAoB,EAAEC,YAAY,QAAQ,UAAS;AAC7F,SAASC,SAAS,QAAQ,QAAO;AAYjC,MAAMC,YAAY,CAACC;IACjB,IACE,YAAYA,QACZ,OAAOA,KAAKC,MAAM,KAAK,YACvBD,KAAKC,MAAM,KAAK,QAChB,QAAQD,KAAKC,MAAM,EACnB;QACAD,KAAKC,MAAM,CAACC,EAAE,GAAG,IAAIT,SAASU,OAAO,GAAGC,WAAW;IACrD,OAAO,IAAI,QAAQJ,MAAM;QACvBA,KAAKE,EAAE,GAAG,IAAIT,SAASU,OAAO,GAAGC,WAAW;IAC9C;IAEA,IAAIJ,KAAKK,QAAQ,EAAE;QACjB,KAAK,MAAMC,SAASN,KAAKK,QAAQ,CAAE;YACjCN,UAAUO;QACZ;IACF;AACF;AAEA,OAAO,SAASC;IACd,MAAM,CAACC,OAAO,GAAGjB;IAEjBO,UAAU;QACR,+DAA+D;QAC/D,0FAA0F;QAC1F,8EAA8E;QAC9E,OAAOU,OAAOC,eAAe,CAC3BZ,cACA,CAACa;YACC,6BAA6B;YAC7B,MAAMC,YAAYjB;YAClB,IAAIC,iBAAiBgB,YAAY;gBAC/B,MAAMX,OAAOW,UAAUC,QAAQ,EAAE,CAAC,EAAE;gBAEpC,MAAMC,iBAAiBb,MAAMc;gBAC7B,MAAMC,0BAA0BC,KAAKC,KAAK,CAACD,KAAKE,SAAS,CAACL;gBAC1Dd,UAAUgB;gBAEV,MAAMI,uBAA6C;oBACjDC,WAAWZ,OAAOa,OAAO,CAACD,SAAS;oBACnCE,OAAO;wBAACP;qBAAwB;gBAClC;gBAEA,MAAMQ,kCAAkCP,KAAKE,SAAS,CAACC;gBAEvD7B,gBAAgBkB,QAAQ,MAAM;oBAC5B,gCAAgCe;oBAChC,cAAc;gBAChB,GAAGC,KAAK,CAAC,CAACC;oBACR,MAAMA;gBACR;gBACA,OAAO;YACT;YAEA,8BAA8B;YAC9BnC,gBAAgBkB,QAAQhB,kBAAkBkB,OAAOgB,kBAAkBhB,QAAQ,MACxEiB,IAAI,CAAC;gBACJ,IAAI,CAAEjB,CAAAA,iBAAiBgB,cAAa,KAAM,CAAChB,MAAMkB,aAAa,EAAE;oBAC9D,MAAM,IAAIC,MAAM;gBAClB;gBACA,MAAMC,qBAAqBpB,MAAMkB,aAAa,CAACG,OAAO,CAAC;gBACvD,IAAI,CAACD,oBAAoB;oBACvB,OAAO;gBACT;gBAEA,MAAME,UAAUhB,KAAKC,KAAK,CAACa;gBAI3B,KAAK,MAAM9B,QAAQgC,QAAQV,KAAK,CAAE;oBAChCvB,UAAUC;gBACZ;gBACA,MAAMiC,cAAcjB,KAAKE,SAAS,CAACc;gBACnCtB,MAAMkB,aAAa,CAACM,OAAO,CAAC,gCAAgCD;YAC9D,GACCT,KAAK,CAAC,CAACC;gBACN,IAAIf,iBAAiBgB,gBAAgB;oBACnChB,MAAMkB,aAAa,EAAEM,QAAQ,gCAAgC;gBAC/D;gBACA,MAAMT;YACR;YACF,OAAO;QACT,GACA7B;IAEJ,GAAG;QAACY;KAAO;IAEX,OAAO;AACT"}
+{"version":3,"file":"index.js","names":["c","_c","copyToClipboard","useLexicalComposerContext","objectKlassEquals","ObjectID","$getSelection","$isNodeSelection","COMMAND_PRIORITY_LOW","COPY_COMMAND","useEffect","changeIds","node","fields","id","default","toHexString","children","child","ClipboardPlugin","$","editor","t0","t1","registerCommand","event","selection","getNodes","serializedNode","exportJSON","deepCloneSerializedNode","JSON","parse","stringify","lexicalClipboardData","namespace","_config","nodes","stringifiedLexicalClipboardData","catch","_temp","ClipboardEvent","then","clipboardData","Error","lexicalStringified","getData","lexical","node_0","stringified","setData","error_0","error"],"sources":["../../../../src/lexical/plugins/ClipboardPlugin/index.tsx"],"sourcesContent":["'use client'\n\nimport { copyToClipboard } from '@lexical/clipboard'\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js'\nimport { objectKlassEquals } from '@lexical/utils'\nimport ObjectID from 'bson-objectid'\nimport { $getSelection, $isNodeSelection, COMMAND_PRIORITY_LOW, COPY_COMMAND } from 'lexical'\nimport { useEffect } from 'react'\n\ntype SerializedUnknownLexicalNode = {\n  children?: SerializedUnknownLexicalNode[]\n  type: string\n}\n\ntype LexicalClipboardData = {\n  namespace: string\n  nodes: SerializedUnknownLexicalNode[]\n}\n\nconst changeIds = (node: SerializedUnknownLexicalNode) => {\n  if (\n    'fields' in node &&\n    typeof node.fields === 'object' &&\n    node.fields !== null &&\n    'id' in node.fields\n  ) {\n    node.fields.id = new ObjectID.default().toHexString()\n  } else if ('id' in node) {\n    node.id = new ObjectID.default().toHexString()\n  }\n\n  if (node.children) {\n    for (const child of node.children) {\n      changeIds(child)\n    }\n  }\n}\n\nexport function ClipboardPlugin() {\n  const [editor] = useLexicalComposerContext()\n\n  useEffect(() => {\n    // Remove duplicated ids from clipboard. We do it here because:\n    // 1. Browsers do not allow setting the clipboardData in paste event for security reasons.\n    // 2. If you cut instead of paste, the id will be kept, which is a good thing.\n    return editor.registerCommand(\n      COPY_COMMAND,\n      (event) => {\n        // Handle decorator node case\n        const selection = $getSelection()\n        if ($isNodeSelection(selection)) {\n          const node = selection.getNodes()[0]\n\n          const serializedNode = node?.exportJSON() as SerializedUnknownLexicalNode\n          const deepCloneSerializedNode = JSON.parse(JSON.stringify(serializedNode))\n          changeIds(deepCloneSerializedNode)\n\n          const lexicalClipboardData: LexicalClipboardData = {\n            namespace: editor._config.namespace,\n            nodes: [deepCloneSerializedNode],\n          }\n\n          const stringifiedLexicalClipboardData = JSON.stringify(lexicalClipboardData)\n\n          copyToClipboard(editor, null, {\n            'application/x-lexical-editor': stringifiedLexicalClipboardData,\n            'text/plain': '',\n          }).catch((error) => {\n            throw error\n          })\n          return true\n        }\n\n        // Handle range selection case\n        copyToClipboard(editor, objectKlassEquals(event, ClipboardEvent) ? event : null)\n          .then(() => {\n            if (!(event instanceof ClipboardEvent) || !event.clipboardData) {\n              throw new Error('No clipboard event')\n            }\n            const lexicalStringified = event.clipboardData.getData('application/x-lexical-editor')\n            if (!lexicalStringified) {\n              return true\n            }\n\n            const lexical = JSON.parse(lexicalStringified) as {\n              nodes: SerializedUnknownLexicalNode[]\n            }\n\n            for (const node of lexical.nodes) {\n              changeIds(node)\n            }\n            const stringified = JSON.stringify(lexical)\n            event.clipboardData.setData('application/x-lexical-editor', stringified)\n          })\n          .catch((error) => {\n            if (event instanceof ClipboardEvent) {\n              event.clipboardData?.setData('application/x-lexical-editor', '')\n            }\n            throw error\n          })\n        return true\n      },\n      COMMAND_PRIORITY_LOW,\n    )\n  }, [editor])\n\n  return null\n}\n"],"mappings":"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","ignoreList":[]}