code stringlengths 24 2.07M | docstring stringlengths 25 85.3k | func_name stringlengths 1 92 | language stringclasses 1
value | repo stringlengths 5 64 | path stringlengths 4 172 | url stringlengths 44 218 | license stringclasses 7
values |
|---|---|---|---|---|---|---|---|
function debounce(func, wait, immediate) {
let timeout;
return function() {
const context = this;
const args = arguments;
const later = () => {
timeout = null;
if (!immediate) {
func.apply(context, args);
}
};
const callNow = immediate && !timeout;
clearTimeout(time... | Returns a function, that, as long as it continues to be invoked, will not
be triggered. The function will be called after it stops being called for
N milliseconds. If `immediate` is passed, trigger the function on the
leading edge, instead of the trailing.
@param {Function} func
@param {Number} wait
@param {Boolean} im... | debounce | javascript | summernote/summernote | src/js/core/func.js | https://github.com/summernote/summernote/blob/master/src/js/core/func.js | MIT |
later = () => {
timeout = null;
if (!immediate) {
func.apply(context, args);
}
} | Returns a function, that, as long as it continues to be invoked, will not
be triggered. The function will be called after it stops being called for
N milliseconds. If `immediate` is passed, trigger the function on the
leading edge, instead of the trailing.
@param {Function} func
@param {Number} wait
@param {Boolean} im... | later | javascript | summernote/summernote | src/js/core/func.js | https://github.com/summernote/summernote/blob/master/src/js/core/func.js | MIT |
later = () => {
timeout = null;
if (!immediate) {
func.apply(context, args);
}
} | Returns a function, that, as long as it continues to be invoked, will not
be triggered. The function will be called after it stops being called for
N milliseconds. If `immediate` is passed, trigger the function on the
leading edge, instead of the trailing.
@param {Function} func
@param {Number} wait
@param {Boolean} im... | later | javascript | summernote/summernote | src/js/core/func.js | https://github.com/summernote/summernote/blob/master/src/js/core/func.js | MIT |
function head(array) {
return array[0];
} | returns the first item of an array.
@param {Array} array | head | javascript | summernote/summernote | src/js/core/lists.js | https://github.com/summernote/summernote/blob/master/src/js/core/lists.js | MIT |
function last(array) {
return array[array.length - 1];
} | returns the last item of an array.
@param {Array} array | last | javascript | summernote/summernote | src/js/core/lists.js | https://github.com/summernote/summernote/blob/master/src/js/core/lists.js | MIT |
function initial(array) {
return array.slice(0, array.length - 1);
} | returns everything but the last entry of the array.
@param {Array} array | initial | javascript | summernote/summernote | src/js/core/lists.js | https://github.com/summernote/summernote/blob/master/src/js/core/lists.js | MIT |
function tail(array) {
return array.slice(1);
} | returns the rest of the items in an array.
@param {Array} array | tail | javascript | summernote/summernote | src/js/core/lists.js | https://github.com/summernote/summernote/blob/master/src/js/core/lists.js | MIT |
function all(array, pred) {
for (let idx = 0, len = array.length; idx < len; idx++) {
if (!pred(array[idx])) {
return false;
}
}
return true;
} | returns true if all of the values in the array pass the predicate truth test. | all | javascript | summernote/summernote | src/js/core/lists.js | https://github.com/summernote/summernote/blob/master/src/js/core/lists.js | MIT |
function contains(array, item) {
if (array && array.length && item) {
if (array.indexOf) {
return array.indexOf(item) !== -1;
} else if (array.contains) {
// `DOMTokenList` doesn't implement `.indexOf`, but it implements `.contains`
return array.contains(item);
}
}
return false;
} | returns true if the value is present in the list. | contains | javascript | summernote/summernote | src/js/core/lists.js | https://github.com/summernote/summernote/blob/master/src/js/core/lists.js | MIT |
function sum(array, fn) {
fn = fn || func.self;
return array.reduce(function(memo, v) {
return memo + fn(v);
}, 0);
} | get sum from a list
@param {Array} array - array
@param {Function} fn - iterator | sum | javascript | summernote/summernote | src/js/core/lists.js | https://github.com/summernote/summernote/blob/master/src/js/core/lists.js | MIT |
function from(collection) {
const result = [];
const length = collection.length;
let idx = -1;
while (++idx < length) {
result[idx] = collection[idx];
}
return result;
} | returns a copy of the collection with array type.
@param {Collection} collection - collection eg) node.childNodes, ... | from | javascript | summernote/summernote | src/js/core/lists.js | https://github.com/summernote/summernote/blob/master/src/js/core/lists.js | MIT |
function isEmpty(array) {
return !array || !array.length;
} | returns whether list is empty or not | isEmpty | javascript | summernote/summernote | src/js/core/lists.js | https://github.com/summernote/summernote/blob/master/src/js/core/lists.js | MIT |
function clusterBy(array, fn) {
if (!array.length) { return []; }
const aTail = tail(array);
return aTail.reduce(function(memo, v) {
const aLast = last(memo);
if (fn(last(aLast), v)) {
aLast[aLast.length] = v;
} else {
memo[memo.length] = [v];
}
return memo;
}, [[head(array)]]);
... | cluster elements by predicate function.
@param {Array} array - array
@param {Function} fn - predicate function for cluster rule
@param {Array[]} | clusterBy | javascript | summernote/summernote | src/js/core/lists.js | https://github.com/summernote/summernote/blob/master/src/js/core/lists.js | MIT |
function compact(array) {
const aResult = [];
for (let idx = 0, len = array.length; idx < len; idx++) {
if (array[idx]) { aResult.push(array[idx]); }
}
return aResult;
} | returns a copy of the array with all false values removed
@param {Array} array - array
@param {Function} fn - predicate function for cluster rule | compact | javascript | summernote/summernote | src/js/core/lists.js | https://github.com/summernote/summernote/blob/master/src/js/core/lists.js | MIT |
function unique(array) {
const results = [];
for (let idx = 0, len = array.length; idx < len; idx++) {
if (!contains(results, array[idx])) {
results.push(array[idx]);
}
}
return results;
} | produces a duplicate-free version of the array
@param {Array} array | unique | javascript | summernote/summernote | src/js/core/lists.js | https://github.com/summernote/summernote/blob/master/src/js/core/lists.js | MIT |
function next(array, item) {
if (array && array.length && item) {
const idx = array.indexOf(item);
return idx === -1 ? null : array[idx + 1];
}
return null;
} | returns next item.
@param {Array} array | next | javascript | summernote/summernote | src/js/core/lists.js | https://github.com/summernote/summernote/blob/master/src/js/core/lists.js | MIT |
function prev(array, item) {
if (array && array.length && item) {
const idx = array.indexOf(item);
return idx === -1 ? null : array[idx - 1];
}
return null;
} | returns prev item.
@param {Array} array | prev | javascript | summernote/summernote | src/js/core/lists.js | https://github.com/summernote/summernote/blob/master/src/js/core/lists.js | MIT |
function textRangeToPoint(textRange, isStart) {
let container = textRange.parentElement();
let offset;
const tester = document.body.createTextRange();
let prevContainer;
const childNodes = lists.from(container.childNodes);
for (offset = 0; offset < childNodes.length; offset++) {
if (dom.isText(childNod... | 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 | textRangeToPoint | javascript | summernote/summernote | src/js/core/range.js | https://github.com/summernote/summernote/blob/master/src/js/core/range.js | MIT |
function pointToTextRange(point) {
const textRangeInfo = function(container, offset) {
let node, isCollapseToStart;
if (dom.isText(container)) {
const prevTextNodes = dom.listPrev(container, func.not(dom.isText));
const prevContainer = lists.last(prevTextNodes).previousSibling;
node = prevC... | return TextRange from boundary point (inspired by google closure-library)
@param {BoundaryPoint} point
@return {TextRange} | pointToTextRange | javascript | summernote/summernote | src/js/core/range.js | https://github.com/summernote/summernote/blob/master/src/js/core/range.js | MIT |
textRangeInfo = function(container, offset) {
let node, isCollapseToStart;
if (dom.isText(container)) {
const prevTextNodes = dom.listPrev(container, func.not(dom.isText));
const prevContainer = lists.last(prevTextNodes).previousSibling;
node = prevContainer || container.parentNode;
off... | return TextRange from boundary point (inspired by google closure-library)
@param {BoundaryPoint} point
@return {TextRange} | textRangeInfo | javascript | summernote/summernote | src/js/core/range.js | https://github.com/summernote/summernote/blob/master/src/js/core/range.js | MIT |
textRangeInfo = function(container, offset) {
let node, isCollapseToStart;
if (dom.isText(container)) {
const prevTextNodes = dom.listPrev(container, func.not(dom.isText));
const prevContainer = lists.last(prevTextNodes).previousSibling;
node = prevContainer || container.parentNode;
off... | return TextRange from boundary point (inspired by google closure-library)
@param {BoundaryPoint} point
@return {TextRange} | textRangeInfo | javascript | summernote/summernote | src/js/core/range.js | https://github.com/summernote/summernote/blob/master/src/js/core/range.js | MIT |
constructor(sc, so, ec, eo) {
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.i... | Wrapped Range
@constructor
@param {Node} sc - start container
@param {Number} so - start offset
@param {Node} ec - end container
@param {Number} eo - end offset | constructor | javascript | summernote/summernote | src/js/core/range.js | https://github.com/summernote/summernote/blob/master/src/js/core/range.js | MIT |
nativeRange() {
if (env.isW3CRangeSupport) {
const w3cRange = document.createRange();
w3cRange.setStart(this.sc, this.so);
w3cRange.setEnd(this.ec, this.eo);
return w3cRange;
} else {
const textRange = pointToTextRange({
node: this.sc,
offset: this.so,
});
... | Wrapped Range
@constructor
@param {Node} sc - start container
@param {Number} so - start offset
@param {Node} ec - end container
@param {Number} eo - end offset | nativeRange | javascript | summernote/summernote | src/js/core/range.js | https://github.com/summernote/summernote/blob/master/src/js/core/range.js | MIT |
getPoints() {
return {
sc: this.sc,
so: this.so,
ec: this.ec,
eo: this.eo,
};
} | Wrapped Range
@constructor
@param {Node} sc - start container
@param {Number} so - start offset
@param {Node} ec - end container
@param {Number} eo - end offset | getPoints | javascript | summernote/summernote | src/js/core/range.js | https://github.com/summernote/summernote/blob/master/src/js/core/range.js | MIT |
getStartPoint() {
return {
node: this.sc,
offset: this.so,
};
} | Wrapped Range
@constructor
@param {Node} sc - start container
@param {Number} so - start offset
@param {Node} ec - end container
@param {Number} eo - end offset | getStartPoint | javascript | summernote/summernote | src/js/core/range.js | https://github.com/summernote/summernote/blob/master/src/js/core/range.js | MIT |
getEndPoint() {
return {
node: this.ec,
offset: this.eo,
};
} | Wrapped Range
@constructor
@param {Node} sc - start container
@param {Number} so - start offset
@param {Node} ec - end container
@param {Number} eo - end offset | getEndPoint | javascript | summernote/summernote | src/js/core/range.js | https://github.com/summernote/summernote/blob/master/src/js/core/range.js | MIT |
scrollIntoView(container) {
const height = $(container).height();
if (container.scrollTop + height < this.sc.offsetTop) {
container.scrollTop += Math.abs(container.scrollTop + height - this.sc.offsetTop);
}
return this;
} | Moves the scrollbar to start container(sc) of current range
@return {WrappedRange} | scrollIntoView | javascript | summernote/summernote | src/js/core/range.js | https://github.com/summernote/summernote/blob/master/src/js/core/range.js | MIT |
getVisiblePoint = function(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... | @param {BoundaryPoint} point
@param {Boolean} isLeftToRight - true: prefer to choose right node
- false: prefer to choose left node
@return {BoundaryPoint} | getVisiblePoint | javascript | summernote/summernote | src/js/core/range.js | https://github.com/summernote/summernote/blob/master/src/js/core/range.js | MIT |
getVisiblePoint = function(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... | @param {BoundaryPoint} point
@param {Boolean} isLeftToRight - true: prefer to choose right node
- false: prefer to choose left node
@return {BoundaryPoint} | getVisiblePoint | javascript | summernote/summernote | src/js/core/range.js | https://github.com/summernote/summernote/blob/master/src/js/core/range.js | MIT |
nodes(pred, options) {
pred = pred || func.ok;
const includeAncestor = options && options.includeAncestor;
const fullyContains = options && options.fullyContains;
// TODO compare points and sort
const startPoint = this.getStartPoint();
const endPoint = this.getEndPoint();
const nodes = []... | returns matched nodes on range
@param {Function} [pred] - predicate function
@param {Object} [options]
@param {Boolean} [options.includeAncestor]
@param {Boolean} [options.fullyContains]
@return {Node[]} | nodes | javascript | summernote/summernote | src/js/core/range.js | https://github.com/summernote/summernote/blob/master/src/js/core/range.js | MIT |
commonAncestor() {
return dom.commonAncestor(this.sc, this.ec);
} | returns commonAncestor of range
@return {Element} - commonAncestor | commonAncestor | javascript | summernote/summernote | src/js/core/range.js | https://github.com/summernote/summernote/blob/master/src/js/core/range.js | MIT |
expand(pred) {
const startAncestor = dom.ancestor(this.sc, pred);
const endAncestor = dom.ancestor(this.ec, pred);
if (!startAncestor && !endAncestor) {
return new WrappedRange(this.sc, this.so, this.ec, this.eo);
}
const boundaryPoints = this.getPoints();
if (startAncestor) {
bou... | returns expanded range by pred
@param {Function} pred - predicate function
@return {WrappedRange} | expand | javascript | summernote/summernote | src/js/core/range.js | https://github.com/summernote/summernote/blob/master/src/js/core/range.js | MIT |
deleteContents() {
if (this.isCollapsed()) {
return this;
}
const rng = this.splitText();
const nodes = rng.nodes(null, {
fullyContains: true,
});
// find new cursor point
const point = dom.prevPointUntil(rng.getStartPoint(), function(point) {
return !lists.contains(nodes... | delete contents on range
@return {WrappedRange} | deleteContents | javascript | summernote/summernote | src/js/core/range.js | https://github.com/summernote/summernote/blob/master/src/js/core/range.js | MIT |
isCollapsed() {
return this.sc === this.ec && this.so === this.eo;
} | returns whether range was collapsed or not | isCollapsed | javascript | summernote/summernote | src/js/core/range.js | https://github.com/summernote/summernote/blob/master/src/js/core/range.js | MIT |
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.
* ... | wrap inline nodes which children of body with paragraph
@return {WrappedRange} | wrapBodyInlineWithPara | javascript | summernote/summernote | src/js/core/range.js | https://github.com/summernote/summernote/blob/master/src/js/core/range.js | MIT |
insertNode(node, doNotInsertPara = false) {
let rng = this;
if (dom.isText(node) || dom.isInline(node)) {
rng = this.wrapBodyInlineWithPara().deleteContents();
}
const info = dom.splitPoint(rng.getStartPoint(), dom.isInline(node));
if (info.rightNode) {
info.rightNode.parentNode.insert... | insert node at current cursor
@param {Node} node
@param {Boolean} doNotInsertPara - default is false, removes added <p> that's added if true
@return {Node} | insertNode | javascript | summernote/summernote | src/js/core/range.js | https://github.com/summernote/summernote/blob/master/src/js/core/range.js | MIT |
toString() {
const nativeRng = this.nativeRange();
return env.isW3CRangeSupport ? nativeRng.toString() : nativeRng.text;
} | returns text in range
@return {String} | toString | javascript | summernote/summernote | src/js/core/range.js | https://github.com/summernote/summernote/blob/master/src/js/core/range.js | MIT |
getWordRange(findAfter) {
let endPoint = this.getEndPoint();
if (!dom.isCharPoint(endPoint)) {
return this;
}
const startPoint = dom.prevPointUntil(endPoint, function(point) {
return !dom.isCharPoint(point);
});
if (findAfter) {
endPoint = dom.nextPointUntil(endPoint, functi... | returns range for word before cursor
@param {Boolean} [findAfter] - find after cursor, default: false
@return {WrappedRange} | getWordRange | javascript | summernote/summernote | src/js/core/range.js | https://github.com/summernote/summernote/blob/master/src/js/core/range.js | MIT |
getWordsRange(findAfter) {
var endPoint = this.getEndPoint();
var isNotTextPoint = function(point) {
return !dom.isCharPoint(point) && !dom.isSpacePoint(point);
};
if (isNotTextPoint(endPoint)) {
return this;
}
var startPoint = dom.prevPointUntil(endPoint, isNotTextPoint);
if... | returns range for words before cursor
@param {Boolean} [findAfter] - find after cursor, default: false
@return {WrappedRange} | getWordsRange | javascript | summernote/summernote | src/js/core/range.js | https://github.com/summernote/summernote/blob/master/src/js/core/range.js | MIT |
isNotTextPoint = function(point) {
return !dom.isCharPoint(point) && !dom.isSpacePoint(point);
} | returns range for words before cursor
@param {Boolean} [findAfter] - find after cursor, default: false
@return {WrappedRange} | isNotTextPoint | javascript | summernote/summernote | src/js/core/range.js | https://github.com/summernote/summernote/blob/master/src/js/core/range.js | MIT |
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,
endPoi... | 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} | getWordsMatchRange | javascript | summernote/summernote | src/js/core/range.js | https://github.com/summernote/summernote/blob/master/src/js/core/range.js | MIT |
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
@param {Node} editable | bookmark | javascript | summernote/summernote | src/js/core/range.js | https://github.com/summernote/summernote/blob/master/src/js/core/range.js | MIT |
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,
},
};
} | create offsetPath bookmark base on paragraph
@param {Node[]} paras | paraBookmark | javascript | summernote/summernote | src/js/core/range.js | https://github.com/summernote/summernote/blob/master/src/js/core/range.js | MIT |
toggleList(listName, editable) {
const rng = range.create(editable).wrapBodyInlineWithPara();
let paras = rng.nodes(dom.isPara, { includeAncestor: true });
const bookmark = rng.paraBookmark(paras);
const clustereds = lists.clusterBy(paras, func.peq2('parentNode'));
// paragraph to list
if (lis... | toggle list
@param {String} listName - OL or UL | toggleList | javascript | summernote/summernote | src/js/editing/Bullet.js | https://github.com/summernote/summernote/blob/master/src/js/editing/Bullet.js | MIT |
wrapList(paras, listName) {
const head = lists.head(paras);
const last = lists.last(paras);
const prevList = dom.isList(head.previousSibling) && head.previousSibling;
const nextList = dom.isList(last.nextSibling) && last.nextSibling;
const listNode = prevList || dom.insertAfter(dom.create(listName... | @param {Node[]} paras
@param {String} listName
@return {Node[]} | wrapList | javascript | summernote/summernote | src/js/editing/Bullet.js | https://github.com/summernote/summernote/blob/master/src/js/editing/Bullet.js | MIT |
releaseList(clustereds, isEscapseToBody) {
let releasedParas = [];
$.each(clustereds, (idx, paras) => {
const head = lists.head(paras);
const last = lists.last(paras);
const headList = isEscapseToBody ? dom.lastAncestor(head, dom.isList) : head.parentNode;
const parentItem = headList.p... | @method releaseList
@param {Array[]} clustereds
@param {Boolean} isEscapseToBody
@return {Node[]} | releaseList | javascript | summernote/summernote | src/js/editing/Bullet.js | https://github.com/summernote/summernote/blob/master/src/js/editing/Bullet.js | MIT |
appendToPrevious(node) {
return node.previousSibling ? dom.appendChildNodes(node.previousSibling, [node]) : this.wrapList([node], 'LI');
} | @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} | appendToPrevious | javascript | summernote/summernote | src/js/editing/Bullet.js | https://github.com/summernote/summernote/blob/master/src/js/editing/Bullet.js | MIT |
findList(node) {
return node ? lists.find(node.children, (child) => ['OL', 'UL'].indexOf(child.nodeName) > -1) : null;
} | @method findList
Finds an existing list in list item
@param {HTMLNode} ListItem
@return {Array[]} | findList | javascript | summernote/summernote | src/js/editing/Bullet.js | https://github.com/summernote/summernote/blob/master/src/js/editing/Bullet.js | MIT |
findNextSiblings(node) {
const siblings = [];
while (node.nextSibling) {
siblings.push(node.nextSibling);
node = node.nextSibling;
}
return siblings;
} | @method findNextSiblings
Finds all list item siblings that follow it
@param {HTMLNode} ListItem
@return {HTMLNode} | findNextSiblings | javascript | summernote/summernote | src/js/editing/Bullet.js | https://github.com/summernote/summernote/blob/master/src/js/editing/Bullet.js | MIT |
rewind() {
// Create snap shot if not yet recorded
if (this.$editable.html() !== this.stack[this.stackOffset].contents) {
this.recordUndo();
}
// Return to the first available snapshot.
this.stackOffset = 0;
// Apply that snapshot.
this.applySnapshot(this.stack[this.stackOffset]);
... | @method rewind
Rewinds the history stack back to the first snapshot taken.
Leaves the stack intact, so that "Redo" can still be used. | rewind | javascript | summernote/summernote | src/js/editing/History.js | https://github.com/summernote/summernote/blob/master/src/js/editing/History.js | MIT |
reset() {
// Clear the stack.
this.stack = [];
// Restore stackOffset to its original value.
this.stackOffset = -1;
// Clear the editable area.
this.$editable.html('');
// Record our first snapshot (of nothing).
this.recordUndo();
} | @method reset
Resets the history stack completely; reverting to an empty editor. | reset | javascript | summernote/summernote | src/js/editing/History.js | https://github.com/summernote/summernote/blob/master/src/js/editing/History.js | MIT |
jQueryCSS($obj, propertyNames) {
const result = {};
$.each(propertyNames, (idx, propertyName) => {
result[propertyName] = $obj.css(propertyName);
});
return result;
} | @method jQueryCSS
[workaround] for old jQuery
passing an array of style properties to .css()
will result in an object of property-value pairs.
(compability with version < 1.9)
@private
@param {jQuery} $obj
@param {Array} propertyNames - An array of one or more CSS properties.
@return {Object} | jQueryCSS | javascript | summernote/summernote | src/js/editing/Style.js | https://github.com/summernote/summernote/blob/master/src/js/editing/Style.js | MIT |
fromNode($node) {
const properties = ['font-family', 'font-size', 'text-align', 'list-style-type', 'line-height'];
const styleInfo = this.jQueryCSS($node, properties) || {};
const fontSize = $node[0].style.fontSize || styleInfo['font-size'];
styleInfo['font-size'] = parseInt(fontSize, 10);
styleIn... | returns style object from node
@param {jQuery} $node
@return {Object} | fromNode | javascript | summernote/summernote | src/js/editing/Style.js | https://github.com/summernote/summernote/blob/master/src/js/editing/Style.js | MIT |
stylePara(rng, styleInfo) {
$.each(rng.nodes(dom.isPara, {
includeAncestor: true,
}), (idx, para) => {
$(para).css(styleInfo);
});
} | paragraph level style
@param {WrappedRange} rng
@param {Object} styleInfo | stylePara | javascript | summernote/summernote | src/js/editing/Style.js | https://github.com/summernote/summernote/blob/master/src/js/editing/Style.js | MIT |
styleNodes(rng, options) {
rng = rng.splitText();
const nodeName = (options && options.nodeName) || 'SPAN';
const expandClosestSibling = !!(options && options.expandClosestSibling);
const onlyPartialContains = !!(options && options.onlyPartialContains);
if (rng.isCollapsed()) {
return [rng.i... | insert and returns styleNodes on range.
@param {WrappedRange} rng
@param {Object} [options] - options for styleNodes
@param {String} [options.nodeName] - default: `SPAN`
@param {Boolean} [options.expandClosestSibling] - default: `false`
@param {Boolean} [options.onlyPartialContains] - default: `false`
@return {Node[]} | styleNodes | javascript | summernote/summernote | src/js/editing/Style.js | https://github.com/summernote/summernote/blob/master/src/js/editing/Style.js | MIT |
current(rng) {
const $cont = $(!dom.isElement(rng.sc) ? rng.sc.parentNode : rng.sc);
let styleInfo = this.fromNode($cont);
// document.queryCommandState for toggle state
// [workaround] prevent Firefox nsresult: "0x80004005 (NS_ERROR_FAILURE)"
try {
styleInfo = $.extend(styleInfo, {
'... | get current style on cursor
@param {WrappedRange} rng
@return {Object} - object contains style properties. | current | javascript | summernote/summernote | src/js/editing/Style.js | https://github.com/summernote/summernote/blob/master/src/js/editing/Style.js | MIT |
TableResultAction = function(startPoint, where, action, domTable) {
const _startPoint = { 'colPos': 0, 'rowPos': 0 };
const _virtualTable = [];
const _actionCellList = [];
/// ///////////////////////////////////////////
// Private functions
/// ///////////////////////////////////////////
/**
* Set th... | @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 {obj... | TableResultAction | javascript | summernote/summernote | src/js/editing/Table.js | https://github.com/summernote/summernote/blob/master/src/js/editing/Table.js | MIT |
TableResultAction = function(startPoint, where, action, domTable) {
const _startPoint = { 'colPos': 0, 'rowPos': 0 };
const _virtualTable = [];
const _actionCellList = [];
/// ///////////////////////////////////////////
// Private functions
/// ///////////////////////////////////////////
/**
* Set th... | @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 {obj... | TableResultAction | javascript | summernote/summernote | src/js/editing/Table.js | https://github.com/summernote/summernote/blob/master/src/js/editing/Table.js | MIT |
function setVirtualTablePosition(rowIndex, cellIndex, baseRow, baseCell, isRowSpan, isColSpan, isVirtualCell) {
const objPosition = {
'baseRow': baseRow,
'baseCell': baseCell,
'isRowSpan': isRowSpan,
'isColSpan': isColSpan,
'isVirtual': isVirtualCell,
};
if (!_virtualTable[rowI... | 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 i... | setVirtualTablePosition | javascript | summernote/summernote | src/js/editing/Table.js | https://github.com/summernote/summernote/blob/master/src/js/editing/Table.js | MIT |
function getActionCell(virtualTableCellObj, resultAction, virtualRowPosition, virtualColPosition) {
return {
'baseCell': virtualTableCellObj.baseCell,
'action': resultAction,
'virtualTable': {
'rowIndex': virtualRowPosition,
'cellIndex': virtualColPosition,
},
};
} | Create action cell object.
@param {object} virtualTableCellObj Object of specific position on virtual table.
@param {enum} resultAction Action to be applied in that item. | getActionCell | javascript | summernote/summernote | src/js/editing/Table.js | https://github.com/summernote/summernote/blob/master/src/js/editing/Table.js | MIT |
function recoverCellIndex(rowIndex, cellIndex) {
if (!_virtualTable[rowIndex]) {
return cellIndex;
}
if (!_virtualTable[rowIndex][cellIndex]) {
return cellIndex;
}
let newCellIndex = cellIndex;
while (_virtualTable[rowIndex][newCellIndex]) {
newCellIndex++;
if (!_virtual... | 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. | recoverCellIndex | javascript | summernote/summernote | src/js/editing/Table.js | https://github.com/summernote/summernote/blob/master/src/js/editing/Table.js | MIT |
function addCellInfoToVirtual(row, cell) {
const cellIndex = recoverCellIndex(row.rowIndex, cell.cellIndex);
const cellHasColspan = (cell.colSpan > 1);
const cellHasRowspan = (cell.rowSpan > 1);
const isThisSelectedCell = (row.rowIndex === _startPoint.rowPos && cell.cellIndex === _startPoint.colPos);
... | 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. | addCellInfoToVirtual | javascript | summernote/summernote | src/js/editing/Table.js | https://github.com/summernote/summernote/blob/master/src/js/editing/Table.js | MIT |
function adjustStartPoint(rowIndex, cellIndex, cell, isSelectedCell) {
if (rowIndex === _startPoint.rowPos && _startPoint.colPos >= cell.cellIndex && cell.cellIndex <= cellIndex && !isSelectedCell) {
_startPoint.colPos++;
}
} | Process validation and adjust of start point if needed
@param {int} rowIndex
@param {int} cellIndex
@param {object} cell
@param {bool} isSelectedCell | adjustStartPoint | javascript | summernote/summernote | src/js/editing/Table.js | https://github.com/summernote/summernote/blob/master/src/js/editing/Table.js | MIT |
function createVirtualTable() {
const rows = domTable.rows;
for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {
const cells = rows[rowIndex].cells;
for (let cellIndex = 0; cellIndex < cells.length; cellIndex++) {
addCellInfoToVirtual(rows[rowIndex], cells[cellIndex]);
}
}
... | Create virtual table of cells with all cells, including span cells. | createVirtualTable | javascript | summernote/summernote | src/js/editing/Table.js | https://github.com/summernote/summernote/blob/master/src/js/editing/Table.js | MIT |
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) {
... | Get action to be applied on the cell.
@param {object} cell virtual table cell to apply action | getDeleteResultActionToCell | javascript | summernote/summernote | src/js/editing/Table.js | https://github.com/summernote/summernote/blob/master/src/js/editing/Table.js | MIT |
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;
}
... | Get action to be applied on the cell.
@param {object} cell virtual table cell to apply action | getAddResultActionToCell | javascript | summernote/summernote | src/js/editing/Table.js | https://github.com/summernote/summernote/blob/master/src/js/editing/Table.js | MIT |
function init() {
setStartPoint();
createVirtualTable();
} | Get action to be applied on the cell.
@param {object} cell virtual table cell to apply action | init | javascript | summernote/summernote | src/js/editing/Table.js | https://github.com/summernote/summernote/blob/master/src/js/editing/Table.js | MIT |
tab(rng, isShift) {
const cell = dom.ancestor(rng.commonAncestor(), dom.isCell);
const table = dom.ancestor(cell, dom.isTable);
const cells = dom.listDescendant(table, dom.isCell);
const nextCell = lists[isShift ? 'prev' : 'next'](cells, cell);
if (nextCell) {
range.create(nextCell, 0).select... | handle tab key
@param {WrappedRange} rng
@param {Boolean} isShift | tab | javascript | summernote/summernote | src/js/editing/Table.js | https://github.com/summernote/summernote/blob/master/src/js/editing/Table.js | MIT |
addRow(rng, position) {
const cell = dom.ancestor(rng.commonAncestor(), dom.isCell);
const currentTr = $(cell).closest('tr');
const trAttributes = this.recoverAttributes(currentTr);
const html = $('<tr' + trAttributes + '></tr>');
const vTable = new TableResultAction(cell, TableResultAction.where.... | Add a new row
@param {WrappedRange} rng
@param {String} position (top/bottom)
@return {Node} | addRow | javascript | summernote/summernote | src/js/editing/Table.js | https://github.com/summernote/summernote/blob/master/src/js/editing/Table.js | MIT |
addCol(rng, position) {
const cell = dom.ancestor(rng.commonAncestor(), dom.isCell);
const row = $(cell).closest('tr');
const rowsGroup = $(row).siblings();
rowsGroup.push(row);
const vTable = new TableResultAction(cell, TableResultAction.where.Column,
TableResultAction.requestAction.Add, $(r... | Add a new col
@param {WrappedRange} rng
@param {String} position (left/right)
@return {Node} | addCol | javascript | summernote/summernote | src/js/editing/Table.js | https://github.com/summernote/summernote/blob/master/src/js/editing/Table.js | MIT |
recoverAttributes(el) {
let resultStr = '';
if (!el) {
return resultStr;
}
const attrList = el.attributes || [];
for (let i = 0; i < attrList.length; i++) {
if (attrList[i].name.toLowerCase() === 'id') {
continue;
}
if (attrList[i].specified) {
resultStr +... | Add a new col
@param {WrappedRange} rng
@param {String} position (left/right)
@return {Node} | recoverAttributes | javascript | summernote/summernote | src/js/editing/Table.js | https://github.com/summernote/summernote/blob/master/src/js/editing/Table.js | MIT |
deleteRow(rng) {
const cell = dom.ancestor(rng.commonAncestor(), dom.isCell);
const row = $(cell).closest('tr');
const cellPos = row.children('td, th').index($(cell));
const rowPos = row[0].rowIndex;
const vTable = new TableResultAction(cell, TableResultAction.where.Row,
TableResultAction.req... | Delete current row
@param {WrappedRange} rng
@return {Node} | deleteRow | javascript | summernote/summernote | src/js/editing/Table.js | https://github.com/summernote/summernote/blob/master/src/js/editing/Table.js | MIT |
deleteCol(rng) {
const cell = dom.ancestor(rng.commonAncestor(), dom.isCell);
const row = $(cell).closest('tr');
const cellPos = row.children('td, th').index($(cell));
const vTable = new TableResultAction(cell, TableResultAction.where.Column,
TableResultAction.requestAction.Delete, $(row).closest... | Delete current col
@param {WrappedRange} rng
@return {Node} | deleteCol | javascript | summernote/summernote | src/js/editing/Table.js | https://github.com/summernote/summernote/blob/master/src/js/editing/Table.js | MIT |
createTable(colCount, rowCount, options) {
const tds = [];
let tdHTML;
for (let idxCol = 0; idxCol < colCount; idxCol++) {
tds.push('<td>' + dom.blank + '</td>');
}
tdHTML = tds.join('');
const trs = [];
let trHTML;
for (let idxRow = 0; idxRow < rowCount; idxRow++) {
trs.pus... | create empty table element
@param {Number} rowCount
@param {Number} colCount
@return {Node} | createTable | javascript | summernote/summernote | src/js/editing/Table.js | https://github.com/summernote/summernote/blob/master/src/js/editing/Table.js | MIT |
deleteTable(rng) {
const cell = dom.ancestor(rng.commonAncestor(), dom.isCell);
$(cell).closest('table').remove();
} | Delete current table
@param {WrappedRange} rng
@return {Node} | deleteTable | javascript | summernote/summernote | src/js/editing/Table.js | https://github.com/summernote/summernote/blob/master/src/js/editing/Table.js | MIT |
insertTab(rng, tabsize) {
const 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 tab
@param {WrappedRange} rng
@param {Number} tabsize | insertTab | javascript | summernote/summernote | src/js/editing/Typing.js | https://github.com/summernote/summernote/blob/master/src/js/editing/Typing.js | MIT |
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
const splitRoot = dom.ancestor(rng.sc, dom.isPara);
... | 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 quo... | insertParagraph | javascript | summernote/summernote | src/js/editing/Typing.js | https://github.com/summernote/summernote/blob/master/src/js/editing/Typing.js | MIT |
addImagePopoverButtons() {
// Image Size Buttons
this.context.memo('button.resizeFull', () => {
return this.button({
contents: '<span class="note-fontsize-10">100%</span>',
tooltip: this.lang.image.resizeFull,
click: this.context.createInvokeHandler('editor.resize', '1'),
}).... | image: [
['imageResize', ['resizeFull', 'resizeHalf', 'resizeQuarter', 'resizeNone']],
['float', ['floatLeft', 'floatRight', 'floatNone']],
['remove', ['removeMedia']],
], | addImagePopoverButtons | javascript | summernote/summernote | src/js/module/Buttons.js | https://github.com/summernote/summernote/blob/master/src/js/module/Buttons.js | MIT |
addLinkPopoverButtons() {
this.context.memo('button.linkDialogShow', () => {
return this.button({
contents: this.ui.icon(this.options.icons.link),
tooltip: this.lang.link.edit,
click: this.context.createInvokeHandler('linkDialog.show'),
}).render();
});
this.context.memo... | image: [
['imageResize', ['resizeFull', 'resizeHalf', 'resizeQuarter', 'resizeNone']],
['float', ['floatLeft', 'floatRight', 'floatNone']],
['remove', ['removeMedia']],
], | addLinkPopoverButtons | javascript | summernote/summernote | src/js/module/Buttons.js | https://github.com/summernote/summernote/blob/master/src/js/module/Buttons.js | MIT |
addTablePopoverButtons() {
this.context.memo('button.addRowUp', () => {
return this.button({
className: 'btn-md',
contents: this.ui.icon(this.options.icons.rowAbove),
tooltip: this.lang.table.addRowAbove,
click: this.context.createInvokeHandler('editor.addRow', 'top'),
})... | table : [
['add', ['addRowDown', 'addRowUp', 'addColLeft', 'addColRight']],
['delete', ['deleteRow', 'deleteCol', 'deleteTable']]
], | addTablePopoverButtons | javascript | summernote/summernote | src/js/module/Buttons.js | https://github.com/summernote/summernote/blob/master/src/js/module/Buttons.js | MIT |
build($container, groups) {
for (let groupIdx = 0, groupLen = groups.length; groupIdx < groupLen; groupIdx++) {
const group = groups[groupIdx];
const groupName = Array.isArray(group) ? group[0] : group;
const buttons = Array.isArray(group) ? ((group.length === 1) ? [group[0]] : group[1]) : [group]... | table : [
['add', ['addRowDown', 'addRowUp', 'addColLeft', 'addColRight']],
['delete', ['deleteRow', 'deleteCol', 'deleteTable']]
], | build | javascript | summernote/summernote | src/js/module/Buttons.js | https://github.com/summernote/summernote/blob/master/src/js/module/Buttons.js | MIT |
pasteByEvent(event) {
if (this.context.isDisabled()) {
return;
}
const clipboardData = event.originalEvent.clipboardData;
if (clipboardData && clipboardData.items && clipboardData.items.length) {
const clipboardFiles = clipboardData.files;
const clipboardText = clipboardData.getData(... | paste by clipboard event
@param {Event} event | pasteByEvent | javascript | summernote/summernote | src/js/module/Clipboard.js | https://github.com/summernote/summernote/blob/master/src/js/module/Clipboard.js | MIT |
purify(value) {
if (this.options.codeviewFilter) {
// filter code view regex
value = value.replace(this.options.codeviewFilterRegex, '');
// allow specific iframe tag
if (this.options.codeviewIframeFilter) {
const whitelist = this.options.codeviewIframeWhitelistSrc.concat(this.option... | purify input value
@param value
@returns {*} | purify | javascript | summernote/summernote | src/js/module/Codeview.js | https://github.com/summernote/summernote/blob/master/src/js/module/Codeview.js | MIT |
initialize() {
// bind custom events
this.$editable.on('keydown', (event) => {
if (event.keyCode === key.code.ENTER) {
this.context.triggerEvent('enter', event);
}
this.context.triggerEvent('keydown', event);
// keep a snapshot to limit text on input event
this.snapshot = ... | resize overlay element
@param {String} value | initialize | javascript | summernote/summernote | src/js/module/Editor.js | https://github.com/summernote/summernote/blob/master/src/js/module/Editor.js | MIT |
handleKeyMap(event) {
const keyMap = this.options.keyMap[env.isMac ? 'mac' : 'pc'];
const keys = [];
if (event.metaKey) { keys.push('CMD'); }
if (event.ctrlKey && !event.altKey) { keys.push('CTRL'); }
if (event.shiftKey) { keys.push('SHIFT'); }
const keyName = key.nameFromCode[event.keyCode];
... | resize overlay element
@param {String} value | handleKeyMap | javascript | summernote/summernote | src/js/module/Editor.js | https://github.com/summernote/summernote/blob/master/src/js/module/Editor.js | MIT |
preventDefaultEditableShortCuts(event) {
// B(Bold, 66) / I(Italic, 73) / U(Underline, 85)
if ((event.ctrlKey || event.metaKey) &&
lists.contains([66, 73, 85], event.keyCode)) {
event.preventDefault();
}
} | resize overlay element
@param {String} value | preventDefaultEditableShortCuts | javascript | summernote/summernote | src/js/module/Editor.js | https://github.com/summernote/summernote/blob/master/src/js/module/Editor.js | MIT |
isLimited(pad, event) {
pad = pad || 0;
if (typeof event !== 'undefined') {
if (key.isMove(event.keyCode) ||
key.isNavigation(event.keyCode) ||
(event.ctrlKey || event.metaKey) ||
lists.contains([key.code.BACKSPACE, key.code.DELETE], event.keyCode)) {
return false;
... | resize overlay element
@param {String} value | isLimited | javascript | summernote/summernote | src/js/module/Editor.js | https://github.com/summernote/summernote/blob/master/src/js/module/Editor.js | MIT |
checkLinkUrl(linkUrl) {
if (MAILTO_PATTERN.test(linkUrl)) {
return 'mailto://' + linkUrl;
} else if (TEL_PATTERN.test(linkUrl)) {
return 'tel://' + linkUrl;
} else if (!URL_SCHEME_PATTERN.test(linkUrl)) {
return 'http://' + linkUrl;
}
return linkUrl;
} | resize overlay element
@param {String} value | checkLinkUrl | javascript | summernote/summernote | src/js/module/Editor.js | https://github.com/summernote/summernote/blob/master/src/js/module/Editor.js | MIT |
createRangeFromList(lst) {
const startRange = range.createFromNodeBefore(lists.head(lst));
const startPoint = startRange.getStartPoint();
const endRange = range.createFromNodeAfter(lists.last(lst));
const endPoint = endRange.getEndPoint();
return range.create(
startPoint.node,
startPoin... | create a new range from the list of elements
@param {list} dom element list
@return {WrappedRange} | createRangeFromList | javascript | summernote/summernote | src/js/module/Editor.js | https://github.com/summernote/summernote/blob/master/src/js/module/Editor.js | MIT |
setLastRange(rng) {
if (rng) {
this.lastRange = rng;
} else {
this.lastRange = range.create(this.editable);
if ($(this.lastRange.sc).closest('.note-editable').length === 0) {
this.lastRange = range.createFromBodyElement(this.editable);
}
}
} | set the last range
if given rng is exist, set rng as the last range
or create a new range at the end of the document
@param {WrappedRange} rng | setLastRange | javascript | summernote/summernote | src/js/module/Editor.js | https://github.com/summernote/summernote/blob/master/src/js/module/Editor.js | MIT |
getLastRange() {
if (!this.lastRange) {
this.setLastRange();
}
return this.lastRange;
} | get the last range
if there is a saved last range, return it
or create a new range and return it
@return {WrappedRange} | getLastRange | javascript | summernote/summernote | src/js/module/Editor.js | https://github.com/summernote/summernote/blob/master/src/js/module/Editor.js | MIT |
saveRange(thenCollapse) {
if (thenCollapse) {
this.getLastRange().collapse().select();
}
} | saveRange
save current range
@param {Boolean} [thenCollapse=false] | saveRange | javascript | summernote/summernote | src/js/module/Editor.js | https://github.com/summernote/summernote/blob/master/src/js/module/Editor.js | MIT |
currentStyle() {
let rng = range.create();
if (rng) {
rng = rng.normalize();
}
return rng ? this.style.current(rng) : this.style.fromNode(this.$editable);
} | currentStyle
current style
@return {Object|Boolean} unfocus | currentStyle | javascript | summernote/summernote | src/js/module/Editor.js | https://github.com/summernote/summernote/blob/master/src/js/module/Editor.js | MIT |
styleFromNode($node) {
return this.style.fromNode($node);
} | style from node
@param {jQuery} $node
@return {Object} | styleFromNode | javascript | summernote/summernote | src/js/module/Editor.js | https://github.com/summernote/summernote/blob/master/src/js/module/Editor.js | MIT |
wrapCommand(fn) {
return function() {
this.beforeCommand();
fn.apply(this, arguments);
this.afterCommand();
};
} | run given function between beforeCommand and afterCommand | wrapCommand | javascript | summernote/summernote | src/js/module/Editor.js | https://github.com/summernote/summernote/blob/master/src/js/module/Editor.js | MIT |
insertImage(src, param) {
return createImage(src, param).then(($image) => {
this.beforeCommand();
if (typeof param === 'function') {
param($image);
} else {
if (typeof param === 'string') {
$image.attr('data-filename', param);
}
$image.css('width', Math.m... | insert image
@param {String} src
@param {String|Function} param
@return {Promise} | insertImage | javascript | summernote/summernote | src/js/module/Editor.js | https://github.com/summernote/summernote/blob/master/src/js/module/Editor.js | MIT |
getSelectedText() {
let rng = this.getLastRange();
// if range on anchor, expand range with anchor
if (rng.isOnAnchor()) {
rng = range.createFromNode(dom.ancestor(rng.sc, dom.isAnchor));
}
return rng.toString();
} | return selected plain text
@return {String} text | getSelectedText | javascript | summernote/summernote | src/js/module/Editor.js | https://github.com/summernote/summernote/blob/master/src/js/module/Editor.js | MIT |
onFormatBlock(tagName, $target) {
// [workaround] for MSIE, IE need `<`
document.execCommand('FormatBlock', false, env.isMSIE ? '<' + tagName + '>' : tagName);
// support custom class
if ($target && $target.length) {
// find the exact element has given tagName
if ($target[0].tagName.toUpper... | return selected plain text
@return {String} text | onFormatBlock | javascript | summernote/summernote | src/js/module/Editor.js | https://github.com/summernote/summernote/blob/master/src/js/module/Editor.js | MIT |
fontStyling(target, value) {
const rng = this.getLastRange();
if (rng !== '') {
const spans = this.style.styleNodes(rng);
this.$editor.find('.note-status-output').html('');
$(spans).css(target, value);
// [workaround] added styled bogus span for style
// - also bogus character n... | return selected plain text
@return {String} text | fontStyling | javascript | summernote/summernote | src/js/module/Editor.js | https://github.com/summernote/summernote/blob/master/src/js/module/Editor.js | MIT |
getLinkInfo() {
if (!this.hasFocus()) {
this.focus();
}
const rng = this.getLastRange().expand(dom.isAnchor);
// Get the first anchor on range(for edit).
const $anchor = $(lists.head(rng.nodes(dom.isAnchor)));
const linkInfo = {
range: rng,
text: rng.toString(),
url: $an... | returns link info
@return {Object}
@return {WrappedRange} return.range
@return {String} return.text
@return {Boolean} [return.isNewWindow=true]
@return {String} [return.url=""] | getLinkInfo | javascript | summernote/summernote | src/js/module/Editor.js | https://github.com/summernote/summernote/blob/master/src/js/module/Editor.js | MIT |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.