Lyndon Jetten
fda2c306b5
FaC: Das alte Flag von Terminen, die in die Zeiterfassung übernommen worden sind, wird ebenfalls berücksichtigt.
786 lines
19 KiB
JavaScript
786 lines
19 KiB
JavaScript
var sync = (function () {
|
|
'use strict';
|
|
|
|
var promise_1 = promise;
|
|
|
|
function promise() {
|
|
var resolve
|
|
, reject
|
|
, p = new Promise(function(res, rej){
|
|
resolve = res, reject = rej;
|
|
});
|
|
|
|
arguments.length && resolve(arguments[0]);
|
|
p.resolve = resolve;
|
|
p.reject = reject;
|
|
return p
|
|
}
|
|
|
|
var flatten = function flatten(p,v){
|
|
if (v instanceof Array) { v = v.reduce(flatten, []); }
|
|
return (p = p || []), p.concat(v)
|
|
};
|
|
|
|
var has = function has(o, k) {
|
|
return k in o
|
|
};
|
|
|
|
var def = function def(o, p, v, w){
|
|
if (o.host && o.host.nodeName) { o = o.host; }
|
|
if (p.name) { v = p, p = p.name; }
|
|
!has(o, p) && Object.defineProperty(o, p, { value: v, writable: w });
|
|
return o[p]
|
|
};
|
|
|
|
var noop = function(){};
|
|
|
|
var emitterify = function emitterify(body, hooks) {
|
|
body = body || {};
|
|
hooks = hooks || {};
|
|
def(body, 'emit', emit, 1);
|
|
def(body, 'once', once, 1);
|
|
def(body, 'off', off, 1);
|
|
def(body, 'on', on, 1);
|
|
body.on['*'] = body.on['*'] || [];
|
|
return body
|
|
|
|
function emit(type, pm, filter) {
|
|
var li = body.on[type.split('.')[0]] || []
|
|
, results = [];
|
|
|
|
for (var i = 0; i < li.length; i++)
|
|
{ if (!li[i].ns || !filter || filter(li[i].ns))
|
|
{ results.push(call(li[i].isOnce ? li.splice(i--, 1)[0] : li[i], pm)); } }
|
|
|
|
for (var i = 0; i < body.on['*'].length; i++)
|
|
{ results.push(call(body.on['*'][i], [type, pm])); }
|
|
|
|
return results.reduce(flatten, [])
|
|
}
|
|
|
|
function call(cb, pm){
|
|
return cb.next ? cb.next(pm)
|
|
: pm instanceof Array ? cb.apply(body, pm)
|
|
: cb.call(body, pm)
|
|
}
|
|
|
|
function on(type, opts, isOnce) {
|
|
var id = type.split('.')[0]
|
|
, ns = type.split('.')[1]
|
|
, li = body.on[id] = body.on[id] || []
|
|
, cb = typeof opts == 'function' ? opts : 0;
|
|
|
|
return !cb && ns ? (cb = body.on[id]['$'+ns]) ? cb : push(observable(body, opts))
|
|
: !cb && !ns ? push(observable(body, opts))
|
|
: cb && ns ? push((remove(li, body.on[id]['$'+ns] || -1), cb))
|
|
: cb && !ns ? push(cb)
|
|
: false
|
|
|
|
function push(cb){
|
|
cb.isOnce = isOnce;
|
|
cb.type = id;
|
|
if (ns) { body.on[id]['$'+(cb.ns = ns)] = cb; }
|
|
li.push(cb)
|
|
;(hooks.on || noop)(cb);
|
|
return cb.next ? cb : body
|
|
}
|
|
}
|
|
|
|
function once(type, callback){
|
|
return body.on(type, callback, true)
|
|
}
|
|
|
|
function remove(li, cb) {
|
|
var i = li.length;
|
|
while (~--i)
|
|
{ if (cb == li[i] || cb == li[i].fn || !cb)
|
|
{ (hooks.off || noop)(li.splice(i, 1)[0]); } }
|
|
}
|
|
|
|
function off(type, cb) {
|
|
remove((body.on[type] || []), cb);
|
|
if (cb && cb.ns) { delete body.on[type]['$'+cb.ns]; }
|
|
return body
|
|
}
|
|
|
|
function observable(parent, opts) {
|
|
opts = opts || {};
|
|
var o = emitterify(opts.base || promise_1());
|
|
o.i = 0;
|
|
o.li = [];
|
|
o.fn = opts.fn;
|
|
o.parent = parent;
|
|
o.source = opts.fn ? o.parent.source : o;
|
|
|
|
o.on('stop', function(reason){
|
|
o.type
|
|
? o.parent.off(o.type, o)
|
|
: o.parent.off(o);
|
|
return o.reason = reason
|
|
});
|
|
|
|
o.each = function(fn) {
|
|
var n = fn.next ? fn : observable(o, { fn: fn });
|
|
o.li.push(n);
|
|
return n
|
|
};
|
|
|
|
o.pipe = function(fn) {
|
|
return fn(o)
|
|
};
|
|
|
|
o.map = function(fn){
|
|
return o.each(function(d, i, n){ return n.next(fn(d, i, n)) })
|
|
};
|
|
|
|
o.filter = function(fn){
|
|
return o.each(function(d, i, n){ return fn(d, i, n) && n.next(d) })
|
|
};
|
|
|
|
o.reduce = function(fn, acc) {
|
|
return o.each(function(d, i, n){ return n.next(acc = fn(acc, d, i, n)) })
|
|
};
|
|
|
|
o.unpromise = function(){
|
|
var n = observable(o, { base: {}, fn: function(d){ return n.next(d) } });
|
|
o.li.push(n);
|
|
return n
|
|
};
|
|
|
|
o.next = function(value) {
|
|
o.resolve && o.resolve(value);
|
|
return o.li.length
|
|
? o.li.map(function(n){ return n.fn(value, n.i++, n) })
|
|
: value
|
|
};
|
|
|
|
o.until = function(stop){
|
|
return !stop ? 0
|
|
: stop.each ? stop.each(o.stop) // TODO: check clean up on stop too
|
|
: stop.then ? stop.then(o.stop)
|
|
: stop.call ? o.filter(stop).map(o.stop)
|
|
: 0
|
|
};
|
|
|
|
o.off = function(fn){
|
|
return remove(o.li, fn), o
|
|
};
|
|
|
|
o.start = function(stop){
|
|
o.until(stop);
|
|
o.source.emit('start');
|
|
return o
|
|
};
|
|
|
|
o.stop = function(reason){
|
|
return o.source.emit('stop', reason)
|
|
};
|
|
|
|
o[Symbol.asyncIterator] = function(){
|
|
return {
|
|
next: function(){
|
|
return o.wait = new Promise(function(resolve){
|
|
o.wait = true;
|
|
o.map(function(d, i, n){
|
|
delete o.wait;
|
|
o.off(n);
|
|
resolve({ value: d, done: false });
|
|
});
|
|
o.emit('pull', o);
|
|
})
|
|
}
|
|
}
|
|
};
|
|
|
|
return o
|
|
}
|
|
};
|
|
|
|
var index = function(url){
|
|
if ( url === void 0 ) url = location.href.replace('http', 'ws');
|
|
|
|
var io = emitterify({ attempt: 0 });
|
|
io.ready = io.once('connected');
|
|
io.connect = connect(io, url);
|
|
io.connect();
|
|
io.send = function (data) { return io.ready.then(function (socket) { return socket.send(data); }); };
|
|
return io
|
|
};
|
|
|
|
var min$1 = Math.min;
|
|
var pow$1 = Math.pow;
|
|
|
|
var connect = function (io, url) { return function () {
|
|
var WebSocket = window.WebSocket;
|
|
var setTimeout = window.setTimeout;
|
|
var socket = new WebSocket(url);
|
|
socket.onopen = function (d) { return io.emit('connected', socket); };
|
|
socket.onmessage = function (d) { return io.emit('recv', d.data); };
|
|
socket.onclose = function (d) {
|
|
io.ready = io.once('connected');
|
|
io.emit('disconnected');
|
|
setTimeout(io.connect, backoff(++io.attempt));
|
|
};
|
|
}; };
|
|
|
|
var backoff = function (attempt, base, cap) {
|
|
if ( base === void 0 ) base = 100;
|
|
if ( cap === void 0 ) cap = 10000;
|
|
|
|
return min$1(cap, base * pow$1(2, attempt));
|
|
};
|
|
|
|
var is_1 = is;
|
|
is.fn = isFunction;
|
|
is.str = isString;
|
|
is.num = isNumber;
|
|
is.obj = isObject;
|
|
is.lit = isLiteral;
|
|
is.bol = isBoolean;
|
|
is.truthy = isTruthy;
|
|
is.falsy = isFalsy;
|
|
is.arr = isArray;
|
|
is.null = isNull;
|
|
is.def = isDef;
|
|
is.in = isIn;
|
|
is.promise = isPromise;
|
|
is.stream = isStream;
|
|
|
|
function is(v){
|
|
return function(d){
|
|
return d == v
|
|
}
|
|
}
|
|
|
|
function isFunction(d) {
|
|
return typeof d == 'function'
|
|
}
|
|
|
|
function isBoolean(d) {
|
|
return typeof d == 'boolean'
|
|
}
|
|
|
|
function isString(d) {
|
|
return typeof d == 'string'
|
|
}
|
|
|
|
function isNumber(d) {
|
|
return typeof d == 'number'
|
|
}
|
|
|
|
function isObject(d) {
|
|
return typeof d == 'object'
|
|
}
|
|
|
|
function isLiteral(d) {
|
|
return d.constructor == Object
|
|
}
|
|
|
|
function isTruthy(d) {
|
|
return !!d == true
|
|
}
|
|
|
|
function isFalsy(d) {
|
|
return !!d == false
|
|
}
|
|
|
|
function isArray(d) {
|
|
return d instanceof Array
|
|
}
|
|
|
|
function isNull(d) {
|
|
return d === null
|
|
}
|
|
|
|
function isDef(d) {
|
|
return typeof d !== 'undefined'
|
|
}
|
|
|
|
function isPromise(d) {
|
|
return d instanceof Promise
|
|
}
|
|
|
|
function isStream(d) {
|
|
return !!(d && d.next)
|
|
}
|
|
|
|
function isIn(set) {
|
|
return function(d){
|
|
return !set ? false
|
|
: set.indexOf ? ~set.indexOf(d)
|
|
: d in set
|
|
}
|
|
}
|
|
|
|
var keys = function keys(o) {
|
|
return Object.keys(is_1.obj(o) || is_1.fn(o) ? o : {})
|
|
};
|
|
|
|
var datum = function datum(node){
|
|
return node.__data__
|
|
};
|
|
|
|
var wrap = function wrap(d){
|
|
return function(){
|
|
return d
|
|
}
|
|
};
|
|
|
|
var str = function str(d){
|
|
return d === 0 ? '0'
|
|
: !d ? ''
|
|
: is_1.fn(d) ? '' + d
|
|
: is_1.obj(d) ? JSON.stringify(d)
|
|
: String(d)
|
|
};
|
|
|
|
var key = function key(k, v){
|
|
var set = arguments.length > 1
|
|
, keys$$1 = is_1.fn(k) ? [] : str(k).split('.').filter(Boolean)
|
|
, root = keys$$1.shift();
|
|
|
|
return function deep(o, i){
|
|
var masked = {};
|
|
|
|
return !o ? undefined
|
|
: !is_1.num(k) && !k ? (set ? replace(o, v) : o)
|
|
: is_1.arr(k) ? (k.map(copy), masked)
|
|
: o[k] || !keys$$1.length ? (set ? ((o[k] = is_1.fn(v) ? v(o[k], i) : v), o)
|
|
: (is_1.fn(k) ? k(o) : o[k]))
|
|
: (set ? (key(keys$$1.join('.'), v)(o[root] ? o[root] : (o[root] = {})), o)
|
|
: key(keys$$1.join('.'))(o[root]))
|
|
|
|
function copy(k){
|
|
var val = key(k)(o);
|
|
val = is_1.fn(v) ? v(val)
|
|
: val == undefined ? v
|
|
: val;
|
|
if (val != undefined)
|
|
{ key(k, is_1.fn(val) ? wrap(val) : val)(masked); }
|
|
}
|
|
|
|
function replace(o, v) {
|
|
keys(o).map(function(k){ delete o[k]; });
|
|
keys(v).map(function(k){ o[k] = v[k]; });
|
|
return o
|
|
}
|
|
}
|
|
};
|
|
|
|
var from_1 = from;
|
|
from.parent = fromParent;
|
|
|
|
function from(o){
|
|
return function(k){
|
|
return key(k)(o)
|
|
}
|
|
}
|
|
|
|
function fromParent(k){
|
|
return datum(this.parentNode)[k]
|
|
}
|
|
|
|
var values = function values(o) {
|
|
return !o ? [] : keys(o).map(from_1(o))
|
|
};
|
|
|
|
var client$2 = function(ref){
|
|
if ( ref === void 0 ) ref = {};
|
|
var socket = ref.socket; if ( socket === void 0 ) socket = index();
|
|
|
|
socket.id = 0;
|
|
|
|
var server = emitterify({
|
|
socket: socket
|
|
, send: send$1(socket)
|
|
, get subscriptions(){
|
|
return values(socket.on)
|
|
.map(function (d) { return d && d[0]; })
|
|
.filter(function (d) { return d && d.type && d.type[0] == '$'; })
|
|
}
|
|
});
|
|
|
|
socket
|
|
.once('disconnected')
|
|
.map(function (d) { return socket
|
|
.on('connected')
|
|
.map(reconnect(server)); }
|
|
);
|
|
|
|
socket
|
|
.on('recv')
|
|
.map(deserialise)
|
|
.each(function (ref) {
|
|
var id = ref.id;
|
|
var data = ref.data;
|
|
|
|
// TODO: check/warn if no sub
|
|
var sink = socket.on[("$" + id)] && socket.on[("$" + id)][0];
|
|
|
|
data.exec ? data.exec(sink, data.value)
|
|
: !id ? server.emit('recv', data)
|
|
: socket.emit(("$" + id), data);
|
|
});
|
|
|
|
return server
|
|
};
|
|
|
|
var deserialise = function (input) { return (new Function(("return " + input)))(); };
|
|
|
|
var reconnect = function (server) { return function () { return server.subscriptions
|
|
.map(function (ref) {
|
|
var subscription = ref.subscription;
|
|
|
|
return server.socket.send(subscription);
|
|
}); }; };
|
|
|
|
|
|
|
|
var send$1 = function (socket, type) { return function (data, meta) {
|
|
if (data instanceof window.Blob)
|
|
{ return binary(socket, data, meta) }
|
|
|
|
var id = str(++socket.id)
|
|
, output = socket.on(("$" + id))
|
|
, next = function (data, count) {
|
|
if ( count === void 0 ) count = 0;
|
|
|
|
return socket
|
|
.send(output.source.subscription = str({ id: id, data: data, type: type }))
|
|
.then(function (d) { return output.emit('sent', { id: id, count: count }); });
|
|
};
|
|
|
|
data.next
|
|
? data.map(next).source.emit('start')
|
|
: next(data);
|
|
|
|
output
|
|
.source
|
|
.once('stop')
|
|
.filter(function (reason) { return reason != 'CLOSED'; })
|
|
.map(function (d) { return send$1(socket, 'UNSUBSCRIBE')(id)
|
|
// TODO: also force stop on close of server created sub (?)
|
|
.filter(function (d, i, n) { return n.source.emit('stop', 'CLOSED'); }); }
|
|
);
|
|
|
|
return output
|
|
}; };
|
|
|
|
var binary = function (socket, blob, meta, start, blockSize) {
|
|
if ( start === void 0 ) start = 0;
|
|
if ( blockSize === void 0 ) blockSize = 1024;
|
|
|
|
var output = emitterify().on('recv')
|
|
, next = function (id) { return function () { return start >= blob.size
|
|
? output.emit('sent', { id: id })
|
|
: ( socket.send(blob.slice(start, start += blockSize))
|
|
, window.setTimeout(next(id))
|
|
); }; };
|
|
|
|
send$1(socket, 'BINARY')({ size: blob.size, meta: meta })
|
|
.on('sent', function (ref) {
|
|
var id = ref.id;
|
|
|
|
return next(id)();
|
|
})
|
|
.on('progress', function (received) { return output.emit('progress', { received: received, total: blob.size }); })
|
|
.map(output.next)
|
|
.source
|
|
.until(output.once('stop'));
|
|
|
|
return output
|
|
};
|
|
|
|
var to = {
|
|
arr: toArray
|
|
, obj: toObject
|
|
};
|
|
|
|
function toArray(d){
|
|
return Array.prototype.slice.call(d, 0)
|
|
}
|
|
|
|
function toObject(d) {
|
|
var by = 'id';
|
|
|
|
return arguments.length == 1
|
|
? (by = d, reduce)
|
|
: reduce.apply(this, arguments)
|
|
|
|
function reduce(p,v,i){
|
|
if (i === 0) { p = {}; }
|
|
p[is_1.fn(by) ? by(v, i) : v[by]] = v;
|
|
return p
|
|
}
|
|
}
|
|
|
|
var act = { add: add, update: update, remove: remove };
|
|
var str$3 = JSON.stringify;
|
|
var parse = JSON.parse;
|
|
|
|
var set = function set(d, skipEmit) {
|
|
return function(o, existing, max) {
|
|
if (!is_1.obj(o) && !is_1.fn(o))
|
|
{ return o }
|
|
|
|
if (!is_1.obj(d)) {
|
|
var log = existing || o.log || []
|
|
, root = o;
|
|
|
|
if (!is_1.def(max)) { max = log.max || 0; }
|
|
if (!max) { log = []; }
|
|
if (max < 0) { log = log.concat(null); }
|
|
if (max > 0) {
|
|
var s = str$3(o);
|
|
root = parse(s);
|
|
log = log.concat({ type: 'update', value: parse(s), time: log.length });
|
|
}
|
|
|
|
def(log, 'max', max);
|
|
|
|
root.log
|
|
? (root.log = log)
|
|
: def(emitterify(root, null), 'log', log, 1);
|
|
|
|
return root
|
|
}
|
|
|
|
if (is_1.def(d.key)) {
|
|
if (!apply(o, d.type, (d.key = '' + d.key).split('.').filter(Boolean), d.value))
|
|
{ return false }
|
|
} else
|
|
{ return false }
|
|
|
|
if (o.log && o.log.max)
|
|
{ o.log.push((d.time = o.log.length, o.log.max > 0 ? d : null)); }
|
|
|
|
if (!skipEmit && o.emit)
|
|
{ o.emit('change', d); }
|
|
|
|
return o
|
|
}
|
|
};
|
|
|
|
function apply(body, type, path, value) {
|
|
var next = path.shift();
|
|
|
|
if (!act[type])
|
|
{ return false }
|
|
if (path.length) {
|
|
if (!(next in body))
|
|
{ if (type == 'remove') { return true }
|
|
else { body[next] = {}; } }
|
|
return apply(body[next], type, path, value)
|
|
}
|
|
else {
|
|
return !act[type](body, next, value)
|
|
}
|
|
}
|
|
|
|
function add(o, k, v) {
|
|
is_1.arr(o)
|
|
? o.splice(k, 0, v)
|
|
: (o[k] = v);
|
|
}
|
|
|
|
function update(o, k, v) {
|
|
if (!is_1.num(k) && !k) {
|
|
if (!is_1.obj(v)) { return true }
|
|
for (var x in o) { delete o[x]; }
|
|
for (var x in v) { o[x] = v[x]; }
|
|
} else
|
|
{ o[k] = v; }
|
|
}
|
|
|
|
function remove(o, k, v) {
|
|
is_1.arr(o)
|
|
? o.splice(k, 1)
|
|
: delete o[k];
|
|
}
|
|
|
|
var time = function time(ms, fn) {
|
|
return arguments.length === 1
|
|
? setTimeout(ms)
|
|
: setTimeout(fn, ms)
|
|
};
|
|
|
|
var client = function sync(
|
|
ripple
|
|
, ref
|
|
, ref$1
|
|
){
|
|
if ( ref === void 0 ) ref = {};
|
|
if ( ref$1 === void 0 ) ref$1 = {};
|
|
var xrs = ref$1.xrs; if ( xrs === void 0 ) xrs = client$2;
|
|
|
|
ripple.server = xrs();
|
|
ripple.send = send(ripple);
|
|
ripple.subscribe = subscribe(ripple);
|
|
ripple.subscriptions = {};
|
|
ripple.get = get(ripple);
|
|
ripple.upload = upload(ripple);
|
|
ripple.upload.id = 0;
|
|
|
|
// TODO: other than cache pushes? ans: use server.type
|
|
ripple
|
|
.server
|
|
.on('recv')
|
|
.map(function (data, i, n) { return cache(ripple)(data, i, n); });
|
|
|
|
return ripple
|
|
};
|
|
|
|
var send = function (ref) {
|
|
var server = ref.server;
|
|
|
|
return function (name, type, value) { return name instanceof Blob ? server.send(name, type)
|
|
: is_1.obj(name) ? server.send(name)
|
|
: server.send({ name: name, type: type, value: value }); };
|
|
};
|
|
|
|
var get = function (ripple) { return function (name, k) { return ripple
|
|
.subscribe(name, k)
|
|
.filter(function (d, i, n) { return n.source.emit('stop'); })
|
|
.start(); }; };
|
|
|
|
var cache = function (ripple, n, k) { return function (change) {
|
|
if (name && change.name && name != change.name) { ripple.link(name, change.name); }
|
|
var name = change.name = change.name || n;
|
|
if (!change.type) { change.type = 'update'; }
|
|
if (is_1.def(k)) { change.key = k + "." + (str(change.key)); }
|
|
!change.key && change.type == 'update'
|
|
? ripple(body(change))
|
|
: set(change)(ripple.resources[name] ? ripple(name) : ripple(name, {}));
|
|
|
|
ripple.change = change;
|
|
|
|
return key(k)(ripple(name))
|
|
}; };
|
|
|
|
var subscribe = function (ripple) { return function (name, k) {
|
|
if (is_1.arr(name)) { return merge(name.map(function (n) { return ripple.subscribe(n, k); }))
|
|
.map(function (d) { return name.reduce(function (p, v, i) { return (p[v] = d[i], p); }, {}); }) }
|
|
|
|
ripple.subscriptions[name] = ripple.subscriptions[name] || {};
|
|
if (is_1.arr(k)) { return merge(k.map(function (k) { return ripple.subscribe(name, k); }))
|
|
.map(function (d) { return key(k)(ripple(name)); }) }
|
|
var output = emitterify().on('subscription');
|
|
|
|
output
|
|
.on('stop')
|
|
.each(function (d, i, n) {
|
|
raw.subs.splice(raw.subs.indexOf(output), 1);
|
|
time(1000, function () {
|
|
if (raw.subs.length) { return }
|
|
raw.source.emit('stop');
|
|
ripple.subscriptions[name][k] = undefined;
|
|
output.emit('end');
|
|
});
|
|
});
|
|
|
|
if (ripple.subscriptions[name][k])
|
|
{ output
|
|
.on('start')
|
|
.map(function () { return key(k)(ripple(name)); })
|
|
.filter(is_1.def)
|
|
.map(function (initial) { return output.next(initial); }); }
|
|
|
|
var raw = ripple.subscriptions[name][k] = ripple.subscriptions[name][k] || ripple
|
|
.send(name, 'SUBSCRIBE', k)
|
|
.map(cache(ripple, name, k))
|
|
.each(function (value) {
|
|
[].concat(raw.subs).map(function (o) { return o.next(value); });
|
|
delete ripple.change;
|
|
});
|
|
|
|
raw.subs = raw.subs || [];
|
|
raw.subs.push(output);
|
|
|
|
return output
|
|
}; };
|
|
|
|
var upload = function (ripple) { return function (name, form) {
|
|
var index = ++ripple.upload.id
|
|
, fields = {}
|
|
, size = 0
|
|
, next = function () {
|
|
if (!files.length) { return true }
|
|
var ref = files.shift();
|
|
var field = ref.field;
|
|
var filename = ref.filename;
|
|
var i = ref.i;
|
|
var blob = ref.blob;
|
|
return ripple
|
|
.send(blob, { filename: filename, field: field, i: i, index: index })
|
|
.on('progress', function (ref) {
|
|
var received = ref.received;
|
|
return output.emit('progress', {
|
|
total: size
|
|
, received:
|
|
size
|
|
- (blob.size - received)
|
|
- files.reduce(function (acc, d) { return (acc += d.blob.size); }, 0)
|
|
});
|
|
})
|
|
.then(next)
|
|
};
|
|
|
|
var files = keys(form)
|
|
.map(function (field) { return (fields[field] = form[field], field); })
|
|
.filter(function (field) { return form[field] instanceof FileList; })
|
|
.map(function (field) {
|
|
fields[field] = [];
|
|
return to.arr(form[field])
|
|
.map(function (f) { return (size += f.size, f); })
|
|
.map(function (f, i) { return ({ field: field, filename: f.name, i: i, blob: f, sent: 0 }); })
|
|
})
|
|
.reduce(flatten, []);
|
|
|
|
var output = ripple.send({
|
|
files: files.length
|
|
, type: 'PREUPLOAD'
|
|
, fields: fields
|
|
, index: index
|
|
, size: size
|
|
, name: name
|
|
}).once('sent', next);
|
|
|
|
return output
|
|
}; };
|
|
|
|
var body = function (ref) {
|
|
var name = ref.name;
|
|
var value = ref.value;
|
|
var headers = ref.headers;
|
|
|
|
return ({ name: name, headers: headers, body: value });
|
|
};
|
|
|
|
|
|
// TODO: factor out
|
|
var merge = function (streams) {
|
|
var output = emitterify().on('merged');
|
|
output.streams = streams;
|
|
|
|
streams.map(function (stream, i) { return stream.each(function (value) {
|
|
stream.latest = value;
|
|
var latest = streams.map(function (d) { return d.latest; });
|
|
if (latest.every(is_1.def)) { output.next(latest); }
|
|
}); }
|
|
);
|
|
|
|
output
|
|
.once('start')
|
|
.map(function (d) { return streams.map(function ($) { return $.source.emit('start'); }); });
|
|
|
|
output
|
|
.once('stop')
|
|
.map(function (d) { return streams.map(function ($) { return $.source.emit('stop'); }); });
|
|
|
|
return output
|
|
};
|
|
|
|
return client;
|
|
|
|
}());
|