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

 /**
- * TinyMCE version 6.8.3 (2024-02-08)
+ * TinyMCE version 7.7.1 (2025-03-05)
  */
 (function () {
       return Optional.from(cs[index]).map(SugarElement.fromDom);
     };
     const firstChild = element => child$3(element, 0);
-    const isShadowRoot = dos => isDocumentFragment(dos) && isNonNullable(dos.dom.host);
-    const supported = isFunction(Element.prototype.attachShadow) && isFunction(Node.prototype.getRootNode);
+    const isShadowRoot = dos => isDocumentFragment(dos) && isNonNullable(dos.dom.host);
-    const getRootNode = supported ? e => SugarElement.fromDom(e.dom.getRootNode()) : documentOrOwner;
+    const getRootNode = e => SugarElement.fromDom(e.dom.getRootNode());
     const getShadowRoot = e => {
       const r = getRootNode(e);
       return isShadowRoot(r) ? Optional.some(r) : Optional.none();
     };
     const fromRgba = rgbaColour => {
       const value = toHex(rgbaColour.red) + toHex(rgbaColour.green) + toHex(rgbaColour.blue);
       return hexColour(value);
     };
-    const rgbRegex = /^\s*rgb\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)\s*$/i;
+    const rgbRegex = /^\s*rgb\s*\(\s*(\d+)\s*[,\s]\s*(\d+)\s*[,\s]\s*(\d+)\s*\)\s*$/i;
-    const rgbaRegex = /^\s*rgba\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d?(?:\.\d+)?)\s*\)\s*$/i;
+    const rgbaRegex = /^\s*rgba\s*\(\s*(\d+)\s*[,\s]\s*(\d+)\s*[,\s]\s*(\d+)\s*[,\s]\s*((?:\d?\.\d+|\d+)%?)\s*\)\s*$/i;
     const rgbaColour = (red, green, blue, alpha) => ({
       red,
       green,
       blue,
       const b = parseInt(blue, 10);
       const a = parseFloat(alpha);
       return rgbaColour(r, g, b, a);
     };
     const fromString = rgbaString => {
-      if (rgbaString === 'transparent') {
-        return Optional.some(rgbaColour(0, 0, 0, 0));
-      }
       const rgbMatch = rgbRegex.exec(rgbaString);
       if (rgbMatch !== null) {
         return Optional.some(fromStringValues(rgbMatch[1], rgbMatch[2], rgbMatch[3], '1'));
+      }
       const rgbaMatch = rgbaRegex.exec(rgbaString);
           text,
           value: item.value
         };
+      }
     });
+    const buildClassList = classList => {
+      if (!classList.length) {
+        return Optional.none();
+      }
+      return Optional.some(buildListItems([
+        {
+          text: 'Select...',
+          value: 'mce-no-match'
+        },
+        ...classList
+      ]));
+    };
     const buildMenuItems = (editor, items, format, onAction) => map(items, item => {
       const text = item.text || item.title;
       if (isListGroup(item)) {
         return {
           type: 'nestedmenuitem',
       const currentType = editor.queryCommandValue('mceTableColType');
       const newType = currentType === 'th' ? 'td' : 'th';
       editor.execCommand('mceTableColType', false, { type: newType });
     };
-    const getClassList$1 = editor => {
-      const classes = buildListItems(getCellClassList(editor));
-      if (classes.length > 0) {
-        return Optional.some({
+    const getClassList$1 = editor => buildClassList(getCellClassList(editor)).map(items => ({
-          name: 'class',
+      name: 'class',
-          type: 'listbox',
+      type: 'listbox',
-          label: 'Class',
-          items: classes
+      label: 'Class',
-        });
-      }
-      return Optional.none();
+      items
-    };
+    }));
     const children = [
+      {
         name: 'width',
         type: 'input',
         label: 'Width'
       },
-      {
-        name: 'height',
-        type: 'input',
-        label: 'Height'
-      },
+      {
         name: 'celltype',
         type: 'listbox',
         label: 'Cell type',
         items: [
         each(keys(baseData), key => {
           each$1(items, (itemValue, itemKey) => {
             const comparisonValue = baseData[key];
             if (comparisonValue !== '' && key === itemKey) {
               if (comparisonValue !== itemValue) {
-                baseData[key] = '';
+                baseData[key] = key === 'class' ? 'mce-no-match' : '';
+              }
+            }
           });
         });
       });
       const dom = editor.dom;
       const colElm = column.getOr(cell);
       const getStyle = (element, style) => dom.getStyle(element, style) || dom.getAttrib(element, style);
       return {
         width: getStyle(colElm, 'width'),
-        height: getStyle(cell, 'height'),
         scope: dom.getAttrib(cell, 'scope'),
         celltype: getNodeName(cell),
         class: dom.getAttrib(cell, 'class', ''),
         halign: getHAlignment(editor, cell),
         valign: getVAlignment(editor, cell),
     };
     const updateSimpleProps$1 = (modifier, colModifier, data, shouldUpdate) => {
       if (shouldUpdate('scope')) {
         modifier.setAttrib('scope', data.scope);
+      }
-      if (shouldUpdate('class')) {
+      if (shouldUpdate('class') && data.class !== 'mce-no-match') {
         modifier.setAttrib('class', data.class);
+      }
-      if (shouldUpdate('height')) {
-        modifier.setStyle('height', addPxSuffix(data.height));
-      }
       if (shouldUpdate('width')) {
         colModifier.setStyle('width', addPxSuffix(data.width));
+      }
     };
     const updateAdvancedProps$1 = (modifier, data, shouldUpdate) => {
         initialData: data,
         onSubmit: curry(onSubmitCellForm, editor, cells, data)
       });
     };
-    const getClassList = editor => {
-      const classes = buildListItems(getRowClassList(editor));
-      if (classes.length > 0) {
-        return Optional.some({
+    const getClassList = editor => buildClassList(getRowClassList(editor)).map(items => ({
-          name: 'class',
+      name: 'class',
-          type: 'listbox',
+      type: 'listbox',
-          label: 'Class',
-          items: classes
+      label: 'Class',
-        });
-      }
-      return Optional.none();
+      items
-    };
+    }));
     const formChildren = [
+      {
         type: 'listbox',
         name: 'type',
+      }
     ];
     const getItems$1 = editor => formChildren.concat(getClassList(editor).toArray());
     const updateSimpleProps = (modifier, data, shouldUpdate) => {
-      if (shouldUpdate('class')) {
+      if (shouldUpdate('class') && data.class !== 'mce-no-match') {
         modifier.setAttrib('class', data.class);
+      }
       if (shouldUpdate('height')) {
         modifier.setStyle('height', addPxSuffix(data.height));
     };
     const applyStyleData = (editor, rows, data, wasChanged) => {
       const isSingleRow = rows.length === 1;
       const shouldOverrideCurrentValue = isSingleRow ? always : wasChanged;
       each(rows, rowElm => {
+        const rowCells = children$1(SugarElement.fromDom(rowElm), 'td,th');
         const modifier = DomModifier.normal(editor, rowElm);
         updateSimpleProps(modifier, data, shouldOverrideCurrentValue);
         if (hasAdvancedRowTab(editor)) {
           updateAdvancedProps(modifier, data, shouldOverrideCurrentValue);
+        }
+        if (wasChanged('height')) {
+          each(rowCells, cell => {
+            editor.dom.setStyle(cell.dom, 'height', null);
+          });
+        }
         if (wasChanged('align')) {
           setAlign(editor, rowElm, data.align);
+        }
       });
     };
               value: 'right'
+            }
+          ]
         }];
       const classListItem = classes.length > 0 ? [{
-          type: 'listbox',
           name: 'class',
+          type: 'listbox',
           label: 'Class',
           items: classes
         }] : [];
       return rowColCountItems.concat(alwaysItems).concat(appearanceItems).concat(alignmentItem).concat(classListItem);
     };
       const dom = editor.dom;
       const attrs = {};
       const styles = {};
       const shouldStyleWithCss$1 = shouldStyleWithCss(editor);
       const hasAdvancedTableTab$1 = hasAdvancedTableTab(editor);
+      const borderIsZero = parseFloat(data.border) === 0;
-      if (!isUndefined(data.class)) {
+      if (!isUndefined(data.class) && data.class !== 'mce-no-match') {
         attrs.class = data.class;
+      }
       styles.height = addPxSuffix(data.height);
       if (shouldStyleWithCss$1) {
         styles.width = addPxSuffix(data.width);
       } else if (dom.getAttrib(tableElm, 'width')) {
         attrs.width = removePxSuffix(data.width);
+      }
       if (shouldStyleWithCss$1) {
+        if (borderIsZero) {
+          attrs.border = 0;
+          styles['border-width'] = '';
+        } else {
-        styles['border-width'] = addPxSuffix(data.border);
+          styles['border-width'] = addPxSuffix(data.border);
+          attrs.border = 1;
+        }
         styles['border-spacing'] = addPxSuffix(data.cellspacing);
       } else {
-        attrs.border = data.border;
+        attrs.border = borderIsZero ? 0 : data.border;
         attrs.cellpadding = data.cellpadding;
         attrs.cellspacing = data.cellspacing;
+      }
       if (shouldStyleWithCss$1 && tableElm.children) {
         const cellStyles = {};
+        if (borderIsZero) {
+          cellStyles['border-width'] = '';
-        if (shouldApplyOnCell.border) {
+        } else if (shouldApplyOnCell.border) {
           cellStyles['border-width'] = addPxSuffix(data.border);
+        }
         if (shouldApplyOnCell.cellpadding) {
           cellStyles.padding = addPxSuffix(data.cellpadding);
+        }
     const onSubmitTableForm = (editor, tableElm, oldData, api) => {
       const dom = editor.dom;
       const data = api.getData();
       const modifiedData = filter$1(data, (value, key) => oldData[key] !== value);
       api.close();
-      if (data.class === '') {
-        delete data.class;
-      }
       editor.undoManager.transact(() => {
         if (!tableElm) {
           const cols = toInt(data.cols).getOr(1);
           const rows = toInt(data.rows).getOr(1);
           editor.execCommand('mceInsertTable', false, {
             data.bordercolor = '';
             data.backgroundcolor = '';
+          }
+        }
+      }
-      const classes = buildListItems(getTableClassList(editor));
+      const classes = buildClassList(getTableClassList(editor));
-      if (classes.length > 0) {
+      if (classes.isSome()) {
         if (data.class) {
           data.class = data.class.replace(/\s*mce\-item\-table\s*/g, '');
+        }
+      }
       const generalPanel = {
         type: 'grid',
         columns: 2,
-        items: getItems(editor, classes, insertNewTable)
+        items: getItems(editor, classes.getOr([]), insertNewTable)
       };
       const nonAdvancedForm = () => ({
         type: 'panel',
         items: [generalPanel]
       });

Proyectos de Subversion Moodle

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