diff options
Diffstat (limited to 'cvp/3rd_party/static/testapi-ui/assets/lib/angular-ui-router/src/resolve.js')
| -rw-r--r-- | cvp/3rd_party/static/testapi-ui/assets/lib/angular-ui-router/src/resolve.js | 252 |
1 files changed, 0 insertions, 252 deletions
diff --git a/cvp/3rd_party/static/testapi-ui/assets/lib/angular-ui-router/src/resolve.js b/cvp/3rd_party/static/testapi-ui/assets/lib/angular-ui-router/src/resolve.js deleted file mode 100644 index f1c17900..00000000 --- a/cvp/3rd_party/static/testapi-ui/assets/lib/angular-ui-router/src/resolve.js +++ /dev/null @@ -1,252 +0,0 @@ -/** - * @ngdoc object - * @name ui.router.util.$resolve - * - * @requires $q - * @requires $injector - * - * @description - * Manages resolution of (acyclic) graphs of promises. - */ -$Resolve.$inject = ['$q', '$injector']; -function $Resolve( $q, $injector) { - - var VISIT_IN_PROGRESS = 1, - VISIT_DONE = 2, - NOTHING = {}, - NO_DEPENDENCIES = [], - NO_LOCALS = NOTHING, - NO_PARENT = extend($q.when(NOTHING), { $$promises: NOTHING, $$values: NOTHING }); - - - /** - * @ngdoc function - * @name ui.router.util.$resolve#study - * @methodOf ui.router.util.$resolve - * - * @description - * Studies a set of invocables that are likely to be used multiple times. - * <pre> - * $resolve.study(invocables)(locals, parent, self) - * </pre> - * is equivalent to - * <pre> - * $resolve.resolve(invocables, locals, parent, self) - * </pre> - * but the former is more efficient (in fact `resolve` just calls `study` - * internally). - * - * @param {object} invocables Invocable objects - * @return {function} a function to pass in locals, parent and self - */ - this.study = function (invocables) { - if (!isObject(invocables)) throw new Error("'invocables' must be an object"); - var invocableKeys = objectKeys(invocables || {}); - - // Perform a topological sort of invocables to build an ordered plan - var plan = [], cycle = [], visited = {}; - function visit(value, key) { - if (visited[key] === VISIT_DONE) return; - - cycle.push(key); - if (visited[key] === VISIT_IN_PROGRESS) { - cycle.splice(0, indexOf(cycle, key)); - throw new Error("Cyclic dependency: " + cycle.join(" -> ")); - } - visited[key] = VISIT_IN_PROGRESS; - - if (isString(value)) { - plan.push(key, [ function() { return $injector.get(value); }], NO_DEPENDENCIES); - } else { - var params = $injector.annotate(value); - forEach(params, function (param) { - if (param !== key && invocables.hasOwnProperty(param)) visit(invocables[param], param); - }); - plan.push(key, value, params); - } - - cycle.pop(); - visited[key] = VISIT_DONE; - } - forEach(invocables, visit); - invocables = cycle = visited = null; // plan is all that's required - - function isResolve(value) { - return isObject(value) && value.then && value.$$promises; - } - - return function (locals, parent, self) { - if (isResolve(locals) && self === undefined) { - self = parent; parent = locals; locals = null; - } - if (!locals) locals = NO_LOCALS; - else if (!isObject(locals)) { - throw new Error("'locals' must be an object"); - } - if (!parent) parent = NO_PARENT; - else if (!isResolve(parent)) { - throw new Error("'parent' must be a promise returned by $resolve.resolve()"); - } - - // To complete the overall resolution, we have to wait for the parent - // promise and for the promise for each invokable in our plan. - var resolution = $q.defer(), - result = resolution.promise, - promises = result.$$promises = {}, - values = extend({}, locals), - wait = 1 + plan.length/3, - merged = false; - - function done() { - // Merge parent values we haven't got yet and publish our own $$values - if (!--wait) { - if (!merged) merge(values, parent.$$values); - result.$$values = values; - result.$$promises = result.$$promises || true; // keep for isResolve() - delete result.$$inheritedValues; - resolution.resolve(values); - } - } - - function fail(reason) { - result.$$failure = reason; - resolution.reject(reason); - } - - // Short-circuit if parent has already failed - if (isDefined(parent.$$failure)) { - fail(parent.$$failure); - return result; - } - - if (parent.$$inheritedValues) { - merge(values, omit(parent.$$inheritedValues, invocableKeys)); - } - - // Merge parent values if the parent has already resolved, or merge - // parent promises and wait if the parent resolve is still in progress. - extend(promises, parent.$$promises); - if (parent.$$values) { - merged = merge(values, omit(parent.$$values, invocableKeys)); - result.$$inheritedValues = omit(parent.$$values, invocableKeys); - done(); - } else { - if (parent.$$inheritedValues) { - result.$$inheritedValues = omit(parent.$$inheritedValues, invocableKeys); - } - parent.then(done, fail); - } - - // Process each invocable in the plan, but ignore any where a local of the same name exists. - for (var i=0, ii=plan.length; i<ii; i+=3) { - if (locals.hasOwnProperty(plan[i])) done(); - else invoke(plan[i], plan[i+1], plan[i+2]); - } - - function invoke(key, invocable, params) { - // Create a deferred for this invocation. Failures will propagate to the resolution as well. - var invocation = $q.defer(), waitParams = 0; - function onfailure(reason) { - invocation.reject(reason); - fail(reason); - } - // Wait for any parameter that we have a promise for (either from parent or from this - // resolve; in that case study() will have made sure it's ordered before us in the plan). - forEach(params, function (dep) { - if (promises.hasOwnProperty(dep) && !locals.hasOwnProperty(dep)) { - waitParams++; - promises[dep].then(function (result) { - values[dep] = result; - if (!(--waitParams)) proceed(); - }, onfailure); - } - }); - if (!waitParams) proceed(); - function proceed() { - if (isDefined(result.$$failure)) return; - try { - invocation.resolve($injector.invoke(invocable, self, values)); - invocation.promise.then(function (result) { - values[key] = result; - done(); - }, onfailure); - } catch (e) { - onfailure(e); - } - } - // Publish promise synchronously; invocations further down in the plan may depend on it. - promises[key] = invocation.promise; - } - - return result; - }; - }; - - /** - * @ngdoc function - * @name ui.router.util.$resolve#resolve - * @methodOf ui.router.util.$resolve - * - * @description - * Resolves a set of invocables. An invocable is a function to be invoked via - * `$injector.invoke()`, and can have an arbitrary number of dependencies. - * An invocable can either return a value directly, - * or a `$q` promise. If a promise is returned it will be resolved and the - * resulting value will be used instead. Dependencies of invocables are resolved - * (in this order of precedence) - * - * - from the specified `locals` - * - from another invocable that is part of this `$resolve` call - * - from an invocable that is inherited from a `parent` call to `$resolve` - * (or recursively - * - from any ancestor `$resolve` of that parent). - * - * The return value of `$resolve` is a promise for an object that contains - * (in this order of precedence) - * - * - any `locals` (if specified) - * - the resolved return values of all injectables - * - any values inherited from a `parent` call to `$resolve` (if specified) - * - * The promise will resolve after the `parent` promise (if any) and all promises - * returned by injectables have been resolved. If any invocable - * (or `$injector.invoke`) throws an exception, or if a promise returned by an - * invocable is rejected, the `$resolve` promise is immediately rejected with the - * same error. A rejection of a `parent` promise (if specified) will likewise be - * propagated immediately. Once the `$resolve` promise has been rejected, no - * further invocables will be called. - * - * Cyclic dependencies between invocables are not permitted and will caues `$resolve` - * to throw an error. As a special case, an injectable can depend on a parameter - * with the same name as the injectable, which will be fulfilled from the `parent` - * injectable of the same name. This allows inherited values to be decorated. - * Note that in this case any other injectable in the same `$resolve` with the same - * dependency would see the decorated value, not the inherited value. - * - * Note that missing dependencies -- unlike cyclic dependencies -- will cause an - * (asynchronous) rejection of the `$resolve` promise rather than a (synchronous) - * exception. - * - * Invocables are invoked eagerly as soon as all dependencies are available. - * This is true even for dependencies inherited from a `parent` call to `$resolve`. - * - * As a special case, an invocable can be a string, in which case it is taken to - * be a service name to be passed to `$injector.get()`. This is supported primarily - * for backwards-compatibility with the `resolve` property of `$routeProvider` - * routes. - * - * @param {object} invocables functions to invoke or - * `$injector` services to fetch. - * @param {object} locals values to make available to the injectables - * @param {object} parent a promise returned by another call to `$resolve`. - * @param {object} self the `this` for the invoked methods - * @return {object} Promise for an object that contains the resolved return value - * of all invocables, as well as any inherited and local values. - */ - this.resolve = function (invocables, locals, parent, self) { - return this.study(invocables)(locals, parent, self); - }; -} - -angular.module('ui.router.util').service('$resolve', $Resolve); - |