Skip to content

Instantly share code, notes, and snippets.

@Peaker

Peaker/flapjax-improved.js

Created February 25, 2016 00:32
Show Gist options
  • Save Peaker/13a1e6c6fc216ad61f54 to your computer and use it in GitHub Desktop.
Save Peaker/13a1e6c6fc216ad61f54 to your computer and use it in GitHub Desktop.
Download ZIP
Improved Javascript Formatting
Raw
flapjax-improved.js
function flapjaxInit(options) {
var defaultOptions = {includeSynonyms: true
,exportMisc: true
,exportCore: true
,exportDOM: true
,exportDOMMisc: true
,exportWS: true
,hide: []
,show: []
,redefine: false};
if (options === false) {
options = {hide: [],show: []};
} else if (options === true || !options) {
options = {};
}
for (var option in defaultOptions) {
if (options[option] === undefined) {
options[option] = defaultOptions[option];
}
}
;
var hideArray = options.hide;
options.hide = {};
for (var i = 0; i < hideArray.length; i++) {
options.hide[hideArray[i]] = true;
}
var showArray = options.show;
options.show = {};
for (var i = 0; i < showArray.length; i++) {
options.show[showArray[i]] = true;
}
var warn = function (s) {};
var flapjax = {version: 4
,base: {}
,combinators: {}
,behaviours: {}
,dom: {}};
var d = flapjax.dom;
flapjax.pub = {util: flapjax};
var annotate = function (fn,names,protoArg,protoObjs,protoNames) {
for (var i = 0; i < names.length; i++) {
flapjax.pub[names[i]] = fn;
}
if (protoArg != undefined) {
var pf = function () {
var args = slice(arguments,0);
args.splice(protoArg,0,this);
return fn.apply(this,args);
};
for (var i = 0; i < protoObjs.length; i++) {
for (var j = 0; j < protoNames.length; j++) {
protoObjs[i][protoNames[j]] = pf;
}
}
}
};
var exports = {};
var synonyms = {};
var misc = {};
var core = {};
var dom = {};
var domMisc = {};
var ws = {};
var fxExport = function (exportCategory,exportVal,exportName) {
if (!(exportCategory instanceof Object)) {
throw "fxExport: category is " + exportCategory;
}
if (typeof exportName != "string") {
console.log(exportVal);
throw "fxExport: name is " + exportName;
}
exportVal.__flapjaxCategory = exportCategory;
exports[exportName] = exportVal;
for (var i = 3; i < arguments.length; i++) {
exports[arguments[i]] = exportVal;
synonyms[arguments[i]] = true;
}
};
var fxMethodSynonyms = function (obj,method) {
if (options.includeSynonyms === true) {
for (var i = 2; i < arguments.length; i++) {
obj.prototype[arguments[i]] =
obj.prototype[method];
}
;
}
};
var slice = function (arr,start,stop) {
var i,len = arr.length,r = [];
if (!stop) {
stop = len;
}
if (stop < 0) {
stop = len + stop;
}
if (start < 0) {
start = len - start;
}
if (stop < start) {
i = start;
start = stop;
stop = i;
}
for (i = 0; i < stop - start; i++) {
r[i] = arr[start + i];
}
return r;
};
var isEqual = function (a,b) {
return a == b || (typeof a == "number" && isNaN(a) || a
== "NaN") && (typeof b == "number" &&
isNaN(b) || b == "NaN");
};
var member = function (elt,lst) {
for (var i = 0; i < lst.length; i++) {
if (isEqual(lst[i],elt)) {
return true;
}
}
return false;
};
var zip = function (arrays) {
if (arrays.length == 0) return [];
var ret = [];
for (var i = 0; i < arrays[0].length; i++) {
ret.push([]);
for (var j = 0; j < arrays.length; j++)
ret[i].push(arrays[j][i]);
}
return ret;
};
var map = function (fn) {
var arrays = slice(arguments,1);
if (arrays.length === 0) {
return [];
} else if (arrays.length === 1) {
var ret = [];
for (var i = 0; i < arrays[0].length; i++) {
ret.push(fn(arrays[0][i]));
}
return ret;
} else {
var ret = zip(arrays);
var o = new Object();
for (var i = 0; i < ret.length; i++) {
ret[i] = fn.apply(o,ret[i]);
}
return ret;
}
};
var filter = function (predFn,arr) {
var res = [];
for (var i = 0; i < arr.length; i++) {
if (predFn(arr[i])) {
res.push(arr[i]);
}
}
return res;
};
var fold = function (fn,init) {
var lists = slice(arguments,2);
if (lists.length === 0) {
return init;
} else if (lists.length === 1) {
var acc = init;
for (var i = 0; i < lists[0].length; i++) {
acc = fn(lists[0][i],acc);
}
return acc;
} else {
var acc = init;
for (var i = 0; i < lists[0].length; i++) {
var args = map(function (lst) {
return lst[i];
}
,lists);
args.push(acc);
acc = fn.apply({},args);
}
return acc;
}
};
var foldR = function (fn,init) {
var lists = slice(arguments,2);
if (lists.length === 0) {
return init;
} else if (lists.length === 1) {
var acc = init;
for (var i = lists[0].length - 1; i > -1; i--) acc
=
fn(lists[0][i]
,acc);
return acc;
} else {
var acc = init;
for (var i = lists[0].length - 1; i > -1; i--) {
var args = map(function (lst) {
return lst[i];
}
,lists);
args.push(acc);
acc = fn.apply({},args);
}
return acc;
}
};
var pushAll = function (destArray,srcArray) {
for (var i = 0; i < srcArray.length; i++) {
destArray.push(srcArray[i]);
}
return destArray;
};
fxExport(misc,slice,"slice");
fxExport(misc,member,"member");
fxExport(misc,map,"map");
fxExport(misc,map,"forEach");
fxExport(misc,filter,"filter");
fxExport(misc,fold,"fold");
fxExport(misc,foldR,"foldR");
var Pulse = function (stamp,value) {
this.stamp = stamp;
this.value = value;
};
var PQ = function () {
var ctx = this;
ctx.val = [];
this.insert = function (kv) {
ctx.val.push(kv);
var kvpos = ctx.val.length - 1;
while (kvpos > 0 && kv.k <
ctx.val[Math.floor((kvpos - 1) / 2)].k) {
var oldpos = kvpos;
kvpos = Math.floor((kvpos - 1) / 2);
ctx.val[oldpos] = ctx.val[kvpos];
ctx.val[kvpos] = kv;
}
};
this.isEmpty = function () {
return ctx.val.length === 0;
};
this.pop = function () {
if (ctx.val.length == 1) {
return ctx.val.pop();
}
var ret = ctx.val.shift();
ctx.val.unshift(ctx.val.pop());
var kvpos = 0;
var kv = ctx.val[0];
while (1) {
var leftChild = kvpos * 2 + 1 < ctx.val.length
? ctx.val[kvpos * 2 + 1].k : kv.k + 1;
var rightChild = kvpos * 2 + 2 <
ctx.val.length ? ctx.val[kvpos * 2 +
2].k : kv.k + 1;
if (leftChild > kv.k && rightChild > kv.k)
break; else if (leftChild < rightChild) {
ctx.val[kvpos] = ctx.val[kvpos * 2 + 1];
ctx.val[kvpos * 2 + 1] = kv;
kvpos = kvpos * 2 + 1;
} else {
ctx.val[kvpos] = ctx.val[kvpos * 2 + 2];
ctx.val[kvpos * 2 + 2] = kv;
kvpos = kvpos * 2 + 2;
}
}
return ret;
};
};
var lastRank = 0;
var stamp = 1;
var nextStamp = function () { return ++stamp;};
var propagatePulse = function (pulse,node) {
var queue = new PQ();
queue.insert({k: node.rank,n: node,v: pulse});
while (!queue.isEmpty()) {
var qv = queue.pop();
qv.n.updater(function (nextPulse) {
for (var i = 0; i <
qv.n.sendsTo.length; i++)
queue.insert({k: qv.n.sendsTo[i].rank
,n: qv.n.sendsTo[i]
,v: nextPulse});
}
,new Pulse(qv.v.stamp,qv.v.value));
}
};
var EventStream = function (nodes,updater) {
this.updater = updater;
this.sendsTo = [];
for (var i = 0; i < nodes.length; i++) {
nodes[i].sendsTo.push(this);
}
this.rank = ++lastRank;
};
EventStream.prototype = new Object();
fxExport(core,EventStream,"EventStream");
var createNode = function (nodes,updater) {
return new EventStream(nodes,updater);
};
var attachListener = function (node,dependent) {
if (!(node instanceof EventStream)) {
throw "attachListenenerNode: expects event as first arg";
}
if (!(dependent instanceof EventStream)) {
throw "attachListenenerNode: expects event as second arg";
}
node.sendsTo.push(dependent);
if (node.rank > dependent.rank) {
var lowest = lastRank + 1;
var q = [dependent];
while (q.length) {
var cur = q.splice(0,1)[0];
cur.rank = ++lastRank;
q = q.concat(cur.sendsTo);
}
}
};
var removeListener = function (node,dependent) {
if (!(node instanceof EventStream)) {
throw "removeListenerNode: expects event as first arg";
}
if (!(dependent instanceof EventStream)) {
throw "removeListenenerNode: expects event as second arg";
}
var foundSending = false;
for (var i = 0; i < node.sendsTo.length &&
!foundSending; i++) {
if (node.sendsTo[i] == dependent) {
node.sendsTo.splice(i,1);
foundSending = true;
}
}
return foundSending;
};
var internal_e = function (dependsOn) {
return createNode(dependsOn || []
,function (send,pulse) {
send(pulse);
});
};
var zero_e = function () {
return createNode([]
,function (send,pulse) {
throw "zero_e : received a value; zero_e should not receive a value; the value was "
+ pulse.value;
});
};
fxExport(core,zero_e,"zero_e");
var one_e = function (val) {
var sent = false;
var evt = createNode([]
,function (send,pulse) {
if (sent) {
throw "one_e : received an extra value";
}
sent = true;
send(pulse);
});
window.setTimeout(function () { sendEvent(evt,val);},0);
return evt;
};
fxExport(core,one_e,"one_e");
var merge_e = function () {
if (arguments.length == 0) {
return zero_e();
} else {
var deps = slice(arguments,0);
return internal_e(deps);
}
};
fxExport(core,merge_e,"merge_e");
EventStream.prototype.merge_e = function () {
var deps = slice(arguments,0);
deps.push(this);
return internal_e(deps);
};
fxMethodSynonyms(EventStream,"merge_e","merge");
EventStream.prototype.constant_e = function (constantValue) {
return createNode([this]
,function (send,pulse) {
pulse.value = constantValue;
send(pulse);
});
};
fxMethodSynonyms(EventStream
,"constant_e"
,"constant"
,"replaceValue_e"
,"replaceValue");
var constant_e = function (e) { return e.constant_e();};
fxExport(core,constant_e,"constant_e","replaceValue_e");
var createTimeSyncNode = function (nodes) {
var nqs = map(function (n) {
var qpulse = [];
return {q: qpulse
,v: createNode([n]
,function (s,p) {
qpulse.push(p.value);
s(p);
}
,nodes)};
}
,nodes);
return createNode(map(function (n) { return n.v;},nqs)
,function (s,p) {
var allfull = fold(function (n
,acc) {
return n.q.length
&& acc;
}
,true
,nqs);
if (allfull) {
p.value = map(function (n) {
return n.q.shift();
}
,nqs);
s(p);
}
});
};
var Behaviour = function (event,init,updater) {
if (!(event instanceof EventStream)) {
throw "Behaviour: expected event as second arg";
}
var behave = this;
this.last = init;
this.underlyingRaw = event;
this.underlying = createNode([event]
,updater ? function (s,p) {
behave.last =
updater(p.value);
p.value = behave.last;
s(p);
} : function (s,p) {
behave.last = p.value;
s(p);
});
};
Behaviour.prototype = new Object();
fxExport(core,Behaviour,"Behaviour");
fxExport(core,Behaviour,"Behavior");
var receiver_e = function () {
var evt = internal_e();
evt.sendEvent = function (value) {
propagatePulse(new Pulse(nextStamp(),value),evt);
};
return evt;
};
fxExport(core,receiver_e,"receiver_e");
var sendEvent = function (node,value) {
if (!(node instanceof EventStream)) {
throw "sendEvent: expected Event as first arg";
}
propagatePulse(new Pulse(nextStamp(),value),node);
};
fxExport(core,sendEvent,"sendEvent");
synonyms["sendEvent"] = true;
EventStream.prototype.bind_e = function (k) {
var m = this;
var prev_e = false;
var out_e = createNode([]
,function (send,pulse) {
send(pulse);
});
out_e.name = "bind out_e";
var in_e = createNode([m]
,function (send,pulse) {
if (prev_e) {
removeListener(prev_e,out_e);
}
prev_e = k(pulse.value);
if (prev_e instanceof EventStream) {
attachListener(prev_e,out_e);
} else {
throw "bind_e : expected EventStream";
}
});
in_e.name = "bind in_e";
return out_e;
};
EventStream.prototype.lift_e = function (f) {
if (!(f instanceof Function)) {
throw "lift_e : expected a function as the first argument; received "
+ f;
}
return createNode([this]
,function (send,pulse) {
pulse.value = f(pulse.value);
send(pulse);
});
};
fxMethodSynonyms(EventStream
,"lift_e"
,"transform_e"
,"map_e"
,"apply_e"
,"lift"
,"transform"
,"map"
,"apply");
EventStream.prototype.not_e = function () {
return this.lift_e(function (v) {
return !v;
});
};
fxMethodSynonyms(EventStream,"not_e","not");
var not_e = function (e) { return e.not_e();};
fxExport(core,not_e,"not_e","not");
EventStream.prototype.filter_e = function (pred) {
if (!(pred instanceof Function)) {
throw "filter_e : expected predicate; received " + pred;
}
return createNode([this]
,function (send,pulse) {
if (pred(pulse.value)) {
send(pulse);
}
});
};
fxMethodSynonyms(EventStream,"filter_e","filter");
var filter_e = function (e,p) { return e.filter_e(p);};
fxExport(core,filter_e,"filter_e");
EventStream.prototype.once_e = function () {
var done = false;
return createNode([this]
,function (send,pulse) {
if (!done) {
done = true;
send(pulse);
}
});
};
fxMethodSynonyms(EventStream,"once_e","once");
var once_e = function (e) { return e.once_e();};
fxExport(core,once_e,"once_e");
EventStream.prototype.skipFirst_e = function () {
var skipped = false;
return createNode([this]
,function (send,pulse) {
if (skipped) {
send(pulse);
} else {
skipped = true;
}
});
};
fxMethodSynonyms(EventStream,"skipFirst_e","skipFirst");
var skipFirst_e = function (e) { return e.skipFirst_e();};
fxExport(core,skipFirst_e,"skipFirst_e");
EventStream.prototype.collect_e = function (init,fold) {
var acc = init;
return this.lift_e(function (n) {
var next = fold(n,acc);
acc = next;
return next;
});
};
fxMethodSynonyms(EventStream
,"collect_e"
,"collect"
,"transformWithMemory");
var collect_e = function (e,i,f) { return e.collect_e(i,f);};
fxExport(core,collect_e,"collect_e");
EventStream.prototype.switch_e = function () {
return this.bind_e(function (v) {
return v;
});
};
fxMethodSynonyms(EventStream,"switch_e","forwardLatest");
var switch_e = function (e) { return e.switch_e();};
fxExport(core,switch_e,"switch_e");
EventStream.prototype.if_e = function (thenE,elseE) {
var testStamp = -1;
var testValue = false;
createNode([this]
,function (_,pulse) {
testStamp = pulse.stamp;
testValue = pulse.value;
});
return merge_e(createNode([thenE]
,function (send,pulse) {
if (testValue && testStamp ==
pulse.stamp) {
send(pulse);
}
})
,createNode([elseE]
,function (send,pulse) {
if (!testValue && testStamp ==
pulse.stamp) {
send(pulse);
}
}));
};
fxMethodSynonyms(EventStream,"if_e","choose_e","choose");
var if_e = function (test,thenE,elseE) {
if (test instanceof EventStream) {
return test.if_e(thenE,elseE);
} else {
return test ? thenE : elseE;
}
};
fxExport(core,if_e,"if_e","choose_e");
var cond_e = function () {
var predValArrays = slice(arguments,0);
var acc = zero_e();
for (var i = predValArrays.length - 1; i > -1; i--) {
acc = if_e(predValArrays[i][0]
,predValArrays[i][1]
,acc);
}
return acc;
};
fxExport(core,cond_e,"cond_e");
var and_e = function () {
var nodes = slice(arguments,0);
var acc = nodes.length > 0 ? nodes[nodes.length - 1]
: one_e(true);
for (var i = nodes.length - 2; i > -1; i--) {
acc = if_e(nodes[i],acc,nodes[i].constant_e(false));
}
return acc;
};
fxExport(core,and_e,"and_e");
EventStream.prototype.and_e = function () {
var deps = [this].concat(slice(arguments,0));
return and_e.apply(this,deps);
};
fxMethodSynonyms(EventStream,"and_e","and");
var or_e = function () {
var nodes = slice(arguments,0);
var acc = nodes.length > 2 ? nodes[nodes.length - 1]
: one_e(false);
for (var i = nodes.length - 2; i > -1; i--) {
acc = if_e(nodes[i],nodes[i],acc);
}
return acc;
};
fxExport(core,or_e,"or_e");
EventStream.prototype.or_e = function () {
var deps = [this].concat(slice(arguments,0));
return or_e.apply(this,deps);
};
fxMethodSynonyms(EventStream,"or_e","or");
var delayStatic_e = function (event,time) {
var resE = internal_e();
createNode([event]
,function (s,p) {
setTimeout(function () {
sendEvent(resE,p.value);
}
,time);
});
return resE;
};
EventStream.prototype.delay_e = function (time) {
var event = this;
if (time instanceof Behaviour) {
var receiverEE = internal_e();
var link = {from: event
,towards: delayStatic_e(event
,valueNow(time))};
var switcherE = createNode([changes(time)]
,function (s,p) {
removeListener(link.from
,link.towards);
link = {from: event
,towards: delayStatic_e(event
,p.value)};
sendEvent(receiverEE
,link.towards);
});
var resE = receiverEE.switch_e();
sendEvent(switcherE,valueNow(time));
return resE;
} else {
return delayStatic_e(event,time);
}
};
fxMethodSynonyms(EventStream,"delay_e","delay");
var delay_e = function (sourceE,interval) {
return sourceE.delay_e(interval);
};
fxExport(core,delay_e,"delay_e");
var lift_e = function (fn) {
var valsOrNodes = slice(arguments,0);
var selectors = [];
var selectI = 0;
var nodes = [];
for (var i = 0; i < valsOrNodes.length; i++) {
if (valsOrNodes[i] instanceof EventStream) {
nodes.push(valsOrNodes[i]);
selectors.push(function (ii) {
return function (realArgs) {
return realArgs[ii];
};
}(selectI));
selectI++;
} else {
selectors.push(function (aa) {
return function () {
return aa;
};
}(valsOrNodes[i]));
}
}
var context = this;
var nofnodes = slice(selectors,1);
if (nodes.length === 0) {
return one_e(fn.apply(context,valsOrNodes));
} else if (nodes.length === 1 && fn instanceof Function)
{
return nodes[0].lift_e(function () {
var args = arguments;
return fn.apply(context
,map(function (s) {
return s(args);
}
,nofnodes));
});
} else if (nodes.length === 1) {
return fn.lift_e(function (v) {
var args = arguments;
return v.apply(context
,map(function (s) {
return s(args);
}
,nofnodes));
});
} else if (fn instanceof Function) {
return createTimeSyncNode(nodes).lift_e(function (arr) {
return fn.apply(this
,map(function (s) {
return s(arr);
}
,nofnodes));
});
} else if (fn instanceof EventStream) {
return createTimeSyncNode(nodes).lift_e(function (arr) {
return arr[0].apply(this
,map(function (s) {
return s(arr);
}
,nofnodes));
});
} else {
throw "unknown lift_e case";
}
};
fxExport(core,lift_e,"lift_e","transform_e","map_e","apply_e");
EventStream.prototype.snapshot_e = function (valueB) {
return createNode([this]
,function (s,p) {
p.value = valueNow(valueB);
s(p);
});
};
fxMethodSynonyms(EventStream
,"snapshot_e"
,"snapshot"
,"takeSnapshot");
var snapshot_e = function (triggerE,valueB) {
return triggerE.snapshot_e(valueB);
};
fxExport(core,snapshot_e,"snapshot_e");
EventStream.prototype.filterRepeats_e = function (optStart) {
var hadFirst = optStart === undefined ? false : true;
var prev = optStart;
return this.filter_e(function (v) {
if (!hadFirst || !isEqual(prev,v)) {
hadFirst = true;
prev = v;
return true;
} else {
return false;
}
});
};
fxMethodSynonyms(EventStream,"filterRepeats_e","filterRepeats");
var filterRepeats_e = function (sourceE,optStart) {
return sourceE.filterRepeats_e(optStart);
};
fxExport(core,filterRepeats_e,"filterRepeats_e","filterRepeats");
var calmStatic_e = function (triggerE,time) {
var out = internal_e();
createNode([triggerE]
,function () {
var towards = null;
return function (s,p) {
if (towards !== null) {
clearTimeout(towards);
}
towards = setTimeout(function () {
towards =
null;
sendEvent(out
,p.value);
}
,time);
};
}());
return out;
};
EventStream.prototype.calm_e = function (time) {
if (time instanceof Behaviour) {
var out = internal_e();
createNode([this]
,function () {
var towards = null;
return function (s,p) {
if (towards !== null) {
clearTimeout(towards);
}
towards = setTimeout(function () {
towards =
null;
sendEvent(out
,p.value);
}
,valueNow(time));
};
}());
return out;
} else {
return calmStatic_e(this,time);
}
};
fxMethodSynonyms(EventStream,"calm_e","calm");
var calm_e = function (sourceE,interval) {
return sourceE.calm_e(interval);
};
fxExport(core,calm_e,"calm_e");
EventStream.prototype.blind_e = function (time) {
return createNode([this]
,function () {
var intervalFn = time instanceof
Behaviour ? function () {
return valueNow(time);
} : function () {
return time;
};
var lastSent = new Date().getTime() -
intervalFn() - 1;
return function (s,p) {
var curTime =
new Date().getTime();
if (curTime - lastSent >
intervalFn()) {
lastSent = curTime;
s(p);
}
};
}());
};
fxMethodSynonyms(EventStream,"blind_e","blind");
var blind_e = function (sourceE,interval) {
return sourceE.blind_e(interval);
};
fxExport(core,blind_e,"blind_e");
EventStream.prototype.hold = function (init) {
return new Behaviour(this,init);
};
fxMethodSynonyms(EventStream,"hold","startsWith","toBehavior");
var hold = function (e,init) {
if (!(e instanceof EventStream)) {
throw "hold: expected EventStream; received " + e;
}
return e.hold(init);
};
fxExport(core,hold,"hold");
Behaviour.prototype.valueNow = function () {
return this.last;
};
var valueNow = function (behavior) { return behavior.valueNow();};
fxExport(core,valueNow,"valueNow");
Behaviour.prototype.changes = function () {
return this.underlying;
};
fxMethodSynonyms(Behaviour,"changes","toEvent");
var changes = function (behave) { return behave.changes();};
fxExport(core,changes,"changes");
Behaviour.prototype.switch_b = function () {
var behaviourCreatorsB = this;
var init = valueNow(behaviourCreatorsB);
var prevSourceE = null;
var receiverE = new internal_e();
var makerE = createNode([changes(behaviourCreatorsB)]
,function (_,p) {
if (!(p.value instanceof
Behaviour)) {
throw "switch_b: expected Behaviour as value of Behaviour of first argument";
}
if (prevSourceE != null) {
removeListener(prevSourceE
,receiverE);
}
prevSourceE = changes(p.value);
attachListener(prevSourceE
,receiverE);
sendEvent(receiverE
,valueNow(p.value));
});
if (init instanceof Behaviour) {
sendEvent(makerE,init);
}
return hold(receiverE
,init instanceof Behaviour ? valueNow(init)
: init);
};
fxMethodSynonyms(Behaviour,"switch_b","forwardLatest");
var switch_b = function (b) { return b.switch_b();};
fxExport(core,switch_b,"switch_b");
var timer_b = function (interval) {
return hold(timer_e(interval),new Date().getTime());
};
fxExport(dom,timer_b,"timer_b","asTimer_b");
var delayStatic_b = function (triggerB,time,init) {
return hold(delayStatic_e(changes(triggerB),time),init);
};
Behaviour.prototype.delay_b = function (time,init) {
var triggerB = this;
if (time instanceof Behaviour) {
return hold(delay_e(changes(triggerB),time)
,arguments.length > 3 ? init
: valueNow(triggerB));
} else {
return delayStatic_b(triggerB
,time
,arguments.length > 3 ? init
: valueNow(triggerB));
}
};
fxMethodSynonyms(Behaviour,"delay_b","delay");
var delay_b = function (srcB,timeB,init) {
return srcB.delay_b(timeB,init);
};
fxExport(core,delay_b,"delay_b");
Behaviour.prototype.sendBehaviour = function (val) {
sendEvent(this.underlyingRaw,val);
};
Behaviour.prototype.sendBehavior =
Behaviour.prototype.sendBehaviour;
var sendBehaviour = function (b,v) { b.sendBehaviour(v);};
fxExport(core,sendBehaviour,"sendBehaviour");
fxExport(core,sendBehaviour,"sendBehavior");
Behaviour.prototype.if_b = function (trueB,falseB) {
var testB = this;
if (!(trueB instanceof Behaviour)) {
trueB = constant_b(trueB);
}
if (!(falseB instanceof Behaviour)) {
falseB = constant_b(falseB);
}
return lift_b(function (te,t,f) {
return te ? t : f;
}
,testB
,trueB
,falseB);
};
fxMethodSynonyms(Behaviour,"if_b","choose_b","choose");
var if_b = function (test,cons,altr) {
if (!(test instanceof Behaviour)) {
test = constant_b(test);
}
return test.if_b(cons,altr);
};
fxExport(core,if_b,"if_b","choose_b");
var cond_b = function () {
var pairs = slice(arguments,0);
return lift_b.apply({}
,[function () {
for (var i = 0; i <
pairs.length; i++) {
if (arguments[i])
return arguments[pairs.length
+ i];
}
return undefined;
}].concat(map(function (pair) {
return pair[0];
}
,pairs).concat(map(function (pair) {
return pair[1];
}
,pairs))));
};
fxExport(core,cond_b,"cond_b");
var constant_b = function (val) {
return new Behaviour(internal_e(),val);
};
fxExport(core,constant_b,"constant_b","receiver_b");
var lift_b = function (fn) {
var args = slice(arguments,1);
var constituentsE = map(changes
,filter(function (v) {
return v instanceof
Behaviour;
}
,arguments));
var getCur = function (v) {
return v instanceof Behaviour ? v.last : v;
};
var ctx = this;
var getRes = function () {
return getCur(fn).apply(ctx
,map(getCur,args));
};
if (constituentsE.length == 1) {
return new Behaviour(constituentsE[0]
,getRes()
,getRes);
}
var prevStamp = -1;
var mid = createNode(constituentsE
,function (s,p) {
if (p.stamp != prevStamp) {
prevStamp = p.stamp;
s(p);
}
});
return new Behaviour(mid,getRes(),getRes);
};
fxExport(core,lift_b,"lift_b","transform_b","apply_b");
Behaviour.prototype.lift_b = function () {
var args = slice(arguments,0).concat([this]);
return lift_b.apply(this,args);
};
fxMethodSynonyms(Behaviour
,"lift_b"
,"transform_b"
,"apply_b"
,"transform"
,"lift");
var and_b = function () {
return lift_b.apply({}
,[function () {
for (var i = 0; i <
arguments.length; i++) {
if (!arguments[i])
return false;
}
return true;
}].concat(slice(arguments,0)));
};
fxExport(core,and_b,"and_b");
Behaviour.prototype.and_b = function () {
return and_b([this].concat(arguments));
};
fxMethodSynonyms(Behaviour,"and_b","and");
var or_b = function () {
return lift_b.apply({}
,[function () {
for (var i = 0; i <
arguments.length; i++) {
if (arguments[i])
return true;
}
return false;
}].concat(slice(arguments,0)));
};
fxExport(core,or_b,"or_b");
Behaviour.prototype.or_b = function () {
return or_b([this].concat(arguments));
};
fxMethodSynonyms(Behaviour,"or_b","or");
Behaviour.prototype.not_b = function () {
return this.lift_b(function (v) {
return !v;
});
};
fxMethodSynonyms(Behaviour,"not_b","not");
var not_b = function (b) { return b.not_b();};
fxExport(core,not_b,"not_b");
Behaviour.prototype.blind_b = function (intervalB) {
return changes(this).blind_e(intervalB).hold(this.valueNow());
};
fxMethodSynonyms(Behaviour,"blind_b","blind");
var blind_b = function (srcB,intervalB) {
return srcB.blind_b(intervalB);
};
fxExport(core,blind_b,"blind_b");
Behaviour.prototype.calm_b = function (intervalB) {
return this.changes().calm_e(intervalB).hold(this.valueNow());
};
fxMethodSynonyms(Behaviour,"calm_b","calm");
var calm_b = function (srcB,intervalB) {
return srcB.calm_b(intervalB);
};
fxExport(core,calm_b,"calm_b");
var addEvent = function (obj,evType,fn) {
if (obj.addEventListener) {
obj.addEventListener(evType,fn,false);
return true;
} else if (obj.attachEvent) {
return obj.attachEvent("on" + evType,fn);
} else {
return false;
}
};
fxExport(domMisc,addEvent,"addEvent");
var getElementsByClass = function (searchClass,node,tag) {
var classElements = [];
if (node === null || node === undefined) {
node = document;
}
if (tag === null || tag === undefined) {
tag = "*";
}
var els = node.getElementsByTagName(tag);
var elsLen = els.length;
var pattern = new RegExp("(^|\\s)" + searchClass +
"(\\s|$)");
for (var i = 0,j = 0; i < elsLen; i++) {
if (pattern.test(els[i].className)) {
classElements.push(els[i]);
}
}
return classElements;
};
fxExport(domMisc,getElementsByClass,"getElementsByClass","$$");
var swapDom = function (replaceMe,withMe) {
if (replaceMe === null || replaceMe === undefined) {
throw "swapDom: expected dom node or id, received: "
+ replaceMe;
}
var replaceMeD = getObj(replaceMe);
if (!(replaceMeD.nodeType > 0)) {
throw "swapDom expected a Dom node as first arg, received "
+ replaceMeD;
}
if (withMe) {
var withMeD = getObj(withMe);
if (!(withMeD.nodeType > 0)) {
throw "swapDom: can only swap with a DOM object";
}
try {
if (withMeD != replaceMeD)
replaceMeD.parentNode.replaceChild(withMeD
,replaceMeD);
} catch (e) {
throw "swapDom error in replace call: withMeD: " +
withMeD + ", replaceMe Parent: " + replaceMeD +
", " + e + ", parent: " + replaceMeD.parentNode;
}
} else {
replaceMeD.parentNode.removeChild(replaceMeD);
}
return replaceMeD;
};
fxExport(domMisc,swapDom,"swapDom");
var getObj = function (name) {
if (typeof name == "object") {
return name;
} else if (typeof name == "null" || typeof name ==
"undefined") {
throw "getObj: expects a Dom obj or Dom id as first arg";
} else {
var res = document.getElementById
? document.getElementById(name)
: document.all ? document.all[name]
: document.layers ? document.layers[name]
: function () {
throw "getObj: flapjax: cannot access object";
}();
if (res === null || res === undefined) {
throw "getObj: no obj to get: " + name;
}
return res;
}
};
fxExport(domMisc,getObj,"getObj");
fxExport(domMisc,getObj,"$");
var getMostDom = function (domObj,indices) {
var acc = getObj(domObj);
if (indices === null || indices === undefined ||
indices.length < 1) {
return acc;
} else {
for (var i = 0; i < indices.length - 1; i++) {
acc = acc[indices[i]];
}
return acc;
}
};
var getDomVal = function (domObj,indices) {
var val = getMostDom(domObj,indices);
if (indices && indices.length > 0) {
val = val[indices[indices.length - 1]];
}
return val;
};
var ___timerID = 0;
var __getTimerId = function () { return ++___timerID;};
var timerDisablers = [];
var disableTimerNode = function (node) {
timerDisablers[node.__timerId]();
};
var disableTimer = function (v) {
if (v instanceof Behaviour) {
disableTimerNode(v.underlyingRaw);
} else if (v instanceof EventStream) {
disableTimerNode(v);
}
};
fxExport(dom,disableTimer,"disableTimer");
var createTimerNodeStatic = function (interval) {
var node = internal_e();
node.__timerId = __getTimerId();
var fn = function () {
sendEvent(node,new Date().getTime());
};
var timer = setInterval(fn,interval);
timerDisablers[node.__timerId] = function () {
clearInterval(timer);
};
return node;
};
var timer_e = function (interval) {
if (interval instanceof Behaviour) {
var receiverE = internal_e();
var res = receiverE.switch_e();
var prevE =
createTimerNodeStatic(valueNow(interval));
sendEvent(receiverE,prevE);
createNode([changes(interval)]
,function (_,p) {
disableTimerNode(prevE);
prevE = createTimerNodeStatic(p.value);
sendEvent(receiverE,prevE);
});
res.__timerId = __getTimerId();
timerDisablers[res.__timerId] = function () {
disableTimerNode[prevE]();
return;
};
return res;
} else {
return createTimerNodeStatic(interval);
}
};
fxExport(dom,timer_e,"timer_e","asTimer_e");
d.TagB = function (tagName,args) {
this.resE = internal_e();
this.currentTag = document.createElement(tagName);
this.extractParameters(args);
this.insertChildrenNodes();
this.styleHooks = [];
this.styleChangedE = internal_e();
var ctx = this;
this.styleChangedE.lift_e(function (_) {
var oldTag = ctx.currentTag;
ctx.currentTag = document.createElement(tagName);
while (oldTag.firstChild) {
ctx.currentTag.appendChild(oldTag.removeChild(oldTag.firstChild));
}
while (ctx.styleHooks.length)
removeListener(ctx.styleHooks.pop()
,ctx.styleChangedE);
ctx.enstyle(ctx.currentTag,ctx.attribs);
sendEvent(ctx.resE,ctx.currentTag);
});
this.enstyle(this.currentTag,this.attribs);
this.resB = hold(this.resE,this.currentTag);
};
d.TagB.prototype = {extractParameters: function (args) {
this.arrs = [];
var attribs = [];
var curarr = [];
this.arrs.push(curarr);
for (var i = 0; i < args.length; i++) {
if (args[i] instanceof Behaviour) {
var vn = valueNow(args[i]);
if (vn instanceof Array) {
this.arrs.push(args[i]);
curarr = [];
this.arrs.push(curarr);
} else {
if (typeof vn == "object" &&
vn.nodeType == 1 || typeof vn ==
"string" || vn == undefined) {
curarr.push(args[i]);
} else if (typeof vn == "object") {
attribs.push(args[i]);
} else {
throw "createParameterizedTagB: unknown behaviour argument argument "
+ i;
}
}
} else {
if (args[i] instanceof Array) {
var arr = args[i];
for (var j = 0; j < arr.length; j++)
{
curarr.push(arr[j]);
}
} else {
var vn = args[i];
if (typeof vn == "object" &&
vn.nodeType == 1 || typeof vn ==
"string" || vn == undefined) {
curarr.push(args[i]);
} else if (typeof vn == "object") {
attribs.push(args[i]);
}
}
}
}
;
if (attribs.length > 1)
throw "createParameterizedTagB " + tagName
+ ": more than one attribute (" +
attribs.length + ")";
this.attribs = attribs.length > 0
? attribs[0] : {};
}
,insertChildrenNodes: function () {
var ctx = this;
function quickNode(e) {
if (typeof e == "object" && e.nodeType)
return e; else if (e == undefined)
return document.createTextNode("");
else return document.createTextNode(e);
}
function unBehaviourize(arr) {
return map(function (n) {
return n instanceof Behaviour
? valueNow(n) : n;
}
,arr);
}
var lnodes = map(function () {
return [];
}
,this.arrs);
var arrLastVals = map(unBehaviourize
,unBehaviourize(this.arrs));
var arrChangesE = internal_e();
var nodeChangesE = internal_e();
function attachNodes(i,arr) {
for (var j = 0; j < arr.length; j++) {
var cnode = arr[j];
if (cnode instanceof Behaviour) {
var newnode = function (jj) {
return changes(cnode).lift_e(function (n) {
return {index: i
,jdex: jj
,val: n};
});
}(j);
lnodes[i].push(newnode);
attachListener(newnode
,nodeChangesE);
cnode = valueNow(cnode);
}
}
}
var childChangesE =
merge_e(arrChangesE.lift_e(function (ai) {
var i = ai.index;
var newarr = ai.val;
while (lnodes[i].length) {
var ln =
lnodes[i].pop();
removeListener(ln
,nodeChangesE);
}
var newvals =
map(function (n) {
return quickNode(n);
}
,unBehaviourize(newarr));
for (var j = 0; j <
arrLastVals[i].length; j++)
try {
ctx.currentTag.removeChild(arrLastVals[i][j]);
} catch (e) {
}
if (newvals.length) {
var nextNode = null;
for (ii = i + 1; ii <
arrLastVals.length
&&
!arrLastVals[ii].length; ii++)
;
if (ii <
arrLastVals.length)
nextNode =
arrLastVals[ii][0];
for (var j = 0; j <
newvals.length; j++)
ctx.currentTag.insertBefore(newvals[j]
,nextNode);
}
arrLastVals[i] = newvals;
attachNodes(i,newarr);
return ctx.currentTag;
})
,nodeChangesE.lift_e(function (ni) {
var i = ni.index;
var j = ni.jdex;
var newnode =
quickNode(ni.val);
swapDom(arrLastVals[i][j]
,newnode);
arrLastVals[i][j] =
newnode;
return ctx.currentTag;
}));
childChangesE.lift_e(function (cc) {
sendEvent(ctx.resE,cc);
});
for (var i = 0; i < this.arrs.length; i++) {
for (var j = 0; j <
arrLastVals[i].length; j++) {
arrLastVals[i][j] =
quickNode(arrLastVals[i][j]);
this.currentTag.appendChild(arrLastVals[i][j]);
}
if (this.arrs[i] instanceof Behaviour) {
attachNodes(i,valueNow(this.arrs[i]));
var newnode = function (ii) {
return changes(ctx.arrs[ii]).lift_e(function (na) {
return {index: ii
,val: na};
});
}(i);
attachListener(newnode,arrChangesE);
} else {
attachNodes(i,this.arrs[i]);
}
}
}
,enstyle: function (obj,vals) {
if (vals instanceof Behaviour) {
if (!(typeof valueNow(vals) == "object"))
{
throw "enstyle: expected object literal as behaviour value";
}
this.styleHooks.push(changes(vals));
attachListener(changes(vals)
,this.styleChangedE);
}
var valsV = vals instanceof Behaviour
? valueNow(vals) : vals;
if (typeof valsV == "object") {
for (var i in valsV) {
if (!Object.prototype ||
!Object.prototype[i]) {
this.enstyleProperty(obj,valsV,i);
}
}
} else {
throw "enstyle: expected object literals";
}
}
,enstyleProperty: function (obj,vals,i) {
if (vals[i] instanceof Behaviour) {
if (typeof valueNow(vals[i]) == "object")
{
this.enstyle(obj[i],vals[i]);
} else {
obj[i] = valueNow(vals[i]);
changes(vals[i]).lift_e(function (v) {
obj[i] = v;
});
}
} else {
if (typeof vals[i] == "object") {
this.enstyle(obj[i],vals[i]);
} else {
obj[i] = vals[i];
}
}
}};
d.createParameterizedTagB = function (tagName) {
return new d.TagB(tagName,slice(arguments,1)).resB;
};
d.enstyleStaticProperty = function (obj,props,index) {
if (typeof props[index] == "object") {
for (var i in props[index]) {
if (!Object.prototype || !Object.prototype[i]) {
d.enstyleStaticProperty(obj[index],props[index],i);
}
}
} else {
obj[index] = props[index];
if (index == "checked") obj["defaultChecked"] =
props[index];
if (index == "selected") obj["defaultSelected"] =
props[index];
}
};
d.staticTagMaker = function (tagName) {
return function () {
var tagD = document.createElement(tagName);
if (!(tagD.nodeType > 0)) {
throw tagName + ": invalid tag name";
}
var attribs = [];
for (var i = 0; i < arguments.length; i++) {
if (arguments[i] instanceof Array) {
for (var j = 0; j < arguments[i].length; j++) {
if (arguments[i][j]) {
tagD.appendChild(typeof arguments[i][j]
== "object" &&
arguments[i][j].nodeType > 0
? arguments[i][j]
: document.createTextNode(arguments[i][j]));
}
}
} else if (!arguments[i]) {
} else if (typeof arguments[i] == "object" &&
arguments[i].nodeType > 0) {
tagD.appendChild(arguments[i]);
} else if (typeof arguments[i] == "object") {
attribs.push(arguments[i]);
} else {
tagD.appendChild(document.createTextNode(arguments[i]));
}
}
if (attribs.length == 1) {
for (var k in attribs[0]) {
if (!Object.prototype || !Object.prototype[k])
{
d.enstyleStaticProperty(tagD,attribs[0],k);
}
}
} else if (attribs.length > 0) {
throw "static enstyle: expected object literals";
}
return tagD;
};
};
var generatedTags = ["a"
,"b"
,"blockquote"
,"br"
,"button"
,"canvas"
,"div"
,"fieldset"
,"form"
,"font"
,"h1"
,"h2"
,"h3"
,"h4"
,"hr"
,"img"
,"iframe"
,"input"
,"label"
,"legend"
,"li"
,"ol"
,"optgroup"
,"option"
,"p"
,"pre"
,"select"
,"span"
,"strong"
,"table"
,"tbody"
,"td"
,"textarea"
,"tfoot"
,"th"
,"thead"
,"tr"
,"tt"
,"ul"];
map(function (tagName) {
var upper = tagName.toUpperCase();
d[upper + "B"] = function () {
return d.createParameterizedTagB.apply(this
,[tagName].concat(slice(arguments
,0)));
};
annotate(d[upper + "B"],[upper + "B"]);
d[upper] = d.staticTagMaker(tagName);
annotate(d[upper],[upper]);
}
,generatedTags);
d.TEXTB = function (strB) {
if (!(strB instanceof Behaviour)) {
strB = constant_b(strB);
}
return hold(changes(strB).lift_e(function (txt) {
return document.createTextNode(txt);
})
,document.createTextNode(valueNow(strB)));
};
annotate(d.TEXTB,["TEXTB"]);
var TEXT = function (str) { return document.createTextNode(str);};
fxExport(dom,TEXT,"TEXT");
var tagRec = function (eventNames,maker) {
if (!(eventNames instanceof Array)) {
throw "tagRec: expected array of event names as first arg";
}
if (!(maker instanceof Function)) {
throw "tagRec: expected function as second arg";
}
var numEvents = eventNames.length;
var internals = [];
var switches = [];
for (var i = 0; i < numEvents; i++) {
internals[i] = internal_e();
switches[i] = internals[i].switch_e();
}
;
var domB = maker.apply(this,switches);
var prevValue;
var interceptE = createNode([domB.changes()]
,function (_,p) {
if (isEqual(p.value
,prevValue)) {
return;
}
prevValue = p.value;
for (var i = 0; i <
numEvents; i++) {
sendEvent(internals[i]
,extractEvent_e(prevValue
,eventNames[i]));
}
;
});
sendEvent(interceptE,domB.valueNow());
return domB;
};
fxExport(dom,tagRec,"tagRec","nodeWithOwnEvents");
var extractEventStatic_e = function (domObj,eventName) {
if (!eventName) {
throw "extractEvent_e : no event name specified";
}
if (!domObj) {
throw "extractEvent_e : no DOM element specified";
}
domObj = getObj(domObj);
var primEventE = internal_e();
addEvent(domObj
,eventName
,function (evt) {
sendEvent(primEventE,evt || window.event);
return true;
});
return primEventE;
};
var extractEvent_e = function (domB,eventName) {
if (!(domB instanceof Behaviour)) {
return extractEventStatic_e(domB,eventName);
} else {
var domE = domB.changes();
var eventEE = domE.lift_e(function (dom) {
return extractEventStatic_e(dom
,eventName);
});
var resultE = eventEE.switch_e();
sendEvent(domE,domB.valueNow());
return resultE;
}
;
};
fxExport(dom,extractEvent_e,"extractEvent_e","$EVT");
d.extractEvents_e = function (domObj) {
var eventNames = slice(arguments,1);
var events = map(function (eventName) {
return extractEvent_e(domObj,eventName);
}
,eventNames.length === 0 ? [] : eventNames);
return merge_e.apply(this,events);
};
annotate(d.extractEvents_e
,["extractEvents_e"]
,0
,[Behaviour.prototype]
,["extractEvents_e"]);
d.extractValueOnEvent_e = function (triggerE,domObj) {
if (!(triggerE instanceof EventStream)) {
throw "extractValueOnEvent_e: expected Event as first arg";
}
return changes(d.extractValueOnEvent_b.apply(this
,arguments));
};
annotate(d.extractValueOnEvent_e,["extractValueOnEvent_e"]);
d.extractDomFieldOnEvent_e = function (triggerE,domObj) {
if (!(triggerE instanceof EventStream)) {
throw "extractDomFieldOnEvent_e: expected Event as first arg";
}
var indices = slice(arguments,2);
var res = triggerE.lift_e(function () {
return getDomVal(domObj,indices);
});
return res;
};
d.extractValue_e = function (domObj) {
return changes(d.extractValue_b.apply(this,arguments));
};
annotate(d.extractValue_e,["extractValue_e","$E"]);
d.extractValueOnEvent_b = function (triggerE,domObj) {
return d.extractValueStatic_b(domObj,triggerE);
};
annotate(d.extractValueOnEvent_b,["extractValueOnEvent_b"]);
d.extractValueStatic_b = function (domObj,triggerE) {
var objD;
try {
objD = getObj(domObj);
if (typeof domObj == "string" && objD.id != domObj) {
throw "Make a radio group";
}
} catch (e) {
objD = {type: "radio-group",name: domObj};
}
var getter;
switch (objD.type)
{
case "checkbox":
return hold(filterRepeats_e(d.extractDomFieldOnEvent_e(triggerE
? triggerE
: d.extractEvents_e(objD
,"click"
,"keyup"
,"change")
,objD
,"checked")
,objD.checked)
,objD.checked);
case "select-one":
getter = function (_) {
return objD.selectedIndex > -1
? objD.options[objD.selectedIndex].value
? objD.options[objD.selectedIndex].value
: objD.options[objD.selectedIndex].innerText
: undefined;
};
return hold(filterRepeats_e((triggerE ? triggerE
: d.extractEvents_e(objD
,"click"
,"keyup"
,"change")).lift_e(getter))
,getter()
,getter());
case "select-multiple":
getter = function (_) {
var res = [];
for (var i = 0; i < objD.options.length; i++) {
if (objD.options[i].selected) {
res.push(objD.options[i].value
? objD.options[i].value
: objD.options[i].innerText);
}
}
return res;
};
return hold((triggerE ? triggerE
: d.extractEvents_e(objD
,"click"
,"keyup"
,"change")).lift_e(getter)
,getter());
case "text":
case "textarea":
case "hidden":
case "password":
return hold(filterRepeats_e(d.extractDomFieldOnEvent_e(triggerE
? triggerE
: d.extractEvents_e(objD
,"click"
,"keyup"
,"change")
,objD
,"value")
,objD.value)
,objD.value);
case "button":
return hold(d.extractDomFieldOnEvent_e(triggerE
? triggerE
: d.extractEvents_e(objD
,"click"
,"keyup"
,"change")
,objD
,"value")
,objD.value);
case "radio":
case "radio-group":
var radiosAD = filter(function (elt) {
return elt.type == "radio" &&
elt.getAttribute("name") ==
objD.name;
}
,document.getElementsByTagName("input"));
getter = objD.type == "radio" ? function (_) {
return objD.checked;
} : function (_) {
for (var i = 0; i < radiosAD.length; i++) {
if (radiosAD[i].checked) {
return radiosAD[i].value;
}
}
return undefined;
};
var actualTriggerE = triggerE ? triggerE
: merge_e.apply(this
,map(function (radio) {
return d.extractEvents_e(radio
,"click"
,"keyup"
,"change");
}
,radiosAD));
return hold(filterRepeats_e(actualTriggerE.lift_e(getter)
,getter())
,getter());
default:
throw "extractValueStatic_b: unknown value type \"" +
objD.type + "\"";
}
};
d.extractValue_b = function (domObj) {
if (domObj instanceof Behaviour) {
return lift_b(function (dom) {
return d.extractValueStatic_b(dom);
}
,domObj).switch_b();
} else {
return d.extractValueStatic_b(domObj);
}
};
annotate(d.extractValue_b
,["extractValue_b","$B"]
,0
,[Behaviour.prototype]
,["extractValue_b","$B"]);
d.deepStaticUpdate = function (into,from,index) {
var fV = from instanceof Behaviour ? valueNow(from) : from;
if (typeof fV == "object") {
for (var i in fV) {
if (!Object.prototype || !Object.prototype[i]) {
d.deepStaticUpdate(index ? into[index] : into
,fV[i]
,i);
}
}
} else {
var old = into[index];
into[index] = fV;
}
};
d.deepDynamicUpdate = function (into,from,index) {
var fV = from instanceof Behaviour ? valueNow(from) : from;
if (typeof fV == "object") {
if (from instanceof Behaviour) {
throw "deepDynamicUpdate: dynamic collections not supported";
}
for (var i in fV) {
if (!Object.prototype || !Object.prototype[i]) {
d.deepDynamicUpdate(index ? into[index] : into
,fV[i]
,i);
}
}
} else {
if (from instanceof Behaviour) {
createNode([changes(from)]
,function (s,p) {
if (index) {
var old = into[index];
into[index] = p.value;
} else {
into = p.value;
}
});
}
}
};
d.insertValue = function (val,domObj) {
var indices = slice(arguments,2);
var parent = getMostDom(domObj,indices);
d.deepStaticUpdate(parent
,val
,indices ? indices[indices.length - 1]
: undefined);
};
annotate(d.insertValue,["insertValue"]);
d.insertValueE = function (triggerE,domObj) {
if (!(triggerE instanceof EventStream)) {
throw "insertValueE: expected Event as first arg";
}
var indices = slice(arguments,2);
var parent = getMostDom(domObj,indices);
triggerE.lift_e(function (v) {
d.deepStaticUpdate(parent
,v
,indices ? indices[indices.length -
1] : undefined);
});
};
annotate(d.insertValueE
,["insertValueE"]
,0
,[EventStream.prototype]
,["insertValueE"]);
d.insertValueB = function (triggerB,domObj) {
var indices = slice(arguments,2);
var parent = getMostDom(domObj,indices);
d.deepStaticUpdate(parent
,triggerB
,indices ? indices[indices.length - 1]
: undefined);
d.deepDynamicUpdate(parent
,triggerB
,indices ? indices[indices.length - 1]
: undefined);
};
annotate(d.insertValueB
,["insertValueB"]
,0
,[Behaviour.prototype]
,["insertValueB"]);
d.insertDomE = function (triggerE,domObj) {
if (!(triggerE instanceof EventStream)) {
throw "insertDomE: expected Event as first arg";
}
var objD = getObj(domObj);
var res = triggerE.lift_e(function (newObj) {
if (!(typeof newObj == "object" &&
newObj.nodeType == 1)) {
newObj = d.SPAN({},newObj);
}
swapDom(objD,newObj);
objD = newObj;
return newObj;
});
return res;
};
annotate(d.insertDomE
,["insertDomE"]
,0
,[EventStream.prototype]
,["insertDomE"]);
d.insertDom = function (hookD,replaceWithD,optPosition) {
switch (optPosition)
{
case undefined:
case null:
case "over":
swapDom(hookD,replaceWithD);
break;
case "before":
hookD.parentNode.insertBefore(replaceWithD,hookD);
break;
case "after":
if (hookD.nextSibling) {
hookD.parentNode.insertBefore(replaceWithD
,hookD.nextSibling);
} else {
hookD.parentNode.appendChild(replaceWithD);
}
break;
case "leftMost":
if (hookD.parentNode.firstChild) {
hookD.parentNode.insertBefore(replaceWithD
,hookD.parentNode.firstChild);
} else {
hookD.parentNode.appendChild(replaceWithD);
}
break;
case "rightMost":
hookD.parentNode.appendChild(replaceWithD);
break;
case "beginning":
if (hookD.firstChild) {
hookD.insertBefore(replaceWithD,hookD.firstChild);
} else {
hookD.appendChild(replaceWithD);
}
break;
case "end":
hookD.appendChild(replaceWithD);
break;
default:
throw "domInsert: unknown position: " + optPosition;
}
};
d.insertDomClean = function (replaceWithD,hook,optPosition) {
d.insertDom(getObj(hook)
,typeof replaceWithD == "object" &&
replaceWithD.nodeType > 0 ? replaceWithD
: document.createTextNode(replaceWithD)
,optPosition);
};
annotate(d.insertDomClean,["insertDom"]);
d.insertDomB = function (initTriggerB,optID,optPosition) {
if (!(initTriggerB instanceof Behaviour)) {
initTriggerB = constant_b(initTriggerB);
}
var triggerB = lift_b(function (d) {
if (typeof d == "object" &&
d.nodeType > 0) {
return d;
} else {
var res =
document.createElement("span");
res.appendChild(document.createTextNode(d));
return res;
}
}
,initTriggerB);
var initD = valueNow(triggerB);
if (!(typeof initD == "object" && initD.nodeType == 1)) {
throw "insertDomB: initial value conversion failed: " +
initD;
}
d.insertDom(optID === null || optID === undefined
? getObj(initD.getAttribute("id"))
: getObj(optID)
,initD
,optPosition);
var resB = hold(d.insertDomE(changes(triggerB),initD)
,initD);
return resB;
};
annotate(d.insertDomB
,["insertDomB"]
,0
,[Behaviour.prototype]
,["insertDomB"]);
d.extractId_b = function (id,start) {
return hold(createNode(start instanceof Behaviour
? [changes(start)] : []
,function (s,p) {
p.value = getObj(id);
s(p);
})
,getObj(id));
};
annotate(d.insertDomB
,["extractId_b"]
,1
,[Behaviour.prototype]
,["extractId_b"]);
var mouse_e = function (elem) {
return extractEvent_e(elem
,"mousemove").lift_e(function (evt) {
if (evt.pageX | evt.pageY) {
return {left: evt.pageX,top: evt.pageY};
} else if (evt.clientX || evt.clientY) {
return {left: evt.clientX +
document.body.scrollLeft
,top: evt.clientY +
document.body.scrollTop};
} else {
return {left: 0,top: 0};
}
});
};
var mouse_b = function (elem) {
return mouse_e(elem).hold({left: 0,top: 0});
};
fxExport(dom,mouse_b,"mouse_b");
var mouseLeft_b = function (elem) {
return lift_b(function (v) {
return v.left;
}
,mouse_b(elem));
};
fxExport(dom,mouseLeft_b,"mouseLeft_b");
var mouseTop_b = function (elem) {
return mouse_b(elem).lift_b(function (v) {
return v.top;
});
};
fxExport(dom,mouseTop_b,"mouseTop_b");
var clicks_e = function (elem) {
return extractEvent_e(elem,"click");
};
fxExport(dom,clicks_e,"clicks_e");
var getURLParam = function (param) {
var lparam = param.toLowerCase();
var aReturn = [];
var strHref = window.location.href;
var endstr = strHref.indexOf("#") > -1
? strHref.indexOf("#") : strHref.length;
if (strHref.indexOf("?") > -1) {
var strQueryString =
strHref.substring(strHref.indexOf("?") + 1
,endstr);
map(function (qp) {
var eq = qp.indexOf("=");
var qname = qp.substr(0,eq + 1).toLowerCase();
if (qname == lparam + "=")
aReturn.push(decodeURIComponent(qp.substr(eq
+ 1)));
}
,strQueryString.split("&"));
}
if (aReturn.length == 0) return undefined;
else if (aReturn.length == 1) return aReturn[0];
else return aReturn;
};
fxExport(domMisc,getURLParam,"getURLParam","$URL");
var readCookie = function (name) {
var nameEQ = name + "=";
var ca = document.cookie.split(";");
for (var i = 0; i < ca.length; i++) {
var co = ca[i];
while (co.charAt(0) == " ") {
co = co.substring(1,co.length);
}
if (co.indexOf(nameEQ) === 0) {
return co.substring(nameEQ.length,co.length);
}
}
return undefined;
};
fxExport(domMisc,readCookie,"readCookie");
var scriptCounter = 0;
var deleteScript = function (scriptID) {
var scriptD = getObj(scriptID);
scriptD.parentNode.removeChild(scriptD);
};
var runScript = function (url,fn,param) {
var script = document.createElement("script");
script.src = url;
var scriptID = "scriptFnRPC" + scriptCounter++;
script.setAttribute("id",scriptID);
document.getElementsByTagName("head").item(0).appendChild(script);
var timer = {};
var check = function () {
eval("try { if (" + param +
"!== undefined) {var stat = " + param +
";}} catch (e) {}");
if (stat !== undefined) {
eval(param + " = undefined;");
clearInterval(timer.timer);
clearInterval(timer.timeout);
if (fn instanceof Function) {
fn(stat);
}
deleteScript(scriptID);
}
};
timer.timer = setInterval(check,3500);
timer.timeout = setTimeout(function () {
try {
clearInterval(timer.timer);
} catch (e) {
}
}
,5000);
};
var evalForeignScriptVal_e = function (urlArg_e) {
var result = receiver_e();
urlArg_e.lift_e(function (urlArg) {
runScript(urlArg.url
,function (val) {
result.sendEvent(val);
}
,urlArg.globalArg);
});
return result;
};
fxExport(ws,evalForeignScriptVal_e,"evalForeignScriptVal_e");
var ajaxRequest = function (method
,url
,body
,async
,useFlash
,callback) {
var xhr;
if (useFlash) {
xhr = new FlashXMLHttpRequest();
xhr.onload = function () {
callback(xhr);
};
} else if (window.XMLHttpRequest &&
!window.ActiveXObject) {
xhr = new window.XMLHttpRequest();
xhr.onload = function () {
callback(xhr);
};
} else if (window.ActiveXObject) {
try {
xhr = new ActiveXObject("Msxml2.XMLHTTP");
} catch (e) {
xhr = new ActiveXObject("Microsoft.XMLHTTP");
}
xhr.onreadystatechange = function () {
if (xhr.readyState == 4) {
callback(xhr);
}
};
}
xhr.open(method,url,async);
if (method == "POST") {
xhr.setRequestHeader("Content-Type"
,"application/x-www-form-urlencoded");
}
xhr.send(body);
return xhr;
};
var encodeREST = function (obj) {
var str = "";
for (var field in obj) {
if (typeof obj[field] !== "function") {
if (str != "") {
str += "&";
}
str += field + "=" +
encodeURIComponent(obj[field]);
}
}
return str;
};
var parseJSON = function (str) {
try {
return !/[^,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]/.test(str.replace(/"(\\.|[^"\\])*"/g
,""))
&& eval("(" + str + ")");
} catch (e) {
throw "cannot parse JSON string: " + e;
}
};
var toJSONString = function () {
var m = {"\b": "\\b"
,"\t": "\\t"
,"\n": "\\n"
,"\f": "\\f"
,"\r": "\\r"
,"\"": "\\\""
,"\\": "\\\\"};
var s = {array: function (x) {
var a = ["["],b,f,i,l = x.length,v;
for (i = 0; i < l; i += 1) {
v = x[i];
f = s[typeof v];
if (f) {
v = f(v);
if (typeof v == "string") {
if (b) {
a[a.length] = ",";
}
a[a.length] = v;
b = true;
}
}
}
a[a.length] = "]";
return a.join("");
}
,"boolean": function (x) {
return String(x);
}
,"null": function (x) {
return "null";
}
,number: function (x) {
return isFinite(x) ? String(x) : "null";
}
,object: function (x) {
if (x) {
if (x instanceof Array) {
return s.array(x);
}
var a = ["{"],b,f,i,v;
for (i in x) {
v = x[i];
f = s[typeof v];
if (f) {
v = f(v);
if (typeof v == "string") {
if (b) {
a[a.length] = ",";
}
a.push(s.string(i),":",v);
b = true;
}
}
}
a[a.length] = "}";
return a.join("");
}
return "null";
}
,string: function (x) {
if (/["\\\x00-\x1f]/.test(x)) {
x = x.replace(/([\x00-\x1f\\"])/g
,function (a,b) {
var c = m[b];
if (c) {
return c;
}
c = b.charCodeAt();
return "\\u00" +
Math.floor(c /
16).toString(16) + (c
%
16).toString(16);
});
}
return "\"" + x + "\"";
}};
return function (val) {
var f = s[typeof val];
if (f) {
return f(val);
} else {
throw "parseJSON: unknown object type: " +
typeof val;
}
};
}();
var serverRequest_e = function (useFlash,requestE) {
var response_e = receiver_e();
requestE.lift_e(function (obj) {
var body = "";
var method = "GET";
var url = obj.url;
var reqType = obj.request ? obj.request
: obj.fields ? "post" : "get";
if (obj.request == "get") {
url += "?" + encodeREST(obj.fields);
body = "";
method = "GET";
} else if (obj.request == "post") {
body = toJSONString(obj.fields);
method = "POST";
} else if (obj.request == "rawPost") {
body = obj.body;
method = "POST";
} else if (obj.request == "rest") {
body = encodeREST(obj.fields);
method = "POST";
} else {
raise("Invalid request type: " + obj.request);
}
var async = obj.async;
var xhr;
if (obj.response == "json") {
xhr = ajaxRequest(method
,url
,body
,async
,useFlash
,function (xhr) {
response_e.sendEvent(parseJSON(xhr.responseText));
});
} else if (obj.response == "xml") {
ajaxRequest(method
,url
,body
,async
,useFlash
,function (xhr) {
response_e.sendEvent(xhr.responseXML);
});
} else if (obj.response == "plain" ||
!obj.response) {
ajaxRequest(method
,url
,body
,async
,useFlash
,function (xhr) {
response_e.sendEvent(xhr.responseText);
});
} else {
raise("Unknown response format: " +
obj.response);
}
});
return response_e;
};
var getWebServiceObject_e = function (requestE) {
return serverRequest_e(false,requestE);
};
fxExport(ws,getWebServiceObject_e,"getWebServiceObject_e");
var getForeignWebServiceObject_e = function (requestE) {
return serverRequest_e(true,requestE);
};
fxExport(ws
,getForeignWebServiceObject_e
,"getForeignWebServiceObject_e");
var cumulativeOffset = function (element) {
var valueT = 0,valueL = 0;
do {
valueT += element.offsetTop || 0;
valueL += element.offsetLeft || 0;
element = element.offsetParent;
} while (element);
return {left: valueL,top: valueT};
};
fxExport(domMisc,cumulativeOffset,"cumulativeOffset");
if (!options.hideAll) {
for (var zz in flapjax.pub) {
if (!options[zz]) {
window[zz] = flapjax.pub[zz];
}
}
}
for (var id in exports) {
if (window[id]) {
if (options.redefine === false) {
warn("window." + id +
" is already defined; Flapjax will not " +
"redefine it.");
} else {
warn("Flapjax is redefining window." + id + ".");
}
}
if (window[id] && options.redefine === false) {
} else if (options.show && options.hide && options.show[id] ===
true && options.hide[id] === true) {
throw "flapjaxInit: invalid options: " + id +
" specified as \'show\' and \'hide\'";
} else if (options.show && options.show[id]) {
window[id] = exports[id];
} else if (options.hide && options.hide[id]) {
} else if (!synonyms[id] || options.includeSynonyms) {
if (options.exportMisc && exports[id].__flapjaxCategory ===
misc) {
window[id] = exports[id];
} else if (options.exportDOMMisc &&
exports[id].__flapjaxCategory === domMisc) {
window[id] = exports[id];
} else if (options.exportDOM && exports[id].__flapjaxCategory
=== dom) {
window[id] = exports[id];
} else if (options.exportCore &&
exports[id].__flapjaxCategory === core) {
window[id] = exports[id];
} else if (options.exportWS && exports[id].__flapjaxCategory
=== ws) {
window[id] = exports[id];
}
}
}
return exports;
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment