633 lines
24 KiB
JavaScript
633 lines
24 KiB
JavaScript
/*
|
|
* Behave.js
|
|
*
|
|
* Copyright 2013, Jacob Kelley - http://jakiestfu.com/
|
|
* Released under the MIT Licence
|
|
* http://opensource.org/licenses/MIT
|
|
*
|
|
* Github: http://github.com/jakiestfu/Behave.js/
|
|
* Version: 1.5
|
|
*/
|
|
|
|
|
|
(function(undefined){
|
|
|
|
'use strict';
|
|
|
|
var BehaveHooks = BehaveHooks || (function(){
|
|
var hooks = {};
|
|
|
|
return {
|
|
add: function(hookName, fn){
|
|
if(typeof hookName == "object"){
|
|
var i;
|
|
for(i=0; i<hookName.length; i++){
|
|
var theHook = hookName[i];
|
|
if(!hooks[theHook]){
|
|
hooks[theHook] = [];
|
|
}
|
|
hooks[theHook].push(fn);
|
|
}
|
|
} else {
|
|
if(!hooks[hookName]){
|
|
hooks[hookName] = [];
|
|
}
|
|
hooks[hookName].push(fn);
|
|
}
|
|
},
|
|
get: function(hookName){
|
|
if(hooks[hookName]){
|
|
return hooks[hookName];
|
|
}
|
|
}
|
|
};
|
|
|
|
})(),
|
|
Behave = Behave || function (userOpts) {
|
|
|
|
if (typeof String.prototype.repeat !== 'function') {
|
|
String.prototype.repeat = function(times) {
|
|
if(times < 1){
|
|
return '';
|
|
}
|
|
if(times % 2){
|
|
return this.repeat(times - 1) + this;
|
|
}
|
|
var half = this.repeat(times / 2);
|
|
return half + half;
|
|
};
|
|
}
|
|
|
|
if (typeof Array.prototype.filter !== 'function') {
|
|
Array.prototype.filter = function(func /*, thisp */) {
|
|
if (this === null) {
|
|
throw new TypeError();
|
|
}
|
|
|
|
var t = Object(this),
|
|
len = t.length >>> 0;
|
|
if (typeof func != "function"){
|
|
throw new TypeError();
|
|
}
|
|
var res = [],
|
|
thisp = arguments[1];
|
|
for (var i = 0; i < len; i++) {
|
|
if (i in t) {
|
|
var val = t[i];
|
|
if (func.call(thisp, val, i, t)) {
|
|
res.push(val);
|
|
}
|
|
}
|
|
}
|
|
return res;
|
|
};
|
|
}
|
|
|
|
var defaults = {
|
|
textarea: null,
|
|
replaceTab: true,
|
|
softTabs: true,
|
|
tabSize: 4,
|
|
autoOpen: true,
|
|
overwrite: true,
|
|
autoStrip: true,
|
|
autoIndent: true,
|
|
fence: false
|
|
},
|
|
tab,
|
|
newLine,
|
|
charSettings = {
|
|
|
|
keyMap: [
|
|
{ open: "\"", close: "\"", canBreak: false },
|
|
{ open: "'", close: "'", canBreak: false },
|
|
{ open: "(", close: ")", canBreak: false },
|
|
{ open: "[", close: "]", canBreak: true },
|
|
{ open: "{", close: "}", canBreak: true }
|
|
]
|
|
|
|
},
|
|
utils = {
|
|
|
|
_callHook: function(hookName, passData){
|
|
var hooks = BehaveHooks.get(hookName);
|
|
passData = typeof passData=="boolean" && passData === false ? false : true;
|
|
|
|
if(hooks){
|
|
if(passData){
|
|
var theEditor = defaults.textarea,
|
|
textVal = theEditor.value,
|
|
caretPos = utils.cursor.get(),
|
|
i;
|
|
|
|
for(i=0; i<hooks.length; i++){
|
|
hooks[i].call(undefined, {
|
|
editor: {
|
|
element: theEditor,
|
|
text: textVal,
|
|
levelsDeep: utils.levelsDeep()
|
|
},
|
|
caret: {
|
|
pos: caretPos
|
|
},
|
|
lines: {
|
|
current: utils.cursor.getLine(textVal, caretPos),
|
|
total: utils.editor.getLines(textVal)
|
|
}
|
|
});
|
|
}
|
|
} else {
|
|
for(i=0; i<hooks.length; i++){
|
|
hooks[i].call(undefined);
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
defineNewLine: function(){
|
|
var ta = document.createElement('textarea');
|
|
ta.value = "\n";
|
|
|
|
if(ta.value.length==2){
|
|
newLine = "\r\n";
|
|
} else {
|
|
newLine = "\n";
|
|
}
|
|
},
|
|
defineTabSize: function(tabSize){
|
|
if(typeof defaults.textarea.style.OTabSize != "undefined"){
|
|
defaults.textarea.style.OTabSize = tabSize; return;
|
|
}
|
|
if(typeof defaults.textarea.style.MozTabSize != "undefined"){
|
|
defaults.textarea.style.MozTabSize = tabSize; return;
|
|
}
|
|
if(typeof defaults.textarea.style.tabSize != "undefined"){
|
|
defaults.textarea.style.tabSize = tabSize; return;
|
|
}
|
|
},
|
|
cursor: {
|
|
getLine: function(textVal, pos){
|
|
return ((textVal.substring(0,pos)).split("\n")).length;
|
|
},
|
|
get: function() {
|
|
|
|
if (typeof document.createElement('textarea').selectionStart==="number") {
|
|
return defaults.textarea.selectionStart;
|
|
} else if (document.selection) {
|
|
var caretPos = 0,
|
|
range = defaults.textarea.createTextRange(),
|
|
rangeDupe = document.selection.createRange().duplicate(),
|
|
rangeDupeBookmark = rangeDupe.getBookmark();
|
|
range.moveToBookmark(rangeDupeBookmark);
|
|
|
|
while (range.moveStart('character' , -1) !== 0) {
|
|
caretPos++;
|
|
}
|
|
return caretPos;
|
|
}
|
|
},
|
|
set: function (start, end) {
|
|
if(!end){
|
|
end = start;
|
|
}
|
|
if (defaults.textarea.setSelectionRange) {
|
|
defaults.textarea.focus();
|
|
defaults.textarea.setSelectionRange(start, end);
|
|
} else if (defaults.textarea.createTextRange) {
|
|
var range = defaults.textarea.createTextRange();
|
|
range.collapse(true);
|
|
range.moveEnd('character', end);
|
|
range.moveStart('character', start);
|
|
range.select();
|
|
}
|
|
},
|
|
selection: function(){
|
|
var textAreaElement = defaults.textarea,
|
|
start = 0,
|
|
end = 0,
|
|
normalizedValue,
|
|
range,
|
|
textInputRange,
|
|
len,
|
|
endRange;
|
|
|
|
if (typeof textAreaElement.selectionStart == "number" && typeof textAreaElement.selectionEnd == "number") {
|
|
start = textAreaElement.selectionStart;
|
|
end = textAreaElement.selectionEnd;
|
|
} else {
|
|
range = document.selection.createRange();
|
|
|
|
if (range && range.parentElement() == textAreaElement) {
|
|
|
|
normalizedValue = utils.editor.get();
|
|
len = normalizedValue.length;
|
|
|
|
textInputRange = textAreaElement.createTextRange();
|
|
textInputRange.moveToBookmark(range.getBookmark());
|
|
|
|
endRange = textAreaElement.createTextRange();
|
|
endRange.collapse(false);
|
|
|
|
if (textInputRange.compareEndPoints("StartToEnd", endRange) > -1) {
|
|
start = end = len;
|
|
} else {
|
|
start = -textInputRange.moveStart("character", -len);
|
|
start += normalizedValue.slice(0, start).split(newLine).length - 1;
|
|
|
|
if (textInputRange.compareEndPoints("EndToEnd", endRange) > -1) {
|
|
end = len;
|
|
} else {
|
|
end = -textInputRange.moveEnd("character", -len);
|
|
end += normalizedValue.slice(0, end).split(newLine).length - 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return start==end ? false : {
|
|
start: start,
|
|
end: end
|
|
};
|
|
}
|
|
},
|
|
editor: {
|
|
getLines: function(textVal){
|
|
return (textVal).split("\n").length;
|
|
},
|
|
get: function(){
|
|
return defaults.textarea.value.replace(/\r/g,'');
|
|
},
|
|
set: function(data){
|
|
defaults.textarea.value = data;
|
|
}
|
|
},
|
|
fenceRange: function(){
|
|
if(typeof defaults.fence == "string"){
|
|
|
|
var data = utils.editor.get(),
|
|
pos = utils.cursor.get(),
|
|
hacked = 0,
|
|
matchedFence = data.indexOf(defaults.fence),
|
|
matchCase = 0;
|
|
|
|
while(matchedFence>=0){
|
|
matchCase++;
|
|
if( pos < (matchedFence+hacked) ){
|
|
break;
|
|
}
|
|
|
|
hacked += matchedFence+defaults.fence.length;
|
|
data = data.substring(matchedFence+defaults.fence.length);
|
|
matchedFence = data.indexOf(defaults.fence);
|
|
|
|
}
|
|
|
|
if( (hacked) < pos && ( (matchedFence+hacked) > pos ) && matchCase%2===0){
|
|
return true;
|
|
}
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
},
|
|
isEven: function(_this,i){
|
|
return i%2;
|
|
},
|
|
levelsDeep: function(){
|
|
var pos = utils.cursor.get(),
|
|
val = utils.editor.get();
|
|
|
|
var left = val.substring(0, pos),
|
|
levels = 0,
|
|
i, j;
|
|
|
|
for(i=0; i<left.length; i++){
|
|
for (j=0; j<charSettings.keyMap.length; j++) {
|
|
if(charSettings.keyMap[j].canBreak){
|
|
if(charSettings.keyMap[j].open == left.charAt(i)){
|
|
levels++;
|
|
}
|
|
|
|
if(charSettings.keyMap[j].close == left.charAt(i)){
|
|
levels--;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
var toDecrement = 0,
|
|
quoteMap = ["'", "\""];
|
|
for(i=0; i<charSettings.keyMap.length; i++) {
|
|
if(charSettings.keyMap[i].canBreak){
|
|
for(j in quoteMap){
|
|
toDecrement += left.split(quoteMap[j]).filter(utils.isEven).join('').split(charSettings.keyMap[i].open).length - 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
var finalLevels = levels - toDecrement;
|
|
|
|
return finalLevels >=0 ? finalLevels : 0;
|
|
},
|
|
deepExtend: function(destination, source) {
|
|
for (var property in source) {
|
|
if (source[property] && source[property].constructor &&
|
|
source[property].constructor === Object) {
|
|
destination[property] = destination[property] || {};
|
|
utils.deepExtend(destination[property], source[property]);
|
|
} else {
|
|
destination[property] = source[property];
|
|
}
|
|
}
|
|
return destination;
|
|
},
|
|
addEvent: function addEvent(element, eventName, func) {
|
|
if (element.addEventListener){
|
|
element.addEventListener(eventName,func,false);
|
|
} else if (element.attachEvent) {
|
|
element.attachEvent("on"+eventName, func);
|
|
}
|
|
},
|
|
removeEvent: function addEvent(element, eventName, func){
|
|
if (element.addEventListener){
|
|
element.removeEventListener(eventName,func,false);
|
|
} else if (element.attachEvent) {
|
|
element.detachEvent("on"+eventName, func);
|
|
}
|
|
},
|
|
|
|
preventDefaultEvent: function(e){
|
|
if(e.preventDefault){
|
|
e.preventDefault();
|
|
} else {
|
|
e.returnValue = false;
|
|
}
|
|
}
|
|
},
|
|
intercept = {
|
|
tabKey: function (e) {
|
|
|
|
if(!utils.fenceRange()){ return; }
|
|
|
|
if (e.keyCode == 9) {
|
|
utils.preventDefaultEvent(e);
|
|
|
|
var toReturn = true;
|
|
utils._callHook('tab:before');
|
|
|
|
var selection = utils.cursor.selection(),
|
|
pos = utils.cursor.get(),
|
|
val = utils.editor.get();
|
|
|
|
if(selection){
|
|
|
|
var tempStart = selection.start;
|
|
while(tempStart--){
|
|
if(val.charAt(tempStart)=="\n"){
|
|
selection.start = tempStart + 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
var toIndent = val.substring(selection.start, selection.end),
|
|
lines = toIndent.split("\n"),
|
|
i;
|
|
|
|
if(e.shiftKey){
|
|
for(i = 0; i<lines.length; i++){
|
|
if(lines[i].substring(0,tab.length) == tab){
|
|
lines[i] = lines[i].substring(tab.length);
|
|
}
|
|
}
|
|
toIndent = lines.join("\n");
|
|
|
|
utils.editor.set( val.substring(0,selection.start) + toIndent + val.substring(selection.end) );
|
|
utils.cursor.set(selection.start, selection.start+toIndent.length);
|
|
|
|
} else {
|
|
for(i in lines){
|
|
lines[i] = tab + lines[i];
|
|
}
|
|
toIndent = lines.join("\n");
|
|
|
|
utils.editor.set( val.substring(0,selection.start) + toIndent + val.substring(selection.end) );
|
|
utils.cursor.set(selection.start, selection.start+toIndent.length);
|
|
}
|
|
} else {
|
|
var left = val.substring(0, pos),
|
|
right = val.substring(pos),
|
|
edited = left + tab + right;
|
|
|
|
if(e.shiftKey){
|
|
if(val.substring(pos-tab.length, pos) == tab){
|
|
edited = val.substring(0, pos-tab.length) + right;
|
|
utils.editor.set(edited);
|
|
utils.cursor.set(pos-tab.length);
|
|
}
|
|
} else {
|
|
utils.editor.set(edited);
|
|
utils.cursor.set(pos + tab.length);
|
|
toReturn = false;
|
|
}
|
|
}
|
|
utils._callHook('tab:after');
|
|
}
|
|
return toReturn;
|
|
},
|
|
enterKey: function (e) {
|
|
|
|
if(!utils.fenceRange()){ return; }
|
|
|
|
if (e.keyCode == 13) {
|
|
|
|
utils.preventDefaultEvent(e);
|
|
utils._callHook('enter:before');
|
|
|
|
var pos = utils.cursor.get(),
|
|
val = utils.editor.get(),
|
|
left = val.substring(0, pos),
|
|
right = val.substring(pos),
|
|
leftChar = left.charAt(left.length - 1),
|
|
rightChar = right.charAt(0),
|
|
numTabs = utils.levelsDeep(),
|
|
ourIndent = "",
|
|
closingBreak = "",
|
|
finalCursorPos,
|
|
i;
|
|
if(!numTabs){
|
|
finalCursorPos = 1;
|
|
} else {
|
|
while(numTabs--){
|
|
ourIndent+=tab;
|
|
}
|
|
ourIndent = ourIndent;
|
|
finalCursorPos = ourIndent.length + 1;
|
|
|
|
for(i=0; i<charSettings.keyMap.length; i++) {
|
|
if (charSettings.keyMap[i].open == leftChar && charSettings.keyMap[i].close == rightChar){
|
|
closingBreak = newLine;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
var edited = left + newLine + ourIndent + closingBreak + (ourIndent.substring(0, ourIndent.length-tab.length) ) + right;
|
|
utils.editor.set(edited);
|
|
utils.cursor.set(pos + finalCursorPos);
|
|
utils._callHook('enter:after');
|
|
}
|
|
},
|
|
deleteKey: function (e) {
|
|
|
|
if(!utils.fenceRange()){ return; }
|
|
|
|
if(e.keyCode == 8){
|
|
utils.preventDefaultEvent(e);
|
|
|
|
utils._callHook('delete:before');
|
|
|
|
var pos = utils.cursor.get(),
|
|
val = utils.editor.get(),
|
|
left = val.substring(0, pos),
|
|
right = val.substring(pos),
|
|
leftChar = left.charAt(left.length - 1),
|
|
rightChar = right.charAt(0),
|
|
i;
|
|
|
|
if( utils.cursor.selection() === false ){
|
|
for(i=0; i<charSettings.keyMap.length; i++) {
|
|
if (charSettings.keyMap[i].open == leftChar && charSettings.keyMap[i].close == rightChar) {
|
|
var edited = val.substring(0,pos-1) + val.substring(pos+1);
|
|
utils.editor.set(edited);
|
|
utils.cursor.set(pos - 1);
|
|
return;
|
|
}
|
|
}
|
|
var edited = val.substring(0,pos-1) + val.substring(pos);
|
|
utils.editor.set(edited);
|
|
utils.cursor.set(pos - 1);
|
|
} else {
|
|
var sel = utils.cursor.selection(),
|
|
edited = val.substring(0,sel.start) + val.substring(sel.end);
|
|
utils.editor.set(edited);
|
|
utils.cursor.set(pos);
|
|
}
|
|
|
|
utils._callHook('delete:after');
|
|
|
|
}
|
|
}
|
|
},
|
|
charFuncs = {
|
|
openedChar: function (_char, e) {
|
|
utils.preventDefaultEvent(e);
|
|
utils._callHook('openChar:before');
|
|
var pos = utils.cursor.get(),
|
|
val = utils.editor.get(),
|
|
left = val.substring(0, pos),
|
|
right = val.substring(pos),
|
|
edited = left + _char.open + _char.close + right;
|
|
|
|
defaults.textarea.value = edited;
|
|
utils.cursor.set(pos + 1);
|
|
utils._callHook('openChar:after');
|
|
},
|
|
closedChar: function (_char, e) {
|
|
var pos = utils.cursor.get(),
|
|
val = utils.editor.get(),
|
|
toOverwrite = val.substring(pos, pos + 1);
|
|
if (toOverwrite == _char.close) {
|
|
utils.preventDefaultEvent(e);
|
|
utils._callHook('closeChar:before');
|
|
utils.cursor.set(utils.cursor.get() + 1);
|
|
utils._callHook('closeChar:after');
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
},
|
|
action = {
|
|
filter: function (e) {
|
|
|
|
if(!utils.fenceRange()){ return; }
|
|
|
|
var theCode = e.which || e.keyCode;
|
|
|
|
if(theCode == 39 || theCode == 40 && e.which===0){ return; }
|
|
|
|
var _char = String.fromCharCode(theCode),
|
|
i;
|
|
|
|
for(i=0; i<charSettings.keyMap.length; i++) {
|
|
|
|
if (charSettings.keyMap[i].close == _char) {
|
|
var didClose = defaults.overwrite && charFuncs.closedChar(charSettings.keyMap[i], e);
|
|
|
|
if (!didClose && charSettings.keyMap[i].open == _char && defaults.autoOpen) {
|
|
charFuncs.openedChar(charSettings.keyMap[i], e);
|
|
}
|
|
} else if (charSettings.keyMap[i].open == _char && defaults.autoOpen) {
|
|
charFuncs.openedChar(charSettings.keyMap[i], e);
|
|
}
|
|
}
|
|
},
|
|
listen: function () {
|
|
|
|
if(defaults.replaceTab){ utils.addEvent(defaults.textarea, 'keydown', intercept.tabKey); }
|
|
if(defaults.autoIndent){ utils.addEvent(defaults.textarea, 'keydown', intercept.enterKey); }
|
|
if(defaults.autoStrip){ utils.addEvent(defaults.textarea, 'keydown', intercept.deleteKey); }
|
|
|
|
utils.addEvent(defaults.textarea, 'keypress', action.filter);
|
|
|
|
utils.addEvent(defaults.textarea, 'keydown', function(){ utils._callHook('keydown'); });
|
|
utils.addEvent(defaults.textarea, 'keyup', function(){ utils._callHook('keyup'); });
|
|
}
|
|
},
|
|
init = function (opts) {
|
|
|
|
if(opts.textarea){
|
|
utils._callHook('init:before', false);
|
|
utils.deepExtend(defaults, opts);
|
|
utils.defineNewLine();
|
|
|
|
if (defaults.softTabs) {
|
|
tab = " ".repeat(defaults.tabSize);
|
|
} else {
|
|
tab = "\t";
|
|
|
|
utils.defineTabSize(defaults.tabSize);
|
|
}
|
|
|
|
action.listen();
|
|
utils._callHook('init:after', false);
|
|
}
|
|
|
|
};
|
|
|
|
this.destroy = function(){
|
|
utils.removeEvent(defaults.textarea, 'keydown', intercept.tabKey);
|
|
utils.removeEvent(defaults.textarea, 'keydown', intercept.enterKey);
|
|
utils.removeEvent(defaults.textarea, 'keydown', intercept.deleteKey);
|
|
utils.removeEvent(defaults.textarea, 'keypress', action.filter);
|
|
};
|
|
|
|
init(userOpts);
|
|
|
|
};
|
|
|
|
if (typeof module !== 'undefined' && module.exports) {
|
|
module.exports = Behave;
|
|
}
|
|
|
|
if (typeof ender === 'undefined') {
|
|
this.Behave = Behave;
|
|
this.BehaveHooks = BehaveHooks;
|
|
}
|
|
|
|
if (typeof define === "function" && define.amd) {
|
|
define("behave", [], function () {
|
|
return Behave;
|
|
});
|
|
}
|
|
|
|
}).call(this); |