tinymce-editor/out/tinymce/plugins/importcss/plugin.js
2023-04-08 21:49:05 +02:00

345 lignes
12 KiB
JavaScript

/**
* TinyMCE version 6.4.1 (2023-03-29)
*/
(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();
})();