WebSVN – Moodle – Diff – /lib/editor/tiny/js/tinymce/plugins/link/plugin.js

 /**
- * TinyMCE version 6.8.3 (2024-02-08)
+ * TinyMCE version 7.7.1 (2025-03-05)
  */
 (function () {
       });
       registerOption('link_quicklink', {
         processor: 'boolean',
         default: false
       });
+      registerOption('link_attributes_postprocess', { processor: 'function' });
     };
     const assumeExternalTargets = option('link_assume_external_targets');
     const hasContextToolbar = option('link_context_toolbar');
     const getLinkList = option('link_list');
     const getDefaultLinkTarget = option('link_default_target');
     const getRelList = option('link_rel_list');
     const getLinkClassList = option('link_class_list');
     const shouldShowLinkTitle = option('link_title');
     const allowUnsafeLinkTarget = option('allow_unsafe_link_target');
     const useQuickLink = option('link_quicklink');
-    var global$4 = tinymce.util.Tools.resolve('tinymce.util.Tools');
-    const getValue = item => isString(item.value) ? item.value : '';
+    const attributesPostProcess = option('link_attributes_postprocess');
-    const getText = item => {
-      if (isString(item.text)) {
-        return item.text;
-      } else if (isString(item.title)) {
-        return item.title;
-      } else {
-        return '';
-      }
-    };
-    const sanitizeList = (list, extractValue) => {
-      const out = [];
-      global$4.each(list, item => {
-        const text = getText(item);
-        if (item.menu !== undefined) {
-          const items = sanitizeList(item.menu, extractValue);
-          out.push({
-            text,
-            items
-          });
-        } else {
-          const value = extractValue(item);
-          out.push({
-            text,
-            value
-          });
-        }
-      });
-      return out;
-    };
-    const sanitizeWith = (extracter = getValue) => list => Optional.from(list).map(list => sanitizeList(list, extracter));
-    const sanitize = list => sanitizeWith(getValue)(list);
-    const createUi = (name, label) => items => ({
-      name,
-      type: 'listbox',
-      label,
-      items
-    });
-    const ListOptions = {
-      sanitize,
-      sanitizeWith,
-      createUi,
-      getValue
-    };
     const keys = Object.keys;
     const hasOwnProperty = Object.hasOwnProperty;
     const each = (obj, f) => {
       return t;
     };
     const has = (obj, key) => hasOwnProperty.call(obj, key);
     const hasNonNullableKey = (obj, key) => has(obj, key) && obj[key] !== undefined && obj[key] !== null;
+    var global$4 = tinymce.util.Tools.resolve('tinymce.util.URI');
     var global$3 = tinymce.util.Tools.resolve('tinymce.dom.TreeWalker');
-    var global$2 = tinymce.util.Tools.resolve('tinymce.util.URI');
+    var global$2 = tinymce.util.Tools.resolve('tinymce.util.Tools');
     const isAnchor = elm => isNonNullable(elm) && elm.nodeName.toLowerCase() === 'a';
       return (_b = (_a = elm.getAttribute('data-mce-href')) !== null && _a !== void 0 ? _a : elm.getAttribute('href')) !== null && _b !== void 0 ? _b : '';
     };
     const applyRelTargetRules = (rel, isUnsafe) => {
       const rules = ['noopener'];
       const rels = rel ? rel.split(/\s+/) : [];
-      const toString = rels => global$4.trim(rels.sort().join(' '));
+      const toString = rels => global$2.trim(rels.sort().join(' '));
       const addTargetRules = rels => {
         rels = removeTargetRules(rels);
         return rels.length > 0 ? rels.concat(rules) : rules;
       };
-      const removeTargetRules = rels => rels.filter(val => global$4.inArray(rules, val) === -1);
+      const removeTargetRules = rels => rels.filter(val => global$2.inArray(rules, val) === -1);
       const newRels = isUnsafe ? addTargetRules(rels) : removeTargetRules(rels);
       return newRels.length > 0 ? toString(newRels) : '';
     };
     const trimCaretContainers = text => text.replace(/\uFEFF/g, '');
     const getAnchorElement = (editor, selectedElm) => {
     const getAnchorText = (selection, anchorElm) => {
       const text = anchorElm.fold(() => selection.getContent({ format: 'text' }), anchorElm => anchorElm.innerText || anchorElm.textContent || '');
       return trimCaretContainers(text);
     };
     const getLinksInSelection = rng => collectNodesInRange(rng, isLink);
-    const getLinks$1 = elements => global$4.grep(elements, isLink);
+    const getLinks$1 = elements => global$2.grep(elements, isLink);
     const hasLinks = elements => getLinks$1(elements).length > 0;
     const hasLinksInSelection = rng => getLinksInSelection(rng).length > 0;
     const isOnlyTextSelected = editor => {
       const inlineTextElements = editor.schema.getTextInlineElements();
       const isElement = elm => elm.nodeType === 1 && !isAnchor(elm) && !has(inlineTextElements, elm.nodeName.toLowerCase());
       } else {
         return true;
+      }
     };
     const isImageFigure = elm => isNonNullable(elm) && elm.nodeName === 'FIGURE' && /\bimage\b/i.test(elm.className);
     const getLinkAttrs = data => {
       const attrs = [
         'title',
         'rel',
         'class',
         } else {
           anchorElm.textContent = text;
+        }
       });
       editor.dom.setAttribs(anchorElm, linkAttrs);
+      const rng = editor.dom.createRng();
+      rng.setStartAfter(anchorElm);
+      rng.setEndAfter(anchorElm);
-      editor.selection.select(anchorElm);
+      editor.selection.setRng(rng);
     };
     const createLink = (editor, selectedElm, text, linkAttrs) => {
       const dom = editor.dom;
       if (isImageFigure(selectedElm)) {
         linkImageFigure(dom, selectedElm, linkAttrs);
       } else {
         text.fold(() => {
           editor.execCommand('mceInsertLink', false, linkAttrs);
+          const end = editor.selection.getEnd();
+          const rng = dom.createRng();
+          rng.setStartAfter(end);
+          rng.setEndAfter(end);
+          editor.selection.setRng(rng);
         }, text => {
           editor.insertContent(dom.createHTML('a', linkAttrs, dom.encode(text)));
         });
+      }
     };
     const linkDomMutation = (editor, attachState, data) => {
       const selectedElm = editor.selection.getNode();
       const anchorElm = getAnchorElement(editor, selectedElm);
       const linkAttrs = applyLinkOverrides(editor, getLinkAttrs(data));
+      const attributesPostProcess$1 = attributesPostProcess(editor);
+      if (isNonNullable(attributesPostProcess$1)) {
+        attributesPostProcess$1(linkAttrs);
+      }
       editor.undoManager.transact(() => {
         if (data.href === attachState.href) {
           attachState.attach();
+        }
         anchorElm.fold(() => {
         allow_svg_data_urls: getOption('allow_svg_data_urls')
       };
       const href = data.href;
       return {
         ...data,
-        href: global$2.isDomSafe(href, 'a', uriOptions) ? href : ''
+        href: global$4.isDomSafe(href, 'a', uriOptions) ? href : ''
       };
     };
     const link = (editor, attachState, data) => {
       const sanitizedData = sanitizeData(editor, data);
       editor.hasPlugin('rtc', true) ? editor.execCommand('createlink', false, unwrapOptions(sanitizedData)) : linkDomMutation(editor, attachState, sanitizedData);
         (_a = img.parentNode) === null || _a === void 0 ? void 0 : _a.insertBefore(a, img);
         a.appendChild(img);
+      }
     };
+    const getValue = item => isString(item.value) ? item.value : '';
+    const getText = item => {
+      if (isString(item.text)) {
+        return item.text;
+      } else if (isString(item.title)) {
+        return item.title;
+      } else {
+        return '';
+      }
+    };
+    const sanitizeList = (list, extractValue) => {
+      const out = [];
+      global$2.each(list, item => {
+        const text = getText(item);
+        if (item.menu !== undefined) {
+          const items = sanitizeList(item.menu, extractValue);
+          out.push({
+            text,
+            items
+          });
+        } else {
+          const value = extractValue(item);
+          out.push({
+            text,
+            value
+          });
+        }
+      });
+      return out;
+    };
+    const sanitizeWith = (extracter = getValue) => list => Optional.from(list).map(list => sanitizeList(list, extracter));
+    const sanitize = list => sanitizeWith(getValue)(list);
+    const createUi = (name, label) => items => ({
+      name,
+      type: 'listbox',
+      label,
+      items
+    });
+    const ListOptions = {
+      sanitize,
+      sanitizeWith,
+      createUi,
+      getValue
+    };
     const isListGroup = item => hasNonNullableKey(item, 'items');
     const findTextByValue = (value, catalog) => findMap(catalog, item => {
       if (isListGroup(item)) {
         return findTextByValue(value, item.items);
     const ClassListOptions = { getClasses };
     const parseJson = text => {
       try {
         return Optional.some(JSON.parse(text));
-      } catch (err) {
+      } catch (_a) {
         return Optional.none();
+      }
     };
     const getLinks = editor => {
           });
         },
         onSubmit
       };
     };
-    const open$1 = editor => {
+    const open = editor => {
       const data = collectData(editor);
       data.then(info => {
         const onSubmit = handleSubmit(editor, info);
         return makeDialog(info, onSubmit, editor);
       }).then(spec => {
     };
     const register = editor => {
       editor.addCommand('mceLink', (_ui, value) => {
         if ((value === null || value === void 0 ? void 0 : value.dialog) === true || !useQuickLink(editor)) {
-          open$1(editor);
+          open(editor);
         } else {
           editor.dispatch('contexttoolbar-show', { toolbarKey: 'quicklink' });
+        }
       });
+    };
+    const setup$2 = editor => {
+      editor.addShortcut('Meta+K', '', () => {
+        editor.execCommand('mceLink');
+      });
+    };
+    const Cell = initial => {
+      let value = initial;
+      const get = () => {
+        return value;
+      };
+      const set = v => {
+        value = v;
+      };
+      return {
+        get,
+        set
+      };
+    };
+    const singleton = doRevoke => {
+      const subject = Cell(Optional.none());
+      const revoke = () => subject.get().each(doRevoke);
+      const clear = () => {
+        revoke();
+        subject.set(Optional.none());
+      };
+      const isSet = () => subject.get().isSome();
+      const get = () => subject.get();
+      const set = s => {
+        revoke();
+        subject.set(Optional.some(s));
+      };
+      return {
+        clear,
+        isSet,
+        get,
+        set
+      };
+    };
+    const value = () => {
+      const subject = singleton(noop);
+      const on = f => subject.get().each(f);
+      return {
+        ...subject,
+        on
+      };
+    };
+    const removeFromStart = (str, numChars) => {
+      return str.substring(numChars);
+    };
+    const checkRange = (str, substr, start) => substr === '' || str.length >= substr.length && str.substr(start, start + substr.length) === substr;
+    const removeLeading = (str, prefix) => {
+      return startsWith(str, prefix) ? removeFromStart(str, prefix.length) : str;
+    };
+    const startsWith = (str, prefix) => {
+      return checkRange(str, prefix, 0);
     };
     var global = tinymce.util.Tools.resolve('tinymce.util.VK');
     const appendClickRemove = (link, evt) => {
       document.body.appendChild(link);
       link.dispatchEvent(evt);
       document.body.removeChild(link);
     };
-    const open = url => {
+    const openLink = url => {
       const link = document.createElement('a');
       link.target = '_blank';
+      link.href = url;
+      link.rel = 'noreferrer noopener';
+      const evt = new MouseEvent('click', {
+        bubbles: true,
-      link.href = url;
+        cancelable: true,
-      link.rel = 'noreferrer noopener';
+        view: window
-      const evt = document.createEvent('MouseEvents');
+      });
-      evt.initMouseEvent('click', true, true, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null);
-      appendClickRemove(link, evt);
-    };
       document.dispatchEvent(evt);
-    const getLink = (editor, elm) => editor.dom.getParent(elm, 'a[href]');
+      appendClickRemove(link, evt);
-    const getSelectedLink = editor => getLink(editor, editor.selection.getStart());
+    };
     const hasOnlyAltModifier = e => {
       return e.altKey === true && e.shiftKey === false && e.ctrlKey === false && e.metaKey === false;
     };
     const gotoLink = (editor, a) => {
       if (a) {
         const href = getHref(a);
         if (/^#/.test(href)) {
-          const targetEl = editor.dom.select(href);
+          const targetEl = editor.dom.select(`${ href },[name="${ removeLeading(href, '#') }"]`);
           if (targetEl.length) {
             editor.selection.scrollIntoView(targetEl[0], true);
+          }
         } else {
-          open(a.href);
+          openLink(a.href);
         }
       }
-    };
-    const openDialog = editor => () => {
+    };
-      editor.execCommand('mceLink', false, { dialog: true });
+    const isSelectionOnImageWithEmbeddedLink = editor => {
-    };
+      const rng = editor.selection.getRng();
+      const node = rng.startContainer;
+      return isLink(node) && rng.startContainer === rng.endContainer && editor.dom.select('img', node).length === 1;
+    };
+    const getLinkFromElement = (editor, element) => {
+      const links = getLinks$1(editor.dom.getParents(element));
+      return someIf(links.length === 1, links[0]);
+    };
+    const getLinkInSelection = editor => {
+      const links = getLinksInSelection(editor.selection.getRng());
-    const gotoSelectedLink = editor => () => {
+      return someIf(links.length > 0, links[0]).or(getLinkFromElement(editor, editor.selection.getNode()));
+    };
+    const getLinkFromSelection = editor => editor.selection.isCollapsed() || isSelectionOnImageWithEmbeddedLink(editor) ? getLinkFromElement(editor, editor.selection.getStart()) : getLinkInSelection(editor);
+    const setup$1 = editor => {
+      const selectedLink = value();
+      const getSelectedLink = () => selectedLink.get().or(getLinkFromSelection(editor));
+      const gotoSelectedLink = () => getSelectedLink().each(link => gotoLink(editor, link));
+      editor.on('contextmenu', e => {
+        getLinkFromElement(editor, e.target).each(selectedLink.set);
+      });
+      editor.on('SelectionChange', () => {
+        if (!selectedLink.isSet()) {
-      gotoLink(editor, getSelectedLink(editor));
+          getLinkFromSelection(editor).each(selectedLink.set);
+        }
-    };
+      });
-    const setupGotoLinks = editor => {
+      editor.on('click', e => {
-      editor.on('click', e => {
+        selectedLink.clear();
-        const link = getLink(editor, e.target);
+        const links = getLinks$1(editor.dom.getParents(e.target));
-        if (link && global.metaKeyPressed(e)) {
+        if (links.length === 1 && global.metaKeyPressed(e)) {
           e.preventDefault();
-          gotoLink(editor, link);
+          gotoLink(editor, links[0]);
+        }
       });
-      });
+      editor.on('keydown', e => {
-      editor.on('keydown', e => {
-        if (!e.isDefaultPrevented() && e.keyCode === 13 && hasOnlyAltModifier(e)) {
+        selectedLink.clear();
-          const link = getSelectedLink(editor);
+        if (!e.isDefaultPrevented() && e.keyCode === 13 && hasOnlyAltModifier(e)) {
-          if (link) {
+          getSelectedLink().each(link => {
             e.preventDefault();
             gotoLink(editor, link);
+          });
+        }
+      });
+      return { gotoSelectedLink };
+    };
     const openDialog = editor => () => {
-      });
+      editor.execCommand('mceLink', false, { dialog: true });
     };
     const toggleState = (editor, toggler) => {
         api.setEnabled(editor.selection.isEditable());
       };
       updateState();
       return toggleState(editor, updateState);
     };
-    const hasExactlyOneLinkInSelection = editor => {
-      const links = editor.selection.isCollapsed() ? getLinks$1(editor.dom.getParents(editor.selection.getStart())) : getLinksInSelection(editor.selection.getRng());
-      return links.length === 1;
-    };
-    const toggleGotoLinkState = editor => api => {
+    const toggleRequiresLinkState = editor => api => {
-      const updateState = () => api.setEnabled(hasExactlyOneLinkInSelection(editor));
-      updateState();
-      return toggleState(editor, updateState);
-    };
-    const toggleUnlinkState = editor => api => {
       const hasLinks$1 = parents => hasLinks(parents) || hasLinksInSelection(editor.selection.getRng());
       const parents = editor.dom.getParents(editor.selection.getStart());
       const updateEnabled = parents => {
         api.setEnabled(hasLinks$1(parents) && editor.selection.isEditable());
       };
       updateEnabled(parents);
       return toggleState(editor, e => updateEnabled(e.parents));
     };
-    const setup = editor => {
-      editor.addShortcut('Meta+K', '', () => {
-        editor.execCommand('mceLink');
-      });
-    };
-    const setupButtons = editor => {
+    const setupButtons = (editor, openLink) => {
       editor.ui.registry.addToggleButton('link', {
         icon: 'link',
         tooltip: 'Insert/edit link',
+        shortcut: 'Meta+K',
         onAction: openDialog(editor),
         onSetup: toggleLinkState(editor)
       });
       editor.ui.registry.addButton('openlink', {
         icon: 'new-tab',
         tooltip: 'Open link',
-        onAction: gotoSelectedLink(editor),
+        onAction: openLink.gotoSelectedLink,
-        onSetup: toggleGotoLinkState(editor)
+        onSetup: toggleRequiresLinkState(editor)
       });
       editor.ui.registry.addButton('unlink', {
         icon: 'unlink',
         tooltip: 'Remove link',
         onAction: () => unlink(editor),
-        onSetup: toggleUnlinkState(editor)
+        onSetup: toggleRequiresLinkState(editor)
       });
     };
-    const setupMenuItems = editor => {
+    const setupMenuItems = (editor, openLink) => {
       editor.ui.registry.addMenuItem('openlink', {
         text: 'Open link',
         icon: 'new-tab',
-        onAction: gotoSelectedLink(editor),
+        onAction: openLink.gotoSelectedLink,
-        onSetup: toggleGotoLinkState(editor)
+        onSetup: toggleRequiresLinkState(editor)
       });
       editor.ui.registry.addMenuItem('link', {
         icon: 'link',
         text: 'Link...',
         shortcut: 'Meta+K',
-        onSetup: toggleLinkMenuState(editor),
+        onAction: openDialog(editor),
-        onAction: openDialog(editor)
+        onSetup: toggleLinkMenuState(editor)
       });
       editor.ui.registry.addMenuItem('unlink', {
         icon: 'unlink',
         text: 'Remove link',
         onAction: () => unlink(editor),
-        onSetup: toggleUnlinkState(editor)
+        onSetup: toggleRequiresLinkState(editor)
       });
     };
     const setupContextMenu = editor => {
       const inLink = 'link unlink openlink';
       const noLink = 'link';
+          }
           return hasLinks(editor.dom.getParents(element, 'a')) ? inLink : noLink;
+        }
       });
     };
-    const setupContextToolbars = editor => {
+    const setupContextToolbars = (editor, openLink) => {
       const collapseSelectionToEnd = editor => {
         editor.selection.collapse(false);
       };
       const onSetupLink = buttonApi => {
         const node = editor.selection.getNode();
-        buttonApi.setEnabled(isInAnchor(editor, node));
+        buttonApi.setEnabled(isInAnchor(editor, node) && editor.selection.isEditable());
         return noop;
       };
       const getLinkText = value => {
         const anchor = getAnchorElement(editor);
         const onlyText = isOnlyTextSelected(editor);
               link(editor, attachState, {
                 href: value,
                 text,
                 title: Optional.none(),
                 rel: Optional.none(),
-                target: Optional.none(),
+                target: Optional.from(getDefaultLinkTarget(editor)),
                 class: Optional.none()
               });
               collapseSelectionToEnd(editor);
               formApi.hide();
+            }
             type: 'contextformbutton',
             icon: 'new-tab',
             tooltip: 'Open link',
             onSetup: onSetupLink,
             onAction: formApi => {
-              gotoSelectedLink(editor)();
+              openLink.gotoSelectedLink();
               formApi.hide();
+            }
+          }
+        ]
       });
     };
+    const setup = editor => {
+      const openLink = setup$1(editor);
+      setupButtons(editor, openLink);
+      setupMenuItems(editor, openLink);
+      setupContextMenu(editor);
+      setupContextToolbars(editor, openLink);
+    };
     var Plugin = () => {
       global$5.add('link', editor => {
-        register$1(editor);
-        setupButtons(editor);
-        setupMenuItems(editor);
-        setupContextMenu(editor);
-        setupContextToolbars(editor);
-        setupGotoLinks(editor);
+        register$1(editor);
         register(editor);
+        setup(editor);
-        setup(editor);
+        setup$2(editor);
       });
     };

Proyectos de Subversion Moodle

(root)/lib/editor/tiny/js/tinymce/plugins/link/plugin.js – Rev 1 → 1441