[Summary view] [Print] [Text view]

   1  /**
   2   * Copyright (c) Tiny Technologies, Inc. All rights reserved.
   3   * Licensed under the LGPL or a commercial license.
   4   * For LGPL see License.txt in the project root for license information.
   5   * For commercial licenses see https://www.tiny.cloud/
   6   *
   7   * Version: 5.10.5 (2022-05-25)
   8   */
   9  (function () {
  10      'use strict';
  11  
  12      var global$4 = tinymce.util.Tools.resolve('tinymce.PluginManager');
  13  
  14      var typeOf = function (x) {
  15        var t = typeof x;
  16        if (x === null) {
  17          return 'null';
  18        } else if (t === 'object' && (Array.prototype.isPrototypeOf(x) || x.constructor && x.constructor.name === 'Array')) {
  19          return 'array';
  20        } else if (t === 'object' && (String.prototype.isPrototypeOf(x) || x.constructor && x.constructor.name === 'String')) {
  21          return 'string';
  22        } else {
  23          return t;
  24        }
  25      };
  26      var isType = function (type) {
  27        return function (value) {
  28          return typeOf(value) === type;
  29        };
  30      };
  31      var isString = isType('string');
  32      var isArray = isType('array');
  33  
  34      var global$3 = tinymce.util.Tools.resolve('tinymce.dom.DOMUtils');
  35  
  36      var global$2 = tinymce.util.Tools.resolve('tinymce.EditorManager');
  37  
  38      var global$1 = tinymce.util.Tools.resolve('tinymce.Env');
  39  
  40      var global = tinymce.util.Tools.resolve('tinymce.util.Tools');
  41  
  42      var shouldMergeClasses = function (editor) {
  43        return editor.getParam('importcss_merge_classes');
  44      };
  45      var shouldImportExclusive = function (editor) {
  46        return editor.getParam('importcss_exclusive');
  47      };
  48      var getSelectorConverter = function (editor) {
  49        return editor.getParam('importcss_selector_converter');
  50      };
  51      var getSelectorFilter = function (editor) {
  52        return editor.getParam('importcss_selector_filter');
  53      };
  54      var getCssGroups = function (editor) {
  55        return editor.getParam('importcss_groups');
  56      };
  57      var shouldAppend = function (editor) {
  58        return editor.getParam('importcss_append');
  59      };
  60      var getFileFilter = function (editor) {
  61        return editor.getParam('importcss_file_filter');
  62      };
  63      var getSkin = function (editor) {
  64        var skin = editor.getParam('skin');
  65        return skin !== false ? skin || 'oxide' : false;
  66      };
  67      var getSkinUrl = function (editor) {
  68        return editor.getParam('skin_url');
  69      };
  70  
  71      var nativePush = Array.prototype.push;
  72      var map = function (xs, f) {
  73        var len = xs.length;
  74        var r = new Array(len);
  75        for (var i = 0; i < len; i++) {
  76          var x = xs[i];
  77          r[i] = f(x, i);
  78        }
  79        return r;
  80      };
  81      var flatten = function (xs) {
  82        var r = [];
  83        for (var i = 0, len = xs.length; i < len; ++i) {
  84          if (!isArray(xs[i])) {
  85            throw new Error('Arr.flatten item ' + i + ' was not an array, input: ' + xs);
  86          }
  87          nativePush.apply(r, xs[i]);
  88        }
  89        return r;
  90      };
  91      var bind = function (xs, f) {
  92        return flatten(map(xs, f));
  93      };
  94  
  95      var generate = function () {
  96        var ungroupedOrder = [];
  97        var groupOrder = [];
  98        var groups = {};
  99        var addItemToGroup = function (groupTitle, itemInfo) {
 100          if (groups[groupTitle]) {
 101            groups[groupTitle].push(itemInfo);
 102          } else {
 103            groupOrder.push(groupTitle);
 104            groups[groupTitle] = [itemInfo];
 105          }
 106        };
 107        var addItem = function (itemInfo) {
 108          ungroupedOrder.push(itemInfo);
 109        };
 110        var toFormats = function () {
 111          var groupItems = bind(groupOrder, function (g) {
 112            var items = groups[g];
 113            return items.length === 0 ? [] : [{
 114                title: g,
 115                items: items
 116              }];
 117          });
 118          return groupItems.concat(ungroupedOrder);
 119        };
 120        return {
 121          addItemToGroup: addItemToGroup,
 122          addItem: addItem,
 123          toFormats: toFormats
 124        };
 125      };
 126  
 127      var internalEditorStyle = /^\.(?:ephox|tiny-pageembed|mce)(?:[.-]+\w+)+$/;
 128      var removeCacheSuffix = function (url) {
 129        var cacheSuffix = global$1.cacheSuffix;
 130        if (isString(url)) {
 131          url = url.replace('?' + cacheSuffix, '').replace('&' + cacheSuffix, '');
 132        }
 133        return url;
 134      };
 135      var isSkinContentCss = function (editor, href) {
 136        var skin = getSkin(editor);
 137        if (skin) {
 138          var skinUrlBase = getSkinUrl(editor);
 139          var skinUrl = skinUrlBase ? editor.documentBaseURI.toAbsolute(skinUrlBase) : global$2.baseURL + '/skins/ui/' + skin;
 140          var contentSkinUrlPart = global$2.baseURL + '/skins/content/';
 141          return href === skinUrl + '/content' + (editor.inline ? '.inline' : '') + '.min.css' || href.indexOf(contentSkinUrlPart) !== -1;
 142        }
 143        return false;
 144      };
 145      var compileFilter = function (filter) {
 146        if (isString(filter)) {
 147          return function (value) {
 148            return value.indexOf(filter) !== -1;
 149          };
 150        } else if (filter instanceof RegExp) {
 151          return function (value) {
 152            return filter.test(value);
 153          };
 154        }
 155        return filter;
 156      };
 157      var isCssImportRule = function (rule) {
 158        return rule.styleSheet;
 159      };
 160      var isCssPageRule = function (rule) {
 161        return rule.selectorText;
 162      };
 163      var getSelectors = function (editor, doc, fileFilter) {
 164        var selectors = [];
 165        var contentCSSUrls = {};
 166        var append = function (styleSheet, imported) {
 167          var href = styleSheet.href, rules;
 168          href = removeCacheSuffix(href);
 169          if (!href || !fileFilter(href, imported) || isSkinContentCss(editor, href)) {
 170            return;
 171          }
 172          global.each(styleSheet.imports, function (styleSheet) {
 173            append(styleSheet, true);
 174          });
 175          try {
 176            rules = styleSheet.cssRules || styleSheet.rules;
 177          } catch (e) {
 178          }
 179          global.each(rules, function (cssRule) {
 180            if (isCssImportRule(cssRule)) {
 181              append(cssRule.styleSheet, true);
 182            } else if (isCssPageRule(cssRule)) {
 183              global.each(cssRule.selectorText.split(','), function (selector) {
 184                selectors.push(global.trim(selector));
 185              });
 186            }
 187          });
 188        };
 189        global.each(editor.contentCSS, function (url) {
 190          contentCSSUrls[url] = true;
 191        });
 192        if (!fileFilter) {
 193          fileFilter = function (href, imported) {
 194            return imported || contentCSSUrls[href];
 195          };
 196        }
 197        try {
 198          global.each(doc.styleSheets, function (styleSheet) {
 199            append(styleSheet);
 200          });
 201        } catch (e) {
 202        }
 203        return selectors;
 204      };
 205      var defaultConvertSelectorToFormat = function (editor, selectorText) {
 206        var format;
 207        var selector = /^(?:([a-z0-9\-_]+))?(\.[a-z0-9_\-\.]+)$/i.exec(selectorText);
 208        if (!selector) {
 209          return;
 210        }
 211        var elementName = selector[1];
 212        var classes = selector[2].substr(1).split('.').join(' ');
 213        var inlineSelectorElements = global.makeMap('a,img');
 214        if (selector[1]) {
 215          format = { title: selectorText };
 216          if (editor.schema.getTextBlockElements()[elementName]) {
 217            format.block = elementName;
 218          } else if (editor.schema.getBlockElements()[elementName] || inlineSelectorElements[elementName.toLowerCase()]) {
 219            format.selector = elementName;
 220          } else {
 221            format.inline = elementName;
 222          }
 223        } else if (selector[2]) {
 224          format = {
 225            inline: 'span',
 226            title: selectorText.substr(1),
 227            classes: classes
 228          };
 229        }
 230        if (shouldMergeClasses(editor) !== false) {
 231          format.classes = classes;
 232        } else {
 233          format.attributes = { class: classes };
 234        }
 235        return format;
 236      };
 237      var getGroupsBySelector = function (groups, selector) {
 238        return global.grep(groups, function (group) {
 239          return !group.filter || group.filter(selector);
 240        });
 241      };
 242      var compileUserDefinedGroups = function (groups) {
 243        return global.map(groups, function (group) {
 244          return global.extend({}, group, {
 245            original: group,
 246            selectors: {},
 247            filter: compileFilter(group.filter)
 248          });
 249        });
 250      };
 251      var isExclusiveMode = function (editor, group) {
 252        return group === null || shouldImportExclusive(editor) !== false;
 253      };
 254      var isUniqueSelector = function (editor, selector, group, globallyUniqueSelectors) {
 255        return !(isExclusiveMode(editor, group) ? selector in globallyUniqueSelectors : selector in group.selectors);
 256      };
 257      var markUniqueSelector = function (editor, selector, group, globallyUniqueSelectors) {
 258        if (isExclusiveMode(editor, group)) {
 259          globallyUniqueSelectors[selector] = true;
 260        } else {
 261          group.selectors[selector] = true;
 262        }
 263      };
 264      var convertSelectorToFormat = function (editor, plugin, selector, group) {
 265        var selectorConverter;
 266        if (group && group.selector_converter) {
 267          selectorConverter = group.selector_converter;
 268        } else if (getSelectorConverter(editor)) {
 269          selectorConverter = getSelectorConverter(editor);
 270        } else {
 271          selectorConverter = function () {
 272            return defaultConvertSelectorToFormat(editor, selector);
 273          };
 274        }
 275        return selectorConverter.call(plugin, selector, group);
 276      };
 277      var setup = function (editor) {
 278        editor.on('init', function () {
 279          var model = generate();
 280          var globallyUniqueSelectors = {};
 281          var selectorFilter = compileFilter(getSelectorFilter(editor));
 282          var groups = compileUserDefinedGroups(getCssGroups(editor));
 283          var processSelector = function (selector, group) {
 284            if (isUniqueSelector(editor, selector, group, globallyUniqueSelectors)) {
 285              markUniqueSelector(editor, selector, group, globallyUniqueSelectors);
 286              var format = convertSelectorToFormat(editor, editor.plugins.importcss, selector, group);
 287              if (format) {
 288                var formatName = format.name || global$3.DOM.uniqueId();
 289                editor.formatter.register(formatName, format);
 290                return {
 291                  title: format.title,
 292                  format: formatName
 293                };
 294              }
 295            }
 296            return null;
 297          };
 298          global.each(getSelectors(editor, editor.getDoc(), compileFilter(getFileFilter(editor))), function (selector) {
 299            if (!internalEditorStyle.test(selector)) {
 300              if (!selectorFilter || selectorFilter(selector)) {
 301                var selectorGroups = getGroupsBySelector(groups, selector);
 302                if (selectorGroups.length > 0) {
 303                  global.each(selectorGroups, function (group) {
 304                    var menuItem = processSelector(selector, group);
 305                    if (menuItem) {
 306                      model.addItemToGroup(group.title, menuItem);
 307                    }
 308                  });
 309                } else {
 310                  var menuItem = processSelector(selector, null);
 311                  if (menuItem) {
 312                    model.addItem(menuItem);
 313                  }
 314                }
 315              }
 316            }
 317          });
 318          var items = model.toFormats();
 319          editor.fire('addStyleModifications', {
 320            items: items,
 321            replace: !shouldAppend(editor)
 322          });
 323        });
 324      };
 325  
 326      var get = function (editor) {
 327        var convertSelectorToFormat = function (selectorText) {
 328          return defaultConvertSelectorToFormat(editor, selectorText);
 329        };
 330        return { convertSelectorToFormat: convertSelectorToFormat };
 331      };
 332  
 333      function Plugin () {
 334        global$4.add('importcss', function (editor) {
 335          setup(editor);
 336          return get(editor);
 337        });
 338      }
 339  
 340      Plugin();
 341  
 342  }());