You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
279 lines
8.5 KiB
Plaintext
279 lines
8.5 KiB
Plaintext
/**
|
|
* Copyright (c) Tiny Technologies, Inc. All rights reserved.
|
|
* Licensed under the LGPL or a commercial license.
|
|
* For LGPL see License.txt in the project root for license information.
|
|
* For commercial licenses see https://www.tiny.cloud/
|
|
*
|
|
* Version: 5.6.2 (2020-12-08)
|
|
*/
|
|
(function () {
|
|
'use strict';
|
|
|
|
var global = tinymce.util.Tools.resolve('tinymce.PluginManager');
|
|
|
|
var applyListFormat = function (editor, listName, styleValue) {
|
|
var cmd = listName === 'UL' ? 'InsertUnorderedList' : 'InsertOrderedList';
|
|
editor.execCommand(cmd, false, styleValue === false ? null : { 'list-style-type': styleValue });
|
|
};
|
|
|
|
var register = function (editor) {
|
|
editor.addCommand('ApplyUnorderedListStyle', function (ui, value) {
|
|
applyListFormat(editor, 'UL', value['list-style-type']);
|
|
});
|
|
editor.addCommand('ApplyOrderedListStyle', function (ui, value) {
|
|
applyListFormat(editor, 'OL', value['list-style-type']);
|
|
});
|
|
};
|
|
|
|
var global$1 = tinymce.util.Tools.resolve('tinymce.util.Tools');
|
|
|
|
var getNumberStyles = function (editor) {
|
|
var styles = editor.getParam('advlist_number_styles', 'default,lower-alpha,lower-greek,lower-roman,upper-alpha,upper-roman');
|
|
return styles ? styles.split(/[ ,]/) : [];
|
|
};
|
|
var getBulletStyles = function (editor) {
|
|
var styles = editor.getParam('advlist_bullet_styles', 'default,circle,square');
|
|
return styles ? styles.split(/[ ,]/) : [];
|
|
};
|
|
|
|
var noop = function () {
|
|
};
|
|
var constant = function (value) {
|
|
return function () {
|
|
return value;
|
|
};
|
|
};
|
|
var never = constant(false);
|
|
var always = constant(true);
|
|
|
|
var none = function () {
|
|
return NONE;
|
|
};
|
|
var NONE = function () {
|
|
var eq = function (o) {
|
|
return o.isNone();
|
|
};
|
|
var call = function (thunk) {
|
|
return thunk();
|
|
};
|
|
var id = function (n) {
|
|
return n;
|
|
};
|
|
var me = {
|
|
fold: function (n, _s) {
|
|
return n();
|
|
},
|
|
is: never,
|
|
isSome: never,
|
|
isNone: always,
|
|
getOr: id,
|
|
getOrThunk: call,
|
|
getOrDie: function (msg) {
|
|
throw new Error(msg || 'error: getOrDie called on none.');
|
|
},
|
|
getOrNull: constant(null),
|
|
getOrUndefined: constant(undefined),
|
|
or: id,
|
|
orThunk: call,
|
|
map: none,
|
|
each: noop,
|
|
bind: none,
|
|
exists: never,
|
|
forall: always,
|
|
filter: none,
|
|
equals: eq,
|
|
equals_: eq,
|
|
toArray: function () {
|
|
return [];
|
|
},
|
|
toString: constant('none()')
|
|
};
|
|
return me;
|
|
}();
|
|
var some = function (a) {
|
|
var constant_a = constant(a);
|
|
var self = function () {
|
|
return me;
|
|
};
|
|
var bind = function (f) {
|
|
return f(a);
|
|
};
|
|
var me = {
|
|
fold: function (n, s) {
|
|
return s(a);
|
|
},
|
|
is: function (v) {
|
|
return a === v;
|
|
},
|
|
isSome: always,
|
|
isNone: never,
|
|
getOr: constant_a,
|
|
getOrThunk: constant_a,
|
|
getOrDie: constant_a,
|
|
getOrNull: constant_a,
|
|
getOrUndefined: constant_a,
|
|
or: self,
|
|
orThunk: self,
|
|
map: function (f) {
|
|
return some(f(a));
|
|
},
|
|
each: function (f) {
|
|
f(a);
|
|
},
|
|
bind: bind,
|
|
exists: bind,
|
|
forall: bind,
|
|
filter: function (f) {
|
|
return f(a) ? me : NONE;
|
|
},
|
|
toArray: function () {
|
|
return [a];
|
|
},
|
|
toString: function () {
|
|
return 'some(' + a + ')';
|
|
},
|
|
equals: function (o) {
|
|
return o.is(a);
|
|
},
|
|
equals_: function (o, elementEq) {
|
|
return o.fold(never, function (b) {
|
|
return elementEq(a, b);
|
|
});
|
|
}
|
|
};
|
|
return me;
|
|
};
|
|
var from = function (value) {
|
|
return value === null || value === undefined ? NONE : some(value);
|
|
};
|
|
var Optional = {
|
|
some: some,
|
|
none: none,
|
|
from: from
|
|
};
|
|
|
|
var isChildOfBody = function (editor, elm) {
|
|
return editor.$.contains(editor.getBody(), elm);
|
|
};
|
|
var isTableCellNode = function (node) {
|
|
return node && /^(TH|TD)$/.test(node.nodeName);
|
|
};
|
|
var isListNode = function (editor) {
|
|
return function (node) {
|
|
return node && /^(OL|UL|DL)$/.test(node.nodeName) && isChildOfBody(editor, node);
|
|
};
|
|
};
|
|
var getSelectedStyleType = function (editor) {
|
|
var listElm = editor.dom.getParent(editor.selection.getNode(), 'ol,ul');
|
|
var style = editor.dom.getStyle(listElm, 'listStyleType');
|
|
return Optional.from(style);
|
|
};
|
|
|
|
var findIndex = function (list, predicate) {
|
|
for (var index = 0; index < list.length; index++) {
|
|
var element = list[index];
|
|
if (predicate(element)) {
|
|
return index;
|
|
}
|
|
}
|
|
return -1;
|
|
};
|
|
var styleValueToText = function (styleValue) {
|
|
return styleValue.replace(/\-/g, ' ').replace(/\b\w/g, function (chr) {
|
|
return chr.toUpperCase();
|
|
});
|
|
};
|
|
var isWithinList = function (editor, e, nodeName) {
|
|
var tableCellIndex = findIndex(e.parents, isTableCellNode);
|
|
var parents = tableCellIndex !== -1 ? e.parents.slice(0, tableCellIndex) : e.parents;
|
|
var lists = global$1.grep(parents, isListNode(editor));
|
|
return lists.length > 0 && lists[0].nodeName === nodeName;
|
|
};
|
|
var addSplitButton = function (editor, id, tooltip, cmd, nodeName, styles) {
|
|
editor.ui.registry.addSplitButton(id, {
|
|
tooltip: tooltip,
|
|
icon: nodeName === 'OL' ? 'ordered-list' : 'unordered-list',
|
|
presets: 'listpreview',
|
|
columns: 3,
|
|
fetch: function (callback) {
|
|
var items = global$1.map(styles, function (styleValue) {
|
|
var iconStyle = nodeName === 'OL' ? 'num' : 'bull';
|
|
var iconName = styleValue === 'disc' || styleValue === 'decimal' ? 'default' : styleValue;
|
|
var itemValue = styleValue === 'default' ? '' : styleValue;
|
|
var displayText = styleValueToText(styleValue);
|
|
return {
|
|
type: 'choiceitem',
|
|
value: itemValue,
|
|
icon: 'list-' + iconStyle + '-' + iconName,
|
|
text: displayText
|
|
};
|
|
});
|
|
callback(items);
|
|
},
|
|
onAction: function () {
|
|
return editor.execCommand(cmd);
|
|
},
|
|
onItemAction: function (_splitButtonApi, value) {
|
|
applyListFormat(editor, nodeName, value);
|
|
},
|
|
select: function (value) {
|
|
var listStyleType = getSelectedStyleType(editor);
|
|
return listStyleType.map(function (listStyle) {
|
|
return value === listStyle;
|
|
}).getOr(false);
|
|
},
|
|
onSetup: function (api) {
|
|
var nodeChangeHandler = function (e) {
|
|
api.setActive(isWithinList(editor, e, nodeName));
|
|
};
|
|
editor.on('NodeChange', nodeChangeHandler);
|
|
return function () {
|
|
return editor.off('NodeChange', nodeChangeHandler);
|
|
};
|
|
}
|
|
});
|
|
};
|
|
var addButton = function (editor, id, tooltip, cmd, nodeName, _styles) {
|
|
editor.ui.registry.addToggleButton(id, {
|
|
active: false,
|
|
tooltip: tooltip,
|
|
icon: nodeName === 'OL' ? 'ordered-list' : 'unordered-list',
|
|
onSetup: function (api) {
|
|
var nodeChangeHandler = function (e) {
|
|
api.setActive(isWithinList(editor, e, nodeName));
|
|
};
|
|
editor.on('NodeChange', nodeChangeHandler);
|
|
return function () {
|
|
return editor.off('NodeChange', nodeChangeHandler);
|
|
};
|
|
},
|
|
onAction: function () {
|
|
return editor.execCommand(cmd);
|
|
}
|
|
});
|
|
};
|
|
var addControl = function (editor, id, tooltip, cmd, nodeName, styles) {
|
|
if (styles.length > 1) {
|
|
addSplitButton(editor, id, tooltip, cmd, nodeName, styles);
|
|
} else {
|
|
addButton(editor, id, tooltip, cmd, nodeName);
|
|
}
|
|
};
|
|
var register$1 = function (editor) {
|
|
addControl(editor, 'numlist', 'Numbered list', 'InsertOrderedList', 'OL', getNumberStyles(editor));
|
|
addControl(editor, 'bullist', 'Bullet list', 'InsertUnorderedList', 'UL', getBulletStyles(editor));
|
|
};
|
|
|
|
function Plugin () {
|
|
global.add('advlist', function (editor) {
|
|
if (editor.hasPlugin('lists')) {
|
|
register$1(editor);
|
|
register(editor);
|
|
}
|
|
});
|
|
}
|
|
|
|
Plugin();
|
|
|
|
}());
|