244 lines
No EOL
27 KiB
JavaScript
Executable file
244 lines
No EOL
27 KiB
JavaScript
Executable file
import * as tslib_1 from "tslib";
|
|
import { Location } from '@angular/common';
|
|
import { Injectable, Optional } from '@angular/core';
|
|
import { NavigationExtras, NavigationStart, Router, UrlSerializer, UrlTree } from '@angular/router';
|
|
import { Platform } from './platform';
|
|
import * as i0 from "@angular/core";
|
|
import * as i1 from "./platform";
|
|
import * as i2 from "@angular/common";
|
|
import * as i3 from "@angular/router";
|
|
var NavController = /** @class */ (function () {
|
|
function NavController(platform, location, serializer, router) {
|
|
var _this = this;
|
|
this.location = location;
|
|
this.serializer = serializer;
|
|
this.router = router;
|
|
this.direction = DEFAULT_DIRECTION;
|
|
this.animated = DEFAULT_ANIMATED;
|
|
this.guessDirection = 'forward';
|
|
this.lastNavId = -1;
|
|
// Subscribe to router events to detect direction
|
|
if (router) {
|
|
router.events.subscribe(function (ev) {
|
|
if (ev instanceof NavigationStart) {
|
|
var id = (ev.restoredState) ? ev.restoredState.navigationId : ev.id;
|
|
_this.guessDirection = id < _this.lastNavId ? 'back' : 'forward';
|
|
_this.guessAnimation = !ev.restoredState ? _this.guessDirection : undefined;
|
|
_this.lastNavId = _this.guessDirection === 'forward' ? ev.id : id;
|
|
}
|
|
});
|
|
}
|
|
// Subscribe to backButton events
|
|
platform.backButton.subscribeWithPriority(0, function (processNextHandler) {
|
|
_this.pop();
|
|
processNextHandler();
|
|
});
|
|
}
|
|
/**
|
|
* This method uses Angular's [Router](https://angular.io/api/router/Router) under the hood,
|
|
* it's equivalent to calling `this.router.navigateByUrl()`, but it's explicit about the **direction** of the transition.
|
|
*
|
|
* Going **forward** means that a new page is going to be pushed to the stack of the outlet (ion-router-outlet),
|
|
* and that it will show a "forward" animation by default.
|
|
*
|
|
* Navigating forward can also be triggered in a declarative manner by using the `[routerDirection]` directive:
|
|
*
|
|
* ```html
|
|
* <a routerLink="/path/to/page" routerDirection="forward">Link</a>
|
|
* ```
|
|
*/
|
|
NavController.prototype.navigateForward = function (url, options) {
|
|
if (options === void 0) { options = {}; }
|
|
this.setDirection('forward', options.animated, options.animationDirection, options.animation);
|
|
return this.navigate(url, options);
|
|
};
|
|
/**
|
|
* This method uses Angular's [Router](https://angular.io/api/router/Router) under the hood,
|
|
* it's equivalent to calling:
|
|
*
|
|
* ```ts
|
|
* this.navController.setDirection('back');
|
|
* this.router.navigateByUrl(path);
|
|
* ```
|
|
*
|
|
* Going **back** means that all the pages in the stack until the navigated page is found will be popped,
|
|
* and that it will show a "back" animation by default.
|
|
*
|
|
* Navigating back can also be triggered in a declarative manner by using the `[routerDirection]` directive:
|
|
*
|
|
* ```html
|
|
* <a routerLink="/path/to/page" routerDirection="back">Link</a>
|
|
* ```
|
|
*/
|
|
NavController.prototype.navigateBack = function (url, options) {
|
|
if (options === void 0) { options = {}; }
|
|
this.setDirection('back', options.animated, options.animationDirection, options.animation);
|
|
return this.navigate(url, options);
|
|
};
|
|
/**
|
|
* This method uses Angular's [Router](https://angular.io/api/router/Router) under the hood,
|
|
* it's equivalent to calling:
|
|
*
|
|
* ```ts
|
|
* this.navController.setDirection('root');
|
|
* this.router.navigateByUrl(path);
|
|
* ```
|
|
*
|
|
* Going **root** means that all existing pages in the stack will be removed,
|
|
* and the navigated page will become the single page in the stack.
|
|
*
|
|
* Navigating root can also be triggered in a declarative manner by using the `[routerDirection]` directive:
|
|
*
|
|
* ```html
|
|
* <a routerLink="/path/to/page" routerDirection="root">Link</a>
|
|
* ```
|
|
*/
|
|
NavController.prototype.navigateRoot = function (url, options) {
|
|
if (options === void 0) { options = {}; }
|
|
this.setDirection('root', options.animated, options.animationDirection, options.animation);
|
|
return this.navigate(url, options);
|
|
};
|
|
/**
|
|
* Same as [Location](https://angular.io/api/common/Location)'s back() method.
|
|
* It will use the standard `window.history.back()` under the hood, but featuring a `back` animation
|
|
* by default.
|
|
*/
|
|
NavController.prototype.back = function (options) {
|
|
if (options === void 0) { options = { animated: true, animationDirection: 'back' }; }
|
|
this.setDirection('back', options.animated, options.animationDirection, options.animation);
|
|
return this.location.back();
|
|
};
|
|
/**
|
|
* This methods goes back in the context of Ionic's stack navigation.
|
|
*
|
|
* It recursively finds the top active `ion-router-outlet` and calls `pop()`.
|
|
* This is the recommended way to go back when you are using `ion-router-outlet`.
|
|
*/
|
|
NavController.prototype.pop = function () {
|
|
return tslib_1.__awaiter(this, void 0, void 0, function () {
|
|
var outlet;
|
|
return tslib_1.__generator(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0:
|
|
outlet = this.topOutlet;
|
|
_a.label = 1;
|
|
case 1:
|
|
if (!outlet) return [3 /*break*/, 3];
|
|
return [4 /*yield*/, outlet.pop()];
|
|
case 2:
|
|
if (_a.sent()) {
|
|
return [3 /*break*/, 3];
|
|
}
|
|
else {
|
|
outlet = outlet.parentOutlet;
|
|
}
|
|
return [3 /*break*/, 1];
|
|
case 3: return [2 /*return*/];
|
|
}
|
|
});
|
|
});
|
|
};
|
|
/**
|
|
* This methods specifies the direction of the next navigation performed by the Angular router.
|
|
*
|
|
* `setDirection()` does not trigger any transition, it just sets some flags to be consumed by `ion-router-outlet`.
|
|
*
|
|
* It's recommended to use `navigateForward()`, `navigateBack()` and `navigateRoot()` instead of `setDirection()`.
|
|
*/
|
|
NavController.prototype.setDirection = function (direction, animated, animationDirection, animationBuilder) {
|
|
this.direction = direction;
|
|
this.animated = getAnimation(direction, animated, animationDirection);
|
|
this.animationBuilder = animationBuilder;
|
|
};
|
|
/**
|
|
* @internal
|
|
*/
|
|
NavController.prototype.setTopOutlet = function (outlet) {
|
|
this.topOutlet = outlet;
|
|
};
|
|
/**
|
|
* @internal
|
|
*/
|
|
NavController.prototype.consumeTransition = function () {
|
|
var direction = 'root';
|
|
var animation;
|
|
var animationBuilder = this.animationBuilder;
|
|
if (this.direction === 'auto') {
|
|
direction = this.guessDirection;
|
|
animation = this.guessAnimation;
|
|
}
|
|
else {
|
|
animation = this.animated;
|
|
direction = this.direction;
|
|
}
|
|
this.direction = DEFAULT_DIRECTION;
|
|
this.animated = DEFAULT_ANIMATED;
|
|
this.animationBuilder = undefined;
|
|
return {
|
|
direction: direction,
|
|
animation: animation,
|
|
animationBuilder: animationBuilder
|
|
};
|
|
};
|
|
NavController.prototype.navigate = function (url, options) {
|
|
if (Array.isArray(url)) {
|
|
return this.router.navigate(url, options);
|
|
}
|
|
else {
|
|
/**
|
|
* navigateByUrl ignores any properties that
|
|
* would change the url, so things like queryParams
|
|
* would be ignored unless we create a url tree
|
|
* More Info: https://github.com/angular/angular/issues/18798
|
|
*/
|
|
var urlTree = this.serializer.parse(url.toString());
|
|
if (options.queryParams !== undefined) {
|
|
urlTree.queryParams = tslib_1.__assign({}, options.queryParams);
|
|
}
|
|
if (options.fragment !== undefined) {
|
|
urlTree.fragment = options.fragment;
|
|
}
|
|
/**
|
|
* `navigateByUrl` will still apply `NavigationExtras` properties
|
|
* that do not modify the url, such as `replaceUrl` which is why
|
|
* `options` is passed in here.
|
|
*/
|
|
return this.router.navigateByUrl(urlTree, options);
|
|
}
|
|
};
|
|
NavController.ctorParameters = function () { return [
|
|
{ type: Platform },
|
|
{ type: Location },
|
|
{ type: UrlSerializer },
|
|
{ type: Router, decorators: [{ type: Optional }] }
|
|
]; };
|
|
NavController.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function NavController_Factory() { return new NavController(i0.ɵɵinject(i1.Platform), i0.ɵɵinject(i2.Location), i0.ɵɵinject(i3.UrlSerializer), i0.ɵɵinject(i3.Router, 8)); }, token: NavController, providedIn: "root" });
|
|
NavController = tslib_1.__decorate([
|
|
Injectable({
|
|
providedIn: 'root',
|
|
}),
|
|
tslib_1.__param(3, Optional())
|
|
], NavController);
|
|
return NavController;
|
|
}());
|
|
export { NavController };
|
|
var getAnimation = function (direction, animated, animationDirection) {
|
|
if (animated === false) {
|
|
return undefined;
|
|
}
|
|
if (animationDirection !== undefined) {
|
|
return animationDirection;
|
|
}
|
|
if (direction === 'forward' || direction === 'back') {
|
|
return direction;
|
|
}
|
|
else if (direction === 'root' && animated === true) {
|
|
return 'forward';
|
|
}
|
|
return undefined;
|
|
};
|
|
var ɵ0 = getAnimation;
|
|
var DEFAULT_DIRECTION = 'auto';
|
|
var DEFAULT_ANIMATED = undefined;
|
|
export { ɵ0 };
|
|
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nav-controller.js","sourceRoot":"ng://@ionic/angular/","sources":["providers/nav-controller.ts"],"names":[],"mappings":"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","sourcesContent":["import { Location } from '@angular/common';\nimport { Injectable, Optional } from '@angular/core';\nimport { NavigationExtras, NavigationStart, Router, UrlSerializer, UrlTree } from '@angular/router';\nimport { AnimationBuilder, NavDirection, RouterDirection } from '@ionic/core';\n\nimport { IonRouterOutlet } from '../directives/navigation/ion-router-outlet';\n\nimport { Platform } from './platform';\n\nexport interface AnimationOptions {\n  animated?: boolean;\n  animation?: AnimationBuilder;\n  animationDirection?: 'forward' | 'back';\n}\n\nexport interface NavigationOptions extends NavigationExtras, AnimationOptions {}\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class NavController {\n\n  private topOutlet?: IonRouterOutlet;\n  private direction: 'forward' | 'back' | 'root' | 'auto' = DEFAULT_DIRECTION;\n  private animated?: NavDirection = DEFAULT_ANIMATED;\n  private animationBuilder?: AnimationBuilder;\n  private guessDirection: RouterDirection = 'forward';\n  private guessAnimation?: NavDirection;\n  private lastNavId = -1;\n\n  constructor(\n    platform: Platform,\n    private location: Location,\n    private serializer: UrlSerializer,\n    @Optional() private router?: Router,\n  ) {\n    // Subscribe to router events to detect direction\n    if (router) {\n      router.events.subscribe(ev => {\n        if (ev instanceof NavigationStart) {\n          const id = (ev.restoredState) ? ev.restoredState.navigationId : ev.id;\n          this.guessDirection = id < this.lastNavId ? 'back' : 'forward';\n          this.guessAnimation = !ev.restoredState ? this.guessDirection : undefined;\n          this.lastNavId = this.guessDirection === 'forward' ? ev.id : id;\n        }\n      });\n    }\n\n    // Subscribe to backButton events\n    platform.backButton.subscribeWithPriority(0, processNextHandler => {\n      this.pop();\n      processNextHandler();\n    });\n  }\n\n  /**\n   * This method uses Angular's [Router](https://angular.io/api/router/Router) under the hood,\n   * it's equivalent to calling `this.router.navigateByUrl()`, but it's explicit about the **direction** of the transition.\n   *\n   * Going **forward** means that a new page is going to be pushed to the stack of the outlet (ion-router-outlet),\n   * and that it will show a \"forward\" animation by default.\n   *\n   * Navigating forward can also be triggered in a declarative manner by using the `[routerDirection]` directive:\n   *\n   * ```html\n   * <a routerLink=\"/path/to/page\" routerDirection=\"forward\">Link</a>\n   * ```\n   */\n  navigateForward(url: string | UrlTree | any[], options: NavigationOptions = {}): Promise<boolean> {\n    this.setDirection('forward', options.animated, options.animationDirection, options.animation);\n    return this.navigate(url, options);\n  }\n\n  /**\n   * This method uses Angular's [Router](https://angular.io/api/router/Router) under the hood,\n   * it's equivalent to calling:\n   *\n   * ```ts\n   * this.navController.setDirection('back');\n   * this.router.navigateByUrl(path);\n   * ```\n   *\n   * Going **back** means that all the pages in the stack until the navigated page is found will be popped,\n   * and that it will show a \"back\" animation by default.\n   *\n   * Navigating back can also be triggered in a declarative manner by using the `[routerDirection]` directive:\n   *\n   * ```html\n   * <a routerLink=\"/path/to/page\" routerDirection=\"back\">Link</a>\n   * ```\n   */\n  navigateBack(url: string | UrlTree | any[], options: NavigationOptions = {}): Promise<boolean> {\n    this.setDirection('back', options.animated, options.animationDirection, options.animation);\n    return this.navigate(url, options);\n  }\n\n  /**\n   * This method uses Angular's [Router](https://angular.io/api/router/Router) under the hood,\n   * it's equivalent to calling:\n   *\n   * ```ts\n   * this.navController.setDirection('root');\n   * this.router.navigateByUrl(path);\n   * ```\n   *\n   * Going **root** means that all existing pages in the stack will be removed,\n   * and the navigated page will become the single page in the stack.\n   *\n   * Navigating root can also be triggered in a declarative manner by using the `[routerDirection]` directive:\n   *\n   * ```html\n   * <a routerLink=\"/path/to/page\" routerDirection=\"root\">Link</a>\n   * ```\n   */\n  navigateRoot(url: string | UrlTree | any[], options: NavigationOptions = {}): Promise<boolean> {\n    this.setDirection('root', options.animated, options.animationDirection, options.animation);\n    return this.navigate(url, options);\n  }\n\n  /**\n   * Same as [Location](https://angular.io/api/common/Location)'s back() method.\n   * It will use the standard `window.history.back()` under the hood, but featuring a `back` animation\n   * by default.\n   */\n  back(options: AnimationOptions = { animated: true, animationDirection: 'back' }) {\n    this.setDirection('back', options.animated, options.animationDirection, options.animation);\n    return this.location.back();\n  }\n\n  /**\n   * This methods goes back in the context of Ionic's stack navigation.\n   *\n   * It recursively finds the top active `ion-router-outlet` and calls `pop()`.\n   * This is the recommended way to go back when you are using `ion-router-outlet`.\n   */\n  async pop() {\n    let outlet = this.topOutlet;\n\n    while (outlet) {\n      if (await outlet.pop()) {\n        break;\n      } else {\n        outlet = outlet.parentOutlet;\n      }\n    }\n  }\n\n  /**\n   * This methods specifies the direction of the next navigation performed by the Angular router.\n   *\n   * `setDirection()` does not trigger any transition, it just sets some flags to be consumed by `ion-router-outlet`.\n   *\n   * It's recommended to use `navigateForward()`, `navigateBack()` and `navigateRoot()` instead of `setDirection()`.\n   */\n  setDirection(direction: RouterDirection, animated?: boolean, animationDirection?: 'forward' | 'back', animationBuilder?: AnimationBuilder) {\n    this.direction = direction;\n    this.animated = getAnimation(direction, animated, animationDirection);\n    this.animationBuilder = animationBuilder;\n  }\n\n  /**\n   * @internal\n   */\n  setTopOutlet(outlet: IonRouterOutlet) {\n    this.topOutlet = outlet;\n  }\n\n  /**\n   * @internal\n   */\n  consumeTransition() {\n    let direction: RouterDirection = 'root';\n    let animation: NavDirection | undefined;\n    const animationBuilder = this.animationBuilder;\n\n    if (this.direction === 'auto') {\n      direction = this.guessDirection;\n      animation = this.guessAnimation;\n    } else {\n      animation = this.animated;\n      direction = this.direction;\n    }\n    this.direction = DEFAULT_DIRECTION;\n    this.animated = DEFAULT_ANIMATED;\n    this.animationBuilder = undefined;\n\n    return {\n      direction,\n      animation,\n      animationBuilder\n    };\n  }\n\n  private navigate(url: string | UrlTree | any[], options: NavigationOptions) {\n    if (Array.isArray(url)) {\n      return this.router!.navigate(url, options);\n    } else {\n\n      /**\n       * navigateByUrl ignores any properties that\n       * would change the url, so things like queryParams\n       * would be ignored unless we create a url tree\n       * More Info: https://github.com/angular/angular/issues/18798\n       */\n      const urlTree = this.serializer.parse(url.toString());\n\n      if (options.queryParams !== undefined) {\n        urlTree.queryParams = { ...options.queryParams };\n      }\n\n      if (options.fragment !== undefined) {\n        urlTree.fragment = options.fragment;\n      }\n\n      /**\n       * `navigateByUrl` will still apply `NavigationExtras` properties\n       * that do not modify the url, such as `replaceUrl` which is why\n       * `options` is passed in here.\n       */\n      return this.router!.navigateByUrl(urlTree, options);\n    }\n  }\n}\n\nconst getAnimation = (direction: RouterDirection, animated: boolean | undefined, animationDirection: 'forward' | 'back' | undefined): NavDirection | undefined => {\n  if (animated === false) {\n    return undefined;\n  }\n  if (animationDirection !== undefined) {\n    return animationDirection;\n  }\n  if (direction === 'forward' || direction === 'back') {\n    return direction;\n  } else if (direction === 'root' && animated === true) {\n    return 'forward';\n  }\n  return undefined;\n};\n\nconst DEFAULT_DIRECTION = 'auto';\nconst DEFAULT_ANIMATED = undefined;\n"]}
|