611 lines
19 KiB
JavaScript
611 lines
19 KiB
JavaScript
(function () {
|
|
var textpattern = (function (domGlobals) {
|
|
'use strict';
|
|
|
|
var Cell = function (initial) {
|
|
var value = initial;
|
|
var get = function () {
|
|
return value;
|
|
};
|
|
var set = function (v) {
|
|
value = v;
|
|
};
|
|
var clone = function () {
|
|
return Cell(get());
|
|
};
|
|
return {
|
|
get: get,
|
|
set: set,
|
|
clone: clone
|
|
};
|
|
};
|
|
|
|
var global = tinymce.util.Tools.resolve('tinymce.PluginManager');
|
|
|
|
function __spreadArrays() {
|
|
for (var s = 0, i = 0, il = arguments.length; i < il; i++)
|
|
s += arguments[i].length;
|
|
for (var r = Array(s), k = 0, i = 0; i < il; i++)
|
|
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
|
|
r[k] = a[j];
|
|
return r;
|
|
}
|
|
|
|
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()')
|
|
};
|
|
if (Object.freeze) {
|
|
Object.freeze(me);
|
|
}
|
|
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 Option = {
|
|
some: some,
|
|
none: none,
|
|
from: from
|
|
};
|
|
|
|
var typeOf = function (x) {
|
|
if (x === null) {
|
|
return 'null';
|
|
}
|
|
var t = typeof x;
|
|
if (t === 'object' && (Array.prototype.isPrototypeOf(x) || x.constructor && x.constructor.name === 'Array')) {
|
|
return 'array';
|
|
}
|
|
if (t === 'object' && (String.prototype.isPrototypeOf(x) || x.constructor && x.constructor.name === 'String')) {
|
|
return 'string';
|
|
}
|
|
return t;
|
|
};
|
|
var isType = function (type) {
|
|
return function (value) {
|
|
return typeOf(value) === type;
|
|
};
|
|
};
|
|
var isFunction = isType('function');
|
|
|
|
var nativeSlice = Array.prototype.slice;
|
|
var filter = function (xs, pred) {
|
|
var r = [];
|
|
for (var i = 0, len = xs.length; i < len; i++) {
|
|
var x = xs[i];
|
|
if (pred(x, i)) {
|
|
r.push(x);
|
|
}
|
|
}
|
|
return r;
|
|
};
|
|
var sort = function (xs, comparator) {
|
|
var copy = nativeSlice.call(xs, 0);
|
|
copy.sort(comparator);
|
|
return copy;
|
|
};
|
|
var from$1 = isFunction(Array.from) ? Array.from : function (x) {
|
|
return nativeSlice.call(x);
|
|
};
|
|
|
|
var hasOwnProperty = Object.hasOwnProperty;
|
|
var get = function (obj, key) {
|
|
return has(obj, key) ? Option.from(obj[key]) : Option.none();
|
|
};
|
|
var has = function (obj, key) {
|
|
return hasOwnProperty.call(obj, key);
|
|
};
|
|
|
|
var isInlinePattern = function (pattern) {
|
|
return has(pattern, 'start') && has(pattern, 'end');
|
|
};
|
|
var isBlockPattern = function (pattern) {
|
|
return !has(pattern, 'end') && !has(pattern, 'replacement');
|
|
};
|
|
var isReplacementPattern = function (pattern) {
|
|
return has(pattern, 'replacement');
|
|
};
|
|
var sortPatterns = function (patterns) {
|
|
return sort(patterns, function (a, b) {
|
|
if (a.start.length === b.start.length) {
|
|
return 0;
|
|
}
|
|
return a.start.length > b.start.length ? -1 : 1;
|
|
});
|
|
};
|
|
var createPatternSet = function (patterns) {
|
|
return {
|
|
inlinePatterns: sortPatterns(filter(patterns, isInlinePattern)),
|
|
blockPatterns: sortPatterns(filter(patterns, isBlockPattern)),
|
|
replacementPatterns: filter(patterns, isReplacementPattern)
|
|
};
|
|
};
|
|
|
|
var get$1 = function (patternsState) {
|
|
var setPatterns = function (newPatterns) {
|
|
patternsState.set(createPatternSet(newPatterns));
|
|
};
|
|
var getPatterns = function () {
|
|
return __spreadArrays(patternsState.get().inlinePatterns, patternsState.get().blockPatterns, patternsState.get().replacementPatterns);
|
|
};
|
|
return {
|
|
setPatterns: setPatterns,
|
|
getPatterns: getPatterns
|
|
};
|
|
};
|
|
var Api = { get: get$1 };
|
|
|
|
var defaultPatterns = [
|
|
{
|
|
start: '*',
|
|
end: '*',
|
|
format: 'italic'
|
|
},
|
|
{
|
|
start: '**',
|
|
end: '**',
|
|
format: 'bold'
|
|
},
|
|
{
|
|
start: '***',
|
|
end: '***',
|
|
format: [
|
|
'bold',
|
|
'italic'
|
|
]
|
|
},
|
|
{
|
|
start: '#',
|
|
format: 'h1'
|
|
},
|
|
{
|
|
start: '##',
|
|
format: 'h2'
|
|
},
|
|
{
|
|
start: '###',
|
|
format: 'h3'
|
|
},
|
|
{
|
|
start: '####',
|
|
format: 'h4'
|
|
},
|
|
{
|
|
start: '#####',
|
|
format: 'h5'
|
|
},
|
|
{
|
|
start: '######',
|
|
format: 'h6'
|
|
},
|
|
{
|
|
start: '1. ',
|
|
cmd: 'InsertOrderedList'
|
|
},
|
|
{
|
|
start: '* ',
|
|
cmd: 'InsertUnorderedList'
|
|
},
|
|
{
|
|
start: '- ',
|
|
cmd: 'InsertUnorderedList'
|
|
}
|
|
];
|
|
var getPatternSet = function (editorSettings) {
|
|
var patterns = get(editorSettings, 'textpattern_patterns').getOr(defaultPatterns);
|
|
return createPatternSet(patterns);
|
|
};
|
|
|
|
var global$1 = tinymce.util.Tools.resolve('tinymce.util.Delay');
|
|
|
|
var global$2 = tinymce.util.Tools.resolve('tinymce.util.VK');
|
|
|
|
var global$3 = tinymce.util.Tools.resolve('tinymce.dom.TreeWalker');
|
|
|
|
var global$4 = tinymce.util.Tools.resolve('tinymce.util.Tools');
|
|
|
|
var findPattern = function (patterns, text) {
|
|
for (var i = 0; i < patterns.length; i++) {
|
|
var pattern = patterns[i];
|
|
if (text.indexOf(pattern.start) !== 0) {
|
|
continue;
|
|
}
|
|
if (pattern.end && text.lastIndexOf(pattern.end) !== text.length - pattern.end.length) {
|
|
continue;
|
|
}
|
|
return pattern;
|
|
}
|
|
};
|
|
var isMatchingPattern = function (pattern, text, offset, delta) {
|
|
var textEnd = text.substr(offset - pattern.end.length - delta, pattern.end.length);
|
|
return textEnd === pattern.end;
|
|
};
|
|
var hasContent = function (offset, delta, pattern) {
|
|
return offset - delta - pattern.end.length - pattern.start.length > 0;
|
|
};
|
|
var findEndPattern = function (patterns, text, offset, delta) {
|
|
var pattern, i;
|
|
for (i = 0; i < patterns.length; i++) {
|
|
pattern = patterns[i];
|
|
if (pattern.end !== undefined && isMatchingPattern(pattern, text, offset, delta) && hasContent(offset, delta, pattern)) {
|
|
return pattern;
|
|
}
|
|
}
|
|
};
|
|
var findInlinePattern = function (patterns, rng, space) {
|
|
if (rng.collapsed === false) {
|
|
return;
|
|
}
|
|
var container = rng.startContainer;
|
|
var text = container.data;
|
|
var delta = space === true ? 1 : 0;
|
|
if (container.nodeType !== 3) {
|
|
return;
|
|
}
|
|
var endPattern = findEndPattern(patterns, text, rng.startOffset, delta);
|
|
if (endPattern === undefined) {
|
|
return;
|
|
}
|
|
var endOffset = text.lastIndexOf(endPattern.end, rng.startOffset - delta);
|
|
var startOffset = text.lastIndexOf(endPattern.start, endOffset - endPattern.end.length);
|
|
endOffset = text.indexOf(endPattern.end, startOffset + endPattern.start.length);
|
|
if (startOffset === -1) {
|
|
return;
|
|
}
|
|
var patternRng = domGlobals.document.createRange();
|
|
patternRng.setStart(container, startOffset);
|
|
patternRng.setEnd(container, endOffset + endPattern.end.length);
|
|
var startPattern = findPattern(patterns, patternRng.toString());
|
|
if (endPattern === undefined || startPattern !== endPattern || container.data.length <= endPattern.start.length + endPattern.end.length) {
|
|
return;
|
|
}
|
|
return {
|
|
pattern: endPattern,
|
|
startOffset: startOffset,
|
|
endOffset: endOffset
|
|
};
|
|
};
|
|
var findReplacementPattern = function (patterns, startSearch, text) {
|
|
for (var i = 0; i < patterns.length; i++) {
|
|
var index = text.lastIndexOf(patterns[i].start, startSearch);
|
|
if (index !== -1) {
|
|
return Option.some({
|
|
pattern: patterns[i],
|
|
startOffset: index
|
|
});
|
|
}
|
|
}
|
|
return Option.none();
|
|
};
|
|
|
|
var isText = function (node) {
|
|
return node && node.nodeType === 3;
|
|
};
|
|
var setSelection = function (editor, textNode, offset) {
|
|
var newRng = editor.dom.createRng();
|
|
newRng.setStart(textNode, offset);
|
|
newRng.setEnd(textNode, offset);
|
|
editor.selection.setRng(newRng);
|
|
};
|
|
var splitContainer = function (container, pattern, endOffset, startOffset) {
|
|
container = startOffset > 0 ? container.splitText(startOffset) : container;
|
|
container.splitText(endOffset - startOffset + pattern.end.length);
|
|
container.deleteData(0, pattern.start.length);
|
|
container.deleteData(container.data.length - pattern.end.length, pattern.end.length);
|
|
return container;
|
|
};
|
|
var splitAndApply = function (editor, container, found, inline) {
|
|
var formatArray = global$4.isArray(found.pattern.format) ? found.pattern.format : [found.pattern.format];
|
|
var validFormats = global$4.grep(formatArray, function (formatName) {
|
|
var format = editor.formatter.get(formatName);
|
|
return format && format[0].inline;
|
|
});
|
|
if (validFormats.length !== 0) {
|
|
editor.undoManager.transact(function () {
|
|
container = splitContainer(container, found.pattern, found.endOffset, found.startOffset);
|
|
if (inline) {
|
|
editor.selection.setCursorLocation(container.nextSibling, 1);
|
|
}
|
|
formatArray.forEach(function (format) {
|
|
editor.formatter.apply(format, {}, container);
|
|
});
|
|
});
|
|
return container;
|
|
}
|
|
};
|
|
var applyInlinePattern = function (editor, patterns, inline) {
|
|
var rng = editor.selection.getRng();
|
|
return Option.from(findInlinePattern(patterns, rng, inline)).map(function (foundPattern) {
|
|
return splitAndApply(editor, rng.startContainer, foundPattern, inline);
|
|
});
|
|
};
|
|
var applyInlinePatternSpace = function (editor, patterns) {
|
|
applyInlinePattern(editor, patterns, true).each(function (wrappedTextNode) {
|
|
var lastChar = wrappedTextNode.data.slice(-1);
|
|
if (/[\u00a0 ]/.test(lastChar)) {
|
|
wrappedTextNode.deleteData(wrappedTextNode.data.length - 1, 1);
|
|
var lastCharNode = editor.dom.doc.createTextNode(lastChar);
|
|
editor.dom.insertAfter(lastCharNode, wrappedTextNode.parentNode);
|
|
setSelection(editor, lastCharNode, 1);
|
|
}
|
|
});
|
|
};
|
|
var applyInlinePatternEnter = function (editor, patterns) {
|
|
applyInlinePattern(editor, patterns, false).each(function (wrappedTextNode) {
|
|
setSelection(editor, wrappedTextNode, wrappedTextNode.data.length);
|
|
});
|
|
};
|
|
var applyBlockPattern = function (editor, patterns) {
|
|
var selection, dom, container, firstTextNode, node, format, textBlockElm, pattern, walker, rng, offset;
|
|
selection = editor.selection;
|
|
dom = editor.dom;
|
|
if (!selection.isCollapsed()) {
|
|
return;
|
|
}
|
|
textBlockElm = dom.getParent(selection.getStart(), 'p');
|
|
if (textBlockElm) {
|
|
walker = new global$3(textBlockElm, textBlockElm);
|
|
while (node = walker.next()) {
|
|
if (isText(node)) {
|
|
firstTextNode = node;
|
|
break;
|
|
}
|
|
}
|
|
if (firstTextNode) {
|
|
pattern = findPattern(patterns, firstTextNode.data);
|
|
if (!pattern) {
|
|
return;
|
|
}
|
|
rng = selection.getRng(true);
|
|
container = rng.startContainer;
|
|
offset = rng.startOffset;
|
|
if (firstTextNode === container) {
|
|
offset = Math.max(0, offset - pattern.start.length);
|
|
}
|
|
if (global$4.trim(firstTextNode.data).length === pattern.start.length) {
|
|
return;
|
|
}
|
|
if (pattern.format) {
|
|
format = editor.formatter.get(pattern.format);
|
|
if (format && format[0].block) {
|
|
firstTextNode.deleteData(0, pattern.start.length);
|
|
editor.formatter.apply(pattern.format, {}, firstTextNode);
|
|
rng.setStart(container, offset);
|
|
rng.collapse(true);
|
|
selection.setRng(rng);
|
|
}
|
|
}
|
|
if (pattern.cmd) {
|
|
editor.undoManager.transact(function () {
|
|
firstTextNode.deleteData(0, pattern.start.length);
|
|
editor.execCommand(pattern.cmd);
|
|
});
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var selectionInsertText = function (editor, string) {
|
|
var rng = editor.selection.getRng();
|
|
var container = rng.startContainer;
|
|
if (isText(container)) {
|
|
var offset = rng.startOffset;
|
|
container.insertData(offset, string);
|
|
setSelection(editor, container, offset + string.length);
|
|
} else {
|
|
var newNode = editor.dom.doc.createTextNode(string);
|
|
rng.insertNode(newNode);
|
|
setSelection(editor, newNode, newNode.length);
|
|
}
|
|
};
|
|
var applyReplacement = function (editor, target, match) {
|
|
target.deleteData(match.startOffset, match.pattern.start.length);
|
|
editor.insertContent(match.pattern.replacement);
|
|
Option.from(target.nextSibling).filter(isText).each(function (nextSibling) {
|
|
nextSibling.insertData(0, target.data);
|
|
editor.dom.remove(target);
|
|
});
|
|
};
|
|
var extractChar = function (node, match) {
|
|
var offset = match.startOffset + match.pattern.start.length;
|
|
var char = node.data.slice(offset, offset + 1);
|
|
node.deleteData(offset, 1);
|
|
return char;
|
|
};
|
|
var applyReplacementPattern = function (editor, patterns, inline) {
|
|
var rng = editor.selection.getRng();
|
|
var container = rng.startContainer;
|
|
if (rng.collapsed && isText(container)) {
|
|
findReplacementPattern(patterns, rng.startOffset, container.data).each(function (match) {
|
|
var char = inline ? Option.some(extractChar(container, match)) : Option.none();
|
|
applyReplacement(editor, container, match);
|
|
char.each(function (ch) {
|
|
return selectionInsertText(editor, ch);
|
|
});
|
|
});
|
|
}
|
|
};
|
|
var applyReplacementPatternSpace = function (editor, patterns) {
|
|
applyReplacementPattern(editor, patterns, true);
|
|
};
|
|
var applyReplacementPatternEnter = function (editor, patterns) {
|
|
applyReplacementPattern(editor, patterns, false);
|
|
};
|
|
|
|
var handleEnter = function (editor, patternSet) {
|
|
applyReplacementPatternEnter(editor, patternSet.replacementPatterns);
|
|
applyInlinePatternEnter(editor, patternSet.inlinePatterns);
|
|
applyBlockPattern(editor, patternSet.blockPatterns);
|
|
};
|
|
var handleInlineKey = function (editor, patternSet) {
|
|
applyReplacementPatternSpace(editor, patternSet.replacementPatterns);
|
|
applyInlinePatternSpace(editor, patternSet.inlinePatterns);
|
|
};
|
|
var checkKeyEvent = function (codes, event, predicate) {
|
|
for (var i = 0; i < codes.length; i++) {
|
|
if (predicate(codes[i], event)) {
|
|
return true;
|
|
}
|
|
}
|
|
};
|
|
var checkKeyCode = function (codes, event) {
|
|
return checkKeyEvent(codes, event, function (code, event) {
|
|
return code === event.keyCode && global$2.modifierPressed(event) === false;
|
|
});
|
|
};
|
|
var checkCharCode = function (chars, event) {
|
|
return checkKeyEvent(chars, event, function (chr, event) {
|
|
return chr.charCodeAt(0) === event.charCode;
|
|
});
|
|
};
|
|
var KeyHandler = {
|
|
handleEnter: handleEnter,
|
|
handleInlineKey: handleInlineKey,
|
|
checkCharCode: checkCharCode,
|
|
checkKeyCode: checkKeyCode
|
|
};
|
|
|
|
var setup = function (editor, patternsState) {
|
|
var charCodes = [
|
|
',',
|
|
'.',
|
|
';',
|
|
':',
|
|
'!',
|
|
'?'
|
|
];
|
|
var keyCodes = [32];
|
|
editor.on('keydown', function (e) {
|
|
if (e.keyCode === 13 && !global$2.modifierPressed(e)) {
|
|
KeyHandler.handleEnter(editor, patternsState.get());
|
|
}
|
|
}, true);
|
|
editor.on('keyup', function (e) {
|
|
if (KeyHandler.checkKeyCode(keyCodes, e)) {
|
|
KeyHandler.handleInlineKey(editor, patternsState.get());
|
|
}
|
|
});
|
|
editor.on('keypress', function (e) {
|
|
if (KeyHandler.checkCharCode(charCodes, e)) {
|
|
global$1.setEditorTimeout(editor, function () {
|
|
KeyHandler.handleInlineKey(editor, patternsState.get());
|
|
});
|
|
}
|
|
});
|
|
};
|
|
var Keyboard = { setup: setup };
|
|
|
|
global.add('textpattern', function (editor) {
|
|
var patternsState = Cell(getPatternSet(editor.settings));
|
|
Keyboard.setup(editor, patternsState);
|
|
return Api.get(patternsState);
|
|
});
|
|
function Plugin () {
|
|
}
|
|
|
|
return Plugin;
|
|
|
|
}(window));
|
|
})();
|