6ddfff5cd5
This is a big change. @matsko also deserves much of the credit for the implementation.
Previously, `ComponentInstruction`s held all the state for async components.
Now, we introduce several subclasses for `Instruction` to describe each type of navigation.
BREAKING CHANGE:
Redirects now use the Link DSL syntax. Before:
```
@RouteConfig([
{ path: '/foo', redirectTo: '/bar' },
{ path: '/bar', component: BarCmp }
])
```
After:
```
@RouteConfig([
{ path: '/foo', redirectTo: ['Bar'] },
{ path: '/bar', component: BarCmp, name: 'Bar' }
])
```
BREAKING CHANGE:
This also introduces `useAsDefault` in the RouteConfig, which makes cases like lazy-loading
and encapsulating large routes with sub-routes easier.
Previously, you could use `redirectTo` like this to expand a URL like `/tab` to `/tab/posts`:
@RouteConfig([
{ path: '/tab', redirectTo: '/tab/users' }
{ path: '/tab', component: TabsCmp, name: 'Tab' }
])
AppCmp { ... }
Now the recommended way to handle this is case is to use `useAsDefault` like so:
```
@RouteConfig([
{ path: '/tab', component: TabsCmp, name: 'Tab' }
])
AppCmp { ... }
@RouteConfig([
{ path: '/posts', component: PostsCmp, useAsDefault: true, name: 'Posts' },
{ path: '/users', component: UsersCmp, name: 'Users' }
])
TabsCmp { ... }
```
In the above example, you can write just `['/Tab']` and the route `Users` is automatically selected as a child route.
Closes #4728
Closes #4228
Closes #4170
Closes #4490
Closes #4694
Closes #5200
Closes #5475
74 lines
2.3 KiB
JavaScript
74 lines
2.3 KiB
JavaScript
|
|
angular.module('ngComponentRouter').
|
|
value('$route', null). // can be overloaded with ngRouteShim
|
|
factory('$router', ['$q', '$location', '$$directiveIntrospector', '$browser', '$rootScope', '$injector', routerFactory]);
|
|
|
|
function routerFactory($q, $location, $$directiveIntrospector, $browser, $rootScope, $injector) {
|
|
|
|
// When this file is processed, the line below is replaced with
|
|
// the contents of `../lib/facades.es5`.
|
|
//{{FACADES}}
|
|
|
|
var exports = {
|
|
Injectable: function () {},
|
|
OpaqueToken: function () {},
|
|
Inject: function () {}
|
|
};
|
|
var require = function () {return exports;};
|
|
|
|
// When this file is processed, the line below is replaced with
|
|
// the contents of the compiled TypeScript classes.
|
|
//{{SHARED_CODE}}
|
|
|
|
//TODO: this is a hack to replace the exiting implementation at run-time
|
|
exports.getCanActivateHook = function (directiveName) {
|
|
var factory = $$directiveIntrospector.getTypeByName(directiveName);
|
|
return factory && factory.$canActivate && function (next, prev) {
|
|
return $injector.invoke(factory.$canActivate, null, {
|
|
$nextInstruction: next,
|
|
$prevInstruction: prev
|
|
});
|
|
};
|
|
};
|
|
|
|
// This hack removes assertions about the type of the "component"
|
|
// property in a route config
|
|
exports.assertComponentExists = function () {};
|
|
|
|
angular.stringifyInstruction = function (instruction) {
|
|
return instruction.toRootUrl();
|
|
};
|
|
|
|
var RouteRegistry = exports.RouteRegistry;
|
|
var RootRouter = exports.RootRouter;
|
|
|
|
|
|
// Because Angular 1 has no notion of a root component, we use an object with unique identity
|
|
// to represent this.
|
|
var ROOT_COMPONENT_OBJECT = new Object();
|
|
|
|
var registry = new RouteRegistry(ROOT_COMPONENT_OBJECT);
|
|
var location = new Location();
|
|
|
|
$$directiveIntrospector(function (name, factory) {
|
|
if (angular.isArray(factory.$routeConfig)) {
|
|
factory.$routeConfig.forEach(function (config) {
|
|
registry.config(name, config);
|
|
});
|
|
}
|
|
});
|
|
|
|
var router = new RootRouter(registry, location, ROOT_COMPONENT_OBJECT);
|
|
$rootScope.$watch(function () { return $location.path(); }, function (path) {
|
|
if (router.lastNavigationAttempt !== path) {
|
|
router.navigateByUrl(path);
|
|
}
|
|
});
|
|
|
|
router.subscribe(function () {
|
|
$rootScope.$broadcast('$routeChangeSuccess', {});
|
|
});
|
|
|
|
return router;
|
|
}
|