b38dea0597
Share Gaia assets and adapters, keep private profiles and development documents local, and update both public READMEs.
3329 lines
99 KiB
JavaScript
3329 lines
99 KiB
JavaScript
/**
|
|
* alameda 0.2.0 Copyright (c) 2011-2014, The Dojo Foundation All Rights Reserved.
|
|
* Available via the MIT or new BSD license.
|
|
* see: http://github.com/requirejs/alameda for details
|
|
*/
|
|
//Going sloppy to avoid 'use strict' string cost, but strict practices should
|
|
//be followed.
|
|
/*jslint sloppy: true, nomen: true, regexp: true */
|
|
/*global setTimeout, process, document, navigator, importScripts,
|
|
setImmediate */
|
|
|
|
var requirejs, require, define;
|
|
(function (global, undef) {
|
|
var prim, topReq, dataMain, src, subPath,
|
|
bootstrapConfig = requirejs || require,
|
|
hasOwn = Object.prototype.hasOwnProperty,
|
|
contexts = {},
|
|
queue = [],
|
|
currDirRegExp = /^\.\//,
|
|
urlRegExp = /^\/|\:|\?|\.js$/,
|
|
commentRegExp = /(\/\*([\s\S]*?)\*\/|([^:]|^)\/\/(.*)$)/mg,
|
|
cjsRequireRegExp = /[^.]\s*require\s*\(\s*["']([^'"\s]+)["']\s*\)/g,
|
|
jsSuffixRegExp = /\.js$/;
|
|
|
|
if (typeof requirejs === 'function') {
|
|
return;
|
|
}
|
|
|
|
function hasProp(obj, prop) {
|
|
return hasOwn.call(obj, prop);
|
|
}
|
|
|
|
function getOwn(obj, prop) {
|
|
return obj && hasProp(obj, prop) && obj[prop];
|
|
}
|
|
|
|
/**
|
|
* Cycles over properties in an object and calls a function for each
|
|
* property value. If the function returns a truthy value, then the
|
|
* iteration is stopped.
|
|
*/
|
|
function eachProp(obj, func) {
|
|
var prop;
|
|
for (prop in obj) {
|
|
if (hasProp(obj, prop)) {
|
|
if (func(obj[prop], prop)) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Simple function to mix in properties from source into target,
|
|
* but only if target does not already have a property of the same name.
|
|
*/
|
|
function mixin(target, source, force, deepStringMixin) {
|
|
if (source) {
|
|
eachProp(source, function (value, prop) {
|
|
if (force || !hasProp(target, prop)) {
|
|
if (deepStringMixin && typeof value === 'object' && value &&
|
|
!Array.isArray(value) && typeof value !== 'function' &&
|
|
!(value instanceof RegExp)) {
|
|
|
|
if (!target[prop]) {
|
|
target[prop] = {};
|
|
}
|
|
mixin(target[prop], value, force, deepStringMixin);
|
|
} else {
|
|
target[prop] = value;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
return target;
|
|
}
|
|
|
|
//Allow getting a global that expressed in
|
|
//dot notation, like 'a.b.c'.
|
|
function getGlobal(value) {
|
|
if (!value) {
|
|
return value;
|
|
}
|
|
var g = global;
|
|
value.split('.').forEach(function (part) {
|
|
g = g[part];
|
|
});
|
|
return g;
|
|
}
|
|
|
|
//START prim 0.0.6
|
|
/**
|
|
* Changes from baseline prim
|
|
* - removed UMD registration
|
|
*/
|
|
(function () {
|
|
'use strict';
|
|
|
|
var waitingId, nextTick,
|
|
waiting = [];
|
|
|
|
function callWaiting() {
|
|
waitingId = 0;
|
|
var w = waiting;
|
|
waiting = [];
|
|
while (w.length) {
|
|
w.shift()();
|
|
}
|
|
}
|
|
|
|
function asyncTick(fn) {
|
|
waiting.push(fn);
|
|
if (!waitingId) {
|
|
waitingId = setTimeout(callWaiting, 0);
|
|
}
|
|
}
|
|
|
|
function syncTick(fn) {
|
|
fn();
|
|
}
|
|
|
|
function isFunObj(x) {
|
|
var type = typeof x;
|
|
return type === 'object' || type === 'function';
|
|
}
|
|
|
|
//Use setImmediate.bind() because attaching it (or setTimeout directly
|
|
//to prim will result in errors. Noticed first on IE10,
|
|
//issue requirejs/alameda#2)
|
|
nextTick = typeof setImmediate === 'function' ? setImmediate.bind() :
|
|
(typeof process !== 'undefined' && process.nextTick ?
|
|
process.nextTick : (typeof setTimeout !== 'undefined' ?
|
|
asyncTick : syncTick));
|
|
|
|
function notify(ary, value) {
|
|
prim.nextTick(function () {
|
|
ary.forEach(function (item) {
|
|
item(value);
|
|
});
|
|
});
|
|
}
|
|
|
|
function callback(p, ok, yes) {
|
|
if (p.hasOwnProperty('v')) {
|
|
prim.nextTick(function () {
|
|
yes(p.v);
|
|
});
|
|
} else {
|
|
ok.push(yes);
|
|
}
|
|
}
|
|
|
|
function errback(p, fail, no) {
|
|
if (p.hasOwnProperty('e')) {
|
|
prim.nextTick(function () {
|
|
no(p.e);
|
|
});
|
|
} else {
|
|
fail.push(no);
|
|
}
|
|
}
|
|
|
|
prim = function prim(fn) {
|
|
var promise, f,
|
|
p = {},
|
|
ok = [],
|
|
fail = [];
|
|
|
|
function makeFulfill() {
|
|
var f, f2,
|
|
called = false;
|
|
|
|
function fulfill(v, prop, listeners) {
|
|
if (called) {
|
|
return;
|
|
}
|
|
called = true;
|
|
|
|
if (promise === v) {
|
|
called = false;
|
|
f.reject(new TypeError('value is same promise'));
|
|
return;
|
|
}
|
|
|
|
try {
|
|
var then = v && v.then;
|
|
if (isFunObj(v) && typeof then === 'function') {
|
|
f2 = makeFulfill();
|
|
then.call(v, f2.resolve, f2.reject);
|
|
} else {
|
|
p[prop] = v;
|
|
notify(listeners, v);
|
|
}
|
|
} catch (e) {
|
|
called = false;
|
|
f.reject(e);
|
|
}
|
|
}
|
|
|
|
f = {
|
|
resolve: function (v) {
|
|
fulfill(v, 'v', ok);
|
|
},
|
|
reject: function(e) {
|
|
fulfill(e, 'e', fail);
|
|
}
|
|
};
|
|
return f;
|
|
}
|
|
|
|
f = makeFulfill();
|
|
|
|
promise = {
|
|
then: function (yes, no) {
|
|
var next = prim(function (nextResolve, nextReject) {
|
|
|
|
function finish(fn, nextFn, v) {
|
|
try {
|
|
if (fn && typeof fn === 'function') {
|
|
v = fn(v);
|
|
nextResolve(v);
|
|
} else {
|
|
nextFn(v);
|
|
}
|
|
} catch (e) {
|
|
nextReject(e);
|
|
}
|
|
}
|
|
|
|
callback(p, ok, finish.bind(undefined, yes, nextResolve));
|
|
errback(p, fail, finish.bind(undefined, no, nextReject));
|
|
|
|
});
|
|
return next;
|
|
},
|
|
|
|
catch: function (no) {
|
|
return promise.then(null, no);
|
|
}
|
|
};
|
|
|
|
try {
|
|
fn(f.resolve, f.reject);
|
|
} catch (e) {
|
|
f.reject(e);
|
|
}
|
|
|
|
return promise;
|
|
};
|
|
|
|
prim.resolve = function (value) {
|
|
return prim(function (yes) {
|
|
yes(value);
|
|
});
|
|
};
|
|
|
|
prim.reject = function (err) {
|
|
return prim(function (yes, no) {
|
|
no(err);
|
|
});
|
|
};
|
|
|
|
prim.cast = function (x) {
|
|
// A bit of a weak check, want "then" to be a function,
|
|
// but also do not want to trigger a getter if accessing
|
|
// it. Good enough for now.
|
|
if (isFunObj(x) && 'then' in x) {
|
|
return x;
|
|
} else {
|
|
return prim(function (yes, no) {
|
|
if (x instanceof Error) {
|
|
no(x);
|
|
} else {
|
|
yes(x);
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
prim.all = function (ary) {
|
|
return prim(function (yes, no) {
|
|
var count = 0,
|
|
length = ary.length,
|
|
result = [];
|
|
|
|
function resolved(i, v) {
|
|
result[i] = v;
|
|
count += 1;
|
|
if (count === length) {
|
|
yes(result);
|
|
}
|
|
}
|
|
|
|
ary.forEach(function (item, i) {
|
|
prim.cast(item).then(function (v) {
|
|
resolved(i, v);
|
|
}, function (err) {
|
|
no(err);
|
|
});
|
|
});
|
|
});
|
|
};
|
|
|
|
prim.nextTick = nextTick;
|
|
}());
|
|
//END prim
|
|
|
|
function newContext(contextName) {
|
|
var req, main, makeMap, callDep, handlers, checkingLater, load, context,
|
|
defined = {},
|
|
waiting = {},
|
|
config = {
|
|
//Defaults. Do not set a default for map
|
|
//config to speed up normalize(), which
|
|
//will run faster if there is no default.
|
|
waitSeconds: 7,
|
|
baseUrl: './',
|
|
paths: {},
|
|
bundles: {},
|
|
pkgs: {},
|
|
shim: {},
|
|
config: {}
|
|
},
|
|
mapCache = {},
|
|
requireDeferreds = [],
|
|
deferreds = {},
|
|
calledDefine = {},
|
|
calledPlugin = {},
|
|
loadCount = 0,
|
|
startTime = (new Date()).getTime(),
|
|
errCount = 0,
|
|
trackedErrors = {},
|
|
urlFetched = {},
|
|
bundlesMap = {};
|
|
|
|
/**
|
|
* Trims the . and .. from an array of path segments.
|
|
* It will keep a leading path segment if a .. will become
|
|
* the first path segment, to help with module name lookups,
|
|
* which act like paths, but can be remapped. But the end result,
|
|
* all paths that use this function should look normalized.
|
|
* NOTE: this method MODIFIES the input array.
|
|
* @param {Array} ary the array of path segments.
|
|
*/
|
|
function trimDots(ary) {
|
|
var i, part, length = ary.length;
|
|
for (i = 0; i < length; i++) {
|
|
part = ary[i];
|
|
if (part === '.') {
|
|
ary.splice(i, 1);
|
|
i -= 1;
|
|
} else if (part === '..') {
|
|
if (i === 1 && (ary[2] === '..' || ary[0] === '..')) {
|
|
//End of the line. Keep at least one non-dot
|
|
//path segment at the front so it can be mapped
|
|
//correctly to disk. Otherwise, there is likely
|
|
//no path mapping for a path starting with '..'.
|
|
//This can still fail, but catches the most reasonable
|
|
//uses of ..
|
|
break;
|
|
} else if (i > 0) {
|
|
ary.splice(i - 1, 2);
|
|
i -= 2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Given a relative module name, like ./something, normalize it to
|
|
* a real name that can be mapped to a path.
|
|
* @param {String} name the relative name
|
|
* @param {String} baseName a real name that the name arg is relative
|
|
* to.
|
|
* @param {Boolean} applyMap apply the map config to the value. Should
|
|
* only be done if this normalization is for a dependency ID.
|
|
* @returns {String} normalized name
|
|
*/
|
|
function normalize(name, baseName, applyMap) {
|
|
var pkgMain, mapValue, nameParts, i, j, nameSegment, lastIndex,
|
|
foundMap, foundI, foundStarMap, starI,
|
|
baseParts = baseName && baseName.split('/'),
|
|
normalizedBaseParts = baseParts,
|
|
map = config.map,
|
|
starMap = map && map['*'];
|
|
|
|
//Adjust any relative paths.
|
|
if (name && name.charAt(0) === '.') {
|
|
//If have a base name, try to normalize against it,
|
|
//otherwise, assume it is a top-level require that will
|
|
//be relative to baseUrl in the end.
|
|
if (baseName) {
|
|
//Convert baseName to array, and lop off the last part,
|
|
//so that . matches that 'directory' and not name of the baseName's
|
|
//module. For instance, baseName of 'one/two/three', maps to
|
|
//'one/two/three.js', but we want the directory, 'one/two' for
|
|
//this normalization.
|
|
normalizedBaseParts = baseParts.slice(0, baseParts.length - 1);
|
|
name = name.split('/');
|
|
lastIndex = name.length - 1;
|
|
|
|
// If wanting node ID compatibility, strip .js from end
|
|
// of IDs. Have to do this here, and not in nameToUrl
|
|
// because node allows either .js or non .js to map
|
|
// to same file.
|
|
if (config.nodeIdCompat && jsSuffixRegExp.test(name[lastIndex])) {
|
|
name[lastIndex] = name[lastIndex].replace(jsSuffixRegExp, '');
|
|
}
|
|
|
|
name = normalizedBaseParts.concat(name);
|
|
trimDots(name);
|
|
name = name.join('/');
|
|
} else if (name.indexOf('./') === 0) {
|
|
// No baseName, so this is ID is resolved relative
|
|
// to baseUrl, pull off the leading dot.
|
|
name = name.substring(2);
|
|
}
|
|
}
|
|
|
|
//Apply map config if available.
|
|
if (applyMap && map && (baseParts || starMap)) {
|
|
nameParts = name.split('/');
|
|
|
|
outerLoop: for (i = nameParts.length; i > 0; i -= 1) {
|
|
nameSegment = nameParts.slice(0, i).join('/');
|
|
|
|
if (baseParts) {
|
|
//Find the longest baseName segment match in the config.
|
|
//So, do joins on the biggest to smallest lengths of baseParts.
|
|
for (j = baseParts.length; j > 0; j -= 1) {
|
|
mapValue = getOwn(map, baseParts.slice(0, j).join('/'));
|
|
|
|
//baseName segment has config, find if it has one for
|
|
//this name.
|
|
if (mapValue) {
|
|
mapValue = getOwn(mapValue, nameSegment);
|
|
if (mapValue) {
|
|
//Match, update name to the new value.
|
|
foundMap = mapValue;
|
|
foundI = i;
|
|
break outerLoop;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//Check for a star map match, but just hold on to it,
|
|
//if there is a shorter segment match later in a matching
|
|
//config, then favor over this star map.
|
|
if (!foundStarMap && starMap && getOwn(starMap, nameSegment)) {
|
|
foundStarMap = getOwn(starMap, nameSegment);
|
|
starI = i;
|
|
}
|
|
}
|
|
|
|
if (!foundMap && foundStarMap) {
|
|
foundMap = foundStarMap;
|
|
foundI = starI;
|
|
}
|
|
|
|
if (foundMap) {
|
|
nameParts.splice(0, foundI, foundMap);
|
|
name = nameParts.join('/');
|
|
}
|
|
}
|
|
|
|
// If the name points to a package's name, use
|
|
// the package main instead.
|
|
pkgMain = getOwn(config.pkgs, name);
|
|
|
|
return pkgMain ? pkgMain : name;
|
|
}
|
|
|
|
function makeShimExports(value) {
|
|
function fn() {
|
|
var ret;
|
|
if (value.init) {
|
|
ret = value.init.apply(global, arguments);
|
|
}
|
|
return ret || (value.exports && getGlobal(value.exports));
|
|
}
|
|
return fn;
|
|
}
|
|
|
|
function takeQueue(anonId) {
|
|
var i, id, args, shim;
|
|
for (i = 0; i < queue.length; i += 1) {
|
|
//Peek to see if anon
|
|
if (typeof queue[i][0] !== 'string') {
|
|
if (anonId) {
|
|
queue[i].unshift(anonId);
|
|
anonId = undef;
|
|
} else {
|
|
//Not our anon module, stop.
|
|
break;
|
|
}
|
|
}
|
|
args = queue.shift();
|
|
id = args[0];
|
|
i -= 1;
|
|
|
|
if (!hasProp(defined, id) && !hasProp(waiting, id)) {
|
|
if (hasProp(deferreds, id)) {
|
|
main.apply(undef, args);
|
|
} else {
|
|
waiting[id] = args;
|
|
}
|
|
}
|
|
}
|
|
|
|
//if get to the end and still have anonId, then could be
|
|
//a shimmed dependency.
|
|
if (anonId) {
|
|
shim = getOwn(config.shim, anonId) || {};
|
|
main(anonId, shim.deps || [], shim.exportsFn);
|
|
}
|
|
}
|
|
|
|
function makeRequire(relName, topLevel) {
|
|
var req = function (deps, callback, errback, alt) {
|
|
var name, cfg;
|
|
|
|
if (topLevel) {
|
|
takeQueue();
|
|
}
|
|
|
|
if (typeof deps === "string") {
|
|
if (handlers[deps]) {
|
|
return handlers[deps](relName);
|
|
}
|
|
//Just return the module wanted. In this scenario, the
|
|
//deps arg is the module name, and second arg (if passed)
|
|
//is just the relName.
|
|
//Normalize module name, if it contains . or ..
|
|
name = makeMap(deps, relName, true).id;
|
|
if (!hasProp(defined, name)) {
|
|
throw new Error('Not loaded: ' + name);
|
|
}
|
|
return defined[name];
|
|
} else if (deps && !Array.isArray(deps)) {
|
|
//deps is a config object, not an array.
|
|
cfg = deps;
|
|
deps = undef;
|
|
|
|
if (Array.isArray(callback)) {
|
|
//callback is an array, which means it is a dependency list.
|
|
//Adjust args if there are dependencies
|
|
deps = callback;
|
|
callback = errback;
|
|
errback = alt;
|
|
}
|
|
|
|
if (topLevel) {
|
|
//Could be a new context, so call returned require
|
|
return req.config(cfg)(deps, callback, errback);
|
|
}
|
|
}
|
|
|
|
//Support require(['a'])
|
|
callback = callback || function () {};
|
|
|
|
//Simulate async callback;
|
|
prim.nextTick(function () {
|
|
//Grab any modules that were defined after a
|
|
//require call.
|
|
takeQueue();
|
|
main(undef, deps || [], callback, errback, relName);
|
|
});
|
|
|
|
return req;
|
|
};
|
|
|
|
req.isBrowser = typeof document !== 'undefined' &&
|
|
typeof navigator !== 'undefined';
|
|
|
|
req.nameToUrl = function (moduleName, ext, skipExt) {
|
|
var paths, syms, i, parentModule, url,
|
|
parentPath, bundleId,
|
|
pkgMain = getOwn(config.pkgs, moduleName);
|
|
|
|
if (pkgMain) {
|
|
moduleName = pkgMain;
|
|
}
|
|
|
|
bundleId = getOwn(bundlesMap, moduleName);
|
|
|
|
if (bundleId) {
|
|
return req.nameToUrl(bundleId, ext, skipExt);
|
|
}
|
|
|
|
//If a colon is in the URL, it indicates a protocol is used and it is just
|
|
//an URL to a file, or if it starts with a slash, contains a query arg (i.e. ?)
|
|
//or ends with .js, then assume the user meant to use an url and not a module id.
|
|
//The slash is important for protocol-less URLs as well as full paths.
|
|
if (urlRegExp.test(moduleName)) {
|
|
//Just a plain path, not module name lookup, so just return it.
|
|
//Add extension if it is included. This is a bit wonky, only non-.js things pass
|
|
//an extension, this method probably needs to be reworked.
|
|
url = moduleName + (ext || '');
|
|
} else {
|
|
//A module that needs to be converted to a path.
|
|
paths = config.paths;
|
|
|
|
syms = moduleName.split('/');
|
|
//For each module name segment, see if there is a path
|
|
//registered for it. Start with most specific name
|
|
//and work up from it.
|
|
for (i = syms.length; i > 0; i -= 1) {
|
|
parentModule = syms.slice(0, i).join('/');
|
|
|
|
parentPath = getOwn(paths, parentModule);
|
|
if (parentPath) {
|
|
//If an array, it means there are a few choices,
|
|
//Choose the one that is desired
|
|
if (Array.isArray(parentPath)) {
|
|
parentPath = parentPath[0];
|
|
}
|
|
syms.splice(0, i, parentPath);
|
|
break;
|
|
}
|
|
}
|
|
|
|
//Join the path parts together, then figure out if baseUrl is needed.
|
|
url = syms.join('/');
|
|
url += (ext || (/^data\:|\?/.test(url) || skipExt ? '' : '.js'));
|
|
url = (url.charAt(0) === '/' || url.match(/^[\w\+\.\-]+:/) ? '' : config.baseUrl) + url;
|
|
}
|
|
|
|
return config.urlArgs ? url +
|
|
((url.indexOf('?') === -1 ? '?' : '&') +
|
|
config.urlArgs) : url;
|
|
};
|
|
|
|
/**
|
|
* Converts a module name + .extension into an URL path.
|
|
* *Requires* the use of a module name. It does not support using
|
|
* plain URLs like nameToUrl.
|
|
*/
|
|
req.toUrl = function (moduleNamePlusExt) {
|
|
var ext,
|
|
index = moduleNamePlusExt.lastIndexOf('.'),
|
|
segment = moduleNamePlusExt.split('/')[0],
|
|
isRelative = segment === '.' || segment === '..';
|
|
|
|
//Have a file extension alias, and it is not the
|
|
//dots from a relative path.
|
|
if (index !== -1 && (!isRelative || index > 1)) {
|
|
ext = moduleNamePlusExt.substring(index, moduleNamePlusExt.length);
|
|
moduleNamePlusExt = moduleNamePlusExt.substring(0, index);
|
|
}
|
|
|
|
return req.nameToUrl(normalize(moduleNamePlusExt, relName), ext, true);
|
|
};
|
|
|
|
req.defined = function (id) {
|
|
return hasProp(defined, makeMap(id, relName, true).id);
|
|
};
|
|
|
|
req.specified = function (id) {
|
|
id = makeMap(id, relName, true).id;
|
|
return hasProp(defined, id) || hasProp(deferreds, id);
|
|
};
|
|
|
|
return req;
|
|
}
|
|
|
|
function resolve(name, d, value) {
|
|
if (name) {
|
|
defined[name] = value;
|
|
if (requirejs.onResourceLoad) {
|
|
requirejs.onResourceLoad(context, d.map, d.deps);
|
|
}
|
|
}
|
|
d.finished = true;
|
|
d.resolve(value);
|
|
}
|
|
|
|
function reject(d, err) {
|
|
d.finished = true;
|
|
d.rejected = true;
|
|
d.reject(err);
|
|
}
|
|
|
|
function makeNormalize(relName) {
|
|
return function (name) {
|
|
return normalize(name, relName, true);
|
|
};
|
|
}
|
|
|
|
function defineModule(d) {
|
|
var name = d.map.id,
|
|
ret = d.factory.apply(defined[name], d.values);
|
|
|
|
if (name) {
|
|
// Favor return value over exports. If node/cjs in play,
|
|
// then will not have a return value anyway. Favor
|
|
// module.exports assignment over exports object.
|
|
if (ret === undef) {
|
|
if (d.cjsModule) {
|
|
ret = d.cjsModule.exports;
|
|
} else if (d.usingExports) {
|
|
ret = defined[name];
|
|
}
|
|
}
|
|
} else {
|
|
//Remove the require deferred from the list to
|
|
//make cycle searching faster. Do not need to track
|
|
//it anymore either.
|
|
requireDeferreds.splice(requireDeferreds.indexOf(d), 1);
|
|
}
|
|
resolve(name, d, ret);
|
|
}
|
|
|
|
//This method is attached to every module deferred,
|
|
//so the "this" in here is the module deferred object.
|
|
function depFinished(val, i) {
|
|
if (!this.rejected && !this.depDefined[i]) {
|
|
this.depDefined[i] = true;
|
|
this.depCount += 1;
|
|
this.values[i] = val;
|
|
if (!this.depending && this.depCount === this.depMax) {
|
|
defineModule(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
function makeDefer(name) {
|
|
var d = {};
|
|
d.promise = prim(function (resolve, reject) {
|
|
d.resolve = resolve;
|
|
d.reject = reject;
|
|
});
|
|
d.map = name ? makeMap(name, null, true) : {};
|
|
d.depCount = 0;
|
|
d.depMax = 0;
|
|
d.values = [];
|
|
d.depDefined = [];
|
|
d.depFinished = depFinished;
|
|
if (d.map.pr) {
|
|
//Plugin resource ID, implicitly
|
|
//depends on plugin. Track it in deps
|
|
//so cycle breaking can work
|
|
d.deps = [makeMap(d.map.pr)];
|
|
}
|
|
return d;
|
|
}
|
|
|
|
function getDefer(name) {
|
|
var d;
|
|
if (name) {
|
|
d = hasProp(deferreds, name) && deferreds[name];
|
|
if (!d) {
|
|
d = deferreds[name] = makeDefer(name);
|
|
}
|
|
} else {
|
|
d = makeDefer();
|
|
requireDeferreds.push(d);
|
|
}
|
|
return d;
|
|
}
|
|
|
|
function makeErrback(d, name) {
|
|
return function (err) {
|
|
if (!d.rejected) {
|
|
if (!err.dynaId) {
|
|
err.dynaId = 'id' + (errCount += 1);
|
|
err.requireModules = [name];
|
|
}
|
|
reject(d, err);
|
|
}
|
|
};
|
|
}
|
|
|
|
function waitForDep(depMap, relName, d, i) {
|
|
d.depMax += 1;
|
|
|
|
//Do the fail at the end to catch errors
|
|
//in the then callback execution.
|
|
callDep(depMap, relName).then(function (val) {
|
|
d.depFinished(val, i);
|
|
}, makeErrback(d, depMap.id)).catch(makeErrback(d, d.map.id));
|
|
}
|
|
|
|
function makeLoad(id) {
|
|
var fromTextCalled;
|
|
function load(value) {
|
|
//Protect against older plugins that call load after
|
|
//calling load.fromText
|
|
if (!fromTextCalled) {
|
|
resolve(id, getDefer(id), value);
|
|
}
|
|
}
|
|
|
|
load.error = function (err) {
|
|
getDefer(id).reject(err);
|
|
};
|
|
|
|
load.fromText = function (text, textAlt) {
|
|
/*jslint evil: true */
|
|
var d = getDefer(id),
|
|
map = makeMap(makeMap(id).n),
|
|
plainId = map.id;
|
|
|
|
fromTextCalled = true;
|
|
|
|
//Set up the factory just to be a return of the value from
|
|
//plainId.
|
|
d.factory = function (p, val) {
|
|
return val;
|
|
};
|
|
|
|
//As of requirejs 2.1.0, support just passing the text, to reinforce
|
|
//fromText only being called once per resource. Still
|
|
//support old style of passing moduleName but discard
|
|
//that moduleName in favor of the internal ref.
|
|
if (textAlt) {
|
|
text = textAlt;
|
|
}
|
|
|
|
//Transfer any config to this other module.
|
|
if (hasProp(config.config, id)) {
|
|
config.config[plainId] = config.config[id];
|
|
}
|
|
|
|
try {
|
|
req.exec(text);
|
|
} catch (e) {
|
|
reject(d, new Error('fromText eval for ' + plainId +
|
|
' failed: ' + e));
|
|
}
|
|
|
|
//Execute any waiting define created by the plainId
|
|
takeQueue(plainId);
|
|
|
|
//Mark this as a dependency for the plugin
|
|
//resource
|
|
d.deps = [map];
|
|
waitForDep(map, null, d, d.deps.length);
|
|
};
|
|
|
|
return load;
|
|
}
|
|
|
|
load = typeof importScripts === 'function' ?
|
|
function (map) {
|
|
var url = map.url;
|
|
if (urlFetched[url]) {
|
|
return;
|
|
}
|
|
urlFetched[url] = true;
|
|
|
|
//Ask for the deferred so loading is triggered.
|
|
//Do this before loading, since loading is sync.
|
|
getDefer(map.id);
|
|
importScripts(url);
|
|
takeQueue(map.id);
|
|
} :
|
|
function (map) {
|
|
var script,
|
|
id = map.id,
|
|
url = map.url;
|
|
|
|
if (urlFetched[url]) {
|
|
return;
|
|
}
|
|
urlFetched[url] = true;
|
|
|
|
script = document.createElement('script');
|
|
script.setAttribute('data-requiremodule', id);
|
|
script.type = config.scriptType || 'text/javascript';
|
|
script.charset = 'utf-8';
|
|
script.async = true;
|
|
|
|
loadCount += 1;
|
|
|
|
script.addEventListener('load', function () {
|
|
loadCount -= 1;
|
|
takeQueue(id);
|
|
}, false);
|
|
script.addEventListener('error', function () {
|
|
loadCount -= 1;
|
|
var err,
|
|
pathConfig = getOwn(config.paths, id),
|
|
d = getOwn(deferreds, id);
|
|
if (pathConfig && Array.isArray(pathConfig) && pathConfig.length > 1) {
|
|
script.parentNode.removeChild(script);
|
|
//Pop off the first array value, since it failed, and
|
|
//retry
|
|
pathConfig.shift();
|
|
d.map = makeMap(id);
|
|
load(d.map);
|
|
} else {
|
|
err = new Error('Load failed: ' + id + ': ' + script.src);
|
|
err.requireModules = [id];
|
|
getDefer(id).reject(err);
|
|
}
|
|
}, false);
|
|
|
|
script.src = url;
|
|
|
|
document.head.appendChild(script);
|
|
};
|
|
|
|
function callPlugin(plugin, map, relName) {
|
|
plugin.load(map.n, makeRequire(relName), makeLoad(map.id), {});
|
|
}
|
|
|
|
callDep = function (map, relName) {
|
|
var args, bundleId,
|
|
name = map.id,
|
|
shim = config.shim[name];
|
|
|
|
if (hasProp(waiting, name)) {
|
|
args = waiting[name];
|
|
delete waiting[name];
|
|
main.apply(undef, args);
|
|
} else if (!hasProp(deferreds, name)) {
|
|
if (map.pr) {
|
|
//If a bundles config, then just load that file instead to
|
|
//resolve the plugin, as it is built into that bundle.
|
|
if ((bundleId = getOwn(bundlesMap, name))) {
|
|
map.url = req.nameToUrl(bundleId);
|
|
load(map);
|
|
} else {
|
|
return callDep(makeMap(map.pr)).then(function (plugin) {
|
|
//Redo map now that plugin is known to be loaded
|
|
var newMap = makeMap(name, relName, true),
|
|
newId = newMap.id,
|
|
shim = getOwn(config.shim, newId);
|
|
|
|
//Make sure to only call load once per resource. Many
|
|
//calls could have been queued waiting for plugin to load.
|
|
if (!hasProp(calledPlugin, newId)) {
|
|
calledPlugin[newId] = true;
|
|
if (shim && shim.deps) {
|
|
req(shim.deps, function () {
|
|
callPlugin(plugin, newMap, relName);
|
|
});
|
|
} else {
|
|
callPlugin(plugin, newMap, relName);
|
|
}
|
|
}
|
|
return getDefer(newId).promise;
|
|
});
|
|
}
|
|
} else if (shim && shim.deps) {
|
|
req(shim.deps, function () {
|
|
load(map);
|
|
});
|
|
} else {
|
|
load(map);
|
|
}
|
|
}
|
|
|
|
return getDefer(name).promise;
|
|
};
|
|
|
|
//Turns a plugin!resource to [plugin, resource]
|
|
//with the plugin being undefined if the name
|
|
//did not have a plugin prefix.
|
|
function splitPrefix(name) {
|
|
var prefix,
|
|
index = name ? name.indexOf('!') : -1;
|
|
if (index > -1) {
|
|
prefix = name.substring(0, index);
|
|
name = name.substring(index + 1, name.length);
|
|
}
|
|
return [prefix, name];
|
|
}
|
|
|
|
/**
|
|
* Makes a name map, normalizing the name, and using a plugin
|
|
* for normalization if necessary. Grabs a ref to plugin
|
|
* too, as an optimization.
|
|
*/
|
|
makeMap = function (name, relName, applyMap) {
|
|
if (typeof name !== 'string') {
|
|
return name;
|
|
}
|
|
|
|
var plugin, url, parts, prefix, result,
|
|
cacheKey = name + ' & ' + (relName || '') + ' & ' + !!applyMap;
|
|
|
|
parts = splitPrefix(name);
|
|
prefix = parts[0];
|
|
name = parts[1];
|
|
|
|
if (!prefix && hasProp(mapCache, cacheKey)) {
|
|
return mapCache[cacheKey];
|
|
}
|
|
|
|
if (prefix) {
|
|
prefix = normalize(prefix, relName, applyMap);
|
|
plugin = hasProp(defined, prefix) && defined[prefix];
|
|
}
|
|
|
|
//Normalize according
|
|
if (prefix) {
|
|
if (plugin && plugin.normalize) {
|
|
name = plugin.normalize(name, makeNormalize(relName));
|
|
} else {
|
|
name = normalize(name, relName, applyMap);
|
|
}
|
|
} else {
|
|
name = normalize(name, relName, applyMap);
|
|
parts = splitPrefix(name);
|
|
prefix = parts[0];
|
|
name = parts[1];
|
|
|
|
url = req.nameToUrl(name);
|
|
}
|
|
|
|
//Using ridiculous property names for space reasons
|
|
result = {
|
|
id: prefix ? prefix + '!' + name : name, //fullName
|
|
n: name,
|
|
pr: prefix,
|
|
url: url
|
|
};
|
|
|
|
if (!prefix) {
|
|
mapCache[cacheKey] = result;
|
|
}
|
|
|
|
return result;
|
|
};
|
|
|
|
handlers = {
|
|
require: function (name) {
|
|
return makeRequire(name);
|
|
},
|
|
exports: function (name) {
|
|
var e = defined[name];
|
|
if (typeof e !== 'undefined') {
|
|
return e;
|
|
} else {
|
|
return (defined[name] = {});
|
|
}
|
|
},
|
|
module: function (name) {
|
|
return {
|
|
id: name,
|
|
uri: '',
|
|
exports: handlers.exports(name),
|
|
config: function () {
|
|
return getOwn(config.config, name) || {};
|
|
}
|
|
};
|
|
}
|
|
};
|
|
|
|
function breakCycle(d, traced, processed) {
|
|
var id = d.map.id;
|
|
|
|
traced[id] = true;
|
|
if (!d.finished && d.deps) {
|
|
d.deps.forEach(function (depMap) {
|
|
var depId = depMap.id,
|
|
dep = !hasProp(handlers, depId) && getDefer(depId);
|
|
|
|
//Only force things that have not completed
|
|
//being defined, so still in the registry,
|
|
//and only if it has not been matched up
|
|
//in the module already.
|
|
if (dep && !dep.finished && !processed[depId]) {
|
|
if (hasProp(traced, depId)) {
|
|
d.deps.forEach(function (depMap, i) {
|
|
if (depMap.id === depId) {
|
|
d.depFinished(defined[depId], i);
|
|
}
|
|
});
|
|
} else {
|
|
breakCycle(dep, traced, processed);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
processed[id] = true;
|
|
}
|
|
|
|
function check(d) {
|
|
var err,
|
|
notFinished = [],
|
|
waitInterval = config.waitSeconds * 1000,
|
|
//It is possible to disable the wait interval by using waitSeconds of 0.
|
|
expired = waitInterval && (startTime + waitInterval) < (new Date()).getTime();
|
|
|
|
if (loadCount === 0) {
|
|
//If passed in a deferred, it is for a specific require call.
|
|
//Could be a sync case that needs resolution right away.
|
|
//Otherwise, if no deferred, means a nextTick and all
|
|
//waiting require deferreds should be checked.
|
|
if (d) {
|
|
if (!d.finished) {
|
|
breakCycle(d, {}, {});
|
|
}
|
|
} else if (requireDeferreds.length) {
|
|
requireDeferreds.forEach(function (d) {
|
|
breakCycle(d, {}, {});
|
|
});
|
|
}
|
|
}
|
|
|
|
//If still waiting on loads, and the waiting load is something
|
|
//other than a plugin resource, or there are still outstanding
|
|
//scripts, then just try back later.
|
|
if (expired) {
|
|
//If wait time expired, throw error of unloaded modules.
|
|
eachProp(deferreds, function (d) {
|
|
if (!d.finished) {
|
|
notFinished.push(d.map.id);
|
|
}
|
|
});
|
|
err = new Error('Timeout for modules: ' + notFinished);
|
|
err.requireModules = notFinished;
|
|
req.onError(err);
|
|
} else if (loadCount || requireDeferreds.length) {
|
|
//Something is still waiting to load. Wait for it, but only
|
|
//if a later check is not already scheduled.
|
|
if (!checkingLater) {
|
|
checkingLater = true;
|
|
prim.nextTick(function () {
|
|
checkingLater = false;
|
|
check();
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
//Used to break out of the promise try/catch chains.
|
|
function delayedError(e) {
|
|
prim.nextTick(function () {
|
|
if (!e.dynaId || !trackedErrors[e.dynaId]) {
|
|
trackedErrors[e.dynaId] = true;
|
|
req.onError(e);
|
|
}
|
|
});
|
|
}
|
|
|
|
main = function (name, deps, factory, errback, relName) {
|
|
//Only allow main calling once per module.
|
|
if (name && hasProp(calledDefine, name)) {
|
|
return;
|
|
}
|
|
calledDefine[name] = true;
|
|
|
|
var d = getDefer(name);
|
|
|
|
//This module may not have dependencies
|
|
if (deps && !Array.isArray(deps)) {
|
|
//deps is not an array, so probably means
|
|
//an object literal or factory function for
|
|
//the value. Adjust args.
|
|
factory = deps;
|
|
deps = [];
|
|
}
|
|
|
|
d.promise.catch(errback || delayedError);
|
|
|
|
//Use name if no relName
|
|
relName = relName || name;
|
|
|
|
//Call the factory to define the module, if necessary.
|
|
if (typeof factory === 'function') {
|
|
|
|
if (!deps.length && factory.length) {
|
|
//Remove comments from the callback string,
|
|
//look for require calls, and pull them into the dependencies,
|
|
//but only if there are function args.
|
|
factory
|
|
.toString()
|
|
.replace(commentRegExp, '')
|
|
.replace(cjsRequireRegExp, function (match, dep) {
|
|
deps.push(dep);
|
|
});
|
|
|
|
//May be a CommonJS thing even without require calls, but still
|
|
//could use exports, and module. Avoid doing exports and module
|
|
//work though if it just needs require.
|
|
//REQUIRES the function to expect the CommonJS variables in the
|
|
//order listed below.
|
|
deps = (factory.length === 1 ?
|
|
['require'] :
|
|
['require', 'exports', 'module']).concat(deps);
|
|
}
|
|
|
|
//Save info for use later.
|
|
d.factory = factory;
|
|
d.deps = deps;
|
|
|
|
d.depending = true;
|
|
deps.forEach(function (depName, i) {
|
|
var depMap;
|
|
deps[i] = depMap = makeMap(depName, relName, true);
|
|
depName = depMap.id;
|
|
|
|
//Fast path CommonJS standard dependencies.
|
|
if (depName === "require") {
|
|
d.values[i] = handlers.require(name);
|
|
} else if (depName === "exports") {
|
|
//CommonJS module spec 1.1
|
|
d.values[i] = handlers.exports(name);
|
|
d.usingExports = true;
|
|
} else if (depName === "module") {
|
|
//CommonJS module spec 1.1
|
|
d.values[i] = d.cjsModule = handlers.module(name);
|
|
} else if (depName === undefined) {
|
|
d.values[i] = undefined;
|
|
} else {
|
|
waitForDep(depMap, relName, d, i);
|
|
}
|
|
});
|
|
d.depending = false;
|
|
|
|
//Some modules just depend on the require, exports, modules, so
|
|
//trigger their definition here if so.
|
|
if (d.depCount === d.depMax) {
|
|
defineModule(d);
|
|
}
|
|
} else if (name) {
|
|
//May just be an object definition for the module. Only
|
|
//worry about defining if have a module name.
|
|
resolve(name, d, factory);
|
|
}
|
|
|
|
startTime = (new Date()).getTime();
|
|
|
|
if (!name) {
|
|
check(d);
|
|
}
|
|
};
|
|
|
|
req = makeRequire(null, true);
|
|
|
|
/*
|
|
* Just drops the config on the floor, but returns req in case
|
|
* the config return value is used.
|
|
*/
|
|
req.config = function (cfg) {
|
|
if (cfg.context && cfg.context !== contextName) {
|
|
return newContext(cfg.context).config(cfg);
|
|
}
|
|
|
|
//Since config changed, mapCache may not be valid any more.
|
|
mapCache = {};
|
|
|
|
//Make sure the baseUrl ends in a slash.
|
|
if (cfg.baseUrl) {
|
|
if (cfg.baseUrl.charAt(cfg.baseUrl.length - 1) !== '/') {
|
|
cfg.baseUrl += '/';
|
|
}
|
|
}
|
|
|
|
//Save off the paths and packages since they require special processing,
|
|
//they are additive.
|
|
var primId,
|
|
shim = config.shim,
|
|
objs = {
|
|
paths: true,
|
|
bundles: true,
|
|
config: true,
|
|
map: true
|
|
};
|
|
|
|
eachProp(cfg, function (value, prop) {
|
|
if (objs[prop]) {
|
|
if (!config[prop]) {
|
|
config[prop] = {};
|
|
}
|
|
mixin(config[prop], value, true, true);
|
|
} else {
|
|
config[prop] = value;
|
|
}
|
|
});
|
|
|
|
//Reverse map the bundles
|
|
if (cfg.bundles) {
|
|
eachProp(cfg.bundles, function (value, prop) {
|
|
value.forEach(function (v) {
|
|
if (v !== prop) {
|
|
bundlesMap[v] = prop;
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
//Merge shim
|
|
if (cfg.shim) {
|
|
eachProp(cfg.shim, function (value, id) {
|
|
//Normalize the structure
|
|
if (Array.isArray(value)) {
|
|
value = {
|
|
deps: value
|
|
};
|
|
}
|
|
if ((value.exports || value.init) && !value.exportsFn) {
|
|
value.exportsFn = makeShimExports(value);
|
|
}
|
|
shim[id] = value;
|
|
});
|
|
config.shim = shim;
|
|
}
|
|
|
|
//Adjust packages if necessary.
|
|
if (cfg.packages) {
|
|
cfg.packages.forEach(function (pkgObj) {
|
|
var location, name;
|
|
|
|
pkgObj = typeof pkgObj === 'string' ? { name: pkgObj } : pkgObj;
|
|
|
|
name = pkgObj.name;
|
|
location = pkgObj.location;
|
|
if (location) {
|
|
config.paths[name] = pkgObj.location;
|
|
}
|
|
|
|
//Save pointer to main module ID for pkg name.
|
|
//Remove leading dot in main, so main paths are normalized,
|
|
//and remove any trailing .js, since different package
|
|
//envs have different conventions: some use a module name,
|
|
//some use a file name.
|
|
config.pkgs[name] = pkgObj.name + '/' + (pkgObj.main || 'main')
|
|
.replace(currDirRegExp, '')
|
|
.replace(jsSuffixRegExp, '');
|
|
});
|
|
}
|
|
|
|
//If want prim injected, inject it now.
|
|
primId = config.definePrim;
|
|
if (primId) {
|
|
waiting[primId] = [primId, [], function () { return prim; }];
|
|
}
|
|
|
|
//If a deps array or a config callback is specified, then call
|
|
//require with those args. This is useful when require is defined as a
|
|
//config object before require.js is loaded.
|
|
if (cfg.deps || cfg.callback) {
|
|
req(cfg.deps, cfg.callback);
|
|
}
|
|
|
|
return req;
|
|
};
|
|
|
|
req.onError = function (err) {
|
|
throw err;
|
|
};
|
|
|
|
context = {
|
|
id: contextName,
|
|
defined: defined,
|
|
waiting: waiting,
|
|
config: config,
|
|
deferreds: deferreds
|
|
};
|
|
|
|
contexts[contextName] = context;
|
|
|
|
return req;
|
|
}
|
|
|
|
requirejs = topReq = newContext('_');
|
|
|
|
if (typeof require !== 'function') {
|
|
require = topReq;
|
|
}
|
|
|
|
/**
|
|
* Executes the text. Normally just uses eval, but can be modified
|
|
* to use a better, environment-specific call. Only used for transpiling
|
|
* loader plugins, not for plain JS modules.
|
|
* @param {String} text the text to execute/evaluate.
|
|
*/
|
|
topReq.exec = function (text) {
|
|
/*jslint evil: true */
|
|
return eval(text);
|
|
};
|
|
|
|
topReq.contexts = contexts;
|
|
|
|
define = function () {
|
|
queue.push([].slice.call(arguments, 0));
|
|
};
|
|
|
|
define.amd = {
|
|
jQuery: true
|
|
};
|
|
|
|
if (bootstrapConfig) {
|
|
topReq.config(bootstrapConfig);
|
|
}
|
|
|
|
//data-main support.
|
|
if (topReq.isBrowser && !contexts._.config.skipDataMain) {
|
|
dataMain = document.querySelectorAll('script[data-main]')[0];
|
|
dataMain = dataMain && dataMain.getAttribute('data-main');
|
|
if (dataMain) {
|
|
//Strip off any trailing .js since dataMain is now
|
|
//like a module name.
|
|
dataMain = dataMain.replace(jsSuffixRegExp, '');
|
|
|
|
if (!bootstrapConfig || !bootstrapConfig.baseUrl) {
|
|
//Pull off the directory of data-main for use as the
|
|
//baseUrl.
|
|
src = dataMain.split('/');
|
|
dataMain = src.pop();
|
|
subPath = src.length ? src.join('/') + '/' : './';
|
|
|
|
topReq.config({baseUrl: subPath});
|
|
}
|
|
|
|
topReq([dataMain]);
|
|
}
|
|
}
|
|
}(this));
|
|
|
|
define("ext/alameda", function(){});
|
|
|
|
// this code is from test-agent might use native dom events
|
|
// or something else in the future to replace this.
|
|
define('common/responder',['require','exports','module'],function(require, exports, module) {
|
|
'use strict';
|
|
|
|
/**
|
|
* @param {Object} list of events to add onto responder.
|
|
*/
|
|
function Responder(events) {
|
|
this._$events = Object.create(null);
|
|
|
|
// Buffer for emitWhenListener that hangs onto events dispatched for topics
|
|
// no one is currently listening for. Inspired by email's function
|
|
// of the same name.
|
|
this.buffer = {};
|
|
|
|
if (typeof(events) !== 'undefined') {
|
|
this.addEventListener(events);
|
|
}
|
|
}
|
|
module.exports = Responder;
|
|
|
|
/**
|
|
* Stringifies request to websocket
|
|
*
|
|
*
|
|
* @param {String} command command name.
|
|
* @param {Object} data object to be sent over the wire.
|
|
* @return {String} json object.
|
|
*/
|
|
Responder.stringify = function stringify(command, data) {
|
|
return JSON.stringify([command, data]);
|
|
};
|
|
|
|
/**
|
|
* Parses request from WebSocket.
|
|
*
|
|
* @param {String} json json string to translate.
|
|
* @return {Object} ex: { event: 'test', data: {} }.
|
|
*/
|
|
Responder.parse = function parse(json) {
|
|
var data;
|
|
try {
|
|
data = (json.forEach) ? json : JSON.parse(json);
|
|
} catch (e) {
|
|
throw new Error('Could not parse json: "' + json + '"');
|
|
}
|
|
|
|
return data;
|
|
};
|
|
|
|
Responder.prototype = {
|
|
parse: Responder.parse,
|
|
stringify: Responder.stringify,
|
|
|
|
/**
|
|
* Events on this instance
|
|
*
|
|
* @type Object
|
|
*/
|
|
events: null,
|
|
|
|
/**
|
|
* Recieves json string event and dispatches an event.
|
|
*
|
|
* @param {String|Object} json data object to respond to.
|
|
* @param {String} json.event event to emit.
|
|
* @param {Object} json.data data to emit with event.
|
|
* @param {Object} [params] option number of params to pass to emit.
|
|
* @return {Object} result of WebSocketCommon.parse.
|
|
*/
|
|
respond: function respond(json) {
|
|
var event = Responder.parse(json);
|
|
var args = Array.prototype.slice.call(arguments).slice(1);
|
|
this.emit.apply(this, event.concat(args));
|
|
return event;
|
|
},
|
|
|
|
/**
|
|
* Adds an event listener to this object.
|
|
*
|
|
* @param {String} type event name.
|
|
* @param {Function} callback event callback.
|
|
*/
|
|
addEventListener: function addEventListener(type, callback) {
|
|
var event;
|
|
|
|
if (typeof(callback) === 'undefined' && typeof(type) === 'object') {
|
|
for (event in type) {
|
|
if (type.hasOwnProperty(event)) {
|
|
this.addEventListener(event, type[event]);
|
|
}
|
|
}
|
|
|
|
return this;
|
|
}
|
|
|
|
if (!(type in this._$events)) {
|
|
this._$events[type] = [];
|
|
}
|
|
|
|
this._$events[type].push(callback);
|
|
return this.flushTopicBuffer(type);
|
|
},
|
|
|
|
/**
|
|
* Adds an event listener which will
|
|
* only fire once and then remove itself.
|
|
*
|
|
*
|
|
* @param {String} type event name.
|
|
* @param {Function} callback fired when event is emitted.
|
|
*/
|
|
once: function once(type, callback) {
|
|
var self = this;
|
|
function onceCb() {
|
|
/*jshint validthis:true */
|
|
self.removeEventListener(type, onceCb);
|
|
callback.apply(this, arguments);
|
|
}
|
|
|
|
this.addEventListener(type, onceCb);
|
|
return this.flushTopicBuffer(type);
|
|
},
|
|
|
|
flushTopicBuffer: function flushTopicBuffer(topic) {
|
|
if (!(topic in this.buffer)) {
|
|
// Nothing to flush.
|
|
return this;
|
|
}
|
|
|
|
this.buffer[topic].forEach(args => {
|
|
args.unshift(topic);
|
|
this.emit.apply(this, args);
|
|
});
|
|
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* Emits an event.
|
|
*
|
|
* Accepts any number of additional arguments to pass unto
|
|
* event listener.
|
|
*
|
|
* @param {String} eventName name of the event to emit.
|
|
* @param {Object} [arguments] additional arguments to pass.
|
|
*/
|
|
emit: function emit() {
|
|
var args = Array.prototype.slice.call(arguments),
|
|
event = args.shift(),
|
|
eventList,
|
|
self = this;
|
|
|
|
if (event in this._$events) {
|
|
eventList = this._$events[event];
|
|
|
|
eventList.forEach(function(callback) {
|
|
if (typeof(callback) === 'object' && callback.handleEvent) {
|
|
callback.handleEvent({ type: event, data: args });
|
|
} else {
|
|
callback.apply(self, args);
|
|
}
|
|
});
|
|
}
|
|
|
|
return this;
|
|
},
|
|
|
|
emitWhenListener: function emitWhenListener() {
|
|
var args = Array.prototype.slice.call(arguments);
|
|
var event = args.shift();
|
|
|
|
if (event in this._$events && this._$events[event].length) {
|
|
// Someone is already listening for this event, so this is just
|
|
// a regular old emit.
|
|
return this.emit.apply(this, arguments);
|
|
}
|
|
|
|
if (!(event in this.buffer)) {
|
|
this.buffer[event] = [];
|
|
}
|
|
|
|
// Now just push the call info onto the topic buffer.
|
|
this.buffer[event].push(args);
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* Removes all event listeners for a given event type
|
|
*
|
|
*
|
|
* @param {String} event event type to remove.
|
|
*/
|
|
removeAllEventListeners: function removeAllEventListeners(name) {
|
|
if (name in this._$events) {
|
|
//reuse array
|
|
this._$events[name].length = 0;
|
|
}
|
|
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* Removes a single event listener from a given event type
|
|
* and callback function.
|
|
*
|
|
*
|
|
* @param {String} eventName event name.
|
|
* @param {Function} callback same instance of event handler.
|
|
*/
|
|
removeEventListener: function removeEventListener(name, callback) {
|
|
var i, length, events;
|
|
|
|
if (!(name in this._$events)) {
|
|
return false;
|
|
}
|
|
|
|
events = this._$events[name];
|
|
|
|
for (i = 0, length = events.length; i < length; i++) {
|
|
if (events[i] && events[i] === callback) {
|
|
events.splice(i, 1);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
};
|
|
|
|
Responder.prototype.on = Responder.prototype.addEventListener;
|
|
Responder.prototype.off = Responder.prototype.removeEventListener;
|
|
|
|
});
|
|
|
|
define('common/debug',['require','exports','module'],function(require, exports, module) {
|
|
'use strict';
|
|
|
|
module.exports = function(name) {
|
|
return function() {
|
|
var args = Array.prototype.slice.call(arguments).map(JSON.stringify);
|
|
args.unshift('[calendar] ');
|
|
args.unshift(name);
|
|
console.log.apply(console, args);
|
|
};
|
|
};
|
|
|
|
});
|
|
|
|
define('worker/thread',['require','exports','module','common/responder','common/debug'],function(require, exports, module) {
|
|
'use strict';
|
|
|
|
var Responder = require('common/responder');
|
|
var debug = require('common/debug')('worker/thread');
|
|
|
|
function Thread(worker) {
|
|
Responder.call(this);
|
|
this.worker = worker;
|
|
this.roles = {};
|
|
|
|
this._initEvents();
|
|
}
|
|
module.exports = Thread;
|
|
|
|
Thread.prototype = {
|
|
__proto__: Responder.prototype,
|
|
|
|
send: function() {
|
|
this.worker.postMessage(Array.prototype.slice.call(arguments));
|
|
},
|
|
|
|
addRole: function(name) {
|
|
this.roles[name] = new Responder();
|
|
},
|
|
|
|
_remoteEmitter: function(id) {
|
|
var self = this;
|
|
return {
|
|
emit: function emitRemote() {
|
|
var args = Array.prototype.slice.call(arguments);
|
|
self.worker.postMessage([id + ' stream'].concat(args));
|
|
}
|
|
};
|
|
},
|
|
|
|
_initEvents: function() {
|
|
var self = this;
|
|
|
|
debug('Will listen for messages from the main thread...');
|
|
this.on('_dispatch', function(data) {
|
|
// data.id
|
|
// data.type
|
|
// data.role
|
|
// data.payload
|
|
var callback = self._requestCallback.bind(
|
|
self, data.id
|
|
);
|
|
|
|
if (data.role) {
|
|
if (data.role in self.roles) {
|
|
if (data.type && data.type === 'stream') {
|
|
self.roles[data.role].respond(
|
|
data.payload,
|
|
self._remoteEmitter(data.id),
|
|
callback
|
|
);
|
|
} else {
|
|
self.roles[data.role].respond(
|
|
data.payload, callback
|
|
);
|
|
}
|
|
} else {
|
|
// TODO: respond with error
|
|
debug('ERROR: ' + data.role + ' is not available.');
|
|
}
|
|
} else {
|
|
self.respond(data.payload, callback);
|
|
}
|
|
});
|
|
},
|
|
|
|
_wrapError: function(err) {
|
|
var errorObject = {};
|
|
|
|
errorObject.stack = err.stack || '';
|
|
errorObject.message = err.message || err.toString();
|
|
errorObject.type = err.type || 'Error';
|
|
errorObject.constructorName = err.constructor.name || 'Error';
|
|
|
|
if (err.name) {
|
|
errorObject.name = err.name;
|
|
}
|
|
|
|
if (err.code) {
|
|
errorObject.code = err.code;
|
|
}
|
|
|
|
return errorObject;
|
|
},
|
|
|
|
_requestCallback: function(id) {
|
|
var args = Array.prototype.slice.call(arguments, 1);
|
|
args.unshift(id + ' end');
|
|
|
|
if (args[1] instanceof Error) {
|
|
args[1] = this._wrapError(args[1]);
|
|
}
|
|
|
|
this.worker.postMessage(args);
|
|
},
|
|
|
|
console: function console(name) {
|
|
return {
|
|
log: function() {
|
|
return postMessage(['log', {
|
|
name: name,
|
|
message: Array.prototype.slice.call(arguments).join(', ')
|
|
}]);
|
|
},
|
|
error: function() {
|
|
return postMessage(['error', {
|
|
name: name,
|
|
message: Array.prototype.slice.call(arguments).join(', ')
|
|
}]);
|
|
}
|
|
};
|
|
}
|
|
};
|
|
|
|
});
|
|
|
|
/**
|
|
* The way that the current caldav library works,
|
|
* we need to preconfigure some global state :/.
|
|
*/
|
|
define('worker/initialize',['require','exports','module','./thread','common/debug'],function(require, exports, module) {
|
|
'use strict';
|
|
|
|
var Thread = require('./thread');
|
|
var debug = require('common/debug')('worker/initialize');
|
|
|
|
self.window = self;
|
|
|
|
module.exports = function() {
|
|
var thread = self.thread = new Thread(window);
|
|
thread.addRole('caldav');
|
|
window.console = new thread.console('worker');
|
|
require(['service/caldav'], (CaldavService) => {
|
|
// Lazily loaded so that we can prime environment first.
|
|
debug('Will create new caldav service...');
|
|
self.caldav = new CaldavService(thread.roles.caldav);
|
|
});
|
|
};
|
|
|
|
});
|
|
|
|
|
|
|
|
require.config({
|
|
baseUrl: '/js',
|
|
waitSeconds: 60,
|
|
paths: {
|
|
shared: '/shared/js'
|
|
},
|
|
shim: {
|
|
'ext/caldav': {
|
|
deps: ['worker/initialize'],
|
|
exports: 'Caldav'
|
|
},
|
|
'ext/ical': {
|
|
deps: ['worker/initialize'],
|
|
exports: 'ICAL'
|
|
}
|
|
}
|
|
});
|
|
|
|
self.addEventListener('message', function onMessage(msg) {
|
|
if (typeof(caldav) !== 'undefined') {
|
|
return self.thread.respond(msg.data);
|
|
}
|
|
|
|
// Try again in a little bit since the worker may not be ready...
|
|
setTimeout(function() {
|
|
onMessage(msg);
|
|
}, 10);
|
|
});
|
|
|
|
require(['worker/initialize'], initialize => initialize());
|
|
|
|
define("caldav_worker", function(){});
|
|
|
|
define('service/ical_recur_expansion',['require','exports','module','ext/ical'],function(require, exports, module) {
|
|
'use strict';
|
|
|
|
var ICAL = require('ext/ical');
|
|
|
|
module.exports = {
|
|
/**
|
|
* Maximum iterations must be > 0 && < Infinity.
|
|
* Lower values are probably better as we can show progress
|
|
* for multiple events rather then complete one long recurring
|
|
* event after another...
|
|
*/
|
|
forEachLimit: 200,
|
|
|
|
_isDone: function(last, sent, max) {
|
|
if (last && max && last.compare(max) >= 0) {
|
|
return true;
|
|
} else if (sent < this.forEachLimit) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
},
|
|
|
|
/**
|
|
* Iterates through a recur expansion instance.
|
|
* Gracefully handles existing iterators (including failures).
|
|
* Will fallback to complete re-expansion when necessary.
|
|
*
|
|
* NOTE: This method intentionally does not accept the "forEach"
|
|
* function as the final argument to indicate it does not follow
|
|
* the NodeJS example...
|
|
*
|
|
* minDate is always exclusive
|
|
* maxDate is not strict and may include one occurrence beyond.
|
|
*
|
|
* @param {ICAL.Event} event complete event.
|
|
* @param {Null|Object} iterator or nothing.
|
|
* @param {Function} forEach receives [nextDate].
|
|
* @param {ICAL.Time|Null} minDate minimum time (defaults to start).
|
|
* @param {ICAL.Time|Null} maxDate maximum date (defaults to none).
|
|
* @return {ICAL.RecurExpansion} iterator.
|
|
*/
|
|
forEach: function(event, iterator, each, min, max) {
|
|
// if there is no iterator create one...
|
|
if (!iterator) {
|
|
return this._beginIteration(event, each, min, max);
|
|
}
|
|
|
|
var iter;
|
|
|
|
try {
|
|
iter = this._resumeIteration(event, iterator, each, min, max);
|
|
} catch (e) {
|
|
console.error('Iteration Error: ' + e.toString());
|
|
iter = this._beginIteration(event, each, min, max);
|
|
}
|
|
|
|
return iter;
|
|
},
|
|
|
|
_resumeIteration: function(event, iterator, each, min, max) {
|
|
if (!(iterator instanceof ICAL.RecurExpansion)) {
|
|
iterator = new ICAL.RecurExpansion(iterator);
|
|
}
|
|
|
|
this._iterate(event, iterator, each, min, max);
|
|
return iterator;
|
|
},
|
|
|
|
_beginIteration: function(event, each, min, max) {
|
|
var iterator = event.iterator();
|
|
this._iterate(event, iterator, each, min, max);
|
|
|
|
return iterator;
|
|
},
|
|
|
|
_iterate: function(event, iterator, each, min, max) {
|
|
// keep track of the iterations
|
|
var sent = 0;
|
|
var current;
|
|
|
|
do {
|
|
current = iterator.next();
|
|
|
|
if (!current) {
|
|
break;
|
|
}
|
|
|
|
if (!min || current.compare(min) > 0) {
|
|
// sent should be inside the loop to guard against
|
|
// the possibility that the resume functionality breaking.
|
|
sent++;
|
|
each(current);
|
|
}
|
|
|
|
} while (!this._isDone(current, sent, max));
|
|
}
|
|
};
|
|
|
|
});
|
|
|
|
define('common/presets',{
|
|
"google": {
|
|
"providerType": "Caldav",
|
|
"group": "remote",
|
|
"authenticationType": "oauth2",
|
|
"apiCredentials": {
|
|
"tokenUrl": "https://accounts.google.com/o/oauth2/token",
|
|
"authorizationUrl": "https://accounts.google.com/o/oauth2/auth",
|
|
"user_info": {
|
|
"url": "https://www.googleapis.com/oauth2/v3/userinfo",
|
|
"field": "email"
|
|
},
|
|
"client_secret": "jQTKlOhF-RclGaGJot3HIcVf",
|
|
"client_id": "605300196874-1ki833poa7uqabmh3hq6u1onlqlsi54h.apps.googleusercontent.com",
|
|
"scope": "https://www.googleapis.com/auth/calendar https://www.googleapis.com/auth/userinfo.email",
|
|
"redirect_uri": "https://oauth.gaiamobile.org/authenticated"
|
|
},
|
|
"options": {
|
|
"domain": "https://apidata.googleusercontent.com",
|
|
"entrypoint": "/caldav/v2/",
|
|
"providerType": "Caldav"
|
|
}
|
|
},
|
|
"yahoo": {
|
|
"providerType": "Caldav",
|
|
"group": "remote",
|
|
"options": {
|
|
"domain": "https://caldav.calendar.yahoo.com",
|
|
"entrypoint": "/",
|
|
"providerType": "Caldav",
|
|
"user": "@yahoo.com",
|
|
"usernameType": "email"
|
|
}
|
|
},
|
|
"caldav": {
|
|
"providerType": "Caldav",
|
|
"group": "remote",
|
|
"options": {
|
|
"domain": "",
|
|
"entrypoint": "",
|
|
"providerType": "Caldav"
|
|
}
|
|
},
|
|
"local": {
|
|
"singleUse": true,
|
|
"providerType": "Local",
|
|
"group": "local",
|
|
"options": {
|
|
"providerType": "Local"
|
|
}
|
|
}
|
|
});
|
|
define('common/extend',['require','exports','module'],function(require, exports, module) {
|
|
'use strict';
|
|
|
|
module.exports = function(target, input) {
|
|
for (var key in input) {
|
|
if (hasOwnProperty.call(input, key)) {
|
|
target[key] = input[key];
|
|
}
|
|
}
|
|
|
|
return target;
|
|
};
|
|
|
|
});
|
|
|
|
// uuid.js
|
|
//
|
|
// Copyright (c) 2010-2012 Robert Kieffer
|
|
// MIT License - http://opensource.org/licenses/mit-license.php
|
|
|
|
(function() {
|
|
var _global = this;
|
|
|
|
// Unique ID creation requires a high quality random # generator. We feature
|
|
// detect to determine the best RNG source, normalizing to a function that
|
|
// returns 128-bits of randomness, since that's what's usually required
|
|
var _rng;
|
|
|
|
// Node.js crypto-based RNG - http://nodejs.org/docs/v0.6.2/api/crypto.html
|
|
//
|
|
// Moderately fast, high quality
|
|
if (typeof(_global.require) == 'function' && typeof(module) != 'undefined' && module.exports) {
|
|
try {
|
|
var _rb = _global.require('crypto').randomBytes;
|
|
_rng = _rb && function() {return _rb(16);};
|
|
} catch(e) {}
|
|
}
|
|
|
|
if (!_rng && _global.crypto && crypto.getRandomValues) {
|
|
// WHATWG crypto-based RNG - http://wiki.whatwg.org/wiki/Crypto
|
|
//
|
|
// Moderately fast, high quality
|
|
var _rnds8 = new Uint8Array(16);
|
|
_rng = function whatwgRNG() {
|
|
crypto.getRandomValues(_rnds8);
|
|
return _rnds8;
|
|
};
|
|
}
|
|
|
|
if (!_rng) {
|
|
// Math.random()-based (RNG)
|
|
//
|
|
// If all else fails, use Math.random(). It's fast, but is of unspecified
|
|
// quality.
|
|
var _rnds = new Array(16);
|
|
_rng = function() {
|
|
for (var i = 0, r; i < 16; i++) {
|
|
if ((i & 0x03) === 0) r = Math.random() * 0x100000000;
|
|
_rnds[i] = r >>> ((i & 0x03) << 3) & 0xff;
|
|
}
|
|
|
|
return _rnds;
|
|
};
|
|
}
|
|
|
|
// Buffer class to use
|
|
var BufferClass = typeof(_global.Buffer) == 'function' ? _global.Buffer : Array;
|
|
|
|
// Maps for number <-> hex string conversion
|
|
var _byteToHex = [];
|
|
var _hexToByte = {};
|
|
for (var i = 0; i < 256; i++) {
|
|
_byteToHex[i] = (i + 0x100).toString(16).substr(1);
|
|
_hexToByte[_byteToHex[i]] = i;
|
|
}
|
|
|
|
// **`parse()` - Parse a UUID into it's component bytes**
|
|
function parse(s, buf, offset) {
|
|
var i = (buf && offset) || 0, ii = 0;
|
|
|
|
buf = buf || [];
|
|
s.toLowerCase().replace(/[0-9a-f]{2}/g, function(oct) {
|
|
if (ii < 16) { // Don't overflow!
|
|
buf[i + ii++] = _hexToByte[oct];
|
|
}
|
|
});
|
|
|
|
// Zero out remaining bytes if string was short
|
|
while (ii < 16) {
|
|
buf[i + ii++] = 0;
|
|
}
|
|
|
|
return buf;
|
|
}
|
|
|
|
// **`unparse()` - Convert UUID byte array (ala parse()) into a string**
|
|
function unparse(buf, offset) {
|
|
var i = offset || 0, bth = _byteToHex;
|
|
return bth[buf[i++]] + bth[buf[i++]] +
|
|
bth[buf[i++]] + bth[buf[i++]] + '-' +
|
|
bth[buf[i++]] + bth[buf[i++]] + '-' +
|
|
bth[buf[i++]] + bth[buf[i++]] + '-' +
|
|
bth[buf[i++]] + bth[buf[i++]] + '-' +
|
|
bth[buf[i++]] + bth[buf[i++]] +
|
|
bth[buf[i++]] + bth[buf[i++]] +
|
|
bth[buf[i++]] + bth[buf[i++]];
|
|
}
|
|
|
|
// **`v1()` - Generate time-based UUID**
|
|
//
|
|
// Inspired by https://github.com/LiosK/UUID.js
|
|
// and http://docs.python.org/library/uuid.html
|
|
|
|
// random #'s we need to init node and clockseq
|
|
var _seedBytes = _rng();
|
|
|
|
// Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1)
|
|
var _nodeId = [
|
|
_seedBytes[0] | 0x01,
|
|
_seedBytes[1], _seedBytes[2], _seedBytes[3], _seedBytes[4], _seedBytes[5]
|
|
];
|
|
|
|
// Per 4.2.2, randomize (14 bit) clockseq
|
|
var _clockseq = (_seedBytes[6] << 8 | _seedBytes[7]) & 0x3fff;
|
|
|
|
// Previous uuid creation time
|
|
var _lastMSecs = 0, _lastNSecs = 0;
|
|
|
|
// See https://github.com/broofa/node-uuid for API details
|
|
function v1(options, buf, offset) {
|
|
var i = buf && offset || 0;
|
|
var b = buf || [];
|
|
|
|
options = options || {};
|
|
|
|
var clockseq = options.clockseq != null ? options.clockseq : _clockseq;
|
|
|
|
// UUID timestamps are 100 nano-second units since the Gregorian epoch,
|
|
// (1582-10-15 00:00). JSNumbers aren't precise enough for this, so
|
|
// time is handled internally as 'msecs' (integer milliseconds) and 'nsecs'
|
|
// (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00.
|
|
var msecs = options.msecs != null ? options.msecs : new Date().getTime();
|
|
|
|
// Per 4.2.1.2, use count of uuid's generated during the current clock
|
|
// cycle to simulate higher resolution clock
|
|
var nsecs = options.nsecs != null ? options.nsecs : _lastNSecs + 1;
|
|
|
|
// Time since last uuid creation (in msecs)
|
|
var dt = (msecs - _lastMSecs) + (nsecs - _lastNSecs)/10000;
|
|
|
|
// Per 4.2.1.2, Bump clockseq on clock regression
|
|
if (dt < 0 && options.clockseq == null) {
|
|
clockseq = clockseq + 1 & 0x3fff;
|
|
}
|
|
|
|
// Reset nsecs if clock regresses (new clockseq) or we've moved onto a new
|
|
// time interval
|
|
if ((dt < 0 || msecs > _lastMSecs) && options.nsecs == null) {
|
|
nsecs = 0;
|
|
}
|
|
|
|
// Per 4.2.1.2 Throw error if too many uuids are requested
|
|
if (nsecs >= 10000) {
|
|
throw new Error('uuid.v1(): Can\'t create more than 10M uuids/sec');
|
|
}
|
|
|
|
_lastMSecs = msecs;
|
|
_lastNSecs = nsecs;
|
|
_clockseq = clockseq;
|
|
|
|
// Per 4.1.4 - Convert from unix epoch to Gregorian epoch
|
|
msecs += 12219292800000;
|
|
|
|
// `time_low`
|
|
var tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;
|
|
b[i++] = tl >>> 24 & 0xff;
|
|
b[i++] = tl >>> 16 & 0xff;
|
|
b[i++] = tl >>> 8 & 0xff;
|
|
b[i++] = tl & 0xff;
|
|
|
|
// `time_mid`
|
|
var tmh = (msecs / 0x100000000 * 10000) & 0xfffffff;
|
|
b[i++] = tmh >>> 8 & 0xff;
|
|
b[i++] = tmh & 0xff;
|
|
|
|
// `time_high_and_version`
|
|
b[i++] = tmh >>> 24 & 0xf | 0x10; // include version
|
|
b[i++] = tmh >>> 16 & 0xff;
|
|
|
|
// `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant)
|
|
b[i++] = clockseq >>> 8 | 0x80;
|
|
|
|
// `clock_seq_low`
|
|
b[i++] = clockseq & 0xff;
|
|
|
|
// `node`
|
|
var node = options.node || _nodeId;
|
|
for (var n = 0; n < 6; n++) {
|
|
b[i + n] = node[n];
|
|
}
|
|
|
|
return buf ? buf : unparse(b);
|
|
}
|
|
|
|
// **`v4()` - Generate random UUID**
|
|
|
|
// See https://github.com/broofa/node-uuid for API details
|
|
function v4(options, buf, offset) {
|
|
// Deprecated - 'format' argument, as supported in v1.2
|
|
var i = buf && offset || 0;
|
|
|
|
if (typeof(options) == 'string') {
|
|
buf = options == 'binary' ? new BufferClass(16) : null;
|
|
options = null;
|
|
}
|
|
options = options || {};
|
|
|
|
var rnds = options.random || (options.rng || _rng)();
|
|
|
|
// Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
|
|
rnds[6] = (rnds[6] & 0x0f) | 0x40;
|
|
rnds[8] = (rnds[8] & 0x3f) | 0x80;
|
|
|
|
// Copy bytes to buffer, if provided
|
|
if (buf) {
|
|
for (var ii = 0; ii < 16; ii++) {
|
|
buf[i + ii] = rnds[ii];
|
|
}
|
|
}
|
|
|
|
return buf || unparse(rnds);
|
|
}
|
|
|
|
// Export public API
|
|
var uuid = v4;
|
|
uuid.v1 = v1;
|
|
uuid.v4 = v4;
|
|
uuid.parse = parse;
|
|
uuid.unparse = unparse;
|
|
uuid.BufferClass = BufferClass;
|
|
|
|
if (typeof define === 'function' && define.amd) {
|
|
// Publish as AMD module
|
|
define('ext/uuid',[],function() {return uuid;});
|
|
} else if (typeof(module) != 'undefined' && module.exports) {
|
|
// Publish as node.js module
|
|
module.exports = uuid;
|
|
} else {
|
|
// Publish as global (in browsers)
|
|
var _previousRoot = _global.uuid;
|
|
|
|
// **`noConflict()` - (browser only) to reset global 'uuid' var**
|
|
uuid.noConflict = function() {
|
|
_global.uuid = _previousRoot;
|
|
return uuid;
|
|
};
|
|
|
|
_global.uuid = uuid;
|
|
}
|
|
}).call(this);
|
|
|
|
define('service/caldav',['require','exports','module','ext/caldav','ext/ical','./ical_recur_expansion','common/presets','common/responder','common/debug','common/extend','ext/uuid'],function(require, exports, module) {
|
|
'use strict';
|
|
|
|
var Caldav = require('ext/caldav');
|
|
var ICAL = require('ext/ical');
|
|
var IcalRecurExpansion = require('./ical_recur_expansion');
|
|
var Presets = require('common/presets');
|
|
var Responder = require('common/responder');
|
|
var debug = require('common/debug')('service/caldav');
|
|
var extend = require('common/extend');
|
|
var uuid = require('ext/uuid');
|
|
|
|
/* TODO: ugly hack to enable system XHR fix upstream in Caldav lib */
|
|
var xhrOpts = {
|
|
/** system is required for cross domain XHR */
|
|
mozSystem: true,
|
|
/** mozAnon is required to avoid system level popups on 401 status */
|
|
mozAnon: true,
|
|
/** enables use of mozilla only streaming api's when available */
|
|
useMozChunkedText: true
|
|
};
|
|
|
|
Caldav.Xhr.prototype.globalXhrOptions = xhrOpts;
|
|
|
|
function Service(service) {
|
|
Responder.call(this);
|
|
|
|
this.service = service;
|
|
this._initEvents();
|
|
}
|
|
module.exports = Service;
|
|
|
|
Service.prototype = {
|
|
__proto__: Responder.prototype,
|
|
|
|
/**
|
|
* See: http://tools.ietf.org/html/rfc5545#section-3.7.3
|
|
*/
|
|
icalProductId: '-//Mozilla//FirefoxOS',
|
|
|
|
/**
|
|
* See: http://tools.ietf.org/html/rfc5545#section-3.7.4
|
|
*/
|
|
icalVersion: '2.0',
|
|
|
|
_initEvents: function() {
|
|
var events = [
|
|
'noop',
|
|
'getAccount',
|
|
'findCalendars',
|
|
'getCalendar',
|
|
'streamEvents',
|
|
'expandComponents',
|
|
'expandRecurringEvent',
|
|
'deleteEvent',
|
|
'updateEvent',
|
|
'createEvent'
|
|
];
|
|
|
|
debug('Will listen for worker events...');
|
|
events.forEach(function(e) {
|
|
this.service.on(e, this);
|
|
}, this);
|
|
},
|
|
|
|
handleEvent: function(e) {
|
|
debug('Worker will fulfill', e.type, 'request...');
|
|
this[e.type].apply(this, e.data);
|
|
},
|
|
|
|
/**
|
|
* Builds an Caldav connection from an account model object.
|
|
*/
|
|
_createConnection: function(account) {
|
|
var params = extend({}, account);
|
|
var preset = Presets[account.preset];
|
|
|
|
if (
|
|
preset &&
|
|
preset.authenticationType &&
|
|
preset.apiCredentials
|
|
) {
|
|
switch (preset.authenticationType) {
|
|
case 'oauth2':
|
|
params.httpHandler = 'oauth2';
|
|
// shallow copy the apiCredentials on the preset
|
|
params.apiCredentials = extend({}, preset.apiCredentials);
|
|
// the url in this case will always be tokenUrl
|
|
params.apiCredentials.url = preset.apiCredentials.tokenUrl;
|
|
break;
|
|
}
|
|
}
|
|
|
|
var connection = new Caldav.Connection(params);
|
|
return connection;
|
|
},
|
|
|
|
_requestHome: function(connection, url) {
|
|
return new Caldav.Request.CalendarHome(
|
|
connection,
|
|
{ url: url }
|
|
);
|
|
},
|
|
|
|
_requestCalendars: function(connection, url) {
|
|
var Finder = Caldav.Request.Resources;
|
|
var Resource = Caldav.Resources.Calendar;
|
|
|
|
var req = new Finder(connection, { url: url });
|
|
|
|
req.addResource('calendar', Resource);
|
|
req.prop(['ical', 'calendar-color']);
|
|
req.prop(['caldav', 'calendar-description']);
|
|
req.prop('current-user-privilege-set');
|
|
req.prop('displayname');
|
|
req.prop('resourcetype');
|
|
req.prop(['calserver', 'getctag']);
|
|
|
|
return req;
|
|
},
|
|
|
|
_requestEvents: function(connection, cal, options) {
|
|
var Resource = Caldav.Resources.Calendar;
|
|
var remoteCal = new Resource(connection, cal);
|
|
var query = remoteCal.createQuery();
|
|
|
|
query.prop('getetag');
|
|
|
|
// only return VEVENT & VTIMEZONE
|
|
var filterQuery = query.filter.setComp('VCALENDAR');
|
|
var filterEvent = filterQuery.comp('VEVENT');
|
|
|
|
if (options && options.startDate) {
|
|
// convert startDate to unix ical time.
|
|
var icalDate = new ICAL.Time();
|
|
|
|
// ical uses seconds not milliseconds
|
|
icalDate.fromUnixTime(options.startDate.valueOf() / 1000);
|
|
filterEvent.setTimeRange({ start: icalDate.toICALString() });
|
|
}
|
|
|
|
// include only the VEVENT/VTIMEZONE in the data
|
|
query.data.setComp('VCALENDAR');
|
|
|
|
return query;
|
|
},
|
|
|
|
noop: function(callback) {
|
|
callback({ ready: true });
|
|
},
|
|
|
|
getAccount: function(account, callback) {
|
|
var url = account.entrypoint;
|
|
debug('Fetching account from:', url);
|
|
|
|
var connection = this._createConnection(account);
|
|
var request = this._requestHome(connection, url);
|
|
debug('Will issue calendar home request.');
|
|
return request.send(function(err, data) {
|
|
if (err) {
|
|
debug('Error sending home request:', err);
|
|
return callback(err);
|
|
}
|
|
|
|
debug('Received data:', data);
|
|
var result = {};
|
|
|
|
if (data.url) {
|
|
result.calendarHome = data.url;
|
|
}
|
|
|
|
if (connection.oauth) {
|
|
result.oauth = connection.oauth;
|
|
}
|
|
|
|
if (connection.user) {
|
|
result.user = connection.user;
|
|
}
|
|
|
|
callback(null, result);
|
|
});
|
|
},
|
|
|
|
_formatCalendar: function(cal) {
|
|
var result = Object.create(null);
|
|
|
|
result.id = cal.url;
|
|
result.url = cal.url;
|
|
result.name = cal.name;
|
|
result.color = cal.color;
|
|
result.description = cal.description;
|
|
result.syncToken = cal.ctag;
|
|
result.privilegeSet = cal.privilegeSet;
|
|
|
|
return result;
|
|
},
|
|
|
|
findCalendars: function(account, callback) {
|
|
var self = this;
|
|
var url = account.calendarHome;
|
|
var connection = this._createConnection(account);
|
|
|
|
var request = this._requestCalendars(
|
|
connection,
|
|
url
|
|
);
|
|
|
|
request.send(function(err, data) {
|
|
if (err) {
|
|
callback(err);
|
|
return;
|
|
}
|
|
|
|
var calendars = data.calendar;
|
|
var results = {};
|
|
var key;
|
|
var item;
|
|
|
|
for (key in calendars) {
|
|
if (calendars.hasOwnProperty(key)) {
|
|
item = calendars[key];
|
|
var formattedCal = self._formatCalendar(
|
|
item
|
|
);
|
|
|
|
// If privilegeSet is not present we will assume full permissions.
|
|
// Its highly unlikey that it is missing however.
|
|
if (('privilegeSet' in formattedCal) &&
|
|
(formattedCal.privilegeSet.indexOf('read') === -1)) {
|
|
|
|
// skip calendars without read permissions
|
|
continue;
|
|
}
|
|
|
|
results[key] = formattedCal;
|
|
}
|
|
}
|
|
callback(null, results);
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Formats an alarm trigger
|
|
* Returns the relative time for that trigger
|
|
*
|
|
* @param {ICAL.Property} trigger property.
|
|
* @param {ICAL.Date} start date.
|
|
*/
|
|
_formatTrigger: function(trigger, startDate) {
|
|
var alarmTrigger;
|
|
if (trigger.type == 'duration') {
|
|
alarmTrigger = trigger.getFirstValue().toSeconds();
|
|
} else {
|
|
// Type is date-time
|
|
alarmTrigger = trigger
|
|
.getFirstValue()
|
|
.subtractDate(startDate)
|
|
.toSeconds();
|
|
}
|
|
|
|
return alarmTrigger;
|
|
},
|
|
|
|
/**
|
|
* Formats an already parsed ICAL.Event instance.
|
|
* Expects event to already contain exceptions, etc..
|
|
*
|
|
* @param {String} etag etag.
|
|
* @param {String} url caldav url.
|
|
* @param {String} ical raw ical string.
|
|
* @param {ICAL.Event} event ical event.
|
|
*/
|
|
_formatEvent: function(etag, url, ical, event) {
|
|
var self = this;
|
|
var exceptions = null;
|
|
var key;
|
|
|
|
if (event.exceptions) {
|
|
exceptions = [];
|
|
for (key in event.exceptions) {
|
|
exceptions.push(this._formatEvent(
|
|
etag,
|
|
url,
|
|
ical,
|
|
event.exceptions[key]
|
|
));
|
|
}
|
|
|
|
if (!exceptions.length) {
|
|
exceptions = null;
|
|
}
|
|
}
|
|
|
|
var rid = event.recurrenceId;
|
|
|
|
if (rid) {
|
|
rid = this.formatICALTime(rid);
|
|
}
|
|
|
|
var resultAlarms = [];
|
|
var alarms = event.component.getAllSubcomponents('valarm');
|
|
alarms.forEach(function(instance) {
|
|
var action = instance.getFirstPropertyValue('action');
|
|
if (action && action === 'DISPLAY') {
|
|
var triggers = instance.getAllProperties('trigger');
|
|
var i = 0;
|
|
var len = triggers.length;
|
|
|
|
for (; i < len; i++) {
|
|
|
|
var trigger = triggers[i];
|
|
|
|
resultAlarms.push({
|
|
action: action,
|
|
trigger: self._formatTrigger(trigger, event.startDate)
|
|
});
|
|
}
|
|
}
|
|
});
|
|
|
|
var result = {
|
|
alarms: resultAlarms,
|
|
syncToken: etag,
|
|
url: url,
|
|
id: event.uid,
|
|
title: event.summary,
|
|
recurrenceId: rid,
|
|
isRecurring: event.isRecurring(),
|
|
description: event.description,
|
|
location: event.location,
|
|
start: this.formatICALTime(event.startDate),
|
|
end: this.formatICALTime(event.endDate),
|
|
exceptions: exceptions
|
|
};
|
|
|
|
return result;
|
|
},
|
|
|
|
/**
|
|
* Find and parse the display alarms for an event.
|
|
*
|
|
* @param {Object} details details for specific instance.
|
|
*/
|
|
_displayAlarms: function(details) {
|
|
var event = details.item;
|
|
var comp = event.component;
|
|
var alarms = comp.getAllSubcomponents('valarm');
|
|
var result = [];
|
|
|
|
var self = this;
|
|
alarms.forEach(function(instance) {
|
|
var action = instance.getFirstPropertyValue('action');
|
|
if (action && action === 'DISPLAY') {
|
|
// lets just assume we might have multiple triggers
|
|
var triggers = instance.getAllProperties('trigger');
|
|
var i = 0;
|
|
var len = triggers.length;
|
|
|
|
for (; i < len; i++) {
|
|
result.push({
|
|
action: action,
|
|
trigger: self._formatTrigger(triggers[i], event.startDate)
|
|
});
|
|
}
|
|
}
|
|
});
|
|
|
|
return result;
|
|
},
|
|
|
|
/**
|
|
* Takes an ICAL.Time object and converts it
|
|
* into the storage format familiar to the calendar app.
|
|
*
|
|
* var time = new ICAL.Time({
|
|
* year: 2012,
|
|
* month: 1,
|
|
* day: 1,
|
|
* zone: 'PST'
|
|
* });
|
|
*
|
|
* // time is converted to a MS
|
|
* // then its UTC offset is added
|
|
* // so the time is at UTC (offset 0) then the
|
|
* // offset is associated with that time.
|
|
*
|
|
* var output = {
|
|
* utc: ms,
|
|
* offset: (+|-)ms,
|
|
* // zone can mostly be ignored except
|
|
* // in the case where the event is "floating"
|
|
* // in time and we need to convert the utc value
|
|
* // to the current local time.
|
|
* tzid: ''
|
|
* };
|
|
*/
|
|
formatICALTime: function(time) {
|
|
var zone = time.zone;
|
|
var offset = time.utcOffset() * 1000;
|
|
var utc = time.toUnixTime() * 1000;
|
|
|
|
utc += offset;
|
|
|
|
var result = {
|
|
tzid: zone.tzid,
|
|
// from seconds to ms
|
|
offset: offset,
|
|
// from seconds to ms
|
|
utc: utc
|
|
};
|
|
|
|
if (time.isDate) {
|
|
result.isDate = true;
|
|
}
|
|
|
|
return result;
|
|
},
|
|
|
|
/**
|
|
* Formats a given time/date into a ICAL.Time instance.
|
|
* Suitable for converting the output of formatICALTime back
|
|
* into a similar representation of the original.
|
|
*
|
|
* Once a time instance goes through this method it should _not_
|
|
* be modified as the DST information is lost (offset is preserved).
|
|
*
|
|
* @param {ICAL.Time|Object} time formatted ical time
|
|
* or output of formatICALTime.
|
|
*/
|
|
formatInputTime: function(time) {
|
|
if (time instanceof ICAL.Time) {
|
|
return time;
|
|
}
|
|
|
|
var utc = time.utc;
|
|
var tzid = time.tzid;
|
|
var offset = time.offset;
|
|
var result;
|
|
|
|
if (tzid === ICAL.Timezone.localTimezone.tzid) {
|
|
result = new ICAL.Time();
|
|
result.fromUnixTime(utc / 1000);
|
|
result.zone = ICAL.Timezone.localTimezone;
|
|
} else {
|
|
result = new ICAL.Time();
|
|
result.fromUnixTime((utc - offset) / 1000);
|
|
result.zone = ICAL.Timezone.utcTimezone;
|
|
}
|
|
|
|
if (time.isDate) {
|
|
result.isDate = true;
|
|
}
|
|
|
|
return result;
|
|
},
|
|
|
|
/**
|
|
* Parse an ical data/string into primary
|
|
* event and exceptions.
|
|
*
|
|
* It is assumed there is only one primary event
|
|
* (does not have a RECURRENCE-ID) in the ical content.
|
|
*
|
|
* @param {Object|String|ICAL.Event} ical vcalendar chunk (and exceptions).
|
|
* @param {Function} callback node style callback [err, primary event].
|
|
*/
|
|
parseEvent: function(ical, callback) {
|
|
if (ical instanceof ICAL.Event) {
|
|
callback(null, ical);
|
|
return;
|
|
}
|
|
|
|
var parser = new ICAL.ComponentParser();
|
|
var primaryEvent;
|
|
var exceptions = [];
|
|
|
|
parser.ontimezone = function(zone) {
|
|
var id = zone.tzid;
|
|
|
|
if (!ICAL.TimezoneService.has(id)) {
|
|
ICAL.TimezoneService.register(id, zone);
|
|
}
|
|
};
|
|
|
|
parser.onevent = function(item) {
|
|
if (item.isRecurrenceException()) {
|
|
exceptions.push(item);
|
|
} else {
|
|
primaryEvent = item;
|
|
}
|
|
};
|
|
|
|
parser.oncomplete = function() {
|
|
if (!primaryEvent) {
|
|
//TODO: in the error handling pass we need to define
|
|
// path to log this information so we can determine
|
|
// the cause of failures.
|
|
callback(new Error('ical parse error'));
|
|
return;
|
|
}
|
|
exceptions.forEach(primaryEvent.relateException, primaryEvent);
|
|
callback(null, primaryEvent);
|
|
};
|
|
|
|
//XXX: Right now ICAL.js is all sync so we
|
|
// can catch the errors this way in the future
|
|
// onerror will replace this.
|
|
try {
|
|
parser.process(ical);
|
|
} catch (e) {
|
|
callback(e);
|
|
}
|
|
},
|
|
|
|
_defaultMaxDate: function() {
|
|
var now = new Date();
|
|
|
|
return new ICAL.Time({
|
|
year: now.getFullYear(),
|
|
// three months in advance
|
|
// +1 because js months are zero based
|
|
month: now.getMonth() + 6,
|
|
day: now.getDate()
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Expands a list recurring events by their component.
|
|
*
|
|
* It is expected for this function to receive an array
|
|
* of items each structured as a icalComponent.
|
|
*
|
|
* [
|
|
* { ical: '...', lastRecurrenceId: '..', iterator: '...' },
|
|
* ...
|
|
* ]
|
|
*
|
|
* @param {Array.<icalComponent>} components list of icalComponents.
|
|
* @param {Calendar.Responder} stream to emit events.
|
|
* @param {Object} options list of options.
|
|
* @param {Object} options.maxDate maximum date to expand to.
|
|
* @param {Function} callback only sends an error if fatal.
|
|
*/
|
|
expandComponents: function(components, options, stream, callback) {
|
|
var pending = components.length;
|
|
|
|
function next() {
|
|
if (!(--pending)) {
|
|
callback();
|
|
}
|
|
}
|
|
|
|
|
|
components.forEach(function(component) {
|
|
var ical = component.ical;
|
|
var localOpts = {
|
|
maxDate: options.maxDate,
|
|
iterator: component.iterator
|
|
};
|
|
|
|
if (component.lastRecurrenceId) {
|
|
localOpts.minDate = component.lastRecurrenceId;
|
|
}
|
|
|
|
// expand each component
|
|
this.expandRecurringEvent(ical, localOpts, stream,
|
|
function(err, iter, lastRecurId, uid) {
|
|
|
|
if (err) {
|
|
stream.emit('error', err);
|
|
next();
|
|
return;
|
|
}
|
|
|
|
stream.emit('component', {
|
|
eventId: uid,
|
|
lastRecurrenceId: lastRecurId,
|
|
ical: ical,
|
|
iterator: iter
|
|
});
|
|
|
|
next();
|
|
});
|
|
}, this);
|
|
},
|
|
|
|
/**
|
|
* Options:
|
|
*
|
|
* - iterator: (ICAL.RecurExpander) optional recurrence expander
|
|
* used to resume the iterator state for existing events.
|
|
*
|
|
* - maxDate: if instance ends after this date stop expansion.
|
|
*
|
|
*
|
|
* Returns:
|
|
*
|
|
* [
|
|
* {
|
|
* start: { offset: inMS, utc: ms },
|
|
* endDate: // same format as start,
|
|
* recurrenceId: // id of specific recurrence.
|
|
* uid: // uid of event
|
|
* isException: // true when is exception to usual rule.
|
|
* },
|
|
* //...
|
|
* ]
|
|
*/
|
|
expandRecurringEvent: function(component, options, stream, callback) {
|
|
var self = this;
|
|
var maxDate;
|
|
var minDate = null;
|
|
var now;
|
|
|
|
if (options.minDate) {
|
|
minDate = this.formatInputTime(options.minDate);
|
|
}
|
|
|
|
if (options.maxDate) {
|
|
maxDate = this.formatInputTime(options.maxDate);
|
|
}
|
|
|
|
if (!('now' in options)) {
|
|
options.now = ICAL.Time.now();
|
|
}
|
|
|
|
now = options.now;
|
|
|
|
// convert to rich ical event
|
|
this.parseEvent(component, function(err, event) {
|
|
if (err) {
|
|
callback(err);
|
|
return;
|
|
}
|
|
|
|
var iter = IcalRecurExpansion.forEach(
|
|
event,
|
|
options.iterator,
|
|
occuranceHandler,
|
|
minDate,
|
|
maxDate
|
|
);
|
|
|
|
function occuranceHandler(next) {
|
|
var details = event.getOccurrenceDetails(next);
|
|
var inFuture = details.endDate.compare(now);
|
|
|
|
debug('alarm time',
|
|
event.summary,
|
|
'will add ' + String(inFuture),
|
|
'start:', details.startDate.toJSDate().toString(),
|
|
'end:', details.endDate.toJSDate().toString(),
|
|
'now:', now.toJSDate().toString());
|
|
|
|
var occurrence = {
|
|
start: self.formatICALTime(details.startDate),
|
|
end: self.formatICALTime(details.endDate),
|
|
recurrenceId: self.formatICALTime(next),
|
|
eventId: details.item.uid,
|
|
isException: details.item.isRecurrenceException()
|
|
};
|
|
|
|
// only set alarms for those dates in the future...
|
|
if (inFuture >= 0) {
|
|
var alarms = self._displayAlarms(details);
|
|
if (alarms) {
|
|
occurrence.alarms = alarms;
|
|
}
|
|
}
|
|
|
|
stream.emit('occurrence', occurrence);
|
|
}
|
|
|
|
var lastRecurrence;
|
|
|
|
if (iter.complete) {
|
|
// when the iterator is complete
|
|
// last recurrence is false.
|
|
// We use this to signify the end
|
|
// of the iteration cycle.
|
|
lastRecurrence = false;
|
|
} else {
|
|
// its very important all times used
|
|
// for comparison are based on the recurrence id
|
|
// and not the start date as those can change
|
|
// with exceptions...
|
|
lastRecurrence = self.formatICALTime(
|
|
iter.last
|
|
);
|
|
}
|
|
|
|
callback(
|
|
null,
|
|
iter.toJSON(),
|
|
lastRecurrence,
|
|
event.uid
|
|
);
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Handle a single caldav event response.
|
|
*
|
|
* @param {String} url location of event.
|
|
* @param {Object} response caldav response object.
|
|
* @param {Calendar.Responder} responder event emitter.
|
|
* @param {Function} callback node style callback fired after event parsing.
|
|
*/
|
|
_handleCaldavEvent: function(url, response, stream, callback) {
|
|
var self = this;
|
|
var etag = response.getetag;
|
|
var event = response['calendar-data'];
|
|
|
|
if (event.status != 200) {
|
|
callback(new Error('non 200 status code "' + url + '"'));
|
|
return;
|
|
}
|
|
|
|
// process event
|
|
var ical = event.value;
|
|
this.parseEvent(ical, function(err, event) {
|
|
|
|
if (err) {
|
|
callback(err);
|
|
return;
|
|
}
|
|
|
|
var result = self._formatEvent(etag.value, url, ical, event);
|
|
stream.emit('event', result);
|
|
|
|
var options = {
|
|
maxDate: self._defaultMaxDate(),
|
|
now: ICAL.Time.now()
|
|
};
|
|
|
|
self.expandRecurringEvent(event, options, stream,
|
|
function(err, iter, lastRecurrenceId) {
|
|
|
|
if (err) {
|
|
callback(err);
|
|
return;
|
|
}
|
|
|
|
if (!event.isRecurring()) {
|
|
stream.emit('component', {
|
|
eventId: result.id,
|
|
isRecurring: false,
|
|
ical: ical
|
|
});
|
|
} else {
|
|
stream.emit('component', {
|
|
eventId: result.id,
|
|
lastRecurrenceId: lastRecurrenceId,
|
|
ical: ical,
|
|
iterator: iter
|
|
});
|
|
}
|
|
|
|
callback(null);
|
|
});
|
|
});
|
|
},
|
|
|
|
streamEvents: function(account, calendar, options, stream, callback) {
|
|
var self = this;
|
|
var hasCompleted = false;
|
|
var connection = this._createConnection(account);
|
|
|
|
var cache = options.cached;
|
|
|
|
// we don't need to pass this around anywhere.
|
|
//delete options.cache;
|
|
|
|
var request = this._requestEvents(connection, calendar, options);
|
|
var pending = 0;
|
|
|
|
function next(err) {
|
|
if (err) {
|
|
try {
|
|
stream.emit('error', err);
|
|
} catch (e) {
|
|
console.error('Failed to transport err:', err.toString(), err.stack);
|
|
}
|
|
}
|
|
|
|
if (!(--pending) && hasCompleted) {
|
|
callback(null);
|
|
}
|
|
}
|
|
|
|
function handleResponse(url, data) {
|
|
if (!data || !data['calendar-data']) {
|
|
// throw some error;
|
|
console.error('Could not sync: ', url);
|
|
return;
|
|
}
|
|
var etag = data.getetag.value;
|
|
if (url in cache) {
|
|
// don't need to track this for missing events.
|
|
if (etag !== cache[url].syncToken) {
|
|
pending++;
|
|
self._handleCaldavEvent(url, data, stream, next);
|
|
}
|
|
|
|
delete cache[url];
|
|
} else {
|
|
pending++;
|
|
self._handleCaldavEvent(url, data, stream, next);
|
|
}
|
|
}
|
|
|
|
request.sax.on('DAV:/response', handleResponse);
|
|
|
|
request.send(function(err) {
|
|
hasCompleted = true;
|
|
// when the request is completed stop listening
|
|
// for sax events.
|
|
request.sax.removeEventListener(
|
|
'DAV:/response', handleResponse
|
|
);
|
|
|
|
if (err) {
|
|
callback(err);
|
|
return;
|
|
}
|
|
|
|
if (!pending) {
|
|
var missing = [];
|
|
|
|
for (var url in cache) {
|
|
missing.push(cache[url].id);
|
|
}
|
|
|
|
// send missing events
|
|
stream.emit('missingEvents', missing);
|
|
|
|
// notify the requester that we have completed.
|
|
callback();
|
|
}
|
|
});
|
|
},
|
|
|
|
_assetRequest: function(connection, url) {
|
|
return new Caldav.Request.Asset(connection, url);
|
|
},
|
|
|
|
deleteEvent: function(account, calendar, event, callback) {
|
|
var connection = this._createConnection(account);
|
|
|
|
var req = this._assetRequest(connection, event.url);
|
|
|
|
req.delete({}, function(err) {
|
|
callback(err);
|
|
});
|
|
},
|
|
|
|
addAlarms: function(component, alarms, account) {
|
|
alarms = alarms || [];
|
|
|
|
for (var i = 0; i < alarms.length; i++) {
|
|
|
|
var valarm = new ICAL.Component('valarm');
|
|
|
|
// valarm details
|
|
valarm.addPropertyWithValue('action', alarms[i].action);
|
|
valarm.addPropertyWithValue('description', 'This is an event reminder');
|
|
var trigger = valarm.addPropertyWithValue('trigger',
|
|
ICAL.Duration.fromSeconds(
|
|
alarms[i].trigger
|
|
)
|
|
);
|
|
trigger.setParameter('relative', 'START');
|
|
component.addSubcomponent(valarm);
|
|
|
|
// Check if we need to mirror the VALARM onto email
|
|
if (this.mirrorAlarms(account)) {
|
|
valarm = new ICAL.Component('valarm');
|
|
valarm.addPropertyWithValue('action', 'EMAIL');
|
|
valarm.addPropertyWithValue('description',
|
|
'This is an event reminder');
|
|
valarm.addPropertyWithValue('ATTENDEE', account.user);
|
|
trigger = valarm.addPropertyWithValue('trigger',
|
|
ICAL.Duration.fromSeconds(
|
|
alarms[i].trigger
|
|
)
|
|
);
|
|
trigger.setParameter('relative', 'START');
|
|
component.addSubcomponent(valarm);
|
|
}
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Update absolute alarm times when the startDate changes.
|
|
*
|
|
* @param {ICAL.Time} originalDate of the event.
|
|
* @param {ICAL.Event} event to update.
|
|
*/
|
|
adjustAbsoluteAlarms: function(originalDate, event) {
|
|
var alarms = event.component.getAllSubcomponents('valarm');
|
|
|
|
alarms.forEach(function(alarm) {
|
|
var trigger = alarm.getFirstProperty('trigger');
|
|
var value = trigger.getValues()[0].clone();
|
|
|
|
// absolute time
|
|
if (value instanceof ICAL.Time) {
|
|
// find absolute time difference
|
|
var diff = value.subtractDateTz(originalDate);
|
|
trigger.setValue(diff);
|
|
}
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Yahoo needs us to mirror all alarms as EMAIL alarms
|
|
*/
|
|
mirrorAlarms: function(account) {
|
|
return account && account.domain === 'https://caldav.calendar.yahoo.com';
|
|
},
|
|
|
|
createEvent: function(account, calendar, event, callback) {
|
|
var connection = this._createConnection(account);
|
|
var vcalendar = new ICAL.Component('vcalendar');
|
|
var icalEvent = new ICAL.Event();
|
|
|
|
// vcalendar details
|
|
vcalendar.addPropertyWithValue('prodid', this.icalProductId);
|
|
vcalendar.addPropertyWithValue('version', this.icalVersion);
|
|
|
|
// text fields
|
|
icalEvent.uid = uuid();
|
|
icalEvent.summary = event.title;
|
|
icalEvent.description = event.description;
|
|
icalEvent.location = event.location;
|
|
icalEvent.sequence = 1;
|
|
|
|
// time fields
|
|
icalEvent.startDate = this.formatInputTime(event.start);
|
|
icalEvent.endDate = this.formatInputTime(event.end);
|
|
|
|
// alarms
|
|
this.addAlarms(icalEvent.component, event.alarms, account);
|
|
|
|
vcalendar.addSubcomponent(icalEvent.component);
|
|
|
|
var url = calendar.url + icalEvent.uid + '.ics';
|
|
var req = this._assetRequest(connection, url);
|
|
|
|
event.id = icalEvent.uid;
|
|
event.url = url;
|
|
event.icalComponent = vcalendar.toString();
|
|
|
|
req.put({}, event.icalComponent, function(err, data, xhr) {
|
|
if (err) {
|
|
callback(err);
|
|
return;
|
|
}
|
|
|
|
var token = xhr.getResponseHeader('Etag');
|
|
event.syncToken = token;
|
|
// TODO: error handling
|
|
callback(err, event);
|
|
});
|
|
|
|
},
|
|
|
|
/**
|
|
* Updates a single caldav event.
|
|
* Will handle updating both primary events and exceptions.
|
|
*
|
|
* @param {Object} account full account details.
|
|
* @param {Object} calendar full calendar details.
|
|
* @param {Object} eventDetails details to update the event.
|
|
* unmodified parsed ical component. (VCALENDAR).
|
|
*/
|
|
updateEvent: function(account, calendar, eventDetails, callback) {
|
|
var connection = this._createConnection(account);
|
|
|
|
var icalComponent = eventDetails.icalComponent;
|
|
var event = eventDetails.event;
|
|
|
|
var self = this;
|
|
var req = this._assetRequest(connection, event.url);
|
|
|
|
// parse event
|
|
this.parseEvent(icalComponent, function(err, icalEvent) {
|
|
if (err) {
|
|
callback(err);
|
|
return;
|
|
}
|
|
|
|
var target = icalEvent;
|
|
var vcalendar = icalEvent.component.parent;
|
|
var originalStartDate = target.startDate;
|
|
|
|
// find correct event
|
|
if (event.recurrenceId) {
|
|
var rid = self.formatInputTime(event.recurrenceId);
|
|
rid = rid.toString();
|
|
if (icalEvent.exceptions[rid]) {
|
|
target = icalEvent.exceptions[rid];
|
|
}
|
|
}
|
|
|
|
// vcalendar pieces
|
|
vcalendar.updatePropertyWithValue('prodid', self.icalProductId);
|
|
|
|
// text fields
|
|
target.summary = event.title;
|
|
target.description = event.description;
|
|
target.location = event.location;
|
|
|
|
if (!target.sequence) {
|
|
target.sequence = 0;
|
|
}
|
|
|
|
target.sequence = parseInt(target.sequence, 10) + 1;
|
|
|
|
// time fields
|
|
target.startDate = self.formatInputTime(
|
|
event.start
|
|
);
|
|
|
|
target.endDate = self.formatInputTime(
|
|
event.end
|
|
);
|
|
|
|
// adjust absolute alarm time ( we do this before adding/changing our
|
|
// new alarm times )
|
|
self.adjustAbsoluteAlarms(originalStartDate, target);
|
|
|
|
// We generally want to remove all 'DISPLAY' alarms
|
|
// UNLESS we are dealing with a YAHOO account
|
|
// Then we overwrite all alarms
|
|
var alarms = target.component.getAllSubcomponents('valarm');
|
|
alarms.forEach(function(alarm) {
|
|
var action = alarm.getFirstPropertyValue('action');
|
|
if (action === 'DISPLAY' || self.mirrorAlarms(account)) {
|
|
target.component.removeSubcomponent(alarm);
|
|
}
|
|
});
|
|
self.addAlarms(target.component, event.alarms, account);
|
|
|
|
var vcal = target.component.parent.toString();
|
|
event.icalComponent = vcal;
|
|
|
|
req.put({}, vcal, function(err, data, xhr) {
|
|
if (err) {
|
|
callback(err);
|
|
return;
|
|
}
|
|
|
|
var token = xhr.getResponseHeader('Etag');
|
|
event.syncToken = token;
|
|
// TODO: error handling
|
|
callback(err, event);
|
|
});
|
|
});
|
|
}
|
|
};
|
|
|
|
});
|
|
|