| |
| |
| |
|
|
| (function () { |
| 'use strict'; |
|
|
| var global$4 = tinymce.util.Tools.resolve('tinymce.PluginManager'); |
|
|
| const hasProto = (v, constructor, predicate) => { |
| var _a; |
| if (predicate(v, constructor.prototype)) { |
| return true; |
| } else { |
| return ((_a = v.constructor) === null || _a === void 0 ? void 0 : _a.name) === constructor.name; |
| } |
| }; |
| const typeOf = x => { |
| const t = typeof x; |
| if (x === null) { |
| return 'null'; |
| } else if (t === 'object' && Array.isArray(x)) { |
| return 'array'; |
| } else if (t === 'object' && hasProto(x, String, (o, proto) => proto.isPrototypeOf(o))) { |
| return 'string'; |
| } else { |
| return t; |
| } |
| }; |
| const isType = type => value => typeOf(value) === type; |
| const isSimpleType = type => value => typeof value === type; |
| const isString = isType('string'); |
| const isObject = isType('object'); |
| const isArray = isType('array'); |
| const isFunction = isSimpleType('function'); |
|
|
| var global$3 = tinymce.util.Tools.resolve('tinymce.dom.DOMUtils'); |
|
|
| var global$2 = tinymce.util.Tools.resolve('tinymce.EditorManager'); |
|
|
| var global$1 = tinymce.util.Tools.resolve('tinymce.Env'); |
|
|
| var global = tinymce.util.Tools.resolve('tinymce.util.Tools'); |
|
|
| const option = name => editor => editor.options.get(name); |
| const register = editor => { |
| const registerOption = editor.options.register; |
| const filterProcessor = value => isString(value) || isFunction(value) || isObject(value); |
| registerOption('importcss_merge_classes', { |
| processor: 'boolean', |
| default: true |
| }); |
| registerOption('importcss_exclusive', { |
| processor: 'boolean', |
| default: true |
| }); |
| registerOption('importcss_selector_converter', { processor: 'function' }); |
| registerOption('importcss_selector_filter', { processor: filterProcessor }); |
| registerOption('importcss_file_filter', { processor: filterProcessor }); |
| registerOption('importcss_groups', { processor: 'object[]' }); |
| registerOption('importcss_append', { |
| processor: 'boolean', |
| default: false |
| }); |
| }; |
| const shouldMergeClasses = option('importcss_merge_classes'); |
| const shouldImportExclusive = option('importcss_exclusive'); |
| const getSelectorConverter = option('importcss_selector_converter'); |
| const getSelectorFilter = option('importcss_selector_filter'); |
| const getCssGroups = option('importcss_groups'); |
| const shouldAppend = option('importcss_append'); |
| const getFileFilter = option('importcss_file_filter'); |
| const getSkin = option('skin'); |
| const getSkinUrl = option('skin_url'); |
|
|
| const nativePush = Array.prototype.push; |
| const map = (xs, f) => { |
| const len = xs.length; |
| const r = new Array(len); |
| for (let i = 0; i < len; i++) { |
| const x = xs[i]; |
| r[i] = f(x, i); |
| } |
| return r; |
| }; |
| const flatten = xs => { |
| const r = []; |
| for (let i = 0, len = xs.length; i < len; ++i) { |
| if (!isArray(xs[i])) { |
| throw new Error('Arr.flatten item ' + i + ' was not an array, input: ' + xs); |
| } |
| nativePush.apply(r, xs[i]); |
| } |
| return r; |
| }; |
| const bind = (xs, f) => flatten(map(xs, f)); |
|
|
| const generate = () => { |
| const ungroupedOrder = []; |
| const groupOrder = []; |
| const groups = {}; |
| const addItemToGroup = (groupTitle, itemInfo) => { |
| if (groups[groupTitle]) { |
| groups[groupTitle].push(itemInfo); |
| } else { |
| groupOrder.push(groupTitle); |
| groups[groupTitle] = [itemInfo]; |
| } |
| }; |
| const addItem = itemInfo => { |
| ungroupedOrder.push(itemInfo); |
| }; |
| const toFormats = () => { |
| const groupItems = bind(groupOrder, g => { |
| const items = groups[g]; |
| return items.length === 0 ? [] : [{ |
| title: g, |
| items |
| }]; |
| }); |
| return groupItems.concat(ungroupedOrder); |
| }; |
| return { |
| addItemToGroup, |
| addItem, |
| toFormats |
| }; |
| }; |
|
|
| const internalEditorStyle = /^\.(?:ephox|tiny-pageembed|mce)(?:[.-]+\w+)+$/; |
| const removeCacheSuffix = url => { |
| const cacheSuffix = global$1.cacheSuffix; |
| if (isString(url)) { |
| url = url.replace('?' + cacheSuffix, '').replace('&' + cacheSuffix, ''); |
| } |
| return url; |
| }; |
| const isSkinContentCss = (editor, href) => { |
| const skin = getSkin(editor); |
| if (skin) { |
| const skinUrlBase = getSkinUrl(editor); |
| const skinUrl = skinUrlBase ? editor.documentBaseURI.toAbsolute(skinUrlBase) : global$2.baseURL + '/skins/ui/' + skin; |
| const contentSkinUrlPart = global$2.baseURL + '/skins/content/'; |
| return href === skinUrl + '/content' + (editor.inline ? '.inline' : '') + '.min.css' || href.indexOf(contentSkinUrlPart) !== -1; |
| } |
| return false; |
| }; |
| const compileFilter = filter => { |
| if (isString(filter)) { |
| return value => { |
| return value.indexOf(filter) !== -1; |
| }; |
| } else if (filter instanceof RegExp) { |
| return value => { |
| return filter.test(value); |
| }; |
| } |
| return filter; |
| }; |
| const isCssImportRule = rule => rule.styleSheet; |
| const isCssPageRule = rule => rule.selectorText; |
| const getSelectors = (editor, doc, fileFilter) => { |
| const selectors = []; |
| const contentCSSUrls = {}; |
| const append = (styleSheet, imported) => { |
| let href = styleSheet.href; |
| let rules; |
| href = removeCacheSuffix(href); |
| if (!href || fileFilter && !fileFilter(href, imported) || isSkinContentCss(editor, href)) { |
| return; |
| } |
| global.each(styleSheet.imports, styleSheet => { |
| append(styleSheet, true); |
| }); |
| try { |
| rules = styleSheet.cssRules || styleSheet.rules; |
| } catch (e) { |
| } |
| global.each(rules, cssRule => { |
| if (isCssImportRule(cssRule)) { |
| append(cssRule.styleSheet, true); |
| } else if (isCssPageRule(cssRule)) { |
| global.each(cssRule.selectorText.split(','), selector => { |
| selectors.push(global.trim(selector)); |
| }); |
| } |
| }); |
| }; |
| global.each(editor.contentCSS, url => { |
| contentCSSUrls[url] = true; |
| }); |
| if (!fileFilter) { |
| fileFilter = (href, imported) => { |
| return imported || contentCSSUrls[href]; |
| }; |
| } |
| try { |
| global.each(doc.styleSheets, styleSheet => { |
| append(styleSheet); |
| }); |
| } catch (e) { |
| } |
| return selectors; |
| }; |
| const defaultConvertSelectorToFormat = (editor, selectorText) => { |
| let format = {}; |
| const selector = /^(?:([a-z0-9\-_]+))?(\.[a-z0-9_\-\.]+)$/i.exec(selectorText); |
| if (!selector) { |
| return; |
| } |
| const elementName = selector[1]; |
| const classes = selector[2].substr(1).split('.').join(' '); |
| const inlineSelectorElements = global.makeMap('a,img'); |
| if (selector[1]) { |
| format = { title: selectorText }; |
| if (editor.schema.getTextBlockElements()[elementName]) { |
| format.block = elementName; |
| } else if (editor.schema.getBlockElements()[elementName] || inlineSelectorElements[elementName.toLowerCase()]) { |
| format.selector = elementName; |
| } else { |
| format.inline = elementName; |
| } |
| } else if (selector[2]) { |
| format = { |
| inline: 'span', |
| title: selectorText.substr(1), |
| classes |
| }; |
| } |
| if (shouldMergeClasses(editor)) { |
| format.classes = classes; |
| } else { |
| format.attributes = { class: classes }; |
| } |
| return format; |
| }; |
| const getGroupsBySelector = (groups, selector) => { |
| return global.grep(groups, group => { |
| return !group.filter || group.filter(selector); |
| }); |
| }; |
| const compileUserDefinedGroups = groups => { |
| return global.map(groups, group => { |
| return global.extend({}, group, { |
| original: group, |
| selectors: {}, |
| filter: compileFilter(group.filter) |
| }); |
| }); |
| }; |
| const isExclusiveMode = (editor, group) => { |
| return group === null || shouldImportExclusive(editor); |
| }; |
| const isUniqueSelector = (editor, selector, group, globallyUniqueSelectors) => { |
| return !(isExclusiveMode(editor, group) ? selector in globallyUniqueSelectors : selector in group.selectors); |
| }; |
| const markUniqueSelector = (editor, selector, group, globallyUniqueSelectors) => { |
| if (isExclusiveMode(editor, group)) { |
| globallyUniqueSelectors[selector] = true; |
| } else { |
| group.selectors[selector] = true; |
| } |
| }; |
| const convertSelectorToFormat = (editor, plugin, selector, group) => { |
| let selectorConverter; |
| const converter = getSelectorConverter(editor); |
| if (group && group.selector_converter) { |
| selectorConverter = group.selector_converter; |
| } else if (converter) { |
| selectorConverter = converter; |
| } else { |
| selectorConverter = () => { |
| return defaultConvertSelectorToFormat(editor, selector); |
| }; |
| } |
| return selectorConverter.call(plugin, selector, group); |
| }; |
| const setup = editor => { |
| editor.on('init', () => { |
| const model = generate(); |
| const globallyUniqueSelectors = {}; |
| const selectorFilter = compileFilter(getSelectorFilter(editor)); |
| const groups = compileUserDefinedGroups(getCssGroups(editor)); |
| const processSelector = (selector, group) => { |
| if (isUniqueSelector(editor, selector, group, globallyUniqueSelectors)) { |
| markUniqueSelector(editor, selector, group, globallyUniqueSelectors); |
| const format = convertSelectorToFormat(editor, editor.plugins.importcss, selector, group); |
| if (format) { |
| const formatName = format.name || global$3.DOM.uniqueId(); |
| editor.formatter.register(formatName, format); |
| return { |
| title: format.title, |
| format: formatName |
| }; |
| } |
| } |
| return null; |
| }; |
| global.each(getSelectors(editor, editor.getDoc(), compileFilter(getFileFilter(editor))), selector => { |
| if (!internalEditorStyle.test(selector)) { |
| if (!selectorFilter || selectorFilter(selector)) { |
| const selectorGroups = getGroupsBySelector(groups, selector); |
| if (selectorGroups.length > 0) { |
| global.each(selectorGroups, group => { |
| const menuItem = processSelector(selector, group); |
| if (menuItem) { |
| model.addItemToGroup(group.title, menuItem); |
| } |
| }); |
| } else { |
| const menuItem = processSelector(selector, null); |
| if (menuItem) { |
| model.addItem(menuItem); |
| } |
| } |
| } |
| } |
| }); |
| const items = model.toFormats(); |
| editor.dispatch('addStyleModifications', { |
| items, |
| replace: !shouldAppend(editor) |
| }); |
| }); |
| }; |
|
|
| const get = editor => { |
| const convertSelectorToFormat = selectorText => { |
| return defaultConvertSelectorToFormat(editor, selectorText); |
| }; |
| return { convertSelectorToFormat }; |
| }; |
|
|
| var Plugin = () => { |
| global$4.add('importcss', editor => { |
| register(editor); |
| setup(editor); |
| return get(editor); |
| }); |
| }; |
|
|
| Plugin(); |
|
|
| })(); |
|
|
