199 lines
7.5 KiB
JavaScript
199 lines
7.5 KiB
JavaScript
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.UrlRouterProvider = void 0;
|
|
/** @publicapi @module url */ /** */
|
|
var core_1 = require("@uirouter/core");
|
|
var core_2 = require("@uirouter/core");
|
|
/**
|
|
* Manages rules for client-side URL
|
|
*
|
|
* ### Deprecation warning:
|
|
* This class is now considered to be an internal API
|
|
* Use the [[UrlService]] instead.
|
|
* For configuring URL rules, use the [[UrlRulesApi]] which can be found as [[UrlService.rules]].
|
|
*
|
|
* This class manages the router rules for what to do when the URL changes.
|
|
*
|
|
* This provider remains for backwards compatibility.
|
|
*
|
|
* @internalapi
|
|
* @deprecated
|
|
*/
|
|
var UrlRouterProvider = /** @class */ (function () {
|
|
/** @hidden */
|
|
function UrlRouterProvider(/** @hidden */ router) {
|
|
this.router = router;
|
|
}
|
|
UrlRouterProvider.injectableHandler = function (router, handler) {
|
|
return function (match) { return core_2.services.$injector.invoke(handler, null, { $match: match, $stateParams: router.globals.params }); };
|
|
};
|
|
/** @hidden */
|
|
UrlRouterProvider.prototype.$get = function () {
|
|
var urlService = this.router.urlService;
|
|
this.router.urlRouter.update(true);
|
|
if (!urlService.interceptDeferred)
|
|
urlService.listen();
|
|
return this.router.urlRouter;
|
|
};
|
|
/**
|
|
* Registers a url handler function.
|
|
*
|
|
* Registers a low level url handler (a `rule`).
|
|
* A rule detects specific URL patterns and returns a redirect, or performs some action.
|
|
*
|
|
* If a rule returns a string, the URL is replaced with the string, and all rules are fired again.
|
|
*
|
|
* #### Example:
|
|
* ```js
|
|
* var app = angular.module('app', ['ui.router.router']);
|
|
*
|
|
* app.config(function ($urlRouterProvider) {
|
|
* // Here's an example of how you might allow case insensitive urls
|
|
* $urlRouterProvider.rule(function ($injector, $location) {
|
|
* var path = $location.path(),
|
|
* normalized = path.toLowerCase();
|
|
*
|
|
* if (path !== normalized) {
|
|
* return normalized;
|
|
* }
|
|
* });
|
|
* });
|
|
* ```
|
|
*
|
|
* @param ruleFn
|
|
* Handler function that takes `$injector` and `$location` services as arguments.
|
|
* You can use them to detect a url and return a different url as a string.
|
|
*
|
|
* @return [[UrlRouterProvider]] (`this`)
|
|
*/
|
|
UrlRouterProvider.prototype.rule = function (ruleFn) {
|
|
var _this = this;
|
|
if (!core_2.isFunction(ruleFn))
|
|
throw new Error("'rule' must be a function");
|
|
var match = function () { return ruleFn(core_2.services.$injector, _this.router.locationService); };
|
|
var rule = new core_1.BaseUrlRule(match, core_2.identity);
|
|
this.router.urlService.rules.rule(rule);
|
|
return this;
|
|
};
|
|
/**
|
|
* Defines the path or behavior to use when no url can be matched.
|
|
*
|
|
* #### Example:
|
|
* ```js
|
|
* var app = angular.module('app', ['ui.router.router']);
|
|
*
|
|
* app.config(function ($urlRouterProvider) {
|
|
* // if the path doesn't match any of the urls you configured
|
|
* // otherwise will take care of routing the user to the
|
|
* // specified url
|
|
* $urlRouterProvider.otherwise('/index');
|
|
*
|
|
* // Example of using function rule as param
|
|
* $urlRouterProvider.otherwise(function ($injector, $location) {
|
|
* return '/a/valid/url';
|
|
* });
|
|
* });
|
|
* ```
|
|
*
|
|
* @param rule
|
|
* The url path you want to redirect to or a function rule that returns the url path or performs a `$state.go()`.
|
|
* The function version is passed two params: `$injector` and `$location` services, and should return a url string.
|
|
*
|
|
* @return {object} `$urlRouterProvider` - `$urlRouterProvider` instance
|
|
*/
|
|
UrlRouterProvider.prototype.otherwise = function (rule) {
|
|
var _this = this;
|
|
var urlRules = this.router.urlService.rules;
|
|
if (core_2.isString(rule)) {
|
|
urlRules.otherwise(rule);
|
|
}
|
|
else if (core_2.isFunction(rule)) {
|
|
urlRules.otherwise(function () { return rule(core_2.services.$injector, _this.router.locationService); });
|
|
}
|
|
else {
|
|
throw new Error("'rule' must be a string or function");
|
|
}
|
|
return this;
|
|
};
|
|
/**
|
|
* Registers a handler for a given url matching.
|
|
*
|
|
* If the handler is a string, it is
|
|
* treated as a redirect, and is interpolated according to the syntax of match
|
|
* (i.e. like `String.replace()` for `RegExp`, or like a `UrlMatcher` pattern otherwise).
|
|
*
|
|
* If the handler is a function, it is injectable.
|
|
* It gets invoked if `$location` matches.
|
|
* You have the option of inject the match object as `$match`.
|
|
*
|
|
* The handler can return
|
|
*
|
|
* - **falsy** to indicate that the rule didn't match after all, then `$urlRouter`
|
|
* will continue trying to find another one that matches.
|
|
* - **string** which is treated as a redirect and passed to `$location.url()`
|
|
* - **void** or any **truthy** value tells `$urlRouter` that the url was handled.
|
|
*
|
|
* #### Example:
|
|
* ```js
|
|
* var app = angular.module('app', ['ui.router.router']);
|
|
*
|
|
* app.config(function ($urlRouterProvider) {
|
|
* $urlRouterProvider.when($state.url, function ($match, $stateParams) {
|
|
* if ($state.$current.navigable !== state ||
|
|
* !equalForKeys($match, $stateParams) {
|
|
* $state.transitionTo(state, $match, false);
|
|
* }
|
|
* });
|
|
* });
|
|
* ```
|
|
*
|
|
* @param what A pattern string to match, compiled as a [[UrlMatcher]].
|
|
* @param handler The path (or function that returns a path) that you want to redirect your user to.
|
|
* @param ruleCallback [optional] A callback that receives the `rule` registered with [[UrlMatcher.rule]]
|
|
*
|
|
* Note: the handler may also invoke arbitrary code, such as `$state.go()`
|
|
*/
|
|
UrlRouterProvider.prototype.when = function (what, handler) {
|
|
if (core_2.isArray(handler) || core_2.isFunction(handler)) {
|
|
handler = UrlRouterProvider.injectableHandler(this.router, handler);
|
|
}
|
|
this.router.urlService.rules.when(what, handler);
|
|
return this;
|
|
};
|
|
/**
|
|
* Disables monitoring of the URL.
|
|
*
|
|
* Call this method before UI-Router has bootstrapped.
|
|
* It will stop UI-Router from performing the initial url sync.
|
|
*
|
|
* This can be useful to perform some asynchronous initialization before the router starts.
|
|
* Once the initialization is complete, call [[listen]] to tell UI-Router to start watching and synchronizing the URL.
|
|
*
|
|
* #### Example:
|
|
* ```js
|
|
* var app = angular.module('app', ['ui.router']);
|
|
*
|
|
* app.config(function ($urlRouterProvider) {
|
|
* // Prevent $urlRouter from automatically intercepting URL changes;
|
|
* $urlRouterProvider.deferIntercept();
|
|
* })
|
|
*
|
|
* app.run(function (MyService, $urlRouter, $http) {
|
|
* $http.get("/stuff").then(function(resp) {
|
|
* MyService.doStuff(resp.data);
|
|
* $urlRouter.listen();
|
|
* $urlRouter.sync();
|
|
* });
|
|
* });
|
|
* ```
|
|
*
|
|
* @param defer Indicates whether to defer location change interception.
|
|
* Passing no parameter is equivalent to `true`.
|
|
*/
|
|
UrlRouterProvider.prototype.deferIntercept = function (defer) {
|
|
this.router.urlService.deferIntercept(defer);
|
|
};
|
|
return UrlRouterProvider;
|
|
}());
|
|
exports.UrlRouterProvider = UrlRouterProvider;
|
|
//# sourceMappingURL=urlRouterProvider.js.map
|