| /** |
| * @license AngularJS v1.2.3 |
| * (c) 2010-2014 Google, Inc. http://angularjs.org |
| * License: MIT |
| */ |
| (function(window, angular, undefined) {'use strict'; |
| |
| /** |
| * @ngdoc overview |
| * @name ngRoute |
| * @description |
| * |
| * # ngRoute |
| * |
| * The `ngRoute` module provides routing and deeplinking services and directives for angular apps. |
| * |
| * ## Example |
| * See {@link ngRoute.$route#example $route} for an example of configuring and using `ngRoute`. |
| * |
| * {@installModule route} |
| * |
| * <div doc-module-components="ngRoute"></div> |
| */ |
| /* global -ngRouteModule */ |
| var ngRouteModule = angular.module('ngRoute', ['ng']). |
| provider('$route', $RouteProvider); |
| |
| /** |
| * @ngdoc object |
| * @name ngRoute.$routeProvider |
| * @function |
| * |
| * @description |
| * |
| * Used for configuring routes. |
| * |
| * ## Example |
| * See {@link ngRoute.$route#example $route} for an example of configuring and using `ngRoute`. |
| * |
| * ## Dependencies |
| * Requires the {@link ngRoute `ngRoute`} module to be installed. |
| */ |
| function $RouteProvider(){ |
| function inherit(parent, extra) { |
| return angular.extend(new (angular.extend(function() {}, {prototype:parent}))(), extra); |
| } |
| |
| var routes = {}; |
| |
| /** |
| * @ngdoc method |
| * @name ngRoute.$routeProvider#when |
| * @methodOf ngRoute.$routeProvider |
| * |
| * @param {string} path Route path (matched against `$location.path`). If `$location.path` |
| * contains redundant trailing slash or is missing one, the route will still match and the |
| * `$location.path` will be updated to add or drop the trailing slash to exactly match the |
| * route definition. |
| * |
| * * `path` can contain named groups starting with a colon (`:name`). All characters up |
| * to the next slash are matched and stored in `$routeParams` under the given `name` |
| * when the route matches. |
| * * `path` can contain named groups starting with a colon and ending with a star (`:name*`). |
| * All characters are eagerly stored in `$routeParams` under the given `name` |
| * when the route matches. |
| * * `path` can contain optional named groups with a question mark (`:name?`). |
| * |
| * For example, routes like `/color/:color/largecode/:largecode*\/edit` will match |
| * `/color/brown/largecode/code/with/slashs/edit` and extract: |
| * |
| * * `color: brown` |
| * * `largecode: code/with/slashs`. |
| * |
| * |
| * @param {Object} route Mapping information to be assigned to `$route.current` on route |
| * match. |
| * |
| * Object properties: |
| * |
| * - `controller` – `{(string|function()=}` – Controller fn that should be associated with |
| * newly created scope or the name of a {@link angular.Module#controller registered |
| * controller} if passed as a string. |
| * - `controllerAs` – `{string=}` – A controller alias name. If present the controller will be |
| * published to scope under the `controllerAs` name. |
| * - `template` – `{string=|function()=}` – html template as a string or a function that |
| * returns an html template as a string which should be used by {@link |
| * ngRoute.directive:ngView ngView} or {@link ng.directive:ngInclude ngInclude} directives. |
| * This property takes precedence over `templateUrl`. |
| * |
| * If `template` is a function, it will be called with the following parameters: |
| * |
| * - `{Array.<Object>}` - route parameters extracted from the current |
| * `$location.path()` by applying the current route |
| * |
| * - `templateUrl` – `{string=|function()=}` – path or function that returns a path to an html |
| * template that should be used by {@link ngRoute.directive:ngView ngView}. |
| * |
| * If `templateUrl` is a function, it will be called with the following parameters: |
| * |
| * - `{Array.<Object>}` - route parameters extracted from the current |
| * `$location.path()` by applying the current route |
| * |
| * - `resolve` - `{Object.<string, function>=}` - An optional map of dependencies which should |
| * be injected into the controller. If any of these dependencies are promises, the router |
| * will wait for them all to be resolved or one to be rejected before the controller is |
| * instantiated. |
| * If all the promises are resolved successfully, the values of the resolved promises are |
| * injected and {@link ngRoute.$route#$routeChangeSuccess $routeChangeSuccess} event is |
| * fired. If any of the promises are rejected the |
| * {@link ngRoute.$route#$routeChangeError $routeChangeError} event is fired. The map object |
| * is: |
| * |
| * - `key` – `{string}`: a name of a dependency to be injected into the controller. |
| * - `factory` - `{string|function}`: If `string` then it is an alias for a service. |
| * Otherwise if function, then it is {@link api/AUTO.$injector#invoke injected} |
| * and the return value is treated as the dependency. If the result is a promise, it is |
| * resolved before its value is injected into the controller. Be aware that |
| * `ngRoute.$routeParams` will still refer to the previous route within these resolve |
| * functions. Use `$route.current.params` to access the new route parameters, instead. |
| * |
| * - `redirectTo` – {(string|function())=} – value to update |
| * {@link ng.$location $location} path with and trigger route redirection. |
| * |
| * If `redirectTo` is a function, it will be called with the following parameters: |
| * |
| * - `{Object.<string>}` - route parameters extracted from the current |
| * `$location.path()` by applying the current route templateUrl. |
| * - `{string}` - current `$location.path()` |
| * - `{Object}` - current `$location.search()` |
| * |
| * The custom `redirectTo` function is expected to return a string which will be used |
| * to update `$location.path()` and `$location.search()`. |
| * |
| * - `[reloadOnSearch=true]` - {boolean=} - reload route when only `$location.search()` |
| * or `$location.hash()` changes. |
| * |
| * If the option is set to `false` and url in the browser changes, then |
| * `$routeUpdate` event is broadcasted on the root scope. |
| * |
| * - `[caseInsensitiveMatch=false]` - {boolean=} - match routes without being case sensitive |
| * |
| * If the option is set to `true`, then the particular route can be matched without being |
| * case sensitive |
| * |
| * @returns {Object} self |
| * |
| * @description |
| * Adds a new route definition to the `$route` service. |
| */ |
| this.when = function(path, route) { |
| routes[path] = angular.extend( |
| {reloadOnSearch: true}, |
| route, |
| path && pathRegExp(path, route) |
| ); |
| |
| // create redirection for trailing slashes |
| if (path) { |
| var redirectPath = (path[path.length-1] == '/') |
| ? path.substr(0, path.length-1) |
| : path +'/'; |
| |
| routes[redirectPath] = angular.extend( |
| {redirectTo: path}, |
| pathRegExp(redirectPath, route) |
| ); |
| } |
| |
| return this; |
| }; |
| |
| /** |
| * @param path {string} path |
| * @param opts {Object} options |
| * @return {?Object} |
| * |
| * @description |
| * Normalizes the given path, returning a regular expression |
| * and the original path. |
| * |
| * Inspired by pathRexp in visionmedia/express/lib/utils.js. |
| */ |
| function pathRegExp(path, opts) { |
| var insensitive = opts.caseInsensitiveMatch, |
| ret = { |
| originalPath: path, |
| regexp: path |
| }, |
| keys = ret.keys = []; |
| |
| path = path |
| .replace(/([().])/g, '\\$1') |
| .replace(/(\/)?:(\w+)([\?|\*])?/g, function(_, slash, key, option){ |
| var optional = option === '?' ? option : null; |
| var star = option === '*' ? option : null; |
| keys.push({ name: key, optional: !!optional }); |
| slash = slash || ''; |
| return '' |
| + (optional ? '' : slash) |
| + '(?:' |
| + (optional ? slash : '') |
| + (star && '(.+?)' || '([^/]+)') |
| + (optional || '') |
| + ')' |
| + (optional || ''); |
| }) |
| .replace(/([\/$\*])/g, '\\$1'); |
| |
| ret.regexp = new RegExp('^' + path + '$', insensitive ? 'i' : ''); |
| return ret; |
| } |
| |
| /** |
| * @ngdoc method |
| * @name ngRoute.$routeProvider#otherwise |
| * @methodOf ngRoute.$routeProvider |
| * |
| * @description |
| * Sets route definition that will be used on route change when no other route definition |
| * is matched. |
| * |
| * @param {Object} params Mapping information to be assigned to `$route.current`. |
| * @returns {Object} self |
| */ |
| this.otherwise = function(params) { |
| this.when(null, params); |
| return this; |
| }; |
| |
| |
| this.$get = ['$rootScope', |
| '$location', |
| '$routeParams', |
| '$q', |
| '$injector', |
| '$http', |
| '$templateCache', |
| '$sce', |
| function($rootScope, $location, $routeParams, $q, $injector, $http, $templateCache, $sce) { |
| |
| /** |
| * @ngdoc object |
| * @name ngRoute.$route |
| * @requires $location |
| * @requires $routeParams |
| * |
| * @property {Object} current Reference to the current route definition. |
| * The route definition contains: |
| * |
| * - `controller`: The controller constructor as define in route definition. |
| * - `locals`: A map of locals which is used by {@link ng.$controller $controller} service for |
| * controller instantiation. The `locals` contain |
| * the resolved values of the `resolve` map. Additionally the `locals` also contain: |
| * |
| * - `$scope` - The current route scope. |
| * - `$template` - The current route template HTML. |
| * |
| * @property {Array.<Object>} routes Array of all configured routes. |
| * |
| * @description |
| * `$route` is used for deep-linking URLs to controllers and views (HTML partials). |
| * It watches `$location.url()` and tries to map the path to an existing route definition. |
| * |
| * Requires the {@link ngRoute `ngRoute`} module to be installed. |
| * |
| * You can define routes through {@link ngRoute.$routeProvider $routeProvider}'s API. |
| * |
| * The `$route` service is typically used in conjunction with the |
| * {@link ngRoute.directive:ngView `ngView`} directive and the |
| * {@link ngRoute.$routeParams `$routeParams`} service. |
| * |
| * @example |
| This example shows how changing the URL hash causes the `$route` to match a route against the |
| URL, and the `ngView` pulls in the partial. |
| |
| Note that this example is using {@link ng.directive:script inlined templates} |
| to get it working on jsfiddle as well. |
| |
| <example module="ngViewExample" deps="angular-route.js"> |
| <file name="index.html"> |
| <div ng-controller="MainCntl"> |
| Choose: |
| <a href="Book/Moby">Moby</a> | |
| <a href="Book/Moby/ch/1">Moby: Ch1</a> | |
| <a href="Book/Gatsby">Gatsby</a> | |
| <a href="Book/Gatsby/ch/4?key=value">Gatsby: Ch4</a> | |
| <a href="Book/Scarlet">Scarlet Letter</a><br/> |
| |
| <div ng-view></div> |
| <hr /> |
| |
| <pre>$location.path() = {{$location.path()}}</pre> |
| <pre>$route.current.templateUrl = {{$route.current.templateUrl}}</pre> |
| <pre>$route.current.params = {{$route.current.params}}</pre> |
| <pre>$route.current.scope.name = {{$route.current.scope.name}}</pre> |
| <pre>$routeParams = {{$routeParams}}</pre> |
| </div> |
| </file> |
| |
| <file name="book.html"> |
| controller: {{name}}<br /> |
| Book Id: {{params.bookId}}<br /> |
| </file> |
| |
| <file name="chapter.html"> |
| controller: {{name}}<br /> |
| Book Id: {{params.bookId}}<br /> |
| Chapter Id: {{params.chapterId}} |
| </file> |
| |
| <file name="script.js"> |
| angular.module('ngViewExample', ['ngRoute']) |
| |
| .config(function($routeProvider, $locationProvider) { |
| $routeProvider.when('/Book/:bookId', { |
| templateUrl: 'book.html', |
| controller: BookCntl, |
| resolve: { |
| // I will cause a 1 second delay |
| delay: function($q, $timeout) { |
| var delay = $q.defer(); |
| $timeout(delay.resolve, 1000); |
| return delay.promise; |
| } |
| } |
| }); |
| $routeProvider.when('/Book/:bookId/ch/:chapterId', { |
| templateUrl: 'chapter.html', |
| controller: ChapterCntl |
| }); |
| |
| // configure html5 to get links working on jsfiddle |
| $locationProvider.html5Mode(true); |
| }); |
| |
| function MainCntl($scope, $route, $routeParams, $location) { |
| $scope.$route = $route; |
| $scope.$location = $location; |
| $scope.$routeParams = $routeParams; |
| } |
| |
| function BookCntl($scope, $routeParams) { |
| $scope.name = "BookCntl"; |
| $scope.params = $routeParams; |
| } |
| |
| function ChapterCntl($scope, $routeParams) { |
| $scope.name = "ChapterCntl"; |
| $scope.params = $routeParams; |
| } |
| </file> |
| |
| <file name="scenario.js"> |
| it('should load and compile correct template', function() { |
| element('a:contains("Moby: Ch1")').click(); |
| var content = element('.doc-example-live [ng-view]').text(); |
| expect(content).toMatch(/controller\: ChapterCntl/); |
| expect(content).toMatch(/Book Id\: Moby/); |
| expect(content).toMatch(/Chapter Id\: 1/); |
| |
| element('a:contains("Scarlet")').click(); |
| sleep(2); // promises are not part of scenario waiting |
| content = element('.doc-example-live [ng-view]').text(); |
| expect(content).toMatch(/controller\: BookCntl/); |
| expect(content).toMatch(/Book Id\: Scarlet/); |
| }); |
| </file> |
| </example> |
| */ |
| |
| /** |
| * @ngdoc event |
| * @name ngRoute.$route#$routeChangeStart |
| * @eventOf ngRoute.$route |
| * @eventType broadcast on root scope |
| * @description |
| * Broadcasted before a route change. At this point the route services starts |
| * resolving all of the dependencies needed for the route change to occurs. |
| * Typically this involves fetching the view template as well as any dependencies |
| * defined in `resolve` route property. Once all of the dependencies are resolved |
| * `$routeChangeSuccess` is fired. |
| * |
| * @param {Object} angularEvent Synthetic event object. |
| * @param {Route} next Future route information. |
| * @param {Route} current Current route information. |
| */ |
| |
| /** |
| * @ngdoc event |
| * @name ngRoute.$route#$routeChangeSuccess |
| * @eventOf ngRoute.$route |
| * @eventType broadcast on root scope |
| * @description |
| * Broadcasted after a route dependencies are resolved. |
| * {@link ngRoute.directive:ngView ngView} listens for the directive |
| * to instantiate the controller and render the view. |
| * |
| * @param {Object} angularEvent Synthetic event object. |
| * @param {Route} current Current route information. |
| * @param {Route|Undefined} previous Previous route information, or undefined if current is |
| * first route entered. |
| */ |
| |
| /** |
| * @ngdoc event |
| * @name ngRoute.$route#$routeChangeError |
| * @eventOf ngRoute.$route |
| * @eventType broadcast on root scope |
| * @description |
| * Broadcasted if any of the resolve promises are rejected. |
| * |
| * @param {Object} angularEvent Synthetic event object |
| * @param {Route} current Current route information. |
| * @param {Route} previous Previous route information. |
| * @param {Route} rejection Rejection of the promise. Usually the error of the failed promise. |
| */ |
| |
| /** |
| * @ngdoc event |
| * @name ngRoute.$route#$routeUpdate |
| * @eventOf ngRoute.$route |
| * @eventType broadcast on root scope |
| * @description |
| * |
| * The `reloadOnSearch` property has been set to false, and we are reusing the same |
| * instance of the Controller. |
| */ |
| |
| var forceReload = false, |
| $route = { |
| routes: routes, |
| |
| /** |
| * @ngdoc method |
| * @name ngRoute.$route#reload |
| * @methodOf ngRoute.$route |
| * |
| * @description |
| * Causes `$route` service to reload the current route even if |
| * {@link ng.$location $location} hasn't changed. |
| * |
| * As a result of that, {@link ngRoute.directive:ngView ngView} |
| * creates new scope, reinstantiates the controller. |
| */ |
| reload: function() { |
| forceReload = true; |
| $rootScope.$evalAsync(updateRoute); |
| } |
| }; |
| |
| $rootScope.$on('$locationChangeSuccess', updateRoute); |
| |
| return $route; |
| |
| ///////////////////////////////////////////////////// |
| |
| /** |
| * @param on {string} current url |
| * @param route {Object} route regexp to match the url against |
| * @return {?Object} |
| * |
| * @description |
| * Check if the route matches the current url. |
| * |
| * Inspired by match in |
| * visionmedia/express/lib/router/router.js. |
| */ |
| function switchRouteMatcher(on, route) { |
| var keys = route.keys, |
| params = {}; |
| |
| if (!route.regexp) return null; |
| |
| var m = route.regexp.exec(on); |
| if (!m) return null; |
| |
| for (var i = 1, len = m.length; i < len; ++i) { |
| var key = keys[i - 1]; |
| |
| var val = 'string' == typeof m[i] |
| ? decodeURIComponent(m[i]) |
| : m[i]; |
| |
| if (key && val) { |
| params[key.name] = val; |
| } |
| } |
| return params; |
| } |
| |
| function updateRoute() { |
| var next = parseRoute(), |
| last = $route.current; |
| |
| if (next && last && next.$$route === last.$$route |
| && angular.equals(next.pathParams, last.pathParams) |
| && !next.reloadOnSearch && !forceReload) { |
| last.params = next.params; |
| angular.copy(last.params, $routeParams); |
| $rootScope.$broadcast('$routeUpdate', last); |
| } else if (next || last) { |
| forceReload = false; |
| $rootScope.$broadcast('$routeChangeStart', next, last); |
| $route.current = next; |
| if (next) { |
| if (next.redirectTo) { |
| if (angular.isString(next.redirectTo)) { |
| $location.path(interpolate(next.redirectTo, next.params)).search(next.params) |
| .replace(); |
| } else { |
| $location.url(next.redirectTo(next.pathParams, $location.path(), $location.search())) |
| .replace(); |
| } |
| } |
| } |
| |
| $q.when(next). |
| then(function() { |
| if (next) { |
| var locals = angular.extend({}, next.resolve), |
| template, templateUrl; |
| |
| angular.forEach(locals, function(value, key) { |
| locals[key] = angular.isString(value) ? |
| $injector.get(value) : $injector.invoke(value); |
| }); |
| |
| if (angular.isDefined(template = next.template)) { |
| if (angular.isFunction(template)) { |
| template = template(next.params); |
| } |
| } else if (angular.isDefined(templateUrl = next.templateUrl)) { |
| if (angular.isFunction(templateUrl)) { |
| templateUrl = templateUrl(next.params); |
| } |
| templateUrl = $sce.getTrustedResourceUrl(templateUrl); |
| if (angular.isDefined(templateUrl)) { |
| next.loadedTemplateUrl = templateUrl; |
| template = $http.get(templateUrl, {cache: $templateCache}). |
| then(function(response) { return response.data; }); |
| } |
| } |
| if (angular.isDefined(template)) { |
| locals['$template'] = template; |
| } |
| return $q.all(locals); |
| } |
| }). |
| // after route change |
| then(function(locals) { |
| if (next == $route.current) { |
| if (next) { |
| next.locals = locals; |
| angular.copy(next.params, $routeParams); |
| } |
| $rootScope.$broadcast('$routeChangeSuccess', next, last); |
| } |
| }, function(error) { |
| if (next == $route.current) { |
| $rootScope.$broadcast('$routeChangeError', next, last, error); |
| } |
| }); |
| } |
| } |
| |
| |
| /** |
| * @returns the current active route, by matching it against the URL |
| */ |
| function parseRoute() { |
| // Match a route |
| var params, match; |
| angular.forEach(routes, function(route, path) { |
| if (!match && (params = switchRouteMatcher($location.path(), route))) { |
| match = inherit(route, { |
| params: angular.extend({}, $location.search(), params), |
| pathParams: params}); |
| match.$$route = route; |
| } |
| }); |
| // No route matched; fallback to "otherwise" route |
| return match || routes[null] && inherit(routes[null], {params: {}, pathParams:{}}); |
| } |
| |
| /** |
| * @returns interpolation of the redirect path with the parameters |
| */ |
| function interpolate(string, params) { |
| var result = []; |
| angular.forEach((string||'').split(':'), function(segment, i) { |
| if (i === 0) { |
| result.push(segment); |
| } else { |
| var segmentMatch = segment.match(/(\w+)(.*)/); |
| var key = segmentMatch[1]; |
| result.push(params[key]); |
| result.push(segmentMatch[2] || ''); |
| delete params[key]; |
| } |
| }); |
| return result.join(''); |
| } |
| }]; |
| } |
| |
| ngRouteModule.provider('$routeParams', $RouteParamsProvider); |
| |
| |
| /** |
| * @ngdoc object |
| * @name ngRoute.$routeParams |
| * @requires $route |
| * |
| * @description |
| * The `$routeParams` service allows you to retrieve the current set of route parameters. |
| * |
| * Requires the {@link ngRoute `ngRoute`} module to be installed. |
| * |
| * The route parameters are a combination of {@link ng.$location `$location`}'s |
| * {@link ng.$location#methods_search `search()`} and {@link ng.$location#methods_path `path()`}. |
| * The `path` parameters are extracted when the {@link ngRoute.$route `$route`} path is matched. |
| * |
| * In case of parameter name collision, `path` params take precedence over `search` params. |
| * |
| * The service guarantees that the identity of the `$routeParams` object will remain unchanged |
| * (but its properties will likely change) even when a route change occurs. |
| * |
| * Note that the `$routeParams` are only updated *after* a route change completes successfully. |
| * This means that you cannot rely on `$routeParams` being correct in route resolve functions. |
| * Instead you can use `$route.current.params` to access the new route's parameters. |
| * |
| * @example |
| * <pre> |
| * // Given: |
| * // URL: http://server.com/index.html#/Chapter/1/Section/2?search=moby |
| * // Route: /Chapter/:chapterId/Section/:sectionId |
| * // |
| * // Then |
| * $routeParams ==> {chapterId:1, sectionId:2, search:'moby'} |
| * </pre> |
| */ |
| function $RouteParamsProvider() { |
| this.$get = function() { return {}; }; |
| } |
| |
| ngRouteModule.directive('ngView', ngViewFactory); |
| |
| /** |
| * @ngdoc directive |
| * @name ngRoute.directive:ngView |
| * @restrict ECA |
| * |
| * @description |
| * # Overview |
| * `ngView` is a directive that complements the {@link ngRoute.$route $route} service by |
| * including the rendered template of the current route into the main layout (`index.html`) file. |
| * Every time the current route changes, the included view changes with it according to the |
| * configuration of the `$route` service. |
| * |
| * Requires the {@link ngRoute `ngRoute`} module to be installed. |
| * |
| * @animations |
| * enter - animation is used to bring new content into the browser. |
| * leave - animation is used to animate existing content away. |
| * |
| * The enter and leave animation occur concurrently. |
| * |
| * @scope |
| * @priority 400 |
| * @example |
| <example module="ngViewExample" deps="angular-route.js" animations="true"> |
| <file name="index.html"> |
| <div ng-controller="MainCntl as main"> |
| Choose: |
| <a href="Book/Moby">Moby</a> | |
| <a href="Book/Moby/ch/1">Moby: Ch1</a> | |
| <a href="Book/Gatsby">Gatsby</a> | |
| <a href="Book/Gatsby/ch/4?key=value">Gatsby: Ch4</a> | |
| <a href="Book/Scarlet">Scarlet Letter</a><br/> |
| |
| <div class="view-animate-container"> |
| <div ng-view class="view-animate"></div> |
| </div> |
| <hr /> |
| |
| <pre>$location.path() = {{main.$location.path()}}</pre> |
| <pre>$route.current.templateUrl = {{main.$route.current.templateUrl}}</pre> |
| <pre>$route.current.params = {{main.$route.current.params}}</pre> |
| <pre>$route.current.scope.name = {{main.$route.current.scope.name}}</pre> |
| <pre>$routeParams = {{main.$routeParams}}</pre> |
| </div> |
| </file> |
| |
| <file name="book.html"> |
| <div> |
| controller: {{book.name}}<br /> |
| Book Id: {{book.params.bookId}}<br /> |
| </div> |
| </file> |
| |
| <file name="chapter.html"> |
| <div> |
| controller: {{chapter.name}}<br /> |
| Book Id: {{chapter.params.bookId}}<br /> |
| Chapter Id: {{chapter.params.chapterId}} |
| </div> |
| </file> |
| |
| <file name="animations.css"> |
| .view-animate-container { |
| position:relative; |
| height:100px!important; |
| position:relative; |
| background:white; |
| border:1px solid black; |
| height:40px; |
| overflow:hidden; |
| } |
| |
| .view-animate { |
| padding:10px; |
| } |
| |
| .view-animate.ng-enter, .view-animate.ng-leave { |
| -webkit-transition:all cubic-bezier(0.250, 0.460, 0.450, 0.940) 1.5s; |
| transition:all cubic-bezier(0.250, 0.460, 0.450, 0.940) 1.5s; |
| |
| display:block; |
| width:100%; |
| border-left:1px solid black; |
| |
| position:absolute; |
| top:0; |
| left:0; |
| right:0; |
| bottom:0; |
| padding:10px; |
| } |
| |
| .view-animate.ng-enter { |
| left:100%; |
| } |
| .view-animate.ng-enter.ng-enter-active { |
| left:0; |
| } |
| .view-animate.ng-leave.ng-leave-active { |
| left:-100%; |
| } |
| </file> |
| |
| <file name="script.js"> |
| angular.module('ngViewExample', ['ngRoute', 'ngAnimate'], |
| function($routeProvider, $locationProvider) { |
| $routeProvider.when('/Book/:bookId', { |
| templateUrl: 'book.html', |
| controller: BookCntl, |
| controllerAs: 'book' |
| }); |
| $routeProvider.when('/Book/:bookId/ch/:chapterId', { |
| templateUrl: 'chapter.html', |
| controller: ChapterCntl, |
| controllerAs: 'chapter' |
| }); |
| |
| // configure html5 to get links working on jsfiddle |
| $locationProvider.html5Mode(true); |
| }); |
| |
| function MainCntl($route, $routeParams, $location) { |
| this.$route = $route; |
| this.$location = $location; |
| this.$routeParams = $routeParams; |
| } |
| |
| function BookCntl($routeParams) { |
| this.name = "BookCntl"; |
| this.params = $routeParams; |
| } |
| |
| function ChapterCntl($routeParams) { |
| this.name = "ChapterCntl"; |
| this.params = $routeParams; |
| } |
| </file> |
| |
| <file name="scenario.js"> |
| it('should load and compile correct template', function() { |
| element('a:contains("Moby: Ch1")').click(); |
| var content = element('.doc-example-live [ng-view]').text(); |
| expect(content).toMatch(/controller\: ChapterCntl/); |
| expect(content).toMatch(/Book Id\: Moby/); |
| expect(content).toMatch(/Chapter Id\: 1/); |
| |
| element('a:contains("Scarlet")').click(); |
| content = element('.doc-example-live [ng-view]').text(); |
| expect(content).toMatch(/controller\: BookCntl/); |
| expect(content).toMatch(/Book Id\: Scarlet/); |
| }); |
| </file> |
| </example> |
| */ |
| |
| |
| /** |
| * @ngdoc event |
| * @name ngRoute.directive:ngView#$viewContentLoaded |
| * @eventOf ngRoute.directive:ngView |
| * @eventType emit on the current ngView scope |
| * @description |
| * Emitted every time the ngView content is reloaded. |
| */ |
| ngViewFactory.$inject = ['$route', '$anchorScroll', '$compile', '$controller', '$animate']; |
| function ngViewFactory( $route, $anchorScroll, $compile, $controller, $animate) { |
| return { |
| restrict: 'ECA', |
| terminal: true, |
| priority: 400, |
| transclude: 'element', |
| link: function(scope, $element, attr, ctrl, $transclude) { |
| var currentScope, |
| currentElement, |
| autoScrollExp = attr.autoscroll, |
| onloadExp = attr.onload || ''; |
| |
| scope.$on('$routeChangeSuccess', update); |
| update(); |
| |
| function cleanupLastView() { |
| if (currentScope) { |
| currentScope.$destroy(); |
| currentScope = null; |
| } |
| if(currentElement) { |
| $animate.leave(currentElement); |
| currentElement = null; |
| } |
| } |
| |
| function update() { |
| var locals = $route.current && $route.current.locals, |
| template = locals && locals.$template; |
| |
| if (template) { |
| var newScope = scope.$new(); |
| |
| // Note: This will also link all children of ng-view that were contained in the original |
| // html. If that content contains controllers, ... they could pollute/change the scope. |
| // However, using ng-view on an element with additional content does not make sense... |
| // Note: We can't remove them in the cloneAttchFn of $transclude as that |
| // function is called before linking the content, which would apply child |
| // directives to non existing elements. |
| var clone = $transclude(newScope, angular.noop); |
| clone.html(template); |
| $animate.enter(clone, null, currentElement || $element, function onNgViewEnter () { |
| if (angular.isDefined(autoScrollExp) |
| && (!autoScrollExp || scope.$eval(autoScrollExp))) { |
| $anchorScroll(); |
| } |
| }); |
| |
| cleanupLastView(); |
| |
| var link = $compile(clone.contents()), |
| current = $route.current; |
| |
| currentScope = current.scope = newScope; |
| currentElement = clone; |
| |
| if (current.controller) { |
| locals.$scope = currentScope; |
| var controller = $controller(current.controller, locals); |
| if (current.controllerAs) { |
| currentScope[current.controllerAs] = controller; |
| } |
| clone.data('$ngControllerController', controller); |
| clone.children().data('$ngControllerController', controller); |
| } |
| |
| link(currentScope); |
| currentScope.$emit('$viewContentLoaded'); |
| currentScope.$eval(onloadExp); |
| } else { |
| cleanupLastView(); |
| } |
| } |
| } |
| }; |
| } |
| |
| |
| })(window, window.angular); |
