@limetech/lime-elements 38.13.0 → 38.13.2

package/dist/esm/limel-prosemirror-adapter.entry.js

@@ -1,4 +1,5 @@
 import { r as registerInstance, c as createEvent, h, H as Host, g as getElement } from './index-2714248e.js';
+import { g as getLinkAttributes, d as decodeHTML, m as markdownToHTML, s as sanitizeHTML } from './markdown-parser-41d15994.js';
 import { k as keys$1, g as getSymbols, U as Uint8Array, a as Stack, i as getAllKeys } from './_baseIsEqual-7961b1ee.js';
 import { a as assignValue } from './_assignValue-1f62c5ff.js';
 import { b as baseAssignValue } from './_baseAssignValue-ba9887b3.js';
@@ -8,19 +9,18 @@ import { d as isPrototype, g as getTag, e as baseUnary, n as nodeUtil, a as isBu
 import { g as getPrototype } from './_getPrototype-8096728a.js';
 import { i as isArray } from './isArray-80298bc7.js';
 import { i as isObjectLike } from './isObjectLike-38996507.js';
-import { d as decodeHTML, m as markdownToHTML, s as sanitizeHTML } from './markdown-parser-1c1fdedc.js';
 import { t as translate$1 } from './translations-489f20b3.js';
 import { c as createRandomString } from './random-string-e74dc48d.js';
 import { i as isItem } from './isItem-b0459122.js';
 import { c as createFileInfo } from './files-2be62a61.js';
 import { i as isEqual } from './isEqual-2c139334.js';
 import { d as debounce } from './debounce-9a05c91c.js';
+import './_commonjsHelpers-9b95d21f.js';
 import './eq-c1c7f528.js';
 import './_getNative-93d6bfe9.js';
 import './_isIndex-6de44c7b.js';
 import './isArrayLike-6597c815.js';
 import './_defineProperty-2105cb48.js';
-import './_commonjsHelpers-9b95d21f.js';
 import './file-metadata-01403ecd.js';
 import './get-icon-props-5a77e17e.js';
 import './toNumber-a6ed64f0.js';
@@ -16898,24 +16898,15 @@ const setActiveMethodForWrap = (command, nodeType) => {
 const createInsertLinkCommand = (schema, _, link) => {
   const command = (state, dispatch) => {
     const { from, to } = state.selection;
+    const linkMark = schema.marks.link.create(getLinkAttributes(link.href, link.href));
     if (from === to) {
       // If no text is selected, insert new text with link
-      const linkMark = schema.marks.link.create({
-        href: link.href,
-        title: link.href,
-        target: isExternalLink(link.href) ? '_blank' : null,
-      });
       const linkText = link.text || link.href;
       const newLink = schema.text(linkText, [linkMark]);
       dispatch(state.tr.insert(from, newLink));
     }
     else {
       // If text is selected, replace selected text with link text
-      const linkMark = schema.marks.link.create({
-        href: link.href,
-        title: link.href,
-        target: isExternalLink(link.href) ? '_blank' : null,
-      });
       const selectedText = state.doc.textBetween(from, to, ' ');
       const newLink = schema.text(link.text || selectedText, [linkMark]);
       dispatch(state.tr.replaceWith(from, to, newLink));
@@ -16989,15 +16980,6 @@ const toggleNodeType = (schema, type, attrs = {}, shouldWrap = false) => {
     return false;
   };
 };
-const isValidUrl = (text) => {
-  try {
-    new URL(text);
-  }
-  catch (_a) {
-    return false;
-  }
-  return true;
-};
 const createSetNodeTypeCommand = (schema, nodeType, level) => {
   const type = schema.nodes[nodeType];
   if (!type) {
@@ -17070,27 +17052,6 @@ const createListCommand = (schema, listType) => {
   setActiveMethodForWrap(command, type);
   return command;
 };
-const copyPasteLinkCommand = (state, dispatch) => {
-  const { from, to } = state.selection;
-  if (from === to) {
-    return false;
-  }
-  const clipboardData = window.clipboardData;
-  if (!clipboardData) {
-    return false;
-  }
-  const copyPastedText = clipboardData.getData('text');
-  if (!isValidUrl(copyPastedText)) {
-    return false;
-  }
-  const linkMark = state.schema.marks.link.create({
-    href: copyPastedText,
-    target: isExternalLink(copyPastedText) ? '_blank' : null,
-  });
-  const selectedText = state.doc.textBetween(from, to, ' ');
-  const newLink = state.schema.text(selectedText, [linkMark]);
-  dispatch(state.tr.replaceWith(from, to, newLink));
-};
 const commandMapping = {
   strong: createToggleMarkCommand,
   em: createToggleMarkCommand,
@@ -17129,7 +17090,6 @@ class MenuCommandFactory {
       'Mod-Shift-X': this.getCommand(EditorMenuTypes.Strikethrough),
       'Mod-`': this.getCommand(EditorMenuTypes.Code),
       'Mod-Shift-C': this.getCommand(EditorMenuTypes.CodeBlock),
-      'Mod-v': copyPasteLinkCommand,
     };
   }
 }
@@ -26256,32 +26216,145 @@ const processClickEvent = (view, event) => {
   }, DOUBLE_CLICK_DELAY);
   return true;
 };
-const processPasteEvent$1 = (view, event) => {
-  const clipboardData = event.clipboardData;
-  if (!clipboardData) {
+/**
+ * Regular expression for matching URLs, mailto links, and phone links
+ */
+const URL_REGEX = /(https?:\/\/[^\s<>"']+|mailto:[^\s<>"']+|tel:[^\s<>"']+)/g;
+/**
+ * Checks if the text contains any URLs, mailto links, or phone links
+ */
+const hasUrls = (text) => {
+  // Reset regex before use
+  URL_REGEX.lastIndex = 0;
+  return URL_REGEX.test(text);
+};
+/**
+ * Creates a text node with the provided content
+ */
+const createTextNode = (schema, content) => {
+  return schema.text(content);
+};
+/**
+ * Creates a link node with the provided URL
+ */
+const createLinkNode = (schema, url) => {
+  const linkMark = schema.marks.link.create(getLinkAttributes(url, url));
+  return schema.text(url, [linkMark]);
+};
+/**
+ * Finds all link matches in the provided text
+ */
+const findLinkMatches = (text) => {
+  const matches = [];
+  let match;
+  // Reset regex before use
+  URL_REGEX.lastIndex = 0;
+  while ((match = URL_REGEX.exec(text)) !== null) {
+    matches.push({
+      url: match[0],
+      start: match.index,
+      end: match.index + match[0].length,
+    });
+  }
+  return matches;
+};
+/**
+ * Creates text nodes with links for any URLs, mailto links, or phone links found in the text
+ */
+const createNodesWithLinks = (text, schema) => {
+  const nodes = [];
+  const matches = findLinkMatches(text);
+  if (matches.length === 0) {
+    // No links found, just return the text as a single node
+    return [createTextNode(schema, text)];
+  }
+  let lastIndex = 0;
+  // Process each match
+  for (const match of matches) {
+    // Add text before the current link if any
+    if (match.start > lastIndex) {
+      nodes.push(createTextNode(schema, text.slice(lastIndex, match.start)));
+    }
+    // Add the link node
+    nodes.push(createLinkNode(schema, match.url));
+    lastIndex = match.end;
+  }
+  // Add any remaining text after the last link
+  if (lastIndex < text.length) {
+    nodes.push(createTextNode(schema, text.slice(lastIndex)));
+  }
+  return nodes;
+};
+/**
+ * Pastes nodes at the current selection
+ * @param view - The editor view
+ * @param nodes - Array of nodes to paste
+ */
+const pasteAsLink = (view, nodes) => {
+  if (nodes.length === 0) {
+    return;
+  }
+  if (isSingleLinkNode(nodes)) {
+    insertSingleLink(view, nodes[0]);
+  }
+  else {
+    insertNodeFragment(view, nodes);
+  }
+};
+/**
+ * Checks if the nodes array contains just a single link node
+ */
+const isSingleLinkNode = (nodes) => {
+  if (nodes.length !== 1) {
     return false;
   }
-  const text = clipboardData.getData('text/plain');
-  // Process as a link if the text is a valid URL
-  if (isValidUrl(text)) {
-    pasteAsLink(view, text);
-    return true;
+  const node = nodes[0];
+  // Must be text with non-empty content
+  if (!node.isText || !node.text || node.text.trim() === '') {
+    return false;
   }
-  return false;
+  // Must have a link mark (even if there are other marks, we just care about link presence)
+  return !!node.marks.find((mark) => mark.type.name === 'link');
 };
-const pasteAsLink = (view, href) => {
+/**
+ * Inserts a single link node, applying it to selected text if present
+ */
+const insertSingleLink = (view, linkNode) => {
   const { state, dispatch } = view;
   const { from, to } = state.selection;
-  const linkMark = schema$1.marks.link.create({
-    href: href,
-    title: href,
-    target: isExternalLink(href) ? '_blank' : null,
-  });
-  const selectedText = state.doc.textBetween(from, to, ' ') || href;
-  const transaction = state.tr
+  const linkMark = linkNode.marks.find((mark) => mark.type.name === 'link');
+  // Use selected text if there's a selection, otherwise use the URL
+  const selectedText = state.doc.textBetween(from, to, ' ') || linkMark.attrs.href;
+  // Insert the text and add the link mark
+  dispatch(state.tr
     .insertText(selectedText, from, to)
-    .addMark(from, from + selectedText.length, linkMark);
-  dispatch(transaction);
+    .addMark(from, from + selectedText.length, linkMark));
+};
+/**
+ * Inserts multiple nodes as a fragment at the current selection
+ * @param view - The editor view
+ * @param nodes - Array of nodes to insert
+ */
+const insertNodeFragment = (view, nodes) => {
+  const { state, dispatch } = view;
+  const { from, to } = state.selection;
+  // Create a fragment from the array of nodes
+  const fragment = Fragment.fromArray(nodes);
+  // Replace the current selection with the fragment
+  dispatch(state.tr.replaceWith(from, to, fragment));
+};
+/**
+ * Handles pasted content, converting URLs to links
+ */
+const processPasteEvent$1 = (view, event) => {
+  var _a;
+  const text = (_a = event.clipboardData) === null || _a === void 0 ? void 0 : _a.getData('text/plain');
+  if (!text || !hasUrls(text)) {
+    return false;
+  }
+  const nodes = createNodesWithLinks(text, view.state.schema);
+  pasteAsLink(view, nodes);
+  return true;
 };
 const createLinkPlugin = (updateLinkCallback) => {
   return new Plugin({
@@ -26323,6 +26396,39 @@ const createLinkPlugin = (updateLinkCallback) => {
   });
 };
 
+const linkMarkSpec = {
+  attrs: {
+    href: { default: '' },
+    title: { default: null },
+    target: { default: null },
+    rel: { default: null },
+    referrerpolicy: { default: null },
+  },
+  inclusive: false,
+  parseDOM: [
+    {
+      tag: 'a[href]',
+      getAttrs: (dom) => {
+        return {
+          href: dom.getAttribute('href') || '',
+          title: dom.getAttribute('title'),
+          target: dom.getAttribute('target'),
+          rel: dom.getAttribute('rel'),
+          referrerpolicy: dom.getAttribute('referrerpolicy'),
+        };
+      },
+    },
+  ],
+  toDOM: (mark) => {
+    const target = mark.attrs.target || null;
+    const securityAttrs = {
+      rel: target === '_blank' ? 'noopener noreferrer' : null,
+      referrerpolicy: target === '_blank' ? 'noreferrer' : null,
+    };
+    return ['a', Object.assign(Object.assign({}, mark.attrs), securityAttrs), 0];
+  },
+};
+
 const pluginKey = new PluginKey('imageInserterPlugin');
 const createImageInserterPlugin = (imagePastedCallback) => {
   return new Plugin({
@@ -26454,9 +26560,29 @@ const processPasteEvent = (view, event, slice) => {
   if (!clipboardData) {
     return false;
   }
+  const isImageFilePasted = handlePastedImages(view, clipboardData);
+  const filteredSlice = new Slice(filterImageNodes(slice.content), slice.openStart, slice.openEnd);
+  if (filteredSlice.content.childCount < slice.content.childCount) {
+    const { state, dispatch } = view;
+    const tr = state.tr.replaceSelection(filteredSlice);
+    dispatch(tr);
+    return true;
+  }
+  return isImageFilePasted;
+};
+/**
+ * Processes any image files found in the clipboard data and dispatches an imagePasted event.
+ *
+ * @param view - The ProseMirror editor view
+ * @param clipboardData - The clipboard data transfer object containing potential image files
+ * @returns True if at least one valid image file was found and processed, false otherwise
+ */
+function handlePastedImages(view, clipboardData) {
+  let isImageFilePasted = false;
   const files = Array.from(clipboardData.files || []);
   for (const file of files) {
-    if (file.type.startsWith('image/')) {
+    if (isImageFile(file, clipboardData)) {
+      isImageFilePasted = true;
       const reader = new FileReader();
       reader.onloadend = () => {
         view.dom.dispatchEvent(new CustomEvent('imagePasted', {
@@ -26466,15 +26592,45 @@ const processPasteEvent = (view, event, slice) => {
       reader.readAsDataURL(file);
     }
   }
-  const filteredSlice = new Slice(filterImageNodes(slice.content), slice.openStart, slice.openEnd);
-  if (filteredSlice.content.childCount < slice.content.childCount) {
-    const { state, dispatch } = view;
-    const tr = state.tr.replaceSelection(filteredSlice);
-    dispatch(tr);
-    return true;
+  return isImageFilePasted;
+}
+/**
+ * Determines if a file is an image that should be processed by the image handler.
+ *
+ * This function checks both the file's MIME type and the clipboard HTML content.
+ * It filters out HTML content from Excel and HTML tables, as they are not relevant for image processing.
+ *
+ * @param file - The file object to check
+ * @param clipboardData - The full clipboard data transfer object to examine for context
+ * @returns True if the file is an image that should be processed, false otherwise
+ */
+function isImageFile(file, clipboardData) {
+  var _a, _b;
+  if (!isContentTypeImage(file)) {
+    return false;
   }
-  return files.length > 0;
-};
+  const html = (_b = (_a = clipboardData === null || clipboardData === void 0 ? void 0 : clipboardData.getData('text/html')) === null || _a === void 0 ? void 0 : _a.toLowerCase()) !== null && _b !== void 0 ? _b : '';
+  return !isHtmlFromExcel(html) && !isHtmlTable(html);
+}
+function isContentTypeImage(file) {
+  if (!(file === null || file === void 0 ? void 0 : file.type)) {
+    return false;
+  }
+  return file.type.startsWith('image/');
+}
+function isHtmlFromExcel(html) {
+  if (!html) {
+    return false;
+  }
+  return (html.includes('name=generator content="microsoft excel"') ||
+    html.includes('xmlns:x="urn:schemas-microsoft-com:office:excel"'));
+}
+function isHtmlTable(html) {
+  if (!html) {
+    return false;
+  }
+  return html.includes('<table');
+}
 
 const MIN_WIDTH = 10;
 const createImageViewPlugin = (language) => {
@@ -28660,6 +28816,7 @@ const ProsemirrorAdapter = class {
       nodes: nodes,
       marks: schema$1.spec.marks.append({
         strikethrough: strikethrough,
+        link: linkMarkSpec,
       }),
     });
   }