angular-meteor
Version:
Combining the simplicity and power of AngularJS and Meteor
1,425 lines (1,086 loc) • 84.6 kB
JavaScript
/*! angular-meteor v1.3.12 */
(function webpackUniversalModuleDefinition(root, factory) {
if(typeof exports === 'object' && typeof module === 'object')
module.exports = factory(require("underscore"), require("jsondiffpatch"));
else if(typeof define === 'function' && define.amd)
define(["underscore", "jsondiffpatch"], factory);
else if(typeof exports === 'object')
exports["angularMeteor"] = factory(require("underscore"), require("jsondiffpatch"));
else
root["angularMeteor"] = factory(root["_"], root["jsondiffpatch"]);
})(this, function(__WEBPACK_EXTERNAL_MODULE_3__, __WEBPACK_EXTERNAL_MODULE_22__) {
return /******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId])
/******/ return installedModules[moduleId].exports;
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ exports: {},
/******/ id: moduleId,
/******/ loaded: false
/******/ };
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/ // Flag the module as loaded
/******/ module.loaded = true;
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/ // Load entry module and return exports
/******/ return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports, __webpack_require__) {
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
__webpack_require__(1);
__webpack_require__(4);
__webpack_require__(5);
__webpack_require__(6);
__webpack_require__(7);
__webpack_require__(8);
__webpack_require__(9);
__webpack_require__(10);
__webpack_require__(11);
__webpack_require__(12);
__webpack_require__(13);
__webpack_require__(14);
__webpack_require__(15);
var _utils = __webpack_require__(16);
var _mixer = __webpack_require__(17);
var _scope = __webpack_require__(18);
var _core = __webpack_require__(19);
var _viewModel = __webpack_require__(20);
var _reactive = __webpack_require__(21);
var _templates = __webpack_require__(23);
// legacy
// lib
var name = 'angular-meteor';
// new
exports.default = name;
angular.module(name, [
// new
_utils.name, _mixer.name, _scope.name, _core.name, _viewModel.name, _reactive.name, _templates.name,
// legacy
'angular-meteor.ironrouter', 'angular-meteor.utils', 'angular-meteor.subscribe', 'angular-meteor.collection', 'angular-meteor.object', 'angular-meteor.user', 'angular-meteor.methods', 'angular-meteor.session', 'angular-meteor.camera']).run([_mixer.Mixer, _core.Core, _viewModel.ViewModel, _reactive.Reactive, function ($Mixer, $$Core, $$ViewModel, $$Reactive) {
// Load all mixins
$Mixer.mixin($$Core).mixin($$ViewModel).mixin($$Reactive);
}])
// legacy
// Putting all services under $meteor service for syntactic sugar
.service('$meteor', ['$meteorCollection', '$meteorCollectionFS', '$meteorObject', '$meteorMethods', '$meteorSession', '$meteorSubscribe', '$meteorUtils', '$meteorCamera', '$meteorUser', function ($meteorCollection, $meteorCollectionFS, $meteorObject, $meteorMethods, $meteorSession, $meteorSubscribe, $meteorUtils, $meteorCamera, $meteorUser) {
var _this = this;
this.collection = $meteorCollection;
this.collectionFS = $meteorCollectionFS;
this.object = $meteorObject;
this.subscribe = $meteorSubscribe.subscribe;
this.call = $meteorMethods.call;
this.session = $meteorSession;
this.autorun = $meteorUtils.autorun;
this.getCollectionByName = $meteorUtils.getCollectionByName;
this.getPicture = $meteorCamera.getPicture;
// $meteorUser
['loginWithPassword', 'requireUser', 'requireValidUser', 'waitForUser', 'createUser', 'changePassword', 'forgotPassword', 'resetPassword', 'verifyEmail', 'loginWithMeteorDeveloperAccount', 'loginWithFacebook', 'loginWithGithub', 'loginWithGoogle', 'loginWithMeetup', 'loginWithTwitter', 'loginWithWeibo', 'logout', 'logoutOtherClients'].forEach(function (method) {
_this[method] = $meteorUser[method];
});
}]);
module.exports = exports['default'];
/***/ }),
/* 1 */
/***/ (function(module, exports, __webpack_require__) {
'use strict';
var _underscore = __webpack_require__(2);
var _underscore2 = _interopRequireDefault(_underscore);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
'use strict';
// https://github.com/DAB0mB/get-updates
/*global
angular, _
*/
(function () {
var module = angular.module('getUpdates', []);
var utils = function () {
var rip = function rip(obj, level) {
if (level < 1) return {};
return _underscore2.default.reduce(obj, function (clone, v, k) {
v = _underscore2.default.isObject(v) ? rip(v, --level) : v;
clone[k] = v;
return clone;
}, {});
};
var toPaths = function toPaths(obj) {
var keys = getKeyPaths(obj);
var values = getDeepValues(obj);
return _underscore2.default.object(keys, values);
};
var getKeyPaths = function getKeyPaths(obj) {
var keys = _underscore2.default.keys(obj).map(function (k) {
var v = obj[k];
if (!_underscore2.default.isObject(v) || _underscore2.default.isEmpty(v) || _underscore2.default.isArray(v)) return k;
return getKeyPaths(v).map(function (subKey) {
return k + '.' + subKey;
});
});
return _underscore2.default.flatten(keys);
};
var getDeepValues = function getDeepValues(obj, arr) {
arr = arr || [];
_underscore2.default.values(obj).forEach(function (v) {
if (!_underscore2.default.isObject(v) || _underscore2.default.isEmpty(v) || _underscore2.default.isArray(v)) arr.push(v);else getDeepValues(v, arr);
});
return arr;
};
var flatten = function flatten(arr) {
return arr.reduce(function (flattened, v, i) {
if (_underscore2.default.isArray(v) && !_underscore2.default.isEmpty(v)) flattened.push.apply(flattened, flatten(v));else flattened.push(v);
return flattened;
}, []);
};
var setFilled = function setFilled(obj, k, v) {
if (!_underscore2.default.isEmpty(v)) obj[k] = v;
};
var assert = function assert(result, msg) {
if (!result) throwErr(msg);
};
var throwErr = function throwErr(msg) {
throw Error('get-updates error - ' + msg);
};
return {
rip: rip,
toPaths: toPaths,
getKeyPaths: getKeyPaths,
getDeepValues: getDeepValues,
setFilled: setFilled,
assert: assert,
throwErr: throwErr
};
}();
var getDifference = function () {
var getDifference = function getDifference(src, dst, isShallow) {
var level;
if (isShallow > 1) level = isShallow;else if (isShallow) level = 1;
if (level) {
src = utils.rip(src, level);
dst = utils.rip(dst, level);
}
return compare(src, dst);
};
var compare = function compare(src, dst) {
var srcKeys = _underscore2.default.keys(src);
var dstKeys = _underscore2.default.keys(dst);
var keys = _underscore2.default.chain([]).concat(srcKeys).concat(dstKeys).uniq().without('$$hashKey').value();
return keys.reduce(function (diff, k) {
var srcValue = src[k];
var dstValue = dst[k];
if (_underscore2.default.isDate(srcValue) && _underscore2.default.isDate(dstValue)) {
if (srcValue.getTime() != dstValue.getTime()) diff[k] = dstValue;
}
if (_underscore2.default.isObject(srcValue) && _underscore2.default.isObject(dstValue)) {
var valueDiff = getDifference(srcValue, dstValue);
utils.setFilled(diff, k, valueDiff);
} else if (srcValue !== dstValue) {
diff[k] = dstValue;
}
return diff;
}, {});
};
return getDifference;
}();
var getUpdates = function () {
var getUpdates = function getUpdates(src, dst, isShallow) {
utils.assert(_underscore2.default.isObject(src), 'first argument must be an object');
utils.assert(_underscore2.default.isObject(dst), 'second argument must be an object');
var diff = getDifference(src, dst, isShallow);
var paths = utils.toPaths(diff);
var set = createSet(paths);
var unset = createUnset(paths);
var pull = createPull(unset);
var updates = {};
utils.setFilled(updates, '$set', set);
utils.setFilled(updates, '$unset', unset);
utils.setFilled(updates, '$pull', pull);
return updates;
};
var createSet = function createSet(paths) {
var undefinedKeys = getUndefinedKeys(paths);
return _underscore2.default.omit(paths, undefinedKeys);
};
var createUnset = function createUnset(paths) {
var undefinedKeys = getUndefinedKeys(paths);
var unset = _underscore2.default.pick(paths, undefinedKeys);
return _underscore2.default.reduce(unset, function (result, v, k) {
result[k] = true;
return result;
}, {});
};
var createPull = function createPull(unset) {
var arrKeyPaths = _underscore2.default.keys(unset).map(function (k) {
var split = k.match(/(.*)\.\d+$/);
return split && split[1];
});
return _underscore2.default.compact(arrKeyPaths).reduce(function (pull, k) {
pull[k] = null;
return pull;
}, {});
};
var getUndefinedKeys = function getUndefinedKeys(obj) {
return _underscore2.default.keys(obj).filter(function (k) {
var v = obj[k];
return _underscore2.default.isUndefined(v);
});
};
return getUpdates;
}();
module.value('getUpdates', getUpdates);
})();
/***/ }),
/* 2 */
/***/ (function(module, exports, __webpack_require__) {
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _underscore = __webpack_require__(3);
var _underscore2 = _interopRequireDefault(_underscore);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
if (typeof _underscore2.default === 'undefined') {
if (typeof Package.underscore === 'undefined') {
throw new Error('underscore is missing');
}
}
exports.default = _underscore2.default || Package.underscore._;
module.exports = exports['default'];
/***/ }),
/* 3 */
/***/ (function(module, exports) {
module.exports = __WEBPACK_EXTERNAL_MODULE_3__;
/***/ }),
/* 4 */
/***/ (function(module, exports, __webpack_require__) {
'use strict';
var _underscore = __webpack_require__(2);
var _underscore2 = _interopRequireDefault(_underscore);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
'use strict'; /*global
angular, _, Package
*/
var _module = angular.module('diffArray', ['getUpdates']);
_module.factory('diffArray', ['getUpdates', function (getUpdates) {
var LocalCollection = Package.minimongo.LocalCollection;
var idStringify = LocalCollection._idStringify || Package['mongo-id'].MongoID.idStringify;
var idParse = LocalCollection._idParse || Package['mongo-id'].MongoID.idParse;
// Calculates the differences between `lastSeqArray` and
// `seqArray` and calls appropriate functions from `callbacks`.
// Reuses Minimongo's diff algorithm implementation.
// XXX Should be replaced with the original diffArray function here:
// https://github.com/meteor/meteor/blob/devel/packages/observe-sequence/observe_sequence.js#L152
// When it will become nested as well, tracking here: https://github.com/meteor/meteor/issues/3764
function diffArray(lastSeqArray, seqArray, callbacks, preventNestedDiff) {
preventNestedDiff = !!preventNestedDiff;
var diffFn = Package.minimongo.LocalCollection._diffQueryOrderedChanges || Package['diff-sequence'].DiffSequence.diffQueryOrderedChanges;
var oldObjIds = [];
var newObjIds = [];
var posOld = {}; // maps from idStringify'd ids
var posNew = {}; // ditto
var posCur = {};
var lengthCur = lastSeqArray.length;
_underscore2.default.each(seqArray, function (doc, i) {
newObjIds.push({ _id: doc._id });
posNew[idStringify(doc._id)] = i;
});
_underscore2.default.each(lastSeqArray, function (doc, i) {
oldObjIds.push({ _id: doc._id });
posOld[idStringify(doc._id)] = i;
posCur[idStringify(doc._id)] = i;
});
// Arrays can contain arbitrary objects. We don't diff the
// objects. Instead we always fire 'changedAt' callback on every
// object. The consumer of `observe-sequence` should deal with
// it appropriately.
diffFn(oldObjIds, newObjIds, {
addedBefore: function addedBefore(id, doc, before) {
var position = before ? posCur[idStringify(before)] : lengthCur;
_underscore2.default.each(posCur, function (pos, id) {
if (pos >= position) posCur[id]++;
});
lengthCur++;
posCur[idStringify(id)] = position;
callbacks.addedAt(id, seqArray[posNew[idStringify(id)]], position, before);
},
movedBefore: function movedBefore(id, before) {
var prevPosition = posCur[idStringify(id)];
var position = before ? posCur[idStringify(before)] : lengthCur - 1;
_underscore2.default.each(posCur, function (pos, id) {
if (pos >= prevPosition && pos <= position) posCur[id]--;else if (pos <= prevPosition && pos >= position) posCur[id]++;
});
posCur[idStringify(id)] = position;
callbacks.movedTo(id, seqArray[posNew[idStringify(id)]], prevPosition, position, before);
},
removed: function removed(id) {
var prevPosition = posCur[idStringify(id)];
_underscore2.default.each(posCur, function (pos, id) {
if (pos >= prevPosition) posCur[id]--;
});
delete posCur[idStringify(id)];
lengthCur--;
callbacks.removedAt(id, lastSeqArray[posOld[idStringify(id)]], prevPosition);
}
});
_underscore2.default.each(posNew, function (pos, idString) {
if (!_underscore2.default.has(posOld, idString)) return;
var id = idParse(idString);
var newItem = seqArray[pos] || {};
var oldItem = lastSeqArray[posOld[idString]];
var updates = getUpdates(oldItem, newItem, preventNestedDiff);
if (!_underscore2.default.isEmpty(updates)) callbacks.changedAt(id, updates, pos, oldItem);
});
}
diffArray.shallow = function (lastSeqArray, seqArray, callbacks) {
return diffArray(lastSeqArray, seqArray, callbacks, true);
};
diffArray.deepCopyChanges = function (oldItem, newItem) {
var setDiff = getUpdates(oldItem, newItem).$set;
_underscore2.default.each(setDiff, function (v, deepKey) {
setDeep(oldItem, deepKey, v);
});
};
diffArray.deepCopyRemovals = function (oldItem, newItem) {
var unsetDiff = getUpdates(oldItem, newItem).$unset;
_underscore2.default.each(unsetDiff, function (v, deepKey) {
unsetDeep(oldItem, deepKey);
});
};
// Finds changes between two collections
diffArray.getChanges = function (newCollection, oldCollection, diffMethod) {
var changes = { added: [], removed: [], changed: [] };
diffMethod(oldCollection, newCollection, {
addedAt: function addedAt(id, item, index) {
changes.added.push({ item: item, index: index });
},
removedAt: function removedAt(id, item, index) {
changes.removed.push({ item: item, index: index });
},
changedAt: function changedAt(id, updates, index, oldItem) {
changes.changed.push({ selector: id, modifier: updates });
},
movedTo: function movedTo(id, item, fromIndex, toIndex) {
// XXX do we need this?
}
});
return changes;
};
var setDeep = function setDeep(obj, deepKey, v) {
var split = deepKey.split('.');
var initialKeys = _underscore2.default.initial(split);
var lastKey = _underscore2.default.last(split);
initialKeys.reduce(function (subObj, k, i) {
var nextKey = split[i + 1];
if (isNumStr(nextKey)) {
if (subObj[k] === null) subObj[k] = [];
if (subObj[k].length == parseInt(nextKey)) subObj[k].push(null);
} else if (subObj[k] === null || !isHash(subObj[k])) {
subObj[k] = {};
}
return subObj[k];
}, obj);
var deepObj = getDeep(obj, initialKeys);
deepObj[lastKey] = v;
return v;
};
var unsetDeep = function unsetDeep(obj, deepKey) {
var split = deepKey.split('.');
var initialKeys = _underscore2.default.initial(split);
var lastKey = _underscore2.default.last(split);
var deepObj = getDeep(obj, initialKeys);
if (_underscore2.default.isArray(deepObj) && isNumStr(lastKey)) return !!deepObj.splice(lastKey, 1);else return delete deepObj[lastKey];
};
var getDeep = function getDeep(obj, keys) {
return keys.reduce(function (subObj, k) {
return subObj[k];
}, obj);
};
var isHash = function isHash(obj) {
return _underscore2.default.isObject(obj) && Object.getPrototypeOf(obj) === Object.prototype;
};
var isNumStr = function isNumStr(str) {
return str.match(/^\d+$/);
};
return diffArray;
}]);
/***/ }),
/* 5 */
/***/ (function(module, exports) {
'use strict';
angular.module('angular-meteor.settings', []).constant('$angularMeteorSettings', {
suppressWarnings: true
});
/***/ }),
/* 6 */
/***/ (function(module, exports) {
'use strict';
angular.module('angular-meteor.ironrouter', []).run(['$compile', '$document', '$rootScope', function ($compile, $document, $rootScope) {
var Router = (Package['iron:router'] || {}).Router;
if (!Router) return;
var isLoaded = false;
// Recompile after iron:router builds page
Router.onAfterAction(function (req, res, next) {
Tracker.afterFlush(function () {
if (isLoaded) return;
$compile($document)($rootScope);
if (!$rootScope.$$phase) $rootScope.$apply();
isLoaded = true;
});
});
}]);
/***/ }),
/* 7 */
/***/ (function(module, exports, __webpack_require__) {
'use strict';
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; /*global
angular, _, Tracker, EJSON, FS, Mongo
*/
var _underscore = __webpack_require__(2);
var _underscore2 = _interopRequireDefault(_underscore);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
'use strict';
var angularMeteorUtils = angular.module('angular-meteor.utils', ['angular-meteor.settings']);
angularMeteorUtils.service('$meteorUtils', ['$q', '$timeout', '$angularMeteorSettings', function ($q, $timeout, $angularMeteorSettings) {
var self = this;
this.autorun = function (scope, fn) {
if (!$angularMeteorSettings.suppressWarnings) console.warn('[angular-meteor.utils.autorun] Please note that this method is deprecated since 1.3.0 and will be removed in 1.4.0! For more info: http://www.angular-meteor.com/api/1.3.6/autorun. You can disable this warning by following this guide http://www.angular-meteor.com/api/1.3.6/settings');
// wrapping around Deps.autorun
var comp = Tracker.autorun(function (c) {
fn(c);
// this is run immediately for the first call
// but after that, we need to $apply to start Angular digest
if (!c.firstRun) $timeout(angular.noop, 0);
});
// stop autorun when scope is destroyed
scope.$on('$destroy', function () {
comp.stop();
});
// return autorun object so that it can be stopped manually
return comp;
};
// Borrowed from angularFire
// https://github.com/firebase/angularfire/blob/master/src/utils.js#L445-L454
this.stripDollarPrefixedKeys = function (data) {
if (!_underscore2.default.isObject(data) || data instanceof Date || data instanceof File || EJSON.toJSONValue(data).$type === 'oid' || (typeof FS === 'undefined' ? 'undefined' : _typeof(FS)) === 'object' && data instanceof FS.File) return data;
var out = _underscore2.default.isArray(data) ? [] : {};
_underscore2.default.each(data, function (v, k) {
if (typeof k !== 'string' || k.charAt(0) !== '$') out[k] = self.stripDollarPrefixedKeys(v);
});
return out;
};
// Returns a callback which fulfills promise
this.fulfill = function (deferred, boundError, boundResult) {
return function (err, result) {
if (err) deferred.reject(boundError == null ? err : boundError);else if (typeof boundResult == "function") deferred.resolve(boundResult == null ? result : boundResult(result));else deferred.resolve(boundResult == null ? result : boundResult);
};
};
// creates a function which invokes method with the given arguments and returns a promise
this.promissor = function (obj, method) {
return function () {
var deferred = $q.defer();
var fulfill = self.fulfill(deferred);
var args = _underscore2.default.toArray(arguments).concat(fulfill);
obj[method].apply(obj, args);
return deferred.promise;
};
};
// creates a $q.all() promise and call digestion loop on fulfillment
this.promiseAll = function (promises) {
var allPromise = $q.all(promises);
allPromise.finally(function () {
// calls digestion loop with no conflicts
$timeout(angular.noop);
});
return allPromise;
};
this.getCollectionByName = function (string) {
return Mongo.Collection.get(string);
};
this.findIndexById = function (collection, doc) {
var foundDoc = _underscore2.default.find(collection, function (colDoc) {
// EJSON.equals used to compare Mongo.ObjectIDs and Strings.
return EJSON.equals(colDoc._id, doc._id);
});
return _underscore2.default.indexOf(collection, foundDoc);
};
}]);
angularMeteorUtils.run(['$rootScope', '$meteorUtils', function ($rootScope, $meteorUtils) {
Object.getPrototypeOf($rootScope).$meteorAutorun = function (fn) {
return $meteorUtils.autorun(this, fn);
};
}]);
/***/ }),
/* 8 */
/***/ (function(module, exports) {
/*global
angular, Meteor
*/
'use strict';
var angularMeteorSubscribe = angular.module('angular-meteor.subscribe', ['angular-meteor.settings']);
angularMeteorSubscribe.service('$meteorSubscribe', ['$q', '$angularMeteorSettings', function ($q, $angularMeteorSettings) {
var self = this;
this._subscribe = function (scope, deferred, args) {
if (!$angularMeteorSettings.suppressWarnings) console.warn('[angular-meteor.subscribe] Please note that this module is deprecated since 1.3.0 and will be removed in 1.4.0! Replace it with the new syntax described here: http://www.angular-meteor.com/api/1.3.6/subscribe. You can disable this warning by following this guide http://www.angular-meteor.com/api/1.3.6/settings');
var subscription = null;
var lastArg = args[args.length - 1];
// User supplied onStop callback
// save it for later use and remove
// from subscription arguments
if (angular.isObject(lastArg) && angular.isFunction(lastArg.onStop)) {
var _onStop = lastArg.onStop;
args.pop();
}
args.push({
onReady: function onReady() {
deferred.resolve(subscription);
},
onStop: function onStop(err) {
if (!deferred.promise.$$state.status) {
if (err) deferred.reject(err);else deferred.reject(new Meteor.Error("Subscription Stopped", "Subscription stopped by a call to stop method. Either by the client or by the server."));
} else if (_onStop)
// After promise was resolved or rejected
// call user supplied onStop callback.
_onStop.apply(this, Array.prototype.slice.call(arguments));
}
});
subscription = Meteor.subscribe.apply(scope, args);
return subscription;
};
this.subscribe = function () {
var deferred = $q.defer();
var args = Array.prototype.slice.call(arguments);
var subscription = null;
self._subscribe(this, deferred, args);
return deferred.promise;
};
}]);
angularMeteorSubscribe.run(['$rootScope', '$q', '$meteorSubscribe', function ($rootScope, $q, $meteorSubscribe) {
Object.getPrototypeOf($rootScope).$meteorSubscribe = function () {
var deferred = $q.defer();
var args = Array.prototype.slice.call(arguments);
var subscription = $meteorSubscribe._subscribe(this, deferred, args);
this.$on('$destroy', function () {
subscription.stop();
});
return deferred.promise;
};
}]);
/***/ }),
/* 9 */
/***/ (function(module, exports, __webpack_require__) {
'use strict';
var _underscore = __webpack_require__(2);
var _underscore2 = _interopRequireDefault(_underscore);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
'use strict'; /*global
angular, _, Tracker, check, Match, Mongo
*/
var angularMeteorCollection = angular.module('angular-meteor.collection', ['angular-meteor.stopper', 'angular-meteor.subscribe', 'angular-meteor.utils', 'diffArray', 'angular-meteor.settings']);
// The reason angular meteor collection is a factory function and not something
// that inherit from array comes from here:
// http://perfectionkills.com/how-ecmascript-5-still-does-not-allow-to-subclass-an-array/
// We went with the direct extensions approach.
angularMeteorCollection.factory('AngularMeteorCollection', ['$q', '$meteorSubscribe', '$meteorUtils', '$rootScope', '$timeout', 'diffArray', '$angularMeteorSettings', function ($q, $meteorSubscribe, $meteorUtils, $rootScope, $timeout, diffArray, $angularMeteorSettings) {
function AngularMeteorCollection(curDefFunc, collection, diffArrayFunc, autoClientSave) {
if (!$angularMeteorSettings.suppressWarnings) console.warn('[angular-meteor.$meteorCollection] Please note that this method is deprecated since 1.3.0 and will be removed in 1.4.0! For more info: http://www.angular-meteor.com/api/1.3.0/meteorCollection. You can disable this warning by following this guide http://www.angular-meteor.com/api/1.3.6/settings');
var data = [];
// Server backup data to evaluate what changes come from client
// after each server update.
data._serverBackup = [];
// Array differ function.
data._diffArrayFunc = diffArrayFunc;
// Handler of the cursor observer.
data._hObserve = null;
// On new cursor autorun handler
// (autorun for reactive variables).
data._hNewCurAutorun = null;
// On new data autorun handler
// (autorun for cursor.fetch).
data._hDataAutorun = null;
if (angular.isDefined(collection)) {
data.$$collection = collection;
} else {
var cursor = curDefFunc();
data.$$collection = $meteorUtils.getCollectionByName(cursor.collection.name);
}
_underscore2.default.extend(data, AngularMeteorCollection);
data._startCurAutorun(curDefFunc, autoClientSave);
return data;
}
AngularMeteorCollection._startCurAutorun = function (curDefFunc, autoClientSave) {
var self = this;
self._hNewCurAutorun = Tracker.autorun(function () {
// When the reactive func gets recomputated we need to stop any previous
// observeChanges.
Tracker.onInvalidate(function () {
self._stopCursor();
});
if (autoClientSave) self._setAutoClientSave();
self._updateCursor(curDefFunc(), autoClientSave);
});
};
AngularMeteorCollection.subscribe = function () {
$meteorSubscribe.subscribe.apply(this, arguments);
return this;
};
AngularMeteorCollection.save = function (docs, useUnsetModifier) {
// save whole collection
if (!docs) docs = this;
// save single doc
docs = [].concat(docs);
var promises = docs.map(function (doc) {
return this._upsertDoc(doc, useUnsetModifier);
}, this);
return $meteorUtils.promiseAll(promises);
};
AngularMeteorCollection._upsertDoc = function (doc, useUnsetModifier) {
var deferred = $q.defer();
var collection = this.$$collection;
var createFulfill = _underscore2.default.partial($meteorUtils.fulfill, deferred, null);
// delete $$hashkey
doc = $meteorUtils.stripDollarPrefixedKeys(doc);
var docId = doc._id;
var isExist = collection.findOne(docId);
// update
if (isExist) {
// Deletes _id property (from the copy) so that
// it can be $set using update.
delete doc._id;
var modifier = useUnsetModifier ? { $unset: doc } : { $set: doc };
// NOTE: do not use #upsert() method, since it does not exist in some collections
collection.update(docId, modifier, createFulfill(function () {
return { _id: docId, action: 'updated' };
}));
}
// insert
else {
collection.insert(doc, createFulfill(function (id) {
return { _id: id, action: 'inserted' };
}));
}
return deferred.promise;
};
// performs $pull operations parallely.
// used for handling splice operations returned from getUpdates() to prevent conflicts.
// see issue: https://github.com/Urigo/angular-meteor/issues/793
AngularMeteorCollection._updateDiff = function (selector, update, callback) {
callback = callback || angular.noop;
var setters = _underscore2.default.omit(update, '$pull');
var updates = [setters];
_underscore2.default.each(update.$pull, function (pull, prop) {
var puller = {};
puller[prop] = pull;
updates.push({ $pull: puller });
});
this._updateParallel(selector, updates, callback);
};
// performs each update operation parallely
AngularMeteorCollection._updateParallel = function (selector, updates, callback) {
var self = this;
var done = _underscore2.default.after(updates.length, callback);
var next = function next(err, affectedDocsNum) {
if (err) return callback(err);
done(null, affectedDocsNum);
};
_underscore2.default.each(updates, function (update) {
self.$$collection.update(selector, update, next);
});
};
AngularMeteorCollection.remove = function (keyOrDocs) {
var keys;
// remove whole collection
if (!keyOrDocs) {
keys = _underscore2.default.pluck(this, '_id');
}
// remove docs
else {
keyOrDocs = [].concat(keyOrDocs);
keys = _underscore2.default.map(keyOrDocs, function (keyOrDoc) {
return keyOrDoc._id || keyOrDoc;
});
}
// Checks if all keys are correct.
check(keys, [Match.OneOf(String, Mongo.ObjectID)]);
var promises = keys.map(function (key) {
return this._removeDoc(key);
}, this);
return $meteorUtils.promiseAll(promises);
};
AngularMeteorCollection._removeDoc = function (id) {
var deferred = $q.defer();
var collection = this.$$collection;
var fulfill = $meteorUtils.fulfill(deferred, null, { _id: id, action: 'removed' });
collection.remove(id, fulfill);
return deferred.promise;
};
AngularMeteorCollection._updateCursor = function (cursor, autoClientSave) {
var self = this;
// XXX - consider adding an option for a non-orderd result for faster performance
if (self._hObserve) self._stopObserving();
self._hObserve = cursor.observe({
addedAt: function addedAt(doc, atIndex) {
self.splice(atIndex, 0, doc);
self._serverBackup.splice(atIndex, 0, doc);
self._setServerUpdateMode();
},
changedAt: function changedAt(doc, oldDoc, atIndex) {
diffArray.deepCopyChanges(self[atIndex], doc);
diffArray.deepCopyRemovals(self[atIndex], doc);
self._serverBackup[atIndex] = self[atIndex];
self._setServerUpdateMode();
},
movedTo: function movedTo(doc, fromIndex, toIndex) {
self.splice(fromIndex, 1);
self.splice(toIndex, 0, doc);
self._serverBackup.splice(fromIndex, 1);
self._serverBackup.splice(toIndex, 0, doc);
self._setServerUpdateMode();
},
removedAt: function removedAt(oldDoc) {
var removedIndex = $meteorUtils.findIndexById(self, oldDoc);
if (removedIndex != -1) {
self.splice(removedIndex, 1);
self._serverBackup.splice(removedIndex, 1);
self._setServerUpdateMode();
} else {
// If it's been removed on client then it's already not in collection
// itself but still is in the _serverBackup.
removedIndex = $meteorUtils.findIndexById(self._serverBackup, oldDoc);
if (removedIndex != -1) {
self._serverBackup.splice(removedIndex, 1);
}
}
}
});
self._hDataAutorun = Tracker.autorun(function () {
cursor.fetch();
if (self._serverMode) self._unsetServerUpdateMode(autoClientSave);
});
};
AngularMeteorCollection._stopObserving = function () {
this._hObserve.stop();
this._hDataAutorun.stop();
delete this._serverMode;
delete this._hUnsetTimeout;
};
AngularMeteorCollection._setServerUpdateMode = function (name) {
this._serverMode = true;
// To simplify server update logic, we don't follow
// updates from the client at the same time.
this._unsetAutoClientSave();
};
// Here we use $timeout to combine multiple updates that go
// each one after another.
AngularMeteorCollection._unsetServerUpdateMode = function (autoClientSave) {
var self = this;
if (self._hUnsetTimeout) {
$timeout.cancel(self._hUnsetTimeout);
self._hUnsetTimeout = null;
}
self._hUnsetTimeout = $timeout(function () {
self._serverMode = false;
// Finds updates that was potentially done from the client side
// and saves them.
var changes = diffArray.getChanges(self, self._serverBackup, self._diffArrayFunc);
self._saveChanges(changes);
// After, continues following client updates.
if (autoClientSave) self._setAutoClientSave();
}, 0);
};
AngularMeteorCollection.stop = function () {
this._stopCursor();
this._hNewCurAutorun.stop();
};
AngularMeteorCollection._stopCursor = function () {
this._unsetAutoClientSave();
if (this._hObserve) {
this._hObserve.stop();
this._hDataAutorun.stop();
}
this.splice(0);
this._serverBackup.splice(0);
};
AngularMeteorCollection._unsetAutoClientSave = function (name) {
if (this._hRegAutoBind) {
this._hRegAutoBind();
this._hRegAutoBind = null;
}
};
AngularMeteorCollection._setAutoClientSave = function () {
var self = this;
// Always unsets auto save to keep only one $watch handler.
self._unsetAutoClientSave();
self._hRegAutoBind = $rootScope.$watch(function () {
return self;
}, function (nItems, oItems) {
if (nItems === oItems) return;
var changes = diffArray.getChanges(self, oItems, self._diffArrayFunc);
self._unsetAutoClientSave();
self._saveChanges(changes);
self._setAutoClientSave();
}, true);
};
AngularMeteorCollection._saveChanges = function (changes) {
var self = this;
// Saves added documents
// Using reversed iteration to prevent indexes from changing during splice
var addedDocs = changes.added.reverse().map(function (descriptor) {
self.splice(descriptor.index, 1);
return descriptor.item;
});
if (addedDocs.length) self.save(addedDocs);
// Removes deleted documents
var removedDocs = changes.removed.map(function (descriptor) {
return descriptor.item;
});
if (removedDocs.length) self.remove(removedDocs);
// Updates changed documents
changes.changed.forEach(function (descriptor) {
self._updateDiff(descriptor.selector, descriptor.modifier);
});
};
return AngularMeteorCollection;
}]);
angularMeteorCollection.factory('$meteorCollectionFS', ['$meteorCollection', 'diffArray', '$angularMeteorSettings', function ($meteorCollection, diffArray, $angularMeteorSettings) {
function $meteorCollectionFS(reactiveFunc, autoClientSave, collection) {
if (!$angularMeteorSettings.suppressWarnings) console.warn('[angular-meteor.$meteorCollectionFS] Please note that this method is deprecated since 1.3.0 and will be removed in 1.4.0! For more info: http://www.angular-meteor.com/api/1.3.0/files. You can disable this warning by following this guide http://www.angular-meteor.com/api/1.3.6/settings');
return new $meteorCollection(reactiveFunc, autoClientSave, collection, diffArray.shallow);
}
return $meteorCollectionFS;
}]);
angularMeteorCollection.factory('$meteorCollection', ['AngularMeteorCollection', '$rootScope', 'diffArray', function (AngularMeteorCollection, $rootScope, diffArray) {
function $meteorCollection(reactiveFunc, autoClientSave, collection, diffFn) {
// Validate parameters
if (!reactiveFunc) {
throw new TypeError('The first argument of $meteorCollection is undefined.');
}
if (!(angular.isFunction(reactiveFunc) || angular.isFunction(reactiveFunc.find))) {
throw new TypeError('The first argument of $meteorCollection must be a function or ' + 'a have a find function property.');
}
if (!angular.isFunction(reactiveFunc)) {
collection = angular.isDefined(collection) ? collection : reactiveFunc;
reactiveFunc = _underscore2.default.bind(reactiveFunc.find, reactiveFunc);
}
// By default auto save - true.
autoClientSave = angular.isDefined(autoClientSave) ? autoClientSave : true;
diffFn = diffFn || diffArray;
return new AngularMeteorCollection(reactiveFunc, collection, diffFn, autoClientSave);
}
return $meteorCollection;
}]);
angularMeteorCollection.run(['$rootScope', '$meteorCollection', '$meteorCollectionFS', '$meteorStopper', function ($rootScope, $meteorCollection, $meteorCollectionFS, $meteorStopper) {
var scopeProto = Object.getPrototypeOf($rootScope);
scopeProto.$meteorCollection = $meteorStopper($meteorCollection);
scopeProto.$meteorCollectionFS = $meteorStopper($meteorCollectionFS);
}]);
/***/ }),
/* 10 */
/***/ (function(module, exports, __webpack_require__) {
'use strict';
var _underscore = __webpack_require__(2);
var _underscore2 = _interopRequireDefault(_underscore);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
'use strict'; /*global
angular, _, Mongo
*/
var angularMeteorObject = angular.module('angular-meteor.object', ['angular-meteor.utils', 'angular-meteor.subscribe', 'angular-meteor.collection', 'getUpdates', 'diffArray', 'angular-meteor.settings']);
angularMeteorObject.factory('AngularMeteorObject', ['$q', '$meteorSubscribe', '$meteorUtils', 'diffArray', 'getUpdates', 'AngularMeteorCollection', '$angularMeteorSettings', function ($q, $meteorSubscribe, $meteorUtils, diffArray, getUpdates, AngularMeteorCollection, $angularMeteorSettings) {
// A list of internals properties to not watch for, nor pass to the Document on update and etc.
AngularMeteorObject.$$internalProps = ['$$collection', '$$options', '$$id', '$$hashkey', '$$internalProps', '$$scope', 'bind', 'save', 'reset', 'subscribe', 'stop', 'autorunComputation', 'unregisterAutoBind', 'unregisterAutoDestroy', 'getRawObject', '_auto', '_setAutos', '_eventEmitter', '_serverBackup', '_updateDiff', '_updateParallel', '_getId'];
function AngularMeteorObject(collection, selector, options) {
if (!$angularMeteorSettings.suppressWarnings) console.warn('[angular-meteor.$meteorObject] Please note that this method is deprecated since 1.3.0 and will be removed in 1.4.0! For more info: http://www.angular-meteor.com/api/1.3.0/meteorObject. You can disable this warning by following this guide http://www.angular-meteor.com/api/1.3.6/settings');
// Make data not be an object so we can extend it to preserve
// Collection Helpers and the like
var helpers = collection._helpers;
var data = _underscore2.default.isFunction(helpers) ? Object.create(helpers.prototype) : {};
var doc = collection.findOne(selector, options);
var collectionExtension = _underscore2.default.pick(AngularMeteorCollection, '_updateParallel');
_underscore2.default.extend(data, doc);
_underscore2.default.extend(data, AngularMeteorObject);
_underscore2.default.extend(data, collectionExtension);
// Omit options that may spoil document finding
data.$$options = _underscore2.default.omit(options, 'skip', 'limit');
data.$$collection = collection;
data.$$id = data._getId(selector);
data._serverBackup = doc || {};
return data;
}
AngularMeteorObject.getRawObject = function () {
return angular.copy(_underscore2.default.omit(this, this.$$internalProps));
};
AngularMeteorObject.subscribe = function () {
$meteorSubscribe.subscribe.apply(this, arguments);
return this;
};
AngularMeteorObject.save = function (custom) {
var deferred = $q.defer();
var collection = this.$$collection;
var createFulfill = _underscore2.default.partial($meteorUtils.fulfill, deferred, null);
var oldDoc = collection.findOne(this.$$id);
var mods;
// update
if (oldDoc) {
if (custom) mods = { $set: custom };else {
mods = getUpdates(oldDoc, this.getRawObject());
// If there are no updates, there is nothing to do here, returning
if (_underscore2.default.isEmpty(mods)) {
return $q.when({ action: 'updated' });
}
}
// NOTE: do not use #upsert() method, since it does not exist in some collections
this._updateDiff(mods, createFulfill({ action: 'updated' }));
}
// insert
else {
if (custom) mods = _underscore2.default.clone(custom);else mods = this.getRawObject();
mods._id = mods._id || this.$$id;
collection.insert(mods, createFulfill({ action: 'inserted' }));
}
return deferred.promise;
};
AngularMeteorObject._updateDiff = function (update, callback) {
var selector = this.$$id;
AngularMeteorCollection._updateDiff.call(this, selector, update, callback);
};
AngularMeteorObject.reset = function (keepClientProps) {
var self = this;
var options = this.$$options;
var id = this.$$id;
var doc = this.$$collection.findOne(id, options);
if (doc) {
// extend SubObject
var docKeys = _underscore2.default.keys(doc);
var docExtension = _underscore2.default.pick(doc, docKeys);
var clientProps;
_underscore2.default.extend(self, docExtension);
_underscore2.default.extend(self._serverBackup, docExtension);
if (keepClientProps) {
clientProps = _underscore2.default.intersection(_underscore2.default.keys(self), _underscore2.default.keys(self._serverBackup));
} else {
clientProps = _underscore2.default.keys(self);
}
var serverProps = _underscore2.default.keys(doc);
var removedKeys = _underscore2.default.difference(clientProps, serverProps, self.$$internalProps);
removedKeys.forEach(function (prop) {
delete self[prop];
delete self._serverBackup[prop];
});
} else {
_underscore2.default.keys(this.getRawObject()).forEach(function (prop) {
delete self[prop];
});
self._serverBackup = {};
}
};
AngularMeteorObject.stop = function () {
if (this.unregisterAutoDestroy) this.unregisterAutoDestroy();
if (this.unregisterAutoBind) this.unregisterAutoBind();
if (this.autorunComputation && this.autorunComputation.stop) this.autorunComputation.stop();
};
AngularMeteorObject._getId = function (selector) {
var options = _underscore2.default.extend({}, this.$$options, {
fields: { _id: 1 },
reactive: false,
transform: null
});
var doc = this.$$collection.findOne(selector, options);
if (doc) return doc._id;
if (selector instanceof Mongo.ObjectID) return selector;
if (_underscore2.default.isString(selector)) return selector;
return new Mongo.ObjectID();
};
return AngularMeteorObject;
}]);
angularMeteorObject.factory('$meteorObject', ['$rootScope', '$meteorUtils', 'getUpdates', 'AngularMeteorObject', function ($rootScope, $meteorUtils, getUpdates, AngularMeteorObject) {
function $meteorObject(collection, id, auto, options) {
// Validate parameters
if (!collection) {
throw new TypeError("The first argument of $meteorObject is undefined.");
}
if (!angular.isFunction(collection.findOne)) {
throw new TypeError("The first argument of $meteorObject must be a function or a have a findOne function property.");
}
var data = new AngularMeteorObject(collection, id, options);
// Making auto default true - http://stackoverflow.com/a/15464208/1426570
data._auto = auto !== false;
_underscore2.default.extend(data, $meteorObject);
data._setAutos();
return data;
}
$meteorObject._setAutos = function () {
var self = this;
this.autorunComputation = $meteorUtils.autorun($rootScope, function () {
self.reset(true);
});
// Deep watches the model and performs autobind
this.unregisterAutoBind = this._auto && $rootScope.$watch(function () {
return self.getRawObject();
}, function (item, oldItem) {
if (item !== oldItem) self.save();
}, true);
this.unregisterAutoDestroy = $rootScope.$on('$destroy', function () {
if (self && self.stop) self.stop();
});
};
return $meteorObject;
}]);
angularMeteorObject.run(['$rootScope', '$meteorObject', '$meteorStopper', function ($rootScope, $meteorObject, $meteorStopper) {
var scopeProto = Object.getPrototypeOf($rootScope);
scopeProto.$meteorObject = $meteorStopper($meteorObject);
}]);
/***/ }),
/* 11 */
/***/ (function(module, exports, __webpack_require__) {
'use strict';
var _underscore = __webpack_require__(2);
var _underscore2 = _interopRequireDefault(_underscore);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
'use strict'; /*global
angular, _, Package, Meteor
*/
var angularMeteorUser = angular.module('angular-meteor.user', ['angular-meteor.utils', 'angular-meteor.core', 'angular-meteor.settings']);
// requires package 'accounts-password'
angularMeteorUser.service('$meteorUser', ['$rootScope', '$meteorUtils', '$q', '$angularMeteorSettings', function ($rootScope, $meteorUtils, $q, $angularMeteorSettings) {
var pack = Package['accounts-base'];
if (!pack) return;
var self = this;
var Accounts = pack.Accounts;
this.waitForUser = function () {
if (!$angularMeteorSettings.suppressWarnings) console.warn('[angular-meteor.waitForUser] Please note that this method is deprecated since 1.3.0 and will be removed in 1.4.0! http://info.meteor.com/blog/angular-meteor-1.3. You can disable this warning by following this guide http://www.angular-meteor.com/api/1.3.6/settings');
var deferred = $q.defer();
$meteorUtils.autorun($rootScope, function () {
if (!Meteor.loggingIn()) deferred.resolve(Meteor.user());
}, true);
return deferred.promise;
};
this.requireUser = function () {
if (!$angularMeteorSettings.suppressWarnings) {
console.warn('[angular-meteor.requireUser] Please note that this method is deprecated since 1.3.0 and will be removed in 1.4.0! http://info.meteor.com/blog/angular-meteor-1.3. You can disable this warning by following this guide http://www.angular-meteor.com/api/1.3.6/settings');
}
var deferred = $q.defer();
$meteorUtils.autorun($rootScope, function () {
if (!Meteor.loggingIn()) {
if (Meteor.user() === null) deferred.reject("AUTH_REQUIRED");else deferred.resolve(Meteor.user());
}
}, true);
return deferred.promise;
};
this.requireV