] var ancestors = listAncestor(point.node, func.eq(root)); if (!ancestors.length) { return null; } else if (ancestors.length === 1) { return splitNode(point, options); } return ancestors.reduce(function (node, parent) { if (node === point.node) { node = splitNode(point, options); } return splitNode( { node: parent, offset: node ? dom_position(node) : nodeLength(parent), }, options ); }); } /** * split point * * @param {Point} point * @param {Boolean} isInline * @return {Object} */ function splitPoint(point, isInline) { // find splitRoot, container // - inline: splitRoot is a child of paragraph // - block: splitRoot is a child of bodyContainer var pred = isInline ? isPara : isBodyContainer; var ancestors = listAncestor(point.node, pred); var topAncestor = lists.last(ancestors) || point.node; var splitRoot, container; if (pred(topAncestor)) { splitRoot = ancestors[ancestors.length - 2]; container = topAncestor; } else { splitRoot = topAncestor; container = splitRoot.parentNode; } // if splitRoot is exists, split with splitTree var pivot = splitRoot && splitTree(splitRoot, point, { isSkipPaddingBlankHTML: isInline, isNotSplitEdgePoint: isInline, }); // if container is point.node, find pivot with point.offset if (!pivot && container === point.node) { pivot = point.node.childNodes[point.offset]; } return { rightNode: pivot, container: container, }; } function dom_create(nodeName) { return document.createElement(nodeName); } function createText(text) { return document.createTextNode(text); } /** * @method remove * * remove node, (isRemoveChild: remove child or not) * * @param {Node} node * @param {Boolean} isRemoveChild */ function remove(node, isRemoveChild) { if (!node || !node.parentNode) { return; } if (node.removeNode) { return node.removeNode(isRemoveChild); } var parent = node.parentNode; if (!isRemoveChild) { var nodes = []; for (var i = 0, len = node.childNodes.length; i < len; i++) { nodes.push(node.childNodes[i]); } for (var _i = 0, _len = nodes.length; _i < _len; _i++) { parent.insertBefore(nodes[_i], node); } } parent.removeChild(node); } /** * @method removeWhile * * @param {Node} node * @param {Function} pred */ function removeWhile(node, pred) { while (node) { if (isEditable(node) || !pred(node)) { break; } var parent = node.parentNode; remove(node); node = parent; } } /** * @method replace * * replace node with provided nodeName * * @param {Node} node * @param {String} nodeName * @return {Node} - new node */ function dom_replace(node, nodeName) { if (node.nodeName.toUpperCase() === nodeName.toUpperCase()) { return node; } var newNode = dom_create(nodeName); if (node.style.cssText) { newNode.style.cssText = node.style.cssText; } appendChildNodes(newNode, lists.from(node.childNodes)); insertAfter(newNode, node); remove(node); return newNode; } var isTextarea = makePredByNodeName("TEXTAREA"); /** * @param {jQuery} $node * @param {Boolean} [stripLinebreaks] - default: false */ function dom_value($node, stripLinebreaks) { var val = isTextarea($node[0]) ? $node.val() : $node.html(); if (stripLinebreaks) { return val.replace(/[\n\r]/g, ""); } return val; } /** * @method html * * get the HTML contents of node * * @param {jQuery} $node * @param {Boolean} [isNewlineOnBlock] */ function dom_html($node, isNewlineOnBlock) { var markup = dom_value($node); if (isNewlineOnBlock) { var regexTag = /<(\/?)(\b(?!!)[^>\s]*)(.*?)(\s*\/?>)/g; markup = markup.replace(regexTag, function (match, endSlash, name) { name = name.toUpperCase(); var isEndOfInlineContainer = /^DIV|^TD|^TH|^P|^LI|^H[1-7]/.test(name) && !!endSlash; var isBlockNode = /^BLOCKQUOTE|^TABLE|^TBODY|^TR|^HR|^UL|^OL/.test( name ); return ( match + (isEndOfInlineContainer || isBlockNode ? "\n" : "") ); }); markup = markup.trim(); } return markup; } function posFromPlaceholder(placeholder) { var $placeholder = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()( placeholder ); var pos = $placeholder.offset(); var height = $placeholder.outerHeight(true); // include margin return { left: pos.left, top: pos.top + height, }; } function attachEvents($node, events) { Object.keys(events).forEach(function (key) { $node.on(key, events[key]); }); } function detachEvents($node, events) { Object.keys(events).forEach(function (key) { $node.off(key, events[key]); }); } /** * @method isCustomStyleTag * * assert if a node contains a "note-styletag" class, * which implies that's a custom-made style tag node * * @param {Node} an HTML DOM node */ function isCustomStyleTag(node) { return ( node && !isText(node) && lists.contains(node.classList, "note-styletag") ); } /* harmony default export */ var dom = { /** @property {String} NBSP_CHAR */ NBSP_CHAR: NBSP_CHAR, /** @property {String} ZERO_WIDTH_NBSP_CHAR */ ZERO_WIDTH_NBSP_CHAR: ZERO_WIDTH_NBSP_CHAR, /** @property {String} blank */ blank: blankHTML, /** @property {String} emptyPara */ emptyPara: "
".concat(blankHTML, "
"), makePredByNodeName: makePredByNodeName, isEditable: isEditable, isControlSizing: isControlSizing, isText: isText, isElement: isElement, isVoid: isVoid, isPara: isPara, isPurePara: isPurePara, isHeading: isHeading, isInline: dom_isInline, isBlock: func.not(dom_isInline), isBodyInline: isBodyInline, isBody: isBody, isParaInline: isParaInline, isPre: isPre, isList: isList, isTable: isTable, isData: isData, isCell: dom_isCell, isBlockquote: isBlockquote, isBodyContainer: isBodyContainer, isAnchor: isAnchor, isDiv: makePredByNodeName("DIV"), isLi: isLi, isBR: makePredByNodeName("BR"), isSpan: makePredByNodeName("SPAN"), isB: makePredByNodeName("B"), isU: makePredByNodeName("U"), isS: makePredByNodeName("S"), isI: makePredByNodeName("I"), isImg: makePredByNodeName("IMG"), isTextarea: isTextarea, deepestChildIsEmpty: deepestChildIsEmpty, isEmpty: dom_isEmpty, isEmptyAnchor: func.and(isAnchor, dom_isEmpty), isClosestSibling: isClosestSibling, withClosestSiblings: withClosestSiblings, nodeLength: nodeLength, isLeftEdgePoint: isLeftEdgePoint, isRightEdgePoint: isRightEdgePoint, isEdgePoint: isEdgePoint, isLeftEdgeOf: dom_isLeftEdgeOf, isRightEdgeOf: isRightEdgeOf, isLeftEdgePointOf: isLeftEdgePointOf, isRightEdgePointOf: isRightEdgePointOf, prevPoint: dom_prevPoint, nextPoint: dom_nextPoint, nextPointWithEmptyNode: nextPointWithEmptyNode, isSamePoint: isSamePoint, isVisiblePoint: isVisiblePoint, prevPointUntil: prevPointUntil, nextPointUntil: nextPointUntil, isCharPoint: isCharPoint, isSpacePoint: isSpacePoint, walkPoint: walkPoint, ancestor: dom_ancestor, singleChildAncestor: singleChildAncestor, listAncestor: listAncestor, lastAncestor: lastAncestor, listNext: listNext, listPrev: listPrev, listDescendant: listDescendant, commonAncestor: dom_commonAncestor, wrap: wrap, insertAfter: insertAfter, appendChildNodes: appendChildNodes, position: dom_position, hasChildren: hasChildren, makeOffsetPath: makeOffsetPath, fromOffsetPath: fromOffsetPath, splitTree: splitTree, splitPoint: splitPoint, create: dom_create, createText: createText, remove: remove, removeWhile: removeWhile, replace: dom_replace, html: dom_html, value: dom_value, posFromPlaceholder: posFromPlaceholder, attachEvents: attachEvents, detachEvents: detachEvents, isCustomStyleTag: isCustomStyleTag, }; // CONCATENATED MODULE: ./src/js/base/Context.js function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } var Context_Context = /*#__PURE__*/ (function () { /** * @param {jQuery} $note * @param {Object} options */ function Context($note, options) { _classCallCheck(this, Context); this.$note = $note; this.memos = {}; this.modules = {}; this.layoutInfo = {}; this.options = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.extend( true, {}, options ); // init ui with options external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.summernote.ui = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.summernote.ui_template( this.options ); this.ui = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.summernote.ui; this.initialize(); } /** * create layout and initialize modules and other resources */ _createClass(Context, [ { key: "initialize", value: function initialize() { this.layoutInfo = this.ui.createLayout(this.$note); this._initialize(); this.$note.hide(); return this; }, /** * destroy modules and other resources and remove layout */ }, { key: "destroy", value: function destroy() { this._destroy(); this.$note.removeData("summernote"); this.ui.removeLayout(this.$note, this.layoutInfo); }, /** * destory modules and other resources and initialize it again */ }, { key: "reset", value: function reset() { var disabled = this.isDisabled(); this.code(dom.emptyPara); this._destroy(); this._initialize(); if (disabled) { this.disable(); } }, }, { key: "_initialize", value: function _initialize() { var _this = this; // set own id this.options.id = func.uniqueId( external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.now() ); // set default container for tooltips, popovers, and dialogs this.options.container = this.options.container || this.layoutInfo.editor; // add optional buttons var buttons = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.extend( {}, this.options.buttons ); Object.keys(buttons).forEach(function (key) { _this.memo("button." + key, buttons[key]); }); var modules = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.extend( {}, this.options.modules, external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default .a.summernote.plugins || {} ); // add and initialize modules Object.keys(modules).forEach(function (key) { _this.module(key, modules[key], true); }); Object.keys(this.modules).forEach(function (key) { _this.initializeModule(key); }); }, }, { key: "_destroy", value: function _destroy() { var _this2 = this; // destroy modules with reversed order Object.keys(this.modules) .reverse() .forEach(function (key) { _this2.removeModule(key); }); Object.keys(this.memos).forEach(function (key) { _this2.removeMemo(key); }); // trigger custom onDestroy callback this.triggerEvent("destroy", this); }, }, { key: "code", value: function code(html) { var isActivated = this.invoke("codeview.isActivated"); if (html === undefined) { this.invoke("codeview.sync"); return isActivated ? this.layoutInfo.codable.val() : this.layoutInfo.editable.html(); } else { if (isActivated) { this.invoke("codeview.sync", html); } else { this.layoutInfo.editable.html(html); } this.$note.val(html); this.triggerEvent("change", html, this.layoutInfo.editable); } }, }, { key: "isDisabled", value: function isDisabled() { return ( this.layoutInfo.editable.attr("contenteditable") === "false" ); }, }, { key: "enable", value: function enable() { this.layoutInfo.editable.attr("contenteditable", true); this.invoke("toolbar.activate", true); this.triggerEvent("disable", false); this.options.editing = true; }, }, { key: "disable", value: function disable() { // close codeview if codeview is opend if (this.invoke("codeview.isActivated")) { this.invoke("codeview.deactivate"); } this.layoutInfo.editable.attr("contenteditable", false); this.options.editing = false; this.invoke("toolbar.deactivate", true); this.triggerEvent("disable", true); }, }, { key: "triggerEvent", value: function triggerEvent() { var namespace = lists.head(arguments); var args = lists.tail(lists.from(arguments)); var callback = this.options.callbacks[ func.namespaceToCamel(namespace, "on") ]; if (callback) { callback.apply(this.$note[0], args); } this.$note.trigger("summernote." + namespace, args); }, }, { key: "initializeModule", value: function initializeModule(key) { var module = this.modules[key]; module.shouldInitialize = module.shouldInitialize || func.ok; if (!module.shouldInitialize()) { return; } // initialize module if (module.initialize) { module.initialize(); } // attach events if (module.events) { dom.attachEvents(this.$note, module.events); } }, }, { key: "module", value: function module(key, ModuleClass, withoutIntialize) { if (arguments.length === 1) { return this.modules[key]; } this.modules[key] = new ModuleClass(this); if (!withoutIntialize) { this.initializeModule(key); } }, }, { key: "removeModule", value: function removeModule(key) { var module = this.modules[key]; if (module.shouldInitialize()) { if (module.events) { dom.detachEvents(this.$note, module.events); } if (module.destroy) { module.destroy(); } } delete this.modules[key]; }, }, { key: "memo", value: function memo(key, obj) { if (arguments.length === 1) { return this.memos[key]; } this.memos[key] = obj; }, }, { key: "removeMemo", value: function removeMemo(key) { if (this.memos[key] && this.memos[key].destroy) { this.memos[key].destroy(); } delete this.memos[key]; }, /** * Some buttons need to change their visual style immediately once they get pressed */ }, { key: "createInvokeHandlerAndUpdateState", value: function createInvokeHandlerAndUpdateState( namespace, value ) { var _this3 = this; return function (event) { _this3.createInvokeHandler(namespace, value)(event); _this3.invoke("buttons.updateCurrentStyle"); }; }, }, { key: "createInvokeHandler", value: function createInvokeHandler(namespace, value) { var _this4 = this; return function (event) { event.preventDefault(); var $target = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()( event.target ); _this4.invoke( namespace, value || $target.closest("[data-value]").data("value"), $target ); }; }, }, { key: "invoke", value: function invoke() { var namespace = lists.head(arguments); var args = lists.tail(lists.from(arguments)); var splits = namespace.split("."); var hasSeparator = splits.length > 1; var moduleName = hasSeparator && lists.head(splits); var methodName = hasSeparator ? lists.last(splits) : lists.head(splits); var module = this.modules[moduleName || "editor"]; if (!moduleName && this[methodName]) { return this[methodName].apply(this, args); } else if ( module && module[methodName] && module.shouldInitialize() ) { return module[methodName].apply(module, args); } }, }, ]); return Context; })(); // CONCATENATED MODULE: ./src/js/summernote.js external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.fn.extend( { /** * Summernote API * * @param {Object|String} * @return {this} */ summernote: function summernote() { var type = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.type( lists.head(arguments) ); var isExternalAPICalled = type === "string"; var hasInitOptions = type === "object"; var options = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.extend( {}, external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default .a.summernote.options, hasInitOptions ? lists.head(arguments) : {} ); // Update options options.langInfo = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.extend( true, {}, external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default .a.summernote.lang["en-US"], external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default .a.summernote.lang[options.lang] ); options.icons = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.extend( true, {}, external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default .a.summernote.options.icons, options.icons ); options.tooltip = options.tooltip === "auto" ? !env.isSupportTouch : options.tooltip; this.each(function (idx, note) { var $note = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()( note ); if (!$note.data("summernote")) { var context = new Context_Context($note, options); $note.data("summernote", context); $note .data("summernote") .triggerEvent("init", context.layoutInfo); } }); var $note = this.first(); if ($note.length) { var context = $note.data("summernote"); if (isExternalAPICalled) { return context.invoke.apply(context, lists.from(arguments)); } else if (options.focus) { context.invoke("editor.focus"); } } return this; }, } ); // CONCATENATED MODULE: ./src/js/base/core/range.js function range_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } function range_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } function range_createClass(Constructor, protoProps, staticProps) { if (protoProps) range_defineProperties(Constructor.prototype, protoProps); if (staticProps) range_defineProperties(Constructor, staticProps); return Constructor; } /** * return boundaryPoint from TextRange, inspired by Andy Na's HuskyRange.js * * @param {TextRange} textRange * @param {Boolean} isStart * @return {BoundaryPoint} * * @see http://msdn.microsoft.com/en-us/library/ie/ms535872(v=vs.85).aspx */ function textRangeToPoint(textRange, isStart) { var container = textRange.parentElement(); var offset; var tester = document.body.createTextRange(); var prevContainer; var childNodes = lists.from(container.childNodes); for (offset = 0; offset < childNodes.length; offset++) { if (dom.isText(childNodes[offset])) { continue; } tester.moveToElementText(childNodes[offset]); if (tester.compareEndPoints("StartToStart", textRange) >= 0) { break; } prevContainer = childNodes[offset]; } if (offset !== 0 && dom.isText(childNodes[offset - 1])) { var textRangeStart = document.body.createTextRange(); var curTextNode = null; textRangeStart.moveToElementText(prevContainer || container); textRangeStart.collapse(!prevContainer); curTextNode = prevContainer ? prevContainer.nextSibling : container.firstChild; var pointTester = textRange.duplicate(); pointTester.setEndPoint("StartToStart", textRangeStart); var textCount = pointTester.text.replace(/[\r\n]/g, "").length; while ( textCount > curTextNode.nodeValue.length && curTextNode.nextSibling ) { textCount -= curTextNode.nodeValue.length; curTextNode = curTextNode.nextSibling; } // [workaround] enforce IE to re-reference curTextNode, hack var dummy = curTextNode.nodeValue; // eslint-disable-line if ( isStart && curTextNode.nextSibling && dom.isText(curTextNode.nextSibling) && textCount === curTextNode.nodeValue.length ) { textCount -= curTextNode.nodeValue.length; curTextNode = curTextNode.nextSibling; } container = curTextNode; offset = textCount; } return { cont: container, offset: offset, }; } /** * return TextRange from boundary point (inspired by google closure-library) * @param {BoundaryPoint} point * @return {TextRange} */ function pointToTextRange(point) { var textRangeInfo = function textRangeInfo(container, offset) { var node, isCollapseToStart; if (dom.isText(container)) { var prevTextNodes = dom.listPrev(container, func.not(dom.isText)); var prevContainer = lists.last(prevTextNodes).previousSibling; node = prevContainer || container.parentNode; offset += lists.sum(lists.tail(prevTextNodes), dom.nodeLength); isCollapseToStart = !prevContainer; } else { node = container.childNodes[offset] || container; if (dom.isText(node)) { return textRangeInfo(node, 0); } offset = 0; isCollapseToStart = false; } return { node: node, collapseToStart: isCollapseToStart, offset: offset, }; }; var textRange = document.body.createTextRange(); var info = textRangeInfo(point.node, point.offset); textRange.moveToElementText(info.node); textRange.collapse(info.collapseToStart); textRange.moveStart("character", info.offset); return textRange; } /** * Wrapped Range * * @constructor * @param {Node} sc - start container * @param {Number} so - start offset * @param {Node} ec - end container * @param {Number} eo - end offset */ var range_WrappedRange = /*#__PURE__*/ (function () { function WrappedRange(sc, so, ec, eo) { range_classCallCheck(this, WrappedRange); this.sc = sc; this.so = so; this.ec = ec; this.eo = eo; // isOnEditable: judge whether range is on editable or not this.isOnEditable = this.makeIsOn(dom.isEditable); // isOnList: judge whether range is on list node or not this.isOnList = this.makeIsOn(dom.isList); // isOnAnchor: judge whether range is on anchor node or not this.isOnAnchor = this.makeIsOn(dom.isAnchor); // isOnCell: judge whether range is on cell node or not this.isOnCell = this.makeIsOn(dom.isCell); // isOnData: judge whether range is on data node or not this.isOnData = this.makeIsOn(dom.isData); } // nativeRange: get nativeRange from sc, so, ec, eo range_createClass(WrappedRange, [ { key: "nativeRange", value: function nativeRange() { if (env.isW3CRangeSupport) { var w3cRange = document.createRange(); w3cRange.setStart(this.sc, this.so); w3cRange.setEnd(this.ec, this.eo); return w3cRange; } else { var textRange = pointToTextRange({ node: this.sc, offset: this.so, }); textRange.setEndPoint( "EndToEnd", pointToTextRange({ node: this.ec, offset: this.eo, }) ); return textRange; } }, }, { key: "getPoints", value: function getPoints() { return { sc: this.sc, so: this.so, ec: this.ec, eo: this.eo, }; }, }, { key: "getStartPoint", value: function getStartPoint() { return { node: this.sc, offset: this.so, }; }, }, { key: "getEndPoint", value: function getEndPoint() { return { node: this.ec, offset: this.eo, }; }, /** * select update visible range */ }, { key: "select", value: function select() { var nativeRng = this.nativeRange(); if (env.isW3CRangeSupport) { var selection = document.getSelection(); if (selection.rangeCount > 0) { selection.removeAllRanges(); } selection.addRange(nativeRng); } else { nativeRng.select(); } return this; }, /** * Moves the scrollbar to start container(sc) of current range * * @return {WrappedRange} */ }, { key: "scrollIntoView", value: function scrollIntoView(container) { var height = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()( container ).height(); if (container.scrollTop + height < this.sc.offsetTop) { container.scrollTop += Math.abs( container.scrollTop + height - this.sc.offsetTop ); } return this; }, /** * @return {WrappedRange} */ }, { key: "normalize", value: function normalize() { /** * @param {BoundaryPoint} point * @param {Boolean} isLeftToRight - true: prefer to choose right node * - false: prefer to choose left node * @return {BoundaryPoint} */ var getVisiblePoint = function getVisiblePoint( point, isLeftToRight ) { if (!point) { return point; } // Just use the given point [XXX:Adhoc] // - case 01. if the point is on the middle of the node // - case 02. if the point is on the right edge and prefer to choose left node // - case 03. if the point is on the left edge and prefer to choose right node // - case 04. if the point is on the right edge and prefer to choose right node but the node is void // - case 05. if the point is on the left edge and prefer to choose left node but the node is void // - case 06. if the point is on the block node and there is no children if (dom.isVisiblePoint(point)) { if ( !dom.isEdgePoint(point) || (dom.isRightEdgePoint(point) && !isLeftToRight) || (dom.isLeftEdgePoint(point) && isLeftToRight) || (dom.isRightEdgePoint(point) && isLeftToRight && dom.isVoid(point.node.nextSibling)) || (dom.isLeftEdgePoint(point) && !isLeftToRight && dom.isVoid(point.node.previousSibling)) || (dom.isBlock(point.node) && dom.isEmpty(point.node)) ) { return point; } } // point on block's edge var block = dom.ancestor(point.node, dom.isBlock); var hasRightNode = false; if (!hasRightNode) { var prevPoint = dom.prevPoint(point) || { node: null, }; hasRightNode = (dom.isLeftEdgePointOf(point, block) || dom.isVoid(prevPoint.node)) && !isLeftToRight; } var hasLeftNode = false; if (!hasLeftNode) { var _nextPoint = dom.nextPoint(point) || { node: null, }; hasLeftNode = (dom.isRightEdgePointOf(point, block) || dom.isVoid(_nextPoint.node)) && isLeftToRight; } if (hasRightNode || hasLeftNode) { // returns point already on visible point if (dom.isVisiblePoint(point)) { return point; } // reverse direction isLeftToRight = !isLeftToRight; } var nextPoint = isLeftToRight ? dom.nextPointUntil( dom.nextPoint(point), dom.isVisiblePoint ) : dom.prevPointUntil( dom.prevPoint(point), dom.isVisiblePoint ); return nextPoint || point; }; var endPoint = getVisiblePoint(this.getEndPoint(), false); var startPoint = this.isCollapsed() ? endPoint : getVisiblePoint(this.getStartPoint(), true); return new WrappedRange( startPoint.node, startPoint.offset, endPoint.node, endPoint.offset ); }, /** * returns matched nodes on range * * @param {Function} [pred] - predicate function * @param {Object} [options] * @param {Boolean} [options.includeAncestor] * @param {Boolean} [options.fullyContains] * @return {Node[]} */ }, { key: "nodes", value: function nodes(pred, options) { pred = pred || func.ok; var includeAncestor = options && options.includeAncestor; var fullyContains = options && options.fullyContains; // TODO compare points and sort var startPoint = this.getStartPoint(); var endPoint = this.getEndPoint(); var nodes = []; var leftEdgeNodes = []; dom.walkPoint( startPoint, endPoint, function (point) { if (dom.isEditable(point.node)) { return; } var node; if (fullyContains) { if (dom.isLeftEdgePoint(point)) { leftEdgeNodes.push(point.node); } if ( dom.isRightEdgePoint(point) && lists.contains(leftEdgeNodes, point.node) ) { node = point.node; } } else if (includeAncestor) { node = dom.ancestor(point.node, pred); } else { node = point.node; } if (node && pred(node)) { nodes.push(node); } }, true ); return lists.unique(nodes); }, /** * returns commonAncestor of range * @return {Element} - commonAncestor */ }, { key: "commonAncestor", value: function commonAncestor() { return dom.commonAncestor(this.sc, this.ec); }, /** * returns expanded range by pred * * @param {Function} pred - predicate function * @return {WrappedRange} */ }, { key: "expand", value: function expand(pred) { var startAncestor = dom.ancestor(this.sc, pred); var endAncestor = dom.ancestor(this.ec, pred); if (!startAncestor && !endAncestor) { return new WrappedRange(this.sc, this.so, this.ec, this.eo); } var boundaryPoints = this.getPoints(); if (startAncestor) { boundaryPoints.sc = startAncestor; boundaryPoints.so = 0; } if (endAncestor) { boundaryPoints.ec = endAncestor; boundaryPoints.eo = dom.nodeLength(endAncestor); } return new WrappedRange( boundaryPoints.sc, boundaryPoints.so, boundaryPoints.ec, boundaryPoints.eo ); }, /** * @param {Boolean} isCollapseToStart * @return {WrappedRange} */ }, { key: "collapse", value: function collapse(isCollapseToStart) { if (isCollapseToStart) { return new WrappedRange(this.sc, this.so, this.sc, this.so); } else { return new WrappedRange(this.ec, this.eo, this.ec, this.eo); } }, /** * splitText on range */ }, { key: "splitText", value: function splitText() { var isSameContainer = this.sc === this.ec; var boundaryPoints = this.getPoints(); if ( dom.isText(this.ec) && !dom.isEdgePoint(this.getEndPoint()) ) { this.ec.splitText(this.eo); } if ( dom.isText(this.sc) && !dom.isEdgePoint(this.getStartPoint()) ) { boundaryPoints.sc = this.sc.splitText(this.so); boundaryPoints.so = 0; if (isSameContainer) { boundaryPoints.ec = boundaryPoints.sc; boundaryPoints.eo = this.eo - this.so; } } return new WrappedRange( boundaryPoints.sc, boundaryPoints.so, boundaryPoints.ec, boundaryPoints.eo ); }, /** * delete contents on range * @return {WrappedRange} */ }, { key: "deleteContents", value: function deleteContents() { if (this.isCollapsed()) { return this; } var rng = this.splitText(); var nodes = rng.nodes(null, { fullyContains: true, }); // find new cursor point var point = dom.prevPointUntil( rng.getStartPoint(), function (point) { return !lists.contains(nodes, point.node); } ); var emptyParents = []; external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.each( nodes, function (idx, node) { // find empty parents var parent = node.parentNode; if (point.node !== parent && dom.nodeLength(parent) === 1) { emptyParents.push(parent); } dom.remove(node, false); } ); // remove empty parents external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.each( emptyParents, function (idx, node) { dom.remove(node, false); } ); return new WrappedRange( point.node, point.offset, point.node, point.offset ).normalize(); }, /** * makeIsOn: return isOn(pred) function */ }, { key: "makeIsOn", value: function makeIsOn(pred) { return function () { var ancestor = dom.ancestor(this.sc, pred); return !!ancestor && ancestor === dom.ancestor(this.ec, pred); }; }, /** * @param {Function} pred * @return {Boolean} */ }, { key: "isLeftEdgeOf", value: function isLeftEdgeOf(pred) { if (!dom.isLeftEdgePoint(this.getStartPoint())) { return false; } var node = dom.ancestor(this.sc, pred); return node && dom.isLeftEdgeOf(this.sc, node); }, /** * returns whether range was collapsed or not */ }, { key: "isCollapsed", value: function isCollapsed() { return this.sc === this.ec && this.so === this.eo; }, /** * wrap inline nodes which children of body with paragraph * * @return {WrappedRange} */ }, { key: "wrapBodyInlineWithPara", value: function wrapBodyInlineWithPara() { if (dom.isBodyContainer(this.sc) && dom.isEmpty(this.sc)) { this.sc.innerHTML = dom.emptyPara; return new WrappedRange( this.sc.firstChild, 0, this.sc.firstChild, 0 ); } /** * [workaround] firefox often create range on not visible point. so normalize here. * - firefox: |text
| * - chrome:|text|
*/ var rng = this.normalize(); if (dom.isParaInline(this.sc) || dom.isPara(this.sc)) { return rng; } // find inline top ancestor var topAncestor; if (dom.isInline(rng.sc)) { var ancestors = dom.listAncestor( rng.sc, func.not(dom.isInline) ); topAncestor = lists.last(ancestors); if (!dom.isInline(topAncestor)) { topAncestor = ancestors[ancestors.length - 2] || rng.sc.childNodes[rng.so]; } } else { topAncestor = rng.sc.childNodes[rng.so > 0 ? rng.so - 1 : 0]; } if (topAncestor) { // siblings not in paragraph var inlineSiblings = dom .listPrev(topAncestor, dom.isParaInline) .reverse(); inlineSiblings = inlineSiblings.concat( dom.listNext(topAncestor.nextSibling, dom.isParaInline) ); // wrap with paragraph if (inlineSiblings.length) { var para = dom.wrap(lists.head(inlineSiblings), "p"); dom.appendChildNodes(para, lists.tail(inlineSiblings)); } } return this.normalize(); }, /** * insert node at current cursor * * @param {Node} node * @return {Node} */ }, { key: "insertNode", value: function insertNode(node) { var rng = this; if (dom.isText(node) || dom.isInline(node)) { rng = this.wrapBodyInlineWithPara().deleteContents(); } var info = dom.splitPoint( rng.getStartPoint(), dom.isInline(node) ); if (info.rightNode) { info.rightNode.parentNode.insertBefore(node, info.rightNode); if (dom.isEmpty(info.rightNode) && dom.isPara(node)) { info.rightNode.parentNode.removeChild(info.rightNode); } } else { info.container.appendChild(node); } return node; }, /** * insert html at current cursor */ }, { key: "pasteHTML", value: function pasteHTML(markup) { markup = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.trim( markup ); var contentsContainer = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()( "" ).html(markup)[0]; var childNodes = lists.from(contentsContainer.childNodes); // const rng = this.wrapBodyInlineWithPara().deleteContents(); var rng = this; var reversed = false; if (rng.so >= 0) { childNodes = childNodes.reverse(); reversed = true; } childNodes = childNodes.map(function (childNode) { return rng.insertNode(childNode); }); if (reversed) { childNodes = childNodes.reverse(); } return childNodes; }, /** * returns text in range * * @return {String} */ }, { key: "toString", value: function toString() { var nativeRng = this.nativeRange(); return env.isW3CRangeSupport ? nativeRng.toString() : nativeRng.text; }, /** * returns range for word before cursor * * @param {Boolean} [findAfter] - find after cursor, default: false * @return {WrappedRange} */ }, { key: "getWordRange", value: function getWordRange(findAfter) { var endPoint = this.getEndPoint(); if (!dom.isCharPoint(endPoint)) { return this; } var startPoint = dom.prevPointUntil(endPoint, function (point) { return !dom.isCharPoint(point); }); if (findAfter) { endPoint = dom.nextPointUntil(endPoint, function (point) { return !dom.isCharPoint(point); }); } return new WrappedRange( startPoint.node, startPoint.offset, endPoint.node, endPoint.offset ); }, /** * returns range for words before cursor * * @param {Boolean} [findAfter] - find after cursor, default: false * @return {WrappedRange} */ }, { key: "getWordsRange", value: function getWordsRange(findAfter) { var endPoint = this.getEndPoint(); var isNotTextPoint = function isNotTextPoint(point) { return !dom.isCharPoint(point) && !dom.isSpacePoint(point); }; if (isNotTextPoint(endPoint)) { return this; } var startPoint = dom.prevPointUntil(endPoint, isNotTextPoint); if (findAfter) { endPoint = dom.nextPointUntil(endPoint, isNotTextPoint); } return new WrappedRange( startPoint.node, startPoint.offset, endPoint.node, endPoint.offset ); }, /** * returns range for words before cursor that match with a Regex * * example: * range: 'hi @Peter Pan' * regex: '/@[a-z ]+/i' * return range: '@Peter Pan' * * @param {RegExp} [regex] * @return {WrappedRange|null} */ }, { key: "getWordsMatchRange", value: function getWordsMatchRange(regex) { var endPoint = this.getEndPoint(); var startPoint = dom.prevPointUntil(endPoint, function (point) { if (!dom.isCharPoint(point) && !dom.isSpacePoint(point)) { return true; } var rng = new WrappedRange( point.node, point.offset, endPoint.node, endPoint.offset ); var result = regex.exec(rng.toString()); return result && result.index === 0; }); var rng = new WrappedRange( startPoint.node, startPoint.offset, endPoint.node, endPoint.offset ); var text = rng.toString(); var result = regex.exec(text); if (result && result[0].length === text.length) { return rng; } else { return null; } }, /** * create offsetPath bookmark * * @param {Node} editable */ }, { key: "bookmark", value: function bookmark(editable) { return { s: { path: dom.makeOffsetPath(editable, this.sc), offset: this.so, }, e: { path: dom.makeOffsetPath(editable, this.ec), offset: this.eo, }, }; }, /** * create offsetPath bookmark base on paragraph * * @param {Node[]} paras */ }, { key: "paraBookmark", value: function paraBookmark(paras) { return { s: { path: lists.tail( dom.makeOffsetPath(lists.head(paras), this.sc) ), offset: this.so, }, e: { path: lists.tail( dom.makeOffsetPath(lists.last(paras), this.ec) ), offset: this.eo, }, }; }, /** * getClientRects * @return {Rect[]} */ }, { key: "getClientRects", value: function getClientRects() { var nativeRng = this.nativeRange(); return nativeRng.getClientRects(); }, }, ]); return WrappedRange; })(); /** * Data structure * * BoundaryPoint: a point of dom tree * * BoundaryPoints: two boundaryPoints corresponding to the start and the end of the Range * * See to http://www.w3.org/TR/DOM-Level-2-Traversal-Range/ranges.html#Level-2-Range-Position */ /* harmony default export */ var range = { /** * create Range Object From arguments or Browser Selection * * @param {Node} sc - start container * @param {Number} so - start offset * @param {Node} ec - end container * @param {Number} eo - end offset * @return {WrappedRange} */ create: function create(sc, so, ec, eo) { if (arguments.length === 4) { return new range_WrappedRange(sc, so, ec, eo); } else if (arguments.length === 2) { // collapsed ec = sc; eo = so; return new range_WrappedRange(sc, so, ec, eo); } else { var wrappedRange = this.createFromSelection(); if (!wrappedRange && arguments.length === 1) { var bodyElement = arguments[0]; if (dom.isEditable(bodyElement)) { bodyElement = bodyElement.lastChild; } return this.createFromBodyElement( bodyElement, dom.emptyPara === arguments[0].innerHTML ); } return wrappedRange; } }, createFromBodyElement: function createFromBodyElement(bodyElement) { var isCollapseToStart = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; var wrappedRange = this.createFromNode(bodyElement); return wrappedRange.collapse(isCollapseToStart); }, createFromSelection: function createFromSelection() { var sc, so, ec, eo; if (env.isW3CRangeSupport) { var selection = document.getSelection(); if (!selection || selection.rangeCount === 0) { return null; } else if (dom.isBody(selection.anchorNode)) { // Firefox: returns entire body as range on initialization. // We won't never need it. return null; } var nativeRng = selection.getRangeAt(0); sc = nativeRng.startContainer; so = nativeRng.startOffset; ec = nativeRng.endContainer; eo = nativeRng.endOffset; } else { // IE8: TextRange var textRange = document.selection.createRange(); var textRangeEnd = textRange.duplicate(); textRangeEnd.collapse(false); var textRangeStart = textRange; textRangeStart.collapse(true); var startPoint = textRangeToPoint(textRangeStart, true); var endPoint = textRangeToPoint(textRangeEnd, false); // same visible point case: range was collapsed. if ( dom.isText(startPoint.node) && dom.isLeftEdgePoint(startPoint) && dom.isTextNode(endPoint.node) && dom.isRightEdgePoint(endPoint) && endPoint.node.nextSibling === startPoint.node ) { startPoint = endPoint; } sc = startPoint.cont; so = startPoint.offset; ec = endPoint.cont; eo = endPoint.offset; } return new range_WrappedRange(sc, so, ec, eo); }, /** * @method * * create WrappedRange from node * * @param {Node} node * @return {WrappedRange} */ createFromNode: function createFromNode(node) { var sc = node; var so = 0; var ec = node; var eo = dom.nodeLength(ec); // browsers can't target a picture or void node if (dom.isVoid(sc)) { so = dom.listPrev(sc).length - 1; sc = sc.parentNode; } if (dom.isBR(ec)) { eo = dom.listPrev(ec).length - 1; ec = ec.parentNode; } else if (dom.isVoid(ec)) { eo = dom.listPrev(ec).length; ec = ec.parentNode; } return this.create(sc, so, ec, eo); }, /** * create WrappedRange from node after position * * @param {Node} node * @return {WrappedRange} */ createFromNodeBefore: function createFromNodeBefore(node) { return this.createFromNode(node).collapse(true); }, /** * create WrappedRange from node after position * * @param {Node} node * @return {WrappedRange} */ createFromNodeAfter: function createFromNodeAfter(node) { return this.createFromNode(node).collapse(); }, /** * @method * * create WrappedRange from bookmark * * @param {Node} editable * @param {Object} bookmark * @return {WrappedRange} */ createFromBookmark: function createFromBookmark(editable, bookmark) { var sc = dom.fromOffsetPath(editable, bookmark.s.path); var so = bookmark.s.offset; var ec = dom.fromOffsetPath(editable, bookmark.e.path); var eo = bookmark.e.offset; return new range_WrappedRange(sc, so, ec, eo); }, /** * @method * * create WrappedRange from paraBookmark * * @param {Object} bookmark * @param {Node[]} paras * @return {WrappedRange} */ createFromParaBookmark: function createFromParaBookmark( bookmark, paras ) { var so = bookmark.s.offset; var eo = bookmark.e.offset; var sc = dom.fromOffsetPath(lists.head(paras), bookmark.s.path); var ec = dom.fromOffsetPath(lists.last(paras), bookmark.e.path); return new range_WrappedRange(sc, so, ec, eo); }, }; // CONCATENATED MODULE: ./src/js/base/core/key.js var KEY_MAP = { BACKSPACE: 8, TAB: 9, ENTER: 13, ESCAPE: 27, SPACE: 32, DELETE: 46, // Arrow LEFT: 37, UP: 38, RIGHT: 39, DOWN: 40, // Number: 0-9 NUM0: 48, NUM1: 49, NUM2: 50, NUM3: 51, NUM4: 52, NUM5: 53, NUM6: 54, NUM7: 55, NUM8: 56, // Alphabet: a-z B: 66, E: 69, I: 73, J: 74, K: 75, L: 76, R: 82, S: 83, U: 85, V: 86, Y: 89, Z: 90, SLASH: 191, LEFTBRACKET: 219, BACKSLASH: 220, RIGHTBRACKET: 221, // Navigation HOME: 36, END: 35, PAGEUP: 33, PAGEDOWN: 34, }; /** * @class core.key * * Object for keycodes. * * @singleton * @alternateClassName key */ /* harmony default export */ var core_key = { /** * @method isEdit * * @param {Number} keyCode * @return {Boolean} */ isEdit: function isEdit(keyCode) { return lists.contains( [ KEY_MAP.BACKSPACE, KEY_MAP.TAB, KEY_MAP.ENTER, KEY_MAP.SPACE, KEY_MAP.DELETE, ], keyCode ); }, /** * @method isMove * * @param {Number} keyCode * @return {Boolean} */ isMove: function isMove(keyCode) { return lists.contains( [KEY_MAP.LEFT, KEY_MAP.UP, KEY_MAP.RIGHT, KEY_MAP.DOWN], keyCode ); }, /** * @method isNavigation * * @param {Number} keyCode * @return {Boolean} */ isNavigation: function isNavigation(keyCode) { return lists.contains( [KEY_MAP.HOME, KEY_MAP.END, KEY_MAP.PAGEUP, KEY_MAP.PAGEDOWN], keyCode ); }, /** * @property {Object} nameFromCode * @property {String} nameFromCode.8 "BACKSPACE" */ nameFromCode: func.invertObject(KEY_MAP), code: KEY_MAP, }; // CONCATENATED MODULE: ./src/js/base/core/async.js /** * @method readFileAsDataURL * * read contents of file as representing URL * * @param {File} file * @return {Promise} - then: dataUrl */ function readFileAsDataURL(file) { return external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a .Deferred(function (deferred) { external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a .extend(new FileReader(), { onload: function onload(e) { var dataURL = e.target.result; deferred.resolve(dataURL); }, onerror: function onerror(err) { deferred.reject(err); }, }) .readAsDataURL(file); }) .promise(); } /** * @method createImage * * create `- ,
- )
dom.appendChildNodes(listNode, paras);
if (nextList) {
dom.appendChildNodes(
listNode,
lists.from(nextList.childNodes)
);
dom.remove(nextList);
}
return paras;
},
/**
* @method releaseList
*
* @param {Array[]} clustereds
* @param {Boolean} isEscapseToBody
* @return {Node[]}
*/
},
{
key: "releaseList",
value: function releaseList(clustereds, isEscapseToBody) {
var _this4 = this;
var releasedParas = [];
external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.each(
clustereds,
function (idx, paras) {
var head = lists.head(paras);
var last = lists.last(paras);
var headList = isEscapseToBody
? dom.lastAncestor(head, dom.isList)
: head.parentNode;
var parentItem = headList.parentNode;
if (headList.parentNode.nodeName === "LI") {
paras.map(function (para) {
var newList = _this4.findNextSiblings(para);
if (parentItem.nextSibling) {
parentItem.parentNode.insertBefore(
para,
parentItem.nextSibling
);
} else {
parentItem.parentNode.appendChild(para);
}
if (newList.length) {
_this4.wrapList(newList, headList.nodeName);
para.appendChild(newList[0].parentNode);
}
});
if (headList.children.length === 0) {
parentItem.removeChild(headList);
}
if (parentItem.childNodes.length === 0) {
parentItem.parentNode.removeChild(parentItem);
}
} else {
var lastList =
headList.childNodes.length > 1
? dom.splitTree(
headList,
{
node: last.parentNode,
offset: dom.position(last) + 1,
},
{
isSkipPaddingBlankHTML: true,
}
)
: null;
var middleList = dom.splitTree(
headList,
{
node: head.parentNode,
offset: dom.position(head),
},
{
isSkipPaddingBlankHTML: true,
}
);
paras = isEscapseToBody
? dom.listDescendant(middleList, dom.isLi)
: lists.from(middleList.childNodes).filter(dom.isLi); // LI to P
if (isEscapseToBody || !dom.isList(headList.parentNode)) {
paras = paras.map(function (para) {
return dom.replace(para, "P");
});
}
external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.each(
lists.from(paras).reverse(),
function (idx, para) {
dom.insertAfter(para, headList);
}
); // remove empty lists
var rootLists = lists.compact([
headList,
middleList,
lastList,
]);
external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.each(
rootLists,
function (idx, rootList) {
var listNodes = [rootList].concat(
dom.listDescendant(rootList, dom.isList)
);
external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.each(
listNodes.reverse(),
function (idx, listNode) {
if (!dom.nodeLength(listNode)) {
dom.remove(listNode, true);
}
}
);
}
);
}
releasedParas = releasedParas.concat(paras);
}
);
return releasedParas;
},
/**
* @method appendToPrevious
*
* Appends list to previous list item, if
* none exist it wraps the list in a new list item.
*
* @param {HTMLNode} ListItem
* @return {HTMLNode}
*/
},
{
key: "appendToPrevious",
value: function appendToPrevious(node) {
return node.previousSibling
? dom.appendChildNodes(node.previousSibling, [node])
: this.wrapList([node], "LI");
},
/**
* @method findList
*
* Finds an existing list in list item
*
* @param {HTMLNode} ListItem
* @return {Array[]}
*/
},
{
key: "findList",
value: function findList(node) {
return node
? lists.find(node.children, function (child) {
return ["OL", "UL"].indexOf(child.nodeName) > -1;
})
: null;
},
/**
* @method findNextSiblings
*
* Finds all list item siblings that follow it
*
* @param {HTMLNode} ListItem
* @return {HTMLNode}
*/
},
{
key: "findNextSiblings",
value: function findNextSiblings(node) {
var siblings = [];
while (node.nextSibling) {
siblings.push(node.nextSibling);
node = node.nextSibling;
}
return siblings;
},
},
]);
return Bullet;
})();
// CONCATENATED MODULE: ./src/js/base/editing/Typing.js
function Typing_classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
}
function Typing_defineProperties(target, props) {
for (var i = 0; i < props.length; i++) {
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}
function Typing_createClass(Constructor, protoProps, staticProps) {
if (protoProps)
Typing_defineProperties(Constructor.prototype, protoProps);
if (staticProps) Typing_defineProperties(Constructor, staticProps);
return Constructor;
}
/**
* @class editing.Typing
*
* Typing
*
*/
var Typing_Typing = /*#__PURE__*/ (function () {
function Typing(context) {
Typing_classCallCheck(this, Typing);
// a Bullet instance to toggle lists off
this.bullet = new Bullet_Bullet();
this.options = context.options;
}
/**
* insert tab
*
* @param {WrappedRange} rng
* @param {Number} tabsize
*/
Typing_createClass(Typing, [
{
key: "insertTab",
value: function insertTab(rng, tabsize) {
var tab = dom.createText(
new Array(tabsize + 1).join(dom.NBSP_CHAR)
);
rng = rng.deleteContents();
rng.insertNode(tab, true);
rng = range.create(tab, tabsize);
rng.select();
},
/**
* insert paragraph
*
* @param {jQuery} $editable
* @param {WrappedRange} rng Can be used in unit tests to "mock" the range
*
* blockquoteBreakingLevel
* 0 - No break, the new paragraph remains inside the quote
* 1 - Break the first blockquote in the ancestors list
* 2 - Break all blockquotes, so that the new paragraph is not quoted (this is the default)
*/
},
{
key: "insertParagraph",
value: function insertParagraph(editable, rng) {
rng = rng || range.create(editable); // deleteContents on range.
rng = rng.deleteContents(); // Wrap range if it needs to be wrapped by paragraph
rng = rng.wrapBodyInlineWithPara(); // finding paragraph
var splitRoot = dom.ancestor(rng.sc, dom.isPara);
var nextPara; // on paragraph: split paragraph
if (splitRoot) {
// if it is an empty line with li
if (
dom.isLi(splitRoot) &&
(dom.isEmpty(splitRoot) ||
dom.deepestChildIsEmpty(splitRoot))
) {
// toggle UL/OL and escape
this.bullet.toggleList(splitRoot.parentNode.nodeName);
return;
} else {
var blockquote = null;
if (this.options.blockquoteBreakingLevel === 1) {
blockquote = dom.ancestor(splitRoot, dom.isBlockquote);
} else if (this.options.blockquoteBreakingLevel === 2) {
blockquote = dom.lastAncestor(
splitRoot,
dom.isBlockquote
);
}
if (blockquote) {
// We're inside a blockquote and options ask us to break it
nextPara = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(
dom.emptyPara
)[0]; // If the split is right before a
, remove it so that there's no "empty line" // after the split in the new blockquote created if ( dom.isRightEdgePoint(rng.getStartPoint()) && dom.isBR(rng.sc.nextSibling) ) { external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()( rng.sc.nextSibling ).remove(); } var split = dom.splitTree( blockquote, rng.getStartPoint(), { isDiscardEmptySplits: true, } ); if (split) { split.parentNode.insertBefore(nextPara, split); } else { dom.insertAfter(nextPara, blockquote); // There's no split if we were at the end of the blockquote } } else { nextPara = dom.splitTree(splitRoot, rng.getStartPoint()); // not a blockquote, just insert the paragraph var emptyAnchors = dom.listDescendant( splitRoot, dom.isEmptyAnchor ); emptyAnchors = emptyAnchors.concat( dom.listDescendant(nextPara, dom.isEmptyAnchor) ); external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.each( emptyAnchors, function (idx, anchor) { dom.remove(anchor); } ); // replace empty heading, pre or custom-made styleTag with P tag if ( (dom.isHeading(nextPara) || dom.isPre(nextPara) || dom.isCustomStyleTag(nextPara)) && dom.isEmpty(nextPara) ) { nextPara = dom.replace(nextPara, "p"); } } } // no paragraph: insert empty paragraph } else { var next = rng.sc.childNodes[rng.so]; nextPara = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()( dom.emptyPara )[0]; if (next) { rng.sc.insertBefore(nextPara, next); } else { rng.sc.appendChild(nextPara); } } range .create(nextPara, 0) .normalize() .select() .scrollIntoView(editable); }, }, ]); return Typing; })(); // CONCATENATED MODULE: ./src/js/base/editing/Table.js function Table_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } function Table_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } function Table_createClass(Constructor, protoProps, staticProps) { if (protoProps) Table_defineProperties(Constructor.prototype, protoProps); if (staticProps) Table_defineProperties(Constructor, staticProps); return Constructor; } /** * @class Create a virtual table to create what actions to do in change. * @param {object} startPoint Cell selected to apply change. * @param {enum} where Where change will be applied Row or Col. Use enum: TableResultAction.where * @param {enum} action Action to be applied. Use enum: TableResultAction.requestAction * @param {object} domTable Dom element of table to make changes. */ var TableResultAction = function TableResultAction( startPoint, where, action, domTable ) { var _startPoint = { colPos: 0, rowPos: 0, }; var _virtualTable = []; var _actionCellList = []; /// /////////////////////////////////////////// // Private functions /// /////////////////////////////////////////// /** * Set the startPoint of action. */ function setStartPoint() { if ( !startPoint || !startPoint.tagName || (startPoint.tagName.toLowerCase() !== "td" && startPoint.tagName.toLowerCase() !== "th") ) { // Impossible to identify start Cell point return; } _startPoint.colPos = startPoint.cellIndex; if ( !startPoint.parentElement || !startPoint.parentElement.tagName || startPoint.parentElement.tagName.toLowerCase() !== "tr" ) { // Impossible to identify start Row point return; } _startPoint.rowPos = startPoint.parentElement.rowIndex; } /** * Define virtual table position info object. * * @param {int} rowIndex Index position in line of virtual table. * @param {int} cellIndex Index position in column of virtual table. * @param {object} baseRow Row affected by this position. * @param {object} baseCell Cell affected by this position. * @param {bool} isSpan Inform if it is an span cell/row. */ function setVirtualTablePosition( rowIndex, cellIndex, baseRow, baseCell, isRowSpan, isColSpan, isVirtualCell ) { var objPosition = { baseRow: baseRow, baseCell: baseCell, isRowSpan: isRowSpan, isColSpan: isColSpan, isVirtual: isVirtualCell, }; if (!_virtualTable[rowIndex]) { _virtualTable[rowIndex] = []; } _virtualTable[rowIndex][cellIndex] = objPosition; } /** * Create action cell object. * * @param {object} virtualTableCellObj Object of specific position on virtual table. * @param {enum} resultAction Action to be applied in that item. */ function getActionCell( virtualTableCellObj, resultAction, virtualRowPosition, virtualColPosition ) { return { baseCell: virtualTableCellObj.baseCell, action: resultAction, virtualTable: { rowIndex: virtualRowPosition, cellIndex: virtualColPosition, }, }; } /** * Recover free index of row to append Cell. * * @param {int} rowIndex Index of row to find free space. * @param {int} cellIndex Index of cell to find free space in table. */ function recoverCellIndex(rowIndex, cellIndex) { if (!_virtualTable[rowIndex]) { return cellIndex; } if (!_virtualTable[rowIndex][cellIndex]) { return cellIndex; } var newCellIndex = cellIndex; while (_virtualTable[rowIndex][newCellIndex]) { newCellIndex++; if (!_virtualTable[rowIndex][newCellIndex]) { return newCellIndex; } } } /** * Recover info about row and cell and add information to virtual table. * * @param {object} row Row to recover information. * @param {object} cell Cell to recover information. */ function addCellInfoToVirtual(row, cell) { var cellIndex = recoverCellIndex(row.rowIndex, cell.cellIndex); var cellHasColspan = cell.colSpan > 1; var cellHasRowspan = cell.rowSpan > 1; var isThisSelectedCell = row.rowIndex === _startPoint.rowPos && cell.cellIndex === _startPoint.colPos; setVirtualTablePosition( row.rowIndex, cellIndex, row, cell, cellHasRowspan, cellHasColspan, false ); // Add span rows to virtual Table. var rowspanNumber = cell.attributes.rowSpan ? parseInt(cell.attributes.rowSpan.value, 10) : 0; if (rowspanNumber > 1) { for (var rp = 1; rp < rowspanNumber; rp++) { var rowspanIndex = row.rowIndex + rp; adjustStartPoint( rowspanIndex, cellIndex, cell, isThisSelectedCell ); setVirtualTablePosition( rowspanIndex, cellIndex, row, cell, true, cellHasColspan, true ); } } // Add span cols to virtual table. var colspanNumber = cell.attributes.colSpan ? parseInt(cell.attributes.colSpan.value, 10) : 0; if (colspanNumber > 1) { for (var cp = 1; cp < colspanNumber; cp++) { var cellspanIndex = recoverCellIndex( row.rowIndex, cellIndex + cp ); adjustStartPoint( row.rowIndex, cellspanIndex, cell, isThisSelectedCell ); setVirtualTablePosition( row.rowIndex, cellspanIndex, row, cell, cellHasRowspan, true, true ); } } } /** * Process validation and adjust of start point if needed * * @param {int} rowIndex * @param {int} cellIndex * @param {object} cell * @param {bool} isSelectedCell */ function adjustStartPoint(rowIndex, cellIndex, cell, isSelectedCell) { if ( rowIndex === _startPoint.rowPos && _startPoint.colPos >= cell.cellIndex && cell.cellIndex <= cellIndex && !isSelectedCell ) { _startPoint.colPos++; } } /** * Create virtual table of cells with all cells, including span cells. */ function createVirtualTable() { var rows = domTable.rows; for (var rowIndex = 0; rowIndex < rows.length; rowIndex++) { var cells = rows[rowIndex].cells; for (var cellIndex = 0; cellIndex < cells.length; cellIndex++) { addCellInfoToVirtual(rows[rowIndex], cells[cellIndex]); } } } /** * Get action to be applied on the cell. * * @param {object} cell virtual table cell to apply action */ function getDeleteResultActionToCell(cell) { switch (where) { case TableResultAction.where.Column: if (cell.isColSpan) { return TableResultAction.resultAction.SubtractSpanCount; } break; case TableResultAction.where.Row: if (!cell.isVirtual && cell.isRowSpan) { return TableResultAction.resultAction.AddCell; } else if (cell.isRowSpan) { return TableResultAction.resultAction.SubtractSpanCount; } break; } return TableResultAction.resultAction.RemoveCell; } /** * Get action to be applied on the cell. * * @param {object} cell virtual table cell to apply action */ function getAddResultActionToCell(cell) { switch (where) { case TableResultAction.where.Column: if (cell.isColSpan) { return TableResultAction.resultAction.SumSpanCount; } else if (cell.isRowSpan && cell.isVirtual) { return TableResultAction.resultAction.Ignore; } break; case TableResultAction.where.Row: if (cell.isRowSpan) { return TableResultAction.resultAction.SumSpanCount; } else if (cell.isColSpan && cell.isVirtual) { return TableResultAction.resultAction.Ignore; } break; } return TableResultAction.resultAction.AddCell; } function init() { setStartPoint(); createVirtualTable(); } /// /////////////////////////////////////////// // Public functions /// /////////////////////////////////////////// /** * Recover array os what to do in table. */ this.getActionList = function () { var fixedRow = where === TableResultAction.where.Row ? _startPoint.rowPos : -1; var fixedCol = where === TableResultAction.where.Column ? _startPoint.colPos : -1; var actualPosition = 0; var canContinue = true; while (canContinue) { var rowPosition = fixedRow >= 0 ? fixedRow : actualPosition; var colPosition = fixedCol >= 0 ? fixedCol : actualPosition; var row = _virtualTable[rowPosition]; if (!row) { canContinue = false; return _actionCellList; } var cell = row[colPosition]; if (!cell) { canContinue = false; return _actionCellList; } // Define action to be applied in this cell var resultAction = TableResultAction.resultAction.Ignore; switch (action) { case TableResultAction.requestAction.Add: resultAction = getAddResultActionToCell(cell); break; case TableResultAction.requestAction.Delete: resultAction = getDeleteResultActionToCell(cell); break; } _actionCellList.push( getActionCell(cell, resultAction, rowPosition, colPosition) ); actualPosition++; } return _actionCellList; }; init(); }; /** * * Where action occours enum. */ TableResultAction.where = { Row: 0, Column: 1, }; /** * * Requested action to apply enum. */ TableResultAction.requestAction = { Add: 0, Delete: 1, }; /** * * Result action to be executed enum. */ TableResultAction.resultAction = { Ignore: 0, SubtractSpanCount: 1, RemoveCell: 2, AddCell: 3, SumSpanCount: 4, }; /** * * @class editing.Table * * Table * */ var Table_Table = /*#__PURE__*/ (function () { function Table() { Table_classCallCheck(this, Table); } Table_createClass(Table, [ { key: "tab", /** * handle tab key * * @param {WrappedRange} rng * @param {Boolean} isShift */ value: function tab(rng, isShift) { var cell = dom.ancestor(rng.commonAncestor(), dom.isCell); var table = dom.ancestor(cell, dom.isTable); var cells = dom.listDescendant(table, dom.isCell); var nextCell = lists[isShift ? "prev" : "next"](cells, cell); if (nextCell) { range.create(nextCell, 0).select(); } }, /** * Add a new row * * @param {WrappedRange} rng * @param {String} position (top/bottom) * @return {Node} */ }, { key: "addRow", value: function addRow(rng, position) { var cell = dom.ancestor(rng.commonAncestor(), dom.isCell); var currentTr = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()( cell ).closest("tr"); var trAttributes = this.recoverAttributes(currentTr); var html = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()( "
' +
this.lang.output.noSelection +
"
"
);
setTimeout(function () {
external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(
"#note-status-output-" + noteStatusOutput
).remove();
}, 5000);
}
},
/**
* unlink
*
* @type command
*/
},
{
key: "unlink",
value: function unlink() {
var rng = this.getLastRange();
if (rng.isOnAnchor()) {
var anchor = dom.ancestor(rng.sc, dom.isAnchor);
rng = range.createFromNode(anchor);
rng.select();
this.setLastRange();
this.beforeCommand();
document.execCommand("unlink");
this.afterCommand();
}
},
/**
* returns link info
*
* @return {Object}
* @return {WrappedRange} return.range
* @return {String} return.text
* @return {Boolean} [return.isNewWindow=true]
* @return {String} [return.url=""]
*/
},
{
key: "getLinkInfo",
value: function getLinkInfo() {
var rng = this.getLastRange().expand(dom.isAnchor); // Get the first anchor on range(for edit).
var $anchor = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(
lists.head(rng.nodes(dom.isAnchor))
);
var linkInfo = {
range: rng,
text: rng.toString(),
url: $anchor.length ? $anchor.attr("href") : "",
}; // When anchor exists,
if ($anchor.length) {
// Set isNewWindow by checking its target.
linkInfo.isNewWindow = $anchor.attr("target") === "_blank";
}
return linkInfo;
},
},
{
key: "addRow",
value: function addRow(position) {
var rng = this.getLastRange(this.$editable);
if (rng.isCollapsed() && rng.isOnCell()) {
this.beforeCommand();
this.table.addRow(rng, position);
this.afterCommand();
}
},
},
{
key: "addCol",
value: function addCol(position) {
var rng = this.getLastRange(this.$editable);
if (rng.isCollapsed() && rng.isOnCell()) {
this.beforeCommand();
this.table.addCol(rng, position);
this.afterCommand();
}
},
},
{
key: "deleteRow",
value: function deleteRow() {
var rng = this.getLastRange(this.$editable);
if (rng.isCollapsed() && rng.isOnCell()) {
this.beforeCommand();
this.table.deleteRow(rng);
this.afterCommand();
}
},
},
{
key: "deleteCol",
value: function deleteCol() {
var rng = this.getLastRange(this.$editable);
if (rng.isCollapsed() && rng.isOnCell()) {
this.beforeCommand();
this.table.deleteCol(rng);
this.afterCommand();
}
},
},
{
key: "deleteTable",
value: function deleteTable() {
var rng = this.getLastRange(this.$editable);
if (rng.isCollapsed() && rng.isOnCell()) {
this.beforeCommand();
this.table.deleteTable(rng);
this.afterCommand();
}
},
/**
* @param {Position} pos
* @param {jQuery} $target - target element
* @param {Boolean} [bKeepRatio] - keep ratio
*/
},
{
key: "resizeTo",
value: function resizeTo(pos, $target, bKeepRatio) {
var imageSize;
if (bKeepRatio) {
var newRatio = pos.y / pos.x;
var ratio = $target.data("ratio");
imageSize = {
width: ratio > newRatio ? pos.x : pos.y / ratio,
height: ratio > newRatio ? pos.x * ratio : pos.y,
};
} else {
imageSize = {
width: pos.x,
height: pos.y,
};
}
$target.css(imageSize);
},
/**
* returns whether editable area has focus or not.
*/
},
{
key: "hasFocus",
value: function hasFocus() {
return this.$editable.is(":focus");
},
/**
* set focus
*/
},
{
key: "focus",
value: function focus() {
// [workaround] Screen will move when page is scolled in IE.
// - do focus when not focused
if (!this.hasFocus()) {
this.$editable.focus();
}
},
/**
* returns whether contents is empty or not.
* @return {Boolean}
*/
},
{
key: "isEmpty",
value: function isEmpty() {
return (
dom.isEmpty(this.$editable[0]) ||
dom.emptyPara === this.$editable.html()
);
},
/**
* Removes all contents and restores the editable instance to an _emptyPara_.
*/
},
{
key: "empty",
value: function empty() {
this.context.invoke("code", dom.emptyPara);
},
/**
* normalize content
*/
},
{
key: "normalizeContent",
value: function normalizeContent() {
this.$editable[0].normalize();
},
},
]);
return Editor;
})();
// CONCATENATED MODULE: ./src/js/base/module/Clipboard.js
function Clipboard_classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
}
function Clipboard_defineProperties(target, props) {
for (var i = 0; i < props.length; i++) {
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}
function Clipboard_createClass(Constructor, protoProps, staticProps) {
if (protoProps)
Clipboard_defineProperties(Constructor.prototype, protoProps);
if (staticProps) Clipboard_defineProperties(Constructor, staticProps);
return Constructor;
}
var Clipboard_Clipboard = /*#__PURE__*/ (function () {
function Clipboard(context) {
Clipboard_classCallCheck(this, Clipboard);
this.context = context;
this.$editable = context.layoutInfo.editable;
}
Clipboard_createClass(Clipboard, [
{
key: "initialize",
value: function initialize() {
this.$editable.on("paste", this.pasteByEvent.bind(this));
},
/**
* paste by clipboard event
*
* @param {Event} event
*/
},
{
key: "pasteByEvent",
value: function pasteByEvent(event) {
var _this = this;
var clipboardData = event.originalEvent.clipboardData;
if (
clipboardData &&
clipboardData.items &&
clipboardData.items.length
) {
var item =
clipboardData.items.length > 1
? clipboardData.items[1]
: lists.head(clipboardData.items);
if (
item.kind === "file" &&
item.type.indexOf("image/") !== -1
) {
// paste img file
this.context.invoke("editor.insertImagesOrCallback", [
item.getAsFile(),
]);
event.preventDefault();
} else if (item.kind === "string") {
// paste text with maxTextLength check
if (
this.context.invoke(
"editor.isLimited",
clipboardData.getData("Text").length
)
) {
event.preventDefault();
}
}
} else if (window.clipboardData) {
// for IE
var text = window.clipboardData.getData("text");
if (this.context.invoke("editor.isLimited", text.length)) {
event.preventDefault();
}
} // Call editor.afterCommand after proceeding default event handler
setTimeout(function () {
_this.context.invoke("editor.afterCommand");
}, 10);
},
},
]);
return Clipboard;
})();
// CONCATENATED MODULE: ./src/js/base/module/Dropzone.js
function Dropzone_classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
}
function Dropzone_defineProperties(target, props) {
for (var i = 0; i < props.length; i++) {
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}
function Dropzone_createClass(Constructor, protoProps, staticProps) {
if (protoProps)
Dropzone_defineProperties(Constructor.prototype, protoProps);
if (staticProps) Dropzone_defineProperties(Constructor, staticProps);
return Constructor;
}
var Dropzone_Dropzone = /*#__PURE__*/ (function () {
function Dropzone(context) {
Dropzone_classCallCheck(this, Dropzone);
this.context = context;
this.$eventListener = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(
document
);
this.$editor = context.layoutInfo.editor;
this.$editable = context.layoutInfo.editable;
this.options = context.options;
this.lang = this.options.langInfo;
this.documentEventHandlers = {};
this.$dropzone = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(
[
'',
'',
"
",
].join("")
).prependTo(this.$editor);
}
/**
* attach Drag and Drop Events
*/
Dropzone_createClass(Dropzone, [
{
key: "initialize",
value: function initialize() {
if (this.options.disableDragAndDrop) {
// prevent default drop event
this.documentEventHandlers.onDrop = function (e) {
e.preventDefault();
}; // do not consider outside of dropzone
this.$eventListener = this.$dropzone;
this.$eventListener.on(
"drop",
this.documentEventHandlers.onDrop
);
} else {
this.attachDragAndDropEvent();
}
},
/**
* attach Drag and Drop Events
*/
},
{
key: "attachDragAndDropEvent",
value: function attachDragAndDropEvent() {
var _this = this;
var collection = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()();
var $dropzoneMessage = this.$dropzone.find(
".note-dropzone-message"
);
this.documentEventHandlers.onDragenter = function (e) {
var isCodeview = _this.context.invoke("codeview.isActivated");
var hasEditorSize =
_this.$editor.width() > 0 && _this.$editor.height() > 0;
if (!isCodeview && !collection.length && hasEditorSize) {
_this.$editor.addClass("dragover");
_this.$dropzone.width(_this.$editor.width());
_this.$dropzone.height(_this.$editor.height());
$dropzoneMessage.text(_this.lang.image.dragImageHere);
}
collection = collection.add(e.target);
};
this.documentEventHandlers.onDragleave = function (e) {
collection = collection.not(e.target); // If nodeName is BODY, then just make it over (fix for IE)
if (!collection.length || e.target.nodeName === "BODY") {
collection = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()();
_this.$editor.removeClass("dragover");
}
};
this.documentEventHandlers.onDrop = function () {
collection = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()();
_this.$editor.removeClass("dragover");
}; // show dropzone on dragenter when dragging a object to document
// -but only if the editor is visible, i.e. has a positive width and height
this.$eventListener
.on("dragenter", this.documentEventHandlers.onDragenter)
.on("dragleave", this.documentEventHandlers.onDragleave)
.on("drop", this.documentEventHandlers.onDrop); // change dropzone's message on hover.
this.$dropzone
.on("dragenter", function () {
_this.$dropzone.addClass("hover");
$dropzoneMessage.text(_this.lang.image.dropImage);
})
.on("dragleave", function () {
_this.$dropzone.removeClass("hover");
$dropzoneMessage.text(_this.lang.image.dragImageHere);
}); // attach dropImage
this.$dropzone
.on("drop", function (event) {
var dataTransfer = event.originalEvent.dataTransfer; // stop the browser from opening the dropped content
event.preventDefault();
if (
dataTransfer &&
dataTransfer.files &&
dataTransfer.files.length
) {
_this.$editable.focus();
_this.context.invoke(
"editor.insertImagesOrCallback",
dataTransfer.files
);
} else {
external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.each(
dataTransfer.types,
function (idx, type) {
// skip moz-specific types
if (type.toLowerCase().indexOf("_moz_") > -1) {
return;
}
var content = dataTransfer.getData(type);
if (type.toLowerCase().indexOf("text") > -1) {
_this.context.invoke("editor.pasteHTML", content);
} else {
external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(
content
).each(function (idx, item) {
_this.context.invoke("editor.insertNode", item);
});
}
}
);
}
})
.on("dragover", false); // prevent default dragover event
},
},
{
key: "destroy",
value: function destroy() {
var _this2 = this;
Object.keys(this.documentEventHandlers).forEach(function (key) {
_this2.$eventListener.off(
key.substr(2).toLowerCase(),
_this2.documentEventHandlers[key]
);
});
this.documentEventHandlers = {};
},
},
]);
return Dropzone;
})();
// CONCATENATED MODULE: ./src/js/base/module/Codeview.js
function _createForOfIteratorHelper(o) {
if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
if (Array.isArray(o) || (o = _unsupportedIterableToArray(o))) {
var i = 0;
var F = function F() {};
return {
s: F,
n: function n() {
if (i >= o.length) return { done: true };
return { done: false, value: o[i++] };
},
e: function e(_e) {
throw _e;
},
f: F,
};
}
throw new TypeError(
"Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."
);
}
var it,
normalCompletion = true,
didErr = false,
err;
return {
s: function s() {
it = o[Symbol.iterator]();
},
n: function n() {
var step = it.next();
normalCompletion = step.done;
return step;
},
e: function e(_e2) {
didErr = true;
err = _e2;
},
f: function f() {
try {
if (!normalCompletion && it["return"] != null) it["return"]();
} finally {
if (didErr) throw err;
}
},
};
}
function _unsupportedIterableToArray(o, minLen) {
if (!o) return;
if (typeof o === "string") return _arrayLikeToArray(o, minLen);
var n = Object.prototype.toString.call(o).slice(8, -1);
if (n === "Object" && o.constructor) n = o.constructor.name;
if (n === "Map" || n === "Set") return Array.from(n);
if (
n === "Arguments" ||
/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)
)
return _arrayLikeToArray(o, minLen);
}
function _arrayLikeToArray(arr, len) {
if (len == null || len > arr.length) len = arr.length;
for (var i = 0, arr2 = new Array(len); i < len; i++) {
arr2[i] = arr[i];
}
return arr2;
}
function Codeview_classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
}
function Codeview_defineProperties(target, props) {
for (var i = 0; i < props.length; i++) {
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}
function Codeview_createClass(Constructor, protoProps, staticProps) {
if (protoProps)
Codeview_defineProperties(Constructor.prototype, protoProps);
if (staticProps) Codeview_defineProperties(Constructor, staticProps);
return Constructor;
}
/**
* @class Codeview
*/
var Codeview_CodeView = /*#__PURE__*/ (function () {
function CodeView(context) {
Codeview_classCallCheck(this, CodeView);
this.context = context;
this.$editor = context.layoutInfo.editor;
this.$editable = context.layoutInfo.editable;
this.$codable = context.layoutInfo.codable;
this.options = context.options;
this.CodeMirrorConstructor = window.CodeMirror;
if (this.options.codemirror.CodeMirrorConstructor) {
this.CodeMirrorConstructor = this.options.codemirror.CodeMirrorConstructor;
}
}
Codeview_createClass(CodeView, [
{
key: "sync",
value: function sync(html) {
var isCodeview = this.isActivated();
var CodeMirror = this.CodeMirrorConstructor;
if (isCodeview) {
if (html) {
if (CodeMirror) {
this.$codable.data("cmEditor").getDoc().setValue(html);
} else {
this.$codable.val(html);
}
} else {
if (CodeMirror) {
this.$codable.data("cmEditor").save();
}
}
}
},
},
{
key: "initialize",
value: function initialize() {
var _this = this;
this.$codable.on("keyup", function (event) {
if (event.keyCode === core_key.code.ESCAPE) {
_this.deactivate();
}
});
},
/**
* @return {Boolean}
*/
},
{
key: "isActivated",
value: function isActivated() {
return this.$editor.hasClass("codeview");
},
/**
* toggle codeview
*/
},
{
key: "toggle",
value: function toggle() {
if (this.isActivated()) {
this.deactivate();
} else {
this.activate();
}
this.context.triggerEvent("codeview.toggled");
},
/**
* purify input value
* @param value
* @returns {*}
*/
},
{
key: "purify",
value: function purify(value) {
if (this.options.codeviewFilter) {
// filter code view regex
value = value.replace(this.options.codeviewFilterRegex, ""); // allow specific iframe tag
if (this.options.codeviewIframeFilter) {
var whitelist = this.options.codeviewIframeWhitelistSrc.concat(
this.options.codeviewIframeWhitelistSrcBase
);
value = value.replace(
/(',
'
",
].join("")
).prependTo(this.$editingArea);
this.$handle.on("mousedown", function (event) {
if (dom.isControlSizing(event.target)) {
event.preventDefault();
event.stopPropagation();
var $target = _this2.$handle
.find(".note-control-selection")
.data("target");
var posStart = $target.offset();
var scrollTop = _this2.$document.scrollTop();
var onMouseMove = function onMouseMove(event) {
_this2.context.invoke(
"editor.resizeTo",
{
x: event.clientX - posStart.left,
y: event.clientY - (posStart.top - scrollTop),
},
$target,
!event.shiftKey
);
_this2.update($target[0], event);
};
_this2.$document
.on("mousemove", onMouseMove)
.one("mouseup", function (e) {
e.preventDefault();
_this2.$document.off("mousemove", onMouseMove);
_this2.context.invoke("editor.afterCommand");
});
if (!$target.data("ratio")) {
// original ratio.
$target.data("ratio", $target.height() / $target.width());
}
}
}); // Listen for scrolling on the handle overlay.
this.$handle.on("wheel", function (e) {
e.preventDefault();
_this2.update();
});
},
},
{
key: "destroy",
value: function destroy() {
this.$handle.remove();
},
},
{
key: "update",
value: function update(target, event) {
if (this.context.isDisabled()) {
return false;
}
var isImage = dom.isImg(target);
var $selection = this.$handle.find(".note-control-selection");
this.context.invoke("imagePopover.update", target, event);
if (isImage) {
var $image = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(
target
);
var position = $image.position();
var pos = {
left:
position.left + parseInt($image.css("marginLeft"), 10),
top: position.top + parseInt($image.css("marginTop"), 10),
}; // exclude margin
var imageSize = {
w: $image.outerWidth(false),
h: $image.outerHeight(false),
};
$selection
.css({
display: "block",
left: pos.left,
top: pos.top,
width: imageSize.w,
height: imageSize.h,
})
.data("target", $image); // save current image element.
var origImageObj = new Image();
origImageObj.src = $image.attr("src");
var sizingText =
imageSize.w +
"x" +
imageSize.h +
" (" +
this.lang.image.original +
": " +
origImageObj.width +
"x" +
origImageObj.height +
")";
$selection
.find(".note-control-selection-info")
.text(sizingText);
this.context.invoke("editor.saveTarget", target);
} else {
this.hide();
}
return isImage;
},
/**
* hide
*
* @param {jQuery} $handle
*/
},
{
key: "hide",
value: function hide() {
this.context.invoke("editor.clearTarget");
this.$handle.children().hide();
},
},
]);
return Handle;
})();
// CONCATENATED MODULE: ./src/js/base/module/AutoLink.js
function AutoLink_classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
}
function AutoLink_defineProperties(target, props) {
for (var i = 0; i < props.length; i++) {
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}
function AutoLink_createClass(Constructor, protoProps, staticProps) {
if (protoProps)
AutoLink_defineProperties(Constructor.prototype, protoProps);
if (staticProps) AutoLink_defineProperties(Constructor, staticProps);
return Constructor;
}
var defaultScheme = "http://";
var linkPattern = /^([A-Za-z][A-Za-z0-9+-.]*\:[\/]{2}|tel:|mailto:[A-Z0-9._%+-]+@)?(www\.)?(.+)$/i;
var AutoLink_AutoLink = /*#__PURE__*/ (function () {
function AutoLink(context) {
var _this = this;
AutoLink_classCallCheck(this, AutoLink);
this.context = context;
this.options = context.options;
this.events = {
"summernote.keyup": function summernoteKeyup(we, e) {
if (!e.isDefaultPrevented()) {
_this.handleKeyup(e);
}
},
"summernote.keydown": function summernoteKeydown(we, e) {
_this.handleKeydown(e);
},
};
}
AutoLink_createClass(AutoLink, [
{
key: "initialize",
value: function initialize() {
this.lastWordRange = null;
},
},
{
key: "destroy",
value: function destroy() {
this.lastWordRange = null;
},
},
{
key: "replace",
value: function replace() {
if (!this.lastWordRange) {
return;
}
var keyword = this.lastWordRange.toString();
var match = keyword.match(linkPattern);
if (match && (match[1] || match[2])) {
var link = match[1] ? keyword : defaultScheme + keyword;
var urlText = this.options.showDomainOnlyForAutolink
? keyword
.replace(
/^(?:https?:\/\/)?(?:tel?:?)?(?:mailto?:?)?(?:www\.)?/i,
""
)
.split("/")[0]
: keyword;
var node = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(
""
)
.html(urlText)
.attr("href", link)[0];
if (this.context.options.linkTargetBlank) {
external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(
node
).attr("target", "_blank");
}
this.lastWordRange.insertNode(node);
this.lastWordRange = null;
this.context.invoke("editor.focus");
}
},
},
{
key: "handleKeydown",
value: function handleKeydown(e) {
if (
lists.contains(
[core_key.code.ENTER, core_key.code.SPACE],
e.keyCode
)
) {
var wordRange = this.context
.invoke("editor.createRange")
.getWordRange();
this.lastWordRange = wordRange;
}
},
},
{
key: "handleKeyup",
value: function handleKeyup(e) {
if (
lists.contains(
[core_key.code.ENTER, core_key.code.SPACE],
e.keyCode
)
) {
this.replace();
}
},
},
]);
return AutoLink;
})();
// CONCATENATED MODULE: ./src/js/base/module/AutoSync.js
function AutoSync_classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
}
function AutoSync_defineProperties(target, props) {
for (var i = 0; i < props.length; i++) {
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}
function AutoSync_createClass(Constructor, protoProps, staticProps) {
if (protoProps)
AutoSync_defineProperties(Constructor.prototype, protoProps);
if (staticProps) AutoSync_defineProperties(Constructor, staticProps);
return Constructor;
}
/**
* textarea auto sync.
*/
var AutoSync_AutoSync = /*#__PURE__*/ (function () {
function AutoSync(context) {
var _this = this;
AutoSync_classCallCheck(this, AutoSync);
this.$note = context.layoutInfo.note;
this.events = {
"summernote.change": function summernoteChange() {
_this.$note.val(context.invoke("code"));
},
};
}
AutoSync_createClass(AutoSync, [
{
key: "shouldInitialize",
value: function shouldInitialize() {
return dom.isTextarea(this.$note[0]);
},
},
]);
return AutoSync;
})();
// CONCATENATED MODULE: ./src/js/base/module/AutoReplace.js
function AutoReplace_classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
}
function AutoReplace_defineProperties(target, props) {
for (var i = 0; i < props.length; i++) {
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}
function AutoReplace_createClass(Constructor, protoProps, staticProps) {
if (protoProps)
AutoReplace_defineProperties(Constructor.prototype, protoProps);
if (staticProps)
AutoReplace_defineProperties(Constructor, staticProps);
return Constructor;
}
var AutoReplace_AutoReplace = /*#__PURE__*/ (function () {
function AutoReplace(context) {
var _this = this;
AutoReplace_classCallCheck(this, AutoReplace);
this.context = context;
this.options = context.options.replace || {};
this.keys = [
core_key.code.ENTER,
core_key.code.SPACE,
core_key.code.PERIOD,
core_key.code.COMMA,
core_key.code.SEMICOLON,
core_key.code.SLASH,
];
this.previousKeydownCode = null;
this.events = {
"summernote.keyup": function summernoteKeyup(we, e) {
if (!e.isDefaultPrevented()) {
_this.handleKeyup(e);
}
},
"summernote.keydown": function summernoteKeydown(we, e) {
_this.handleKeydown(e);
},
};
}
AutoReplace_createClass(AutoReplace, [
{
key: "shouldInitialize",
value: function shouldInitialize() {
return !!this.options.match;
},
},
{
key: "initialize",
value: function initialize() {
this.lastWord = null;
},
},
{
key: "destroy",
value: function destroy() {
this.lastWord = null;
},
},
{
key: "replace",
value: function replace() {
if (!this.lastWord) {
return;
}
var self = this;
var keyword = this.lastWord.toString();
this.options.match(keyword, function (match) {
if (match) {
var node = "";
if (typeof match === "string") {
node = dom.createText(match);
} else if (match instanceof jQuery) {
node = match[0];
} else if (match instanceof Node) {
node = match;
}
if (!node) return;
self.lastWord.insertNode(node);
self.lastWord = null;
self.context.invoke("editor.focus");
}
});
},
},
{
key: "handleKeydown",
value: function handleKeydown(e) {
// this forces it to remember the last whole word, even if multiple termination keys are pressed
// before the previous key is let go.
if (
this.previousKeydownCode &&
lists.contains(this.keys, this.previousKeydownCode)
) {
this.previousKeydownCode = e.keyCode;
return;
}
if (lists.contains(this.keys, e.keyCode)) {
var wordRange = this.context
.invoke("editor.createRange")
.getWordRange();
this.lastWord = wordRange;
}
this.previousKeydownCode = e.keyCode;
},
},
{
key: "handleKeyup",
value: function handleKeyup(e) {
if (lists.contains(this.keys, e.keyCode)) {
this.replace();
}
},
},
]);
return AutoReplace;
})();
// CONCATENATED MODULE: ./src/js/base/module/Placeholder.js
function Placeholder_classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
}
function Placeholder_defineProperties(target, props) {
for (var i = 0; i < props.length; i++) {
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}
function Placeholder_createClass(Constructor, protoProps, staticProps) {
if (protoProps)
Placeholder_defineProperties(Constructor.prototype, protoProps);
if (staticProps)
Placeholder_defineProperties(Constructor, staticProps);
return Constructor;
}
var Placeholder_Placeholder = /*#__PURE__*/ (function () {
function Placeholder(context) {
var _this = this;
Placeholder_classCallCheck(this, Placeholder);
this.context = context;
this.$editingArea = context.layoutInfo.editingArea;
this.options = context.options;
if (this.options.inheritPlaceholder === true) {
// get placeholder value from the original element
this.options.placeholder =
this.context.$note.attr("placeholder") ||
this.options.placeholder;
}
this.events = {
"summernote.init summernote.change": function summernoteInitSummernoteChange() {
_this.update();
},
"summernote.codeview.toggled": function summernoteCodeviewToggled() {
_this.update();
},
};
}
Placeholder_createClass(Placeholder, [
{
key: "shouldInitialize",
value: function shouldInitialize() {
return !!this.options.placeholder;
},
},
{
key: "initialize",
value: function initialize() {
var _this2 = this;
this.$placeholder = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(
'',
'',
'',
'',
'',
'',
this.options.disableResizeImage
? ""
: '',
"
",
"'
);
this.$placeholder
.on("click", function () {
_this2.context.invoke("focus");
})
.html(this.options.placeholder)
.prependTo(this.$editingArea);
this.update();
},
},
{
key: "destroy",
value: function destroy() {
this.$placeholder.remove();
},
},
{
key: "update",
value: function update() {
var isShow =
!this.context.invoke("codeview.isActivated") &&
this.context.invoke("editor.isEmpty");
this.$placeholder.toggle(isShow);
},
},
]);
return Placeholder;
})();
// CONCATENATED MODULE: ./src/js/base/module/Buttons.js
function Buttons_classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
}
function Buttons_defineProperties(target, props) {
for (var i = 0; i < props.length; i++) {
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}
function Buttons_createClass(Constructor, protoProps, staticProps) {
if (protoProps)
Buttons_defineProperties(Constructor.prototype, protoProps);
if (staticProps) Buttons_defineProperties(Constructor, staticProps);
return Constructor;
}
var Buttons_Buttons = /*#__PURE__*/ (function () {
function Buttons(context) {
Buttons_classCallCheck(this, Buttons);
this.ui =
external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.summernote.ui;
this.context = context;
this.$toolbar = context.layoutInfo.toolbar;
this.options = context.options;
this.lang = this.options.langInfo;
this.invertedKeyMap = func.invertObject(
this.options.keyMap[env.isMac ? "mac" : "pc"]
);
}
Buttons_createClass(Buttons, [
{
key: "representShortcut",
value: function representShortcut(editorMethod) {
var shortcut = this.invertedKeyMap[editorMethod];
if (!this.options.shortcuts || !shortcut) {
return "";
}
if (env.isMac) {
shortcut = shortcut.replace("CMD", "⌘").replace("SHIFT", "⇧");
}
shortcut = shortcut
.replace("BACKSLASH", "\\")
.replace("SLASH", "/")
.replace("LEFTBRACKET", "[")
.replace("RIGHTBRACKET", "]");
return " (" + shortcut + ")";
},
},
{
key: "button",
value: function button(o) {
if (!this.options.tooltip && o.tooltip) {
delete o.tooltip;
}
o.container = this.options.container;
return this.ui.button(o);
},
},
{
key: "initialize",
value: function initialize() {
this.addToolbarButtons();
this.addImagePopoverButtons();
this.addLinkPopoverButtons();
this.addTablePopoverButtons();
this.fontInstalledMap = {};
},
},
{
key: "destroy",
value: function destroy() {
delete this.fontInstalledMap;
},
},
{
key: "isFontInstalled",
value: function isFontInstalled(name) {
if (
!Object.prototype.hasOwnProperty.call(
this.fontInstalledMap,
name
)
) {
this.fontInstalledMap[name] =
env.isFontInstalled(name) ||
lists.contains(this.options.fontNamesIgnoreCheck, name);
}
return this.fontInstalledMap[name];
},
},
{
key: "isFontDeservedToAdd",
value: function isFontDeservedToAdd(name) {
name = name.toLowerCase();
return (
name !== "" &&
this.isFontInstalled(name) &&
env.genericFontFamilies.indexOf(name) === -1
);
},
},
{
key: "colorPalette",
value: function colorPalette(
className,
tooltip,
backColor,
foreColor
) {
var _this = this;
return this.ui
.buttonGroup({
className: "note-color " + className,
children: [
this.button({
className: "note-current-color-button",
contents: this.ui.icon(
this.options.icons.font + " note-recent-color"
),
tooltip: tooltip,
click: function click(e) {
var $button = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(
e.currentTarget
);
if (backColor && foreColor) {
_this.context.invoke("editor.color", {
backColor: $button.attr("data-backColor"),
foreColor: $button.attr("data-foreColor"),
});
} else if (backColor) {
_this.context.invoke("editor.color", {
backColor: $button.attr("data-backColor"),
});
} else if (foreColor) {
_this.context.invoke("editor.color", {
foreColor: $button.attr("data-foreColor"),
});
}
},
callback: function callback($button) {
var $recentColor = $button.find(".note-recent-color");
if (backColor) {
$recentColor.css(
"background-color",
_this.options.colorButton.backColor
);
$button.attr(
"data-backColor",
_this.options.colorButton.backColor
);
}
if (foreColor) {
$recentColor.css(
"color",
_this.options.colorButton.foreColor
);
$button.attr(
"data-foreColor",
_this.options.colorButton.foreColor
);
} else {
$recentColor.css("color", "transparent");
}
},
}),
this.button({
className: "dropdown-toggle",
contents: this.ui.dropdownButtonContents(
"",
this.options
),
tooltip: this.lang.color.more,
data: {
toggle: "dropdown",
},
}),
this.ui.dropdown({
items:
(backColor
? [
'
',
'
",
].join("")
: "") +
(foreColor
? [
'' +
this.lang.color.background +
"
",
"",
'",
"
",
'',
"",
'",
'',
"
",
'',
"',
'
",
].join("")
: ""),
callback: function callback($dropdown) {
$dropdown
.find(".note-holder")
.each(function (idx, item) {
var $holder = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(
item
);
$holder.append(
_this.ui
.palette({
colors: _this.options.colors,
colorsName: _this.options.colorsName,
eventName: $holder.data("event"),
container: _this.options.container,
tooltip: _this.options.tooltip,
})
.render()
);
});
/* TODO: do we have to record recent custom colors within cookies? */
var customColors = [
[
"#FFFFFF",
"#FFFFFF",
"#FFFFFF",
"#FFFFFF",
"#FFFFFF",
"#FFFFFF",
"#FFFFFF",
"#FFFFFF",
],
];
$dropdown
.find(".note-holder-custom")
.each(function (idx, item) {
var $holder = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(
item
);
$holder.append(
_this.ui
.palette({
colors: customColors,
colorsName: customColors,
eventName: $holder.data("event"),
container: _this.options.container,
tooltip: _this.options.tooltip,
})
.render()
);
});
$dropdown
.find("input[type=color]")
.each(function (idx, item) {
external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(
item
).change(function () {
var $chip = $dropdown
.find(
"#" +
external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(
this
).data("event")
)
.find(".note-color-btn")
.first();
var color = this.value.toUpperCase();
$chip
.css("background-color", color)
.attr("aria-label", color)
.attr("data-value", color)
.attr("data-original-title", color);
$chip.click();
});
});
},
click: function click(event) {
event.stopPropagation();
var $parent = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(
"." + className
).find(".note-dropdown-menu");
var $button = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(
event.target
);
var eventName = $button.data("event");
var value = $button.attr("data-value");
if (eventName === "openPalette") {
var $picker = $parent.find("#" + value);
var $palette = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(
$parent
.find("#" + $picker.data("event"))
.find(".note-color-row")[0]
); // Shift palette chips
var $chip = $palette
.find(".note-color-btn")
.last()
.detach(); // Set chip attributes
var color = $picker.val();
$chip
.css("background-color", color)
.attr("aria-label", color)
.attr("data-value", color)
.attr("data-original-title", color);
$palette.prepend($chip);
$picker.click();
} else {
if (
lists.contains(
["backColor", "foreColor"],
eventName
)
) {
var key =
eventName === "backColor"
? "background-color"
: "color";
var $color = $button
.closest(".note-color")
.find(".note-recent-color");
var $currentButton = $button
.closest(".note-color")
.find(".note-current-color-button");
$color.css(key, value);
$currentButton.attr("data-" + eventName, value);
}
_this.context.invoke("editor." + eventName, value);
}
},
}),
],
})
.render();
},
},
{
key: "addToolbarButtons",
value: function addToolbarButtons() {
var _this2 = this;
this.context.memo("button.style", function () {
return _this2.ui
.buttonGroup([
_this2.button({
className: "dropdown-toggle",
contents: _this2.ui.dropdownButtonContents(
_this2.ui.icon(_this2.options.icons.magic),
_this2.options
),
tooltip: _this2.lang.style.style,
data: {
toggle: "dropdown",
},
}),
_this2.ui.dropdown({
className: "dropdown-style",
items: _this2.options.styleTags,
title: _this2.lang.style.style,
template: function template(item) {
// TBD: need to be simplified
if (typeof item === "string") {
item = {
tag: item,
title: Object.prototype.hasOwnProperty.call(
_this2.lang.style,
item
)
? _this2.lang.style[item]
: item,
};
}
var tag = item.tag;
var title = item.title;
var style = item.style
? ' style="' + item.style + '" '
: "";
var className = item.className
? ' class="' + item.className + '"'
: "";
return (
"<" +
tag +
style +
className +
">" +
title +
""
);
},
click: _this2.context.createInvokeHandler(
"editor.formatBlock"
),
}),
])
.render();
});
var _loop = function _loop(styleIdx, styleLen) {
var item = _this2.options.styleTags[styleIdx];
_this2.context.memo("button.style." + item, function () {
return _this2
.button({
className: "note-btn-style-" + item,
contents:
'' +
this.lang.color.foreground +
"
",
"",
'",
"
",
'',
"",
'",
'',
"
", // Fix missing Div, Commented to find easily if it's wrong
'',
"' +
item.toUpperCase() +
"
",
tooltip: _this2.lang.style[item],
click: _this2.context.createInvokeHandler(
"editor.formatBlock"
),
})
.render();
});
};
for (
var styleIdx = 0, styleLen = this.options.styleTags.length;
styleIdx < styleLen;
styleIdx++
) {
_loop(styleIdx, styleLen);
}
this.context.memo("button.bold", function () {
return _this2
.button({
className: "note-btn-bold",
contents: _this2.ui.icon(_this2.options.icons.bold),
tooltip:
_this2.lang.font.bold +
_this2.representShortcut("bold"),
click: _this2.context.createInvokeHandlerAndUpdateState(
"editor.bold"
),
})
.render();
});
this.context.memo("button.italic", function () {
return _this2
.button({
className: "note-btn-italic",
contents: _this2.ui.icon(_this2.options.icons.italic),
tooltip:
_this2.lang.font.italic +
_this2.representShortcut("italic"),
click: _this2.context.createInvokeHandlerAndUpdateState(
"editor.italic"
),
})
.render();
});
this.context.memo("button.underline", function () {
return _this2
.button({
className: "note-btn-underline",
contents: _this2.ui.icon(_this2.options.icons.underline),
tooltip:
_this2.lang.font.underline +
_this2.representShortcut("underline"),
click: _this2.context.createInvokeHandlerAndUpdateState(
"editor.underline"
),
})
.render();
});
this.context.memo("button.clear", function () {
return _this2
.button({
contents: _this2.ui.icon(_this2.options.icons.eraser),
tooltip:
_this2.lang.font.clear +
_this2.representShortcut("removeFormat"),
click: _this2.context.createInvokeHandler(
"editor.removeFormat"
),
})
.render();
});
this.context.memo("button.strikethrough", function () {
return _this2
.button({
className: "note-btn-strikethrough",
contents: _this2.ui.icon(
_this2.options.icons.strikethrough
),
tooltip:
_this2.lang.font.strikethrough +
_this2.representShortcut("strikethrough"),
click: _this2.context.createInvokeHandlerAndUpdateState(
"editor.strikethrough"
),
})
.render();
});
this.context.memo("button.superscript", function () {
return _this2
.button({
className: "note-btn-superscript",
contents: _this2.ui.icon(
_this2.options.icons.superscript
),
tooltip: _this2.lang.font.superscript,
click: _this2.context.createInvokeHandlerAndUpdateState(
"editor.superscript"
),
})
.render();
});
this.context.memo("button.subscript", function () {
return _this2
.button({
className: "note-btn-subscript",
contents: _this2.ui.icon(_this2.options.icons.subscript),
tooltip: _this2.lang.font.subscript,
click: _this2.context.createInvokeHandlerAndUpdateState(
"editor.subscript"
),
})
.render();
});
this.context.memo("button.fontname", function () {
var styleInfo = _this2.context.invoke("editor.currentStyle");
if (_this2.options.addDefaultFonts) {
// Add 'default' fonts into the fontnames array if not exist
external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.each(
styleInfo["font-family"].split(","),
function (idx, fontname) {
fontname = fontname.trim().replace(/['"]+/g, "");
if (_this2.isFontDeservedToAdd(fontname)) {
if (
_this2.options.fontNames.indexOf(fontname) === -1
) {
_this2.options.fontNames.push(fontname);
}
}
}
);
}
return _this2.ui
.buttonGroup([
_this2.button({
className: "dropdown-toggle",
contents: _this2.ui.dropdownButtonContents(
'',
_this2.options
),
tooltip: _this2.lang.font.name,
data: {
toggle: "dropdown",
},
}),
_this2.ui.dropdownCheck({
className: "dropdown-fontname",
checkClassName: _this2.options.icons.menuCheck,
items: _this2.options.fontNames.filter(
_this2.isFontInstalled.bind(_this2)
),
title: _this2.lang.font.name,
template: function template(item) {
return (
'' +
item +
""
);
},
click: _this2.context.createInvokeHandlerAndUpdateState(
"editor.fontName"
),
}),
])
.render();
});
this.context.memo("button.fontsize", function () {
return _this2.ui
.buttonGroup([
_this2.button({
className: "dropdown-toggle",
contents: _this2.ui.dropdownButtonContents(
'',
_this2.options
),
tooltip: _this2.lang.font.size,
data: {
toggle: "dropdown",
},
}),
_this2.ui.dropdownCheck({
className: "dropdown-fontsize",
checkClassName: _this2.options.icons.menuCheck,
items: _this2.options.fontSizes,
title: _this2.lang.font.size,
click: _this2.context.createInvokeHandlerAndUpdateState(
"editor.fontSize"
),
}),
])
.render();
});
this.context.memo("button.fontsizeunit", function () {
return _this2.ui
.buttonGroup([
_this2.button({
className: "dropdown-toggle",
contents: _this2.ui.dropdownButtonContents(
'',
_this2.options
),
tooltip: _this2.lang.font.sizeunit,
data: {
toggle: "dropdown",
},
}),
_this2.ui.dropdownCheck({
className: "dropdown-fontsizeunit",
checkClassName: _this2.options.icons.menuCheck,
items: _this2.options.fontSizeUnits,
title: _this2.lang.font.sizeunit,
click: _this2.context.createInvokeHandlerAndUpdateState(
"editor.fontSizeUnit"
),
}),
])
.render();
});
this.context.memo("button.color", function () {
return _this2.colorPalette(
"note-color-all",
_this2.lang.color.recent,
true,
true
);
});
this.context.memo("button.forecolor", function () {
return _this2.colorPalette(
"note-color-fore",
_this2.lang.color.foreground,
false,
true
);
});
this.context.memo("button.backcolor", function () {
return _this2.colorPalette(
"note-color-back",
_this2.lang.color.background,
true,
false
);
});
this.context.memo("button.ul", function () {
return _this2
.button({
contents: _this2.ui.icon(
_this2.options.icons.unorderedlist
),
tooltip:
_this2.lang.lists.unordered +
_this2.representShortcut("insertUnorderedList"),
click: _this2.context.createInvokeHandler(
"editor.insertUnorderedList"
),
})
.render();
});
this.context.memo("button.ol", function () {
return _this2
.button({
contents: _this2.ui.icon(
_this2.options.icons.orderedlist
),
tooltip:
_this2.lang.lists.ordered +
_this2.representShortcut("insertOrderedList"),
click: _this2.context.createInvokeHandler(
"editor.insertOrderedList"
),
})
.render();
});
var justifyLeft = this.button({
contents: this.ui.icon(this.options.icons.alignLeft),
tooltip:
this.lang.paragraph.left +
this.representShortcut("justifyLeft"),
click: this.context.createInvokeHandler("editor.justifyLeft"),
});
var justifyCenter = this.button({
contents: this.ui.icon(this.options.icons.alignCenter),
tooltip:
this.lang.paragraph.center +
this.representShortcut("justifyCenter"),
click: this.context.createInvokeHandler(
"editor.justifyCenter"
),
});
var justifyRight = this.button({
contents: this.ui.icon(this.options.icons.alignRight),
tooltip:
this.lang.paragraph.right +
this.representShortcut("justifyRight"),
click: this.context.createInvokeHandler(
"editor.justifyRight"
),
});
var justifyFull = this.button({
contents: this.ui.icon(this.options.icons.alignJustify),
tooltip:
this.lang.paragraph.justify +
this.representShortcut("justifyFull"),
click: this.context.createInvokeHandler("editor.justifyFull"),
});
var outdent = this.button({
contents: this.ui.icon(this.options.icons.outdent),
tooltip:
this.lang.paragraph.outdent +
this.representShortcut("outdent"),
click: this.context.createInvokeHandler("editor.outdent"),
});
var indent = this.button({
contents: this.ui.icon(this.options.icons.indent),
tooltip:
this.lang.paragraph.indent +
this.representShortcut("indent"),
click: this.context.createInvokeHandler("editor.indent"),
});
this.context.memo(
"button.justifyLeft",
func.invoke(justifyLeft, "render")
);
this.context.memo(
"button.justifyCenter",
func.invoke(justifyCenter, "render")
);
this.context.memo(
"button.justifyRight",
func.invoke(justifyRight, "render")
);
this.context.memo(
"button.justifyFull",
func.invoke(justifyFull, "render")
);
this.context.memo(
"button.outdent",
func.invoke(outdent, "render")
);
this.context.memo(
"button.indent",
func.invoke(indent, "render")
);
this.context.memo("button.paragraph", function () {
return _this2.ui
.buttonGroup([
_this2.button({
className: "dropdown-toggle",
contents: _this2.ui.dropdownButtonContents(
_this2.ui.icon(_this2.options.icons.alignLeft),
_this2.options
),
tooltip: _this2.lang.paragraph.paragraph,
data: {
toggle: "dropdown",
},
}),
_this2.ui.dropdown([
_this2.ui.buttonGroup({
className: "note-align",
children: [
justifyLeft,
justifyCenter,
justifyRight,
justifyFull,
],
}),
_this2.ui.buttonGroup({
className: "note-list",
children: [outdent, indent],
}),
]),
])
.render();
});
this.context.memo("button.height", function () {
return _this2.ui
.buttonGroup([
_this2.button({
className: "dropdown-toggle",
contents: _this2.ui.dropdownButtonContents(
_this2.ui.icon(_this2.options.icons.textHeight),
_this2.options
),
tooltip: _this2.lang.font.height,
data: {
toggle: "dropdown",
},
}),
_this2.ui.dropdownCheck({
items: _this2.options.lineHeights,
checkClassName: _this2.options.icons.menuCheck,
className: "dropdown-line-height",
title: _this2.lang.font.height,
click: _this2.context.createInvokeHandler(
"editor.lineHeight"
),
}),
])
.render();
});
this.context.memo("button.table", function () {
return _this2.ui
.buttonGroup(
[
_this2.button({
className: "dropdown-toggle",
contents: _this2.ui.dropdownButtonContents(
_this2.ui.icon(_this2.options.icons.table),
_this2.options
),
tooltip: _this2.lang.table.table,
data: {
toggle: "dropdown",
},
}),
_this2.ui.dropdown({
title: _this2.lang.table.table,
className: "note-table",
items: [
'',
'',
'',
'',
"
",
'1 x 1
',
].join(""),
}),
],
{
callback: function callback($node) {
var $catcher = $node.find(
".note-dimension-picker-mousecatcher"
);
$catcher
.css({
width:
_this2.options.insertTableMaxSize.col + "em",
height:
_this2.options.insertTableMaxSize.row + "em",
})
.mousedown(
_this2.context.createInvokeHandler(
"editor.insertTable"
)
)
.on(
"mousemove",
_this2.tableMoveHandler.bind(_this2)
);
},
}
)
.render();
});
this.context.memo("button.link", function () {
return _this2
.button({
contents: _this2.ui.icon(_this2.options.icons.link),
tooltip:
_this2.lang.link.link +
_this2.representShortcut("linkDialog.show"),
click: _this2.context.createInvokeHandler(
"linkDialog.show"
),
})
.render();
});
this.context.memo("button.picture", function () {
return _this2
.button({
contents: _this2.ui.icon(_this2.options.icons.picture),
tooltip: _this2.lang.image.image,
click: _this2.context.createInvokeHandler(
"imageDialog.show"
),
})
.render();
});
this.context.memo("button.video", function () {
return _this2
.button({
contents: _this2.ui.icon(_this2.options.icons.video),
tooltip: _this2.lang.video.video,
click: _this2.context.createInvokeHandler(
"videoDialog.show"
),
})
.render();
});
this.context.memo("button.hr", function () {
return _this2
.button({
contents: _this2.ui.icon(_this2.options.icons.minus),
tooltip:
_this2.lang.hr.insert +
_this2.representShortcut("insertHorizontalRule"),
click: _this2.context.createInvokeHandler(
"editor.insertHorizontalRule"
),
})
.render();
});
this.context.memo("button.fullscreen", function () {
return _this2
.button({
className: "btn-fullscreen note-codeview-keep",
contents: _this2.ui.icon(_this2.options.icons.arrowsAlt),
tooltip: _this2.lang.options.fullscreen,
click: _this2.context.createInvokeHandler(
"fullscreen.toggle"
),
})
.render();
});
this.context.memo("button.codeview", function () {
return _this2
.button({
className: "btn-codeview note-codeview-keep",
contents: _this2.ui.icon(_this2.options.icons.code),
tooltip: _this2.lang.options.codeview,
click: _this2.context.createInvokeHandler(
"codeview.toggle"
),
})
.render();
});
this.context.memo("button.redo", function () {
return _this2
.button({
contents: _this2.ui.icon(_this2.options.icons.redo),
tooltip:
_this2.lang.history.redo +
_this2.representShortcut("redo"),
click: _this2.context.createInvokeHandler("editor.redo"),
})
.render();
});
this.context.memo("button.undo", function () {
return _this2
.button({
contents: _this2.ui.icon(_this2.options.icons.undo),
tooltip:
_this2.lang.history.undo +
_this2.representShortcut("undo"),
click: _this2.context.createInvokeHandler("editor.undo"),
})
.render();
});
this.context.memo("button.help", function () {
return _this2
.button({
contents: _this2.ui.icon(_this2.options.icons.question),
tooltip: _this2.lang.options.help,
click: _this2.context.createInvokeHandler(
"helpDialog.show"
),
})
.render();
});
},
/**
* image: [
* ['imageResize', ['resizeFull', 'resizeHalf', 'resizeQuarter', 'resizeNone']],
* ['float', ['floatLeft', 'floatRight', 'floatNone']],
* ['remove', ['removeMedia']],
* ],
*/
},
{
key: "addImagePopoverButtons",
value: function addImagePopoverButtons() {
var _this3 = this;
// Image Size Buttons
this.context.memo("button.resizeFull", function () {
return _this3
.button({
contents: '100%',
tooltip: _this3.lang.image.resizeFull,
click: _this3.context.createInvokeHandler(
"editor.resize",
"1"
),
})
.render();
});
this.context.memo("button.resizeHalf", function () {
return _this3
.button({
contents: '50%',
tooltip: _this3.lang.image.resizeHalf,
click: _this3.context.createInvokeHandler(
"editor.resize",
"0.5"
),
})
.render();
});
this.context.memo("button.resizeQuarter", function () {
return _this3
.button({
contents: '25%',
tooltip: _this3.lang.image.resizeQuarter,
click: _this3.context.createInvokeHandler(
"editor.resize",
"0.25"
),
})
.render();
});
this.context.memo("button.resizeNone", function () {
return _this3
.button({
contents: _this3.ui.icon(_this3.options.icons.rollback),
tooltip: _this3.lang.image.resizeNone,
click: _this3.context.createInvokeHandler(
"editor.resize",
"0"
),
})
.render();
}); // Float Buttons
this.context.memo("button.floatLeft", function () {
return _this3
.button({
contents: _this3.ui.icon(_this3.options.icons.floatLeft),
tooltip: _this3.lang.image.floatLeft,
click: _this3.context.createInvokeHandler(
"editor.floatMe",
"left"
),
})
.render();
});
this.context.memo("button.floatRight", function () {
return _this3
.button({
contents: _this3.ui.icon(_this3.options.icons.floatRight),
tooltip: _this3.lang.image.floatRight,
click: _this3.context.createInvokeHandler(
"editor.floatMe",
"right"
),
})
.render();
});
this.context.memo("button.floatNone", function () {
return _this3
.button({
contents: _this3.ui.icon(_this3.options.icons.rollback),
tooltip: _this3.lang.image.floatNone,
click: _this3.context.createInvokeHandler(
"editor.floatMe",
"none"
),
})
.render();
}); // Remove Buttons
this.context.memo("button.removeMedia", function () {
return _this3
.button({
contents: _this3.ui.icon(_this3.options.icons.trash),
tooltip: _this3.lang.image.remove,
click: _this3.context.createInvokeHandler(
"editor.removeMedia"
),
})
.render();
});
},
},
{
key: "addLinkPopoverButtons",
value: function addLinkPopoverButtons() {
var _this4 = this;
this.context.memo("button.linkDialogShow", function () {
return _this4
.button({
contents: _this4.ui.icon(_this4.options.icons.link),
tooltip: _this4.lang.link.edit,
click: _this4.context.createInvokeHandler(
"linkDialog.show"
),
})
.render();
});
this.context.memo("button.unlink", function () {
return _this4
.button({
contents: _this4.ui.icon(_this4.options.icons.unlink),
tooltip: _this4.lang.link.unlink,
click: _this4.context.createInvokeHandler(
"editor.unlink"
),
})
.render();
});
},
/**
* table : [
* ['add', ['addRowDown', 'addRowUp', 'addColLeft', 'addColRight']],
* ['delete', ['deleteRow', 'deleteCol', 'deleteTable']]
* ],
*/
},
{
key: "addTablePopoverButtons",
value: function addTablePopoverButtons() {
var _this5 = this;
this.context.memo("button.addRowUp", function () {
return _this5
.button({
className: "btn-md",
contents: _this5.ui.icon(_this5.options.icons.rowAbove),
tooltip: _this5.lang.table.addRowAbove,
click: _this5.context.createInvokeHandler(
"editor.addRow",
"top"
),
})
.render();
});
this.context.memo("button.addRowDown", function () {
return _this5
.button({
className: "btn-md",
contents: _this5.ui.icon(_this5.options.icons.rowBelow),
tooltip: _this5.lang.table.addRowBelow,
click: _this5.context.createInvokeHandler(
"editor.addRow",
"bottom"
),
})
.render();
});
this.context.memo("button.addColLeft", function () {
return _this5
.button({
className: "btn-md",
contents: _this5.ui.icon(_this5.options.icons.colBefore),
tooltip: _this5.lang.table.addColLeft,
click: _this5.context.createInvokeHandler(
"editor.addCol",
"left"
),
})
.render();
});
this.context.memo("button.addColRight", function () {
return _this5
.button({
className: "btn-md",
contents: _this5.ui.icon(_this5.options.icons.colAfter),
tooltip: _this5.lang.table.addColRight,
click: _this5.context.createInvokeHandler(
"editor.addCol",
"right"
),
})
.render();
});
this.context.memo("button.deleteRow", function () {
return _this5
.button({
className: "btn-md",
contents: _this5.ui.icon(_this5.options.icons.rowRemove),
tooltip: _this5.lang.table.delRow,
click: _this5.context.createInvokeHandler(
"editor.deleteRow"
),
})
.render();
});
this.context.memo("button.deleteCol", function () {
return _this5
.button({
className: "btn-md",
contents: _this5.ui.icon(_this5.options.icons.colRemove),
tooltip: _this5.lang.table.delCol,
click: _this5.context.createInvokeHandler(
"editor.deleteCol"
),
})
.render();
});
this.context.memo("button.deleteTable", function () {
return _this5
.button({
className: "btn-md",
contents: _this5.ui.icon(_this5.options.icons.trash),
tooltip: _this5.lang.table.delTable,
click: _this5.context.createInvokeHandler(
"editor.deleteTable"
),
})
.render();
});
},
},
{
key: "build",
value: function build($container, groups) {
for (
var groupIdx = 0, groupLen = groups.length;
groupIdx < groupLen;
groupIdx++
) {
var group = groups[groupIdx];
var groupName = Array.isArray(group) ? group[0] : group;
var buttons = Array.isArray(group)
? group.length === 1
? [group[0]]
: group[1]
: [group];
var $group = this.ui
.buttonGroup({
className: "note-" + groupName,
})
.render();
for (var idx = 0, len = buttons.length; idx < len; idx++) {
var btn = this.context.memo("button." + buttons[idx]);
if (btn) {
$group.append(
typeof btn === "function" ? btn(this.context) : btn
);
}
}
$group.appendTo($container);
}
},
/**
* @param {jQuery} [$container]
*/
},
{
key: "updateCurrentStyle",
value: function updateCurrentStyle($container) {
var _this6 = this;
var $cont = $container || this.$toolbar;
var styleInfo = this.context.invoke("editor.currentStyle");
this.updateBtnStates($cont, {
".note-btn-bold": function noteBtnBold() {
return styleInfo["font-bold"] === "bold";
},
".note-btn-italic": function noteBtnItalic() {
return styleInfo["font-italic"] === "italic";
},
".note-btn-underline": function noteBtnUnderline() {
return styleInfo["font-underline"] === "underline";
},
".note-btn-subscript": function noteBtnSubscript() {
return styleInfo["font-subscript"] === "subscript";
},
".note-btn-superscript": function noteBtnSuperscript() {
return styleInfo["font-superscript"] === "superscript";
},
".note-btn-strikethrough": function noteBtnStrikethrough() {
return styleInfo["font-strikethrough"] === "strikethrough";
},
});
if (styleInfo["font-family"]) {
var fontNames = styleInfo["font-family"]
.split(",")
.map(function (name) {
return name
.replace(/[\'\"]/g, "")
.replace(/\s+$/, "")
.replace(/^\s+/, "");
});
var fontName = lists.find(
fontNames,
this.isFontInstalled.bind(this)
);
$cont.find(".dropdown-fontname a").each(function (idx, item) {
var $item = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(
item
); // always compare string to avoid creating another func.
var isChecked = $item.data("value") + "" === fontName + "";
$item.toggleClass("checked", isChecked);
});
$cont
.find(".note-current-fontname")
.text(fontName)
.css("font-family", fontName);
}
if (styleInfo["font-size"]) {
var fontSize = styleInfo["font-size"];
$cont.find(".dropdown-fontsize a").each(function (idx, item) {
var $item = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(
item
); // always compare with string to avoid creating another func.
var isChecked = $item.data("value") + "" === fontSize + "";
$item.toggleClass("checked", isChecked);
});
$cont.find(".note-current-fontsize").text(fontSize);
var fontSizeUnit = styleInfo["font-size-unit"];
// console.log(fontSizeUnit);
$cont
.find(".dropdown-fontsizeunit a")
.each(function (idx, item) {
var $item = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(
item
);
var isChecked =
$item.data("value") + "" === fontSizeUnit + "";
// console.log(isChecked);
$item.toggleClass("checked", isChecked);
});
$cont.find(".note-current-fontsizeunit").text(fontSizeUnit);
}
if (styleInfo["line-height"]) {
var lineHeight = styleInfo["line-height"];
$cont
.find(".dropdown-line-height li a")
.each(function (idx, item) {
// always compare with string to avoid creating another func.
var isChecked =
external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(
item
).data("value") +
"" ===
lineHeight + "";
_this6.className = isChecked ? "checked" : "";
});
}
},
},
{
key: "updateBtnStates",
value: function updateBtnStates($container, infos) {
var _this7 = this;
external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.each(
infos,
function (selector, pred) {
_this7.ui.toggleBtnActive(
$container.find(selector),
pred()
);
}
);
},
},
{
key: "tableMoveHandler",
value: function tableMoveHandler(event) {
var PX_PER_EM = 18;
var $picker = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(
event.target.parentNode
); // target is mousecatcher
var $dimensionDisplay = $picker.next();
var $catcher = $picker.find(
".note-dimension-picker-mousecatcher"
);
var $highlighted = $picker.find(
".note-dimension-picker-highlighted"
);
var $unhighlighted = $picker.find(
".note-dimension-picker-unhighlighted"
);
var posOffset; // HTML5 with jQuery - e.offsetX is undefined in Firefox
if (event.offsetX === undefined) {
var posCatcher = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(
event.target
).offset();
posOffset = {
x: event.pageX - posCatcher.left,
y: event.pageY - posCatcher.top,
};
} else {
posOffset = {
x: event.offsetX,
y: event.offsetY,
};
}
var dim = {
c: Math.ceil(posOffset.x / PX_PER_EM) || 1,
r: Math.ceil(posOffset.y / PX_PER_EM) || 1,
};
$highlighted.css({
width: dim.c + "em",
height: dim.r + "em",
});
$catcher.data("value", dim.c + "x" + dim.r);
if (dim.c > 3 && dim.c < this.options.insertTableMaxSize.col) {
$unhighlighted.css({
width: dim.c + 1 + "em",
});
}
if (dim.r > 3 && dim.r < this.options.insertTableMaxSize.row) {
$unhighlighted.css({
height: dim.r + 1 + "em",
});
}
$dimensionDisplay.html(dim.c + " x " + dim.r);
},
},
]);
return Buttons;
})();
// CONCATENATED MODULE: ./src/js/base/module/Toolbar.js
function Toolbar_classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
}
function Toolbar_defineProperties(target, props) {
for (var i = 0; i < props.length; i++) {
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}
function Toolbar_createClass(Constructor, protoProps, staticProps) {
if (protoProps)
Toolbar_defineProperties(Constructor.prototype, protoProps);
if (staticProps) Toolbar_defineProperties(Constructor, staticProps);
return Constructor;
}
var Toolbar_Toolbar = /*#__PURE__*/ (function () {
function Toolbar(context) {
Toolbar_classCallCheck(this, Toolbar);
this.context = context;
this.$window = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(
window
);
this.$document = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(
document
);
this.ui =
external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.summernote.ui;
this.$note = context.layoutInfo.note;
this.$editor = context.layoutInfo.editor;
this.$toolbar = context.layoutInfo.toolbar;
this.$editable = context.layoutInfo.editable;
this.$statusbar = context.layoutInfo.statusbar;
this.options = context.options;
this.isFollowing = false;
this.followScroll = this.followScroll.bind(this);
}
Toolbar_createClass(Toolbar, [
{
key: "shouldInitialize",
value: function shouldInitialize() {
return !this.options.airMode;
},
},
{
key: "initialize",
value: function initialize() {
var _this = this;
this.options.toolbar = this.options.toolbar || [];
if (!this.options.toolbar.length) {
this.$toolbar.hide();
} else {
this.context.invoke(
"buttons.build",
this.$toolbar,
this.options.toolbar
);
}
if (this.options.toolbarContainer) {
this.$toolbar.appendTo(this.options.toolbarContainer);
}
this.changeContainer(false);
this.$note.on(
"summernote.keyup summernote.mouseup summernote.change",
function () {
_this.context.invoke("buttons.updateCurrentStyle");
}
);
this.context.invoke("buttons.updateCurrentStyle");
if (this.options.followingToolbar) {
this.$window.on("scroll resize", this.followScroll);
}
},
},
{
key: "destroy",
value: function destroy() {
this.$toolbar.children().remove();
if (this.options.followingToolbar) {
this.$window.off("scroll resize", this.followScroll);
}
},
},
{
key: "followScroll",
value: function followScroll() {
if (this.$editor.hasClass("fullscreen")) {
return false;
}
var editorHeight = this.$editor.outerHeight();
var editorWidth = this.$editor.width();
var toolbarHeight = this.$toolbar.height();
var statusbarHeight = this.$statusbar.height(); // check if the web app is currently using another static bar
var otherBarHeight = 0;
if (this.options.otherStaticBar) {
otherBarHeight = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(
this.options.otherStaticBar
).outerHeight();
}
var currentOffset = this.$document.scrollTop();
var editorOffsetTop = this.$editor.offset().top;
var editorOffsetBottom = editorOffsetTop + editorHeight;
var activateOffset = editorOffsetTop - otherBarHeight;
var deactivateOffsetBottom =
editorOffsetBottom -
otherBarHeight -
toolbarHeight -
statusbarHeight;
if (
!this.isFollowing &&
currentOffset > activateOffset &&
currentOffset < deactivateOffsetBottom - toolbarHeight
) {
this.isFollowing = true;
this.$editable.css({
marginTop: this.$toolbar.outerHeight(),
});
this.$toolbar.css({
position: "fixed",
top: otherBarHeight,
width: editorWidth,
zIndex: 1000,
});
} else if (
this.isFollowing &&
(currentOffset < activateOffset ||
currentOffset > deactivateOffsetBottom)
) {
this.isFollowing = false;
this.$toolbar.css({
position: "relative",
top: 0,
width: "100%",
zIndex: "auto",
});
this.$editable.css({
marginTop: "",
});
}
},
},
{
key: "changeContainer",
value: function changeContainer(isFullscreen) {
if (isFullscreen) {
this.$toolbar.prependTo(this.$editor);
} else {
if (this.options.toolbarContainer) {
this.$toolbar.appendTo(this.options.toolbarContainer);
}
}
if (this.options.followingToolbar) {
this.followScroll();
}
},
},
{
key: "updateFullscreen",
value: function updateFullscreen(isFullscreen) {
this.ui.toggleBtnActive(
this.$toolbar.find(".btn-fullscreen"),
isFullscreen
);
this.changeContainer(isFullscreen);
},
},
{
key: "updateCodeview",
value: function updateCodeview(isCodeview) {
this.ui.toggleBtnActive(
this.$toolbar.find(".btn-codeview"),
isCodeview
);
if (isCodeview) {
this.deactivate();
} else {
this.activate();
}
},
},
{
key: "activate",
value: function activate(isIncludeCodeview) {
var $btn = this.$toolbar.find("button");
if (!isIncludeCodeview) {
$btn = $btn.not(".note-codeview-keep");
}
this.ui.toggleBtn($btn, true);
},
},
{
key: "deactivate",
value: function deactivate(isIncludeCodeview) {
var $btn = this.$toolbar.find("button");
if (!isIncludeCodeview) {
$btn = $btn.not(".note-codeview-keep");
}
this.ui.toggleBtn($btn, false);
},
},
]);
return Toolbar;
})();
// CONCATENATED MODULE: ./src/js/base/module/LinkDialog.js
function LinkDialog_classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
}
function LinkDialog_defineProperties(target, props) {
for (var i = 0; i < props.length; i++) {
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}
function LinkDialog_createClass(Constructor, protoProps, staticProps) {
if (protoProps)
LinkDialog_defineProperties(Constructor.prototype, protoProps);
if (staticProps)
LinkDialog_defineProperties(Constructor, staticProps);
return Constructor;
}
var LinkDialog_LinkDialog = /*#__PURE__*/ (function () {
function LinkDialog(context) {
LinkDialog_classCallCheck(this, LinkDialog);
this.context = context;
this.ui =
external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.summernote.ui;
this.$body = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(
document.body
);
this.$editor = context.layoutInfo.editor;
this.options = context.options;
this.lang = this.options.langInfo;
context.memo(
"help.linkDialog.show",
this.options.langInfo.help["linkDialog.show"]
);
}
LinkDialog_createClass(LinkDialog, [
{
key: "initialize",
value: function initialize() {
var $container = this.options.dialogsInBody
? this.$body
: this.options.container;
var body = [
'',
'"),
''
),
"
",
'',
'"),
''
),
"
",
!this.options.disableLinkTarget
? external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(
""
)
.append(
this.ui
.checkbox({
className: "sn-checkbox-open-in-new-window",
text: this.lang.link.openInNewWindow,
checked: true,
})
.render()
)
.html()
: "",
external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(
""
)
.append(
this.ui
.checkbox({
className: "sn-checkbox-use-protocol",
text: this.lang.link.useProtocol,
checked: true,
})
.render()
)
.html(),
].join("");
var buttonClass =
"btn btn-primary note-btn note-btn-primary note-link-btn";
var footer = '');
this.$dialog = this.ui
.dialog({
className: "link-dialog",
title: this.lang.link.insert,
fade: this.options.dialogsFade,
body: body,
footer: footer,
})
.render()
.appendTo($container);
},
},
{
key: "destroy",
value: function destroy() {
this.ui.hideDialog(this.$dialog);
this.$dialog.remove();
},
},
{
key: "bindEnterKey",
value: function bindEnterKey($input, $btn) {
$input.on("keypress", function (event) {
if (event.keyCode === core_key.code.ENTER) {
event.preventDefault();
$btn.trigger("click");
}
});
},
/**
* toggle update button
*/
},
{
key: "toggleLinkBtn",
value: function toggleLinkBtn($linkBtn, $linkText, $linkUrl) {
this.ui.toggleBtn($linkBtn, $linkText.val() && $linkUrl.val());
},
/**
* Show link dialog and set event handlers on dialog controls.
*
* @param {Object} linkInfo
* @return {Promise}
*/
},
{
key: "showLinkDialog",
value: function showLinkDialog(linkInfo) {
var _this = this;
return external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a
.Deferred(function (deferred) {
var $linkText = _this.$dialog.find(".note-link-text");
var $linkUrl = _this.$dialog.find(".note-link-url");
var $linkBtn = _this.$dialog.find(".note-link-btn");
var $openInNewWindow = _this.$dialog.find(
".sn-checkbox-open-in-new-window input[type=checkbox]"
);
var $useProtocol = _this.$dialog.find(
".sn-checkbox-use-protocol input[type=checkbox]"
);
_this.ui.onDialogShown(_this.$dialog, function () {
_this.context.triggerEvent("dialog.shown"); // If no url was given and given text is valid URL then copy that into URL Field
if (!linkInfo.url && func.isValidUrl(linkInfo.text)) {
linkInfo.url = linkInfo.text;
}
$linkText
.on("input paste propertychange", function () {
// If linktext was modified by input events,
// cloning text from linkUrl will be stopped.
linkInfo.text = $linkText.val();
_this.toggleLinkBtn($linkBtn, $linkText, $linkUrl);
})
.val(linkInfo.text);
$linkUrl
.on("input paste propertychange", function () {
// Display same text on `Text to display` as default
// when linktext has no text
if (!linkInfo.text) {
$linkText.val($linkUrl.val());
}
_this.toggleLinkBtn($linkBtn, $linkText, $linkUrl);
})
.val(linkInfo.url);
if (!env.isSupportTouch) {
$linkUrl.trigger("focus");
}
_this.toggleLinkBtn($linkBtn, $linkText, $linkUrl);
_this.bindEnterKey($linkUrl, $linkBtn);
_this.bindEnterKey($linkText, $linkBtn);
var isNewWindowChecked =
linkInfo.isNewWindow !== undefined
? linkInfo.isNewWindow
: _this.context.options.linkTargetBlank;
$openInNewWindow.prop("checked", isNewWindowChecked);
var useProtocolChecked = linkInfo.url
? false
: _this.context.options.useProtocol;
$useProtocol.prop("checked", useProtocolChecked);
$linkBtn.one("click", function (event) {
event.preventDefault();
deferred.resolve({
range: linkInfo.range,
url: $linkUrl.val(),
text: $linkText.val(),
isNewWindow: $openInNewWindow.is(":checked"),
checkProtocol: $useProtocol.is(":checked"),
});
_this.ui.hideDialog(_this.$dialog);
});
});
_this.ui.onDialogHidden(_this.$dialog, function () {
// detach events
$linkText.off();
$linkUrl.off();
$linkBtn.off();
if (deferred.state() === "pending") {
deferred.reject();
}
});
_this.ui.showDialog(_this.$dialog);
})
.promise();
},
/**
* @param {Object} layoutInfo
*/
},
{
key: "show",
value: function show() {
var _this2 = this;
var linkInfo = this.context.invoke("editor.getLinkInfo");
this.context.invoke("editor.saveRange");
this.showLinkDialog(linkInfo)
.then(function (linkInfo) {
_this2.context.invoke("editor.restoreRange");
_this2.context.invoke("editor.createLink", linkInfo);
})
.fail(function () {
_this2.context.invoke("editor.restoreRange");
});
},
},
]);
return LinkDialog;
})();
// CONCATENATED MODULE: ./src/js/base/module/LinkPopover.js
function LinkPopover_classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
}
function LinkPopover_defineProperties(target, props) {
for (var i = 0; i < props.length; i++) {
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}
function LinkPopover_createClass(Constructor, protoProps, staticProps) {
if (protoProps)
LinkPopover_defineProperties(Constructor.prototype, protoProps);
if (staticProps)
LinkPopover_defineProperties(Constructor, staticProps);
return Constructor;
}
var LinkPopover_LinkPopover = /*#__PURE__*/ (function () {
function LinkPopover(context) {
var _this = this;
LinkPopover_classCallCheck(this, LinkPopover);
this.context = context;
this.ui =
external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.summernote.ui;
this.options = context.options;
this.events = {
"summernote.keyup summernote.mouseup summernote.change summernote.scroll": function summernoteKeyupSummernoteMouseupSummernoteChangeSummernoteScroll() {
_this.update();
},
"summernote.disable summernote.dialog.shown summernote.blur": function summernoteDisableSummernoteDialogShownSummernoteBlur() {
_this.hide();
},
};
}
LinkPopover_createClass(LinkPopover, [
{
key: "shouldInitialize",
value: function shouldInitialize() {
return !lists.isEmpty(this.options.popover.link);
},
},
{
key: "initialize",
value: function initialize() {
this.$popover = this.ui
.popover({
className: "note-link-popover",
callback: function callback($node) {
var $content = $node.find(
".popover-content,.note-popover-content"
);
$content.prepend(
' '
);
},
})
.render()
.appendTo(this.options.container);
var $content = this.$popover.find(
".popover-content,.note-popover-content"
);
this.context.invoke(
"buttons.build",
$content,
this.options.popover.link
);
this.$popover.on("mousedown", function (e) {
e.preventDefault();
});
},
},
{
key: "destroy",
value: function destroy() {
this.$popover.remove();
},
},
{
key: "update",
value: function update() {
// Prevent focusing on editable when invoke('code') is executed
if (!this.context.invoke("editor.hasFocus")) {
this.hide();
return;
}
var rng = this.context.invoke("editor.getLastRange");
if (rng.isCollapsed() && rng.isOnAnchor()) {
var anchor = dom.ancestor(rng.sc, dom.isAnchor);
var href = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(
anchor
).attr("href");
this.$popover.find("a").attr("href", href).text(href);
var pos = dom.posFromPlaceholder(anchor);
var containerOffset = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(
this.options.container
).offset();
pos.top -= containerOffset.top;
pos.left -= containerOffset.left;
this.$popover.css({
display: "block",
left: pos.left,
top: pos.top,
});
} else {
this.hide();
}
},
},
{
key: "hide",
value: function hide() {
this.$popover.hide();
},
},
]);
return LinkPopover;
})();
// CONCATENATED MODULE: ./src/js/base/module/ImageDialog.js
function ImageDialog_classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
}
function ImageDialog_defineProperties(target, props) {
for (var i = 0; i < props.length; i++) {
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}
function ImageDialog_createClass(Constructor, protoProps, staticProps) {
if (protoProps)
ImageDialog_defineProperties(Constructor.prototype, protoProps);
if (staticProps)
ImageDialog_defineProperties(Constructor, staticProps);
return Constructor;
}
var ImageDialog_ImageDialog = /*#__PURE__*/ (function () {
function ImageDialog(context) {
ImageDialog_classCallCheck(this, ImageDialog);
this.context = context;
this.ui =
external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.summernote.ui;
this.$body = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(
document.body
);
this.$editor = context.layoutInfo.editor;
this.options = context.options;
this.lang = this.options.langInfo;
}
ImageDialog_createClass(ImageDialog, [
{
key: "initialize",
value: function initialize() {
var imageLimitation = "";
if (this.options.maximumImageFileSize) {
var unit = Math.floor(
Math.log(this.options.maximumImageFileSize) / Math.log(1024)
);
var readableSize =
(
this.options.maximumImageFileSize / Math.pow(1024, unit)
).toFixed(2) *
1 +
" " +
" KMGTP"[unit] +
"B";
imageLimitation = "".concat(
this.lang.image.maximumFileSize + " : " + readableSize,
""
);
}
var $container = this.options.dialogsInBody
? this.$body
: this.options.container;
var body = [
'',
'",
'',
imageLimitation,
"
",
'',
'",
'',
"
",
].join("");
var buttonClass =
"btn btn-primary note-btn note-btn-primary note-image-btn";
var footer = '');
this.$dialog = this.ui
.dialog({
title: this.lang.image.insert,
fade: this.options.dialogsFade,
body: body,
footer: footer,
})
.render()
.appendTo($container);
},
},
{
key: "destroy",
value: function destroy() {
this.ui.hideDialog(this.$dialog);
this.$dialog.remove();
},
},
{
key: "bindEnterKey",
value: function bindEnterKey($input, $btn) {
$input.on("keypress", function (event) {
if (event.keyCode === core_key.code.ENTER) {
event.preventDefault();
$btn.trigger("click");
}
});
},
},
{
key: "show",
value: function show() {
var _this = this;
this.context.invoke("editor.saveRange");
this.showImageDialog()
.then(function (data) {
// [workaround] hide dialog before restore range for IE range focus
_this.ui.hideDialog(_this.$dialog);
_this.context.invoke("editor.restoreRange");
if (typeof data === "string") {
// image url
// If onImageLinkInsert set,
if (_this.options.callbacks.onImageLinkInsert) {
_this.context.triggerEvent("image.link.insert", data);
} else {
_this.context.invoke("editor.insertImage", data);
}
} else {
// array of files
_this.context.invoke(
"editor.insertImagesOrCallback",
data
);
}
})
.fail(function () {
_this.context.invoke("editor.restoreRange");
});
},
/**
* show image dialog
*
* @param {jQuery} $dialog
* @return {Promise}
*/
},
{
key: "showImageDialog",
value: function showImageDialog() {
var _this2 = this;
return external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.Deferred(
function (deferred) {
var $imageInput = _this2.$dialog.find(".note-image-input");
var $imageUrl = _this2.$dialog.find(".note-image-url");
var $imageBtn = _this2.$dialog.find(".note-image-btn");
_this2.ui.onDialogShown(_this2.$dialog, function () {
_this2.context.triggerEvent("dialog.shown"); // Cloning imageInput to clear element.
$imageInput.replaceWith(
$imageInput
.clone()
.on("change", function (event) {
deferred.resolve(
event.target.files || event.target.value
);
})
.val("")
);
$imageUrl
.on("input paste propertychange", function () {
_this2.ui.toggleBtn($imageBtn, $imageUrl.val());
})
.val("");
if (!env.isSupportTouch) {
$imageUrl.trigger("focus");
}
$imageBtn.click(function (event) {
event.preventDefault();
deferred.resolve($imageUrl.val());
});
_this2.bindEnterKey($imageUrl, $imageBtn);
});
_this2.ui.onDialogHidden(_this2.$dialog, function () {
$imageInput.off();
$imageUrl.off();
$imageBtn.off();
if (deferred.state() === "pending") {
deferred.reject();
}
});
_this2.ui.showDialog(_this2.$dialog);
}
);
},
},
]);
return ImageDialog;
})();
// CONCATENATED MODULE: ./src/js/base/module/ImagePopover.js
function ImagePopover_classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
}
function ImagePopover_defineProperties(target, props) {
for (var i = 0; i < props.length; i++) {
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}
function ImagePopover_createClass(
Constructor,
protoProps,
staticProps
) {
if (protoProps)
ImagePopover_defineProperties(Constructor.prototype, protoProps);
if (staticProps)
ImagePopover_defineProperties(Constructor, staticProps);
return Constructor;
}
/**
* Image popover module
* mouse events that show/hide popover will be handled by Handle.js.
* Handle.js will receive the events and invoke 'imagePopover.update'.
*/
var ImagePopover_ImagePopover = /*#__PURE__*/ (function () {
function ImagePopover(context) {
var _this = this;
ImagePopover_classCallCheck(this, ImagePopover);
this.context = context;
this.ui =
external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.summernote.ui;
this.editable = context.layoutInfo.editable[0];
this.options = context.options;
this.events = {
"summernote.disable summernote.blur": function summernoteDisableSummernoteBlur() {
_this.hide();
},
};
}
ImagePopover_createClass(ImagePopover, [
{
key: "shouldInitialize",
value: function shouldInitialize() {
return !lists.isEmpty(this.options.popover.image);
},
},
{
key: "initialize",
value: function initialize() {
this.$popover = this.ui
.popover({
className: "note-image-popover",
})
.render()
.appendTo(this.options.container);
var $content = this.$popover.find(
".popover-content,.note-popover-content"
);
this.context.invoke(
"buttons.build",
$content,
this.options.popover.image
);
this.$popover.on("mousedown", function (e) {
e.preventDefault();
});
},
},
{
key: "destroy",
value: function destroy() {
this.$popover.remove();
},
},
{
key: "update",
value: function update(target, event) {
if (dom.isImg(target)) {
var position = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(
target
).offset();
var containerOffset = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(
this.options.container
).offset();
var pos = {};
if (this.options.popatmouse) {
pos.left = event.pageX - 20;
pos.top = event.pageY;
} else {
pos = position;
}
pos.top -= containerOffset.top;
pos.left -= containerOffset.left;
this.$popover.css({
display: "block",
left: pos.left,
top: pos.top,
});
} else {
this.hide();
}
},
},
{
key: "hide",
value: function hide() {
this.$popover.hide();
},
},
]);
return ImagePopover;
})();
// CONCATENATED MODULE: ./src/js/base/module/TablePopover.js
function TablePopover_classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
}
function TablePopover_defineProperties(target, props) {
for (var i = 0; i < props.length; i++) {
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}
function TablePopover_createClass(
Constructor,
protoProps,
staticProps
) {
if (protoProps)
TablePopover_defineProperties(Constructor.prototype, protoProps);
if (staticProps)
TablePopover_defineProperties(Constructor, staticProps);
return Constructor;
}
var TablePopover_TablePopover = /*#__PURE__*/ (function () {
function TablePopover(context) {
var _this = this;
TablePopover_classCallCheck(this, TablePopover);
this.context = context;
this.ui =
external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.summernote.ui;
this.options = context.options;
this.events = {
"summernote.mousedown": function summernoteMousedown(we, e) {
_this.update(e.target);
},
"summernote.keyup summernote.scroll summernote.change": function summernoteKeyupSummernoteScrollSummernoteChange() {
_this.update();
},
"summernote.disable summernote.blur": function summernoteDisableSummernoteBlur() {
_this.hide();
},
};
}
TablePopover_createClass(TablePopover, [
{
key: "shouldInitialize",
value: function shouldInitialize() {
return !lists.isEmpty(this.options.popover.table);
},
},
{
key: "initialize",
value: function initialize() {
this.$popover = this.ui
.popover({
className: "note-table-popover",
})
.render()
.appendTo(this.options.container);
var $content = this.$popover.find(
".popover-content,.note-popover-content"
);
this.context.invoke(
"buttons.build",
$content,
this.options.popover.table
); // [workaround] Disable Firefox's default table editor
if (env.isFF) {
document.execCommand(
"enableInlineTableEditing",
false,
false
);
}
this.$popover.on("mousedown", function (e) {
e.preventDefault();
});
},
},
{
key: "destroy",
value: function destroy() {
this.$popover.remove();
},
},
{
key: "update",
value: function update(target) {
if (this.context.isDisabled()) {
return false;
}
var isCell = dom.isCell(target);
if (isCell) {
var pos = dom.posFromPlaceholder(target);
var containerOffset = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(
this.options.container
).offset();
pos.top -= containerOffset.top;
pos.left -= containerOffset.left;
this.$popover.css({
display: "block",
left: pos.left,
top: pos.top,
});
} else {
this.hide();
}
return isCell;
},
},
{
key: "hide",
value: function hide() {
this.$popover.hide();
},
},
]);
return TablePopover;
})();
// CONCATENATED MODULE: ./src/js/base/module/VideoDialog.js
function VideoDialog_classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
}
function VideoDialog_defineProperties(target, props) {
for (var i = 0; i < props.length; i++) {
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}
function VideoDialog_createClass(Constructor, protoProps, staticProps) {
if (protoProps)
VideoDialog_defineProperties(Constructor.prototype, protoProps);
if (staticProps)
VideoDialog_defineProperties(Constructor, staticProps);
return Constructor;
}
var VideoDialog_VideoDialog = /*#__PURE__*/ (function () {
function VideoDialog(context) {
VideoDialog_classCallCheck(this, VideoDialog);
this.context = context;
this.ui =
external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default.a.summernote.ui;
this.$body = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(
document.body
);
this.$editor = context.layoutInfo.editor;
this.options = context.options;
this.lang = this.options.langInfo;
}
VideoDialog_createClass(VideoDialog, [
{
key: "initialize",
value: function initialize() {
var $container = this.options.dialogsInBody
? this.$body
: this.options.container;
var body = [
'',
'"),
''
),
"
",
].join("");
var buttonClass =
"btn btn-primary note-btn note-btn-primary note-video-btn";
var footer = '');
this.$dialog = this.ui
.dialog({
title: this.lang.video.insert,
fade: this.options.dialogsFade,
body: body,
footer: footer,
})
.render()
.appendTo($container);
},
},
{
key: "destroy",
value: function destroy() {
this.ui.hideDialog(this.$dialog);
this.$dialog.remove();
},
},
{
key: "bindEnterKey",
value: function bindEnterKey($input, $btn) {
$input.on("keypress", function (event) {
if (event.keyCode === core_key.code.ENTER) {
event.preventDefault();
$btn.trigger("click");
}
});
},
},
{
key: "createVideoNode",
value: function createVideoNode(url) {
// video url patterns(youtube, instagram, vimeo, dailymotion, youku, mp4, ogg, webm)
var ytRegExp = /\/\/(?:(?:www|m)\.)?(?:youtu\.be\/|youtube\.com\/(?:embed\/|v\/|watch\?v=|watch\?.+&v=))([\w|-]{11})(?:(?:[\?&]t=)(\S+))?$/;
var ytRegExpForStart = /^(?:(\d+)h)?(?:(\d+)m)?(?:(\d+)s)?$/;
var ytMatch = url.match(ytRegExp);
var igRegExp = /(?:www\.|\/\/)instagram\.com\/p\/(.[a-zA-Z0-9_-]*)/;
var igMatch = url.match(igRegExp);
var vRegExp = /\/\/vine\.co\/v\/([a-zA-Z0-9]+)/;
var vMatch = url.match(vRegExp);
var vimRegExp = /\/\/(player\.)?vimeo\.com\/([a-z]*\/)*(\d+)[?]?.*/;
var vimMatch = url.match(vimRegExp);
var dmRegExp = /.+dailymotion.com\/(video|hub)\/([^_]+)[^#]*(#video=([^_&]+))?/;
var dmMatch = url.match(dmRegExp);
var youkuRegExp = /\/\/v\.youku\.com\/v_show\/id_(\w+)=*\.html/;
var youkuMatch = url.match(youkuRegExp);
var qqRegExp = /\/\/v\.qq\.com.*?vid=(.+)/;
var qqMatch = url.match(qqRegExp);
var qqRegExp2 = /\/\/v\.qq\.com\/x?\/?(page|cover).*?\/([^\/]+)\.html\??.*/;
var qqMatch2 = url.match(qqRegExp2);
var mp4RegExp = /^.+.(mp4|m4v)$/;
var mp4Match = url.match(mp4RegExp);
var oggRegExp = /^.+.(ogg|ogv)$/;
var oggMatch = url.match(oggRegExp);
var webmRegExp = /^.+.(webm)$/;
var webmMatch = url.match(webmRegExp);
var fbRegExp = /(?:www\.|\/\/)facebook\.com\/([^\/]+)\/videos\/([0-9]+)/;
var fbMatch = url.match(fbRegExp);
var $video;
if (ytMatch && ytMatch[1].length === 11) {
var youtubeId = ytMatch[1];
var start = 0;
if (typeof ytMatch[2] !== "undefined") {
var ytMatchForStart = ytMatch[2].match(ytRegExpForStart);
if (ytMatchForStart) {
for (
var n = [3600, 60, 1], i = 0, r = n.length;
i < r;
i++
) {
start +=
typeof ytMatchForStart[i + 1] !== "undefined"
? n[i] * parseInt(ytMatchForStart[i + 1], 10)
: 0;
}
}
}
$video = external_root_jQuery_commonjs2_jquery_commonjs_jquery_amd_jquery_default()(
"