1 | import { __decorate, __param, __awaiter } from 'tslib';
|
2 | import { HostListener, Injector, ElementRef, Directive, Inject, NgZone, ɵɵdefineInjectable, ɵɵinject, Injectable, Optional, ChangeDetectorRef, Component, ChangeDetectionStrategy, InjectionToken, ApplicationRef, EventEmitter, ViewContainerRef, ComponentFactoryResolver, Attribute, SkipSelf, Output, ViewChild, ContentChild, TemplateRef, IterableDiffers, APP_INITIALIZER, NgModule } from '@angular/core';
|
3 | import { NgControl, NG_VALUE_ACCESSOR } from '@angular/forms';
|
4 | import { DOCUMENT, Location, LocationStrategy, CommonModule } from '@angular/common';
|
5 | import { NavigationStart, UrlSerializer, Router, PRIMARY_OUTLET, ActivatedRoute, ChildrenOutletContexts, RouterLink } from '@angular/router';
|
6 | import { isPlatform, getPlatforms, LIFECYCLE_WILL_ENTER, LIFECYCLE_DID_ENTER, LIFECYCLE_WILL_LEAVE, LIFECYCLE_DID_LEAVE, LIFECYCLE_WILL_UNLOAD, componentOnReady, actionSheetController, alertController, loadingController, menuController, pickerController, modalController, popoverController, toastController, createAnimation, getTimeGivenProgression, createGesture } from '@ionic/core';
|
7 | export { IonicSafeString, createAnimation, getPlatforms, iosTransitionAnimation, isPlatform, mdTransitionAnimation } from '@ionic/core';
|
8 | import { Subject, fromEvent, BehaviorSubject } from 'rxjs';
|
9 | import { filter, switchMap, distinctUntilChanged } from 'rxjs/operators';
|
10 | import { applyPolyfills, defineCustomElements } from '@ionic/core/loader';
|
11 |
|
12 | const raf = (h) => {
|
13 | if (typeof __zone_symbol__requestAnimationFrame === 'function') {
|
14 | return __zone_symbol__requestAnimationFrame(h);
|
15 | }
|
16 | if (typeof requestAnimationFrame === 'function') {
|
17 | return requestAnimationFrame(h);
|
18 | }
|
19 | return setTimeout(h);
|
20 | };
|
21 |
|
22 | class ValueAccessor {
|
23 | constructor(injector, el) {
|
24 | this.injector = injector;
|
25 | this.el = el;
|
26 | this.onChange = () => { };
|
27 | this.onTouched = () => { };
|
28 | }
|
29 | writeValue(value) {
|
30 | |
31 |
|
32 |
|
33 |
|
34 |
|
35 |
|
36 |
|
37 | this.el.nativeElement.value = this.lastValue = value == null ? '' : value;
|
38 | setIonicClasses(this.el);
|
39 | }
|
40 | handleChangeEvent(el, value) {
|
41 | if (el === this.el.nativeElement) {
|
42 | if (value !== this.lastValue) {
|
43 | this.lastValue = value;
|
44 | this.onChange(value);
|
45 | }
|
46 | setIonicClasses(this.el);
|
47 | }
|
48 | }
|
49 | _handleBlurEvent(el) {
|
50 | if (el === this.el.nativeElement) {
|
51 | this.onTouched();
|
52 | setIonicClasses(this.el);
|
53 | }
|
54 | }
|
55 | registerOnChange(fn) {
|
56 | this.onChange = fn;
|
57 | }
|
58 | registerOnTouched(fn) {
|
59 | this.onTouched = fn;
|
60 | }
|
61 | setDisabledState(isDisabled) {
|
62 | this.el.nativeElement.disabled = isDisabled;
|
63 | }
|
64 | ngOnDestroy() {
|
65 | if (this.statusChanges) {
|
66 | this.statusChanges.unsubscribe();
|
67 | }
|
68 | }
|
69 | ngAfterViewInit() {
|
70 | let ngControl;
|
71 | try {
|
72 | ngControl = this.injector.get(NgControl);
|
73 | }
|
74 | catch ( _a) { }
|
75 | if (!ngControl) {
|
76 | return;
|
77 | }
|
78 |
|
79 | if (ngControl.statusChanges) {
|
80 | this.statusChanges = ngControl.statusChanges.subscribe(() => setIonicClasses(this.el));
|
81 | }
|
82 | |
83 |
|
84 |
|
85 |
|
86 |
|
87 |
|
88 |
|
89 |
|
90 |
|
91 |
|
92 | const formControl = ngControl.control;
|
93 | if (formControl) {
|
94 | const methodsToPatch = ['markAsTouched', 'markAllAsTouched', 'markAsUntouched', 'markAsDirty', 'markAsPristine'];
|
95 | methodsToPatch.forEach(method => {
|
96 | if (formControl[method]) {
|
97 | const oldFn = formControl[method].bind(formControl);
|
98 | formControl[method] = (...params) => {
|
99 | oldFn(...params);
|
100 | setIonicClasses(this.el);
|
101 | };
|
102 | }
|
103 | });
|
104 | }
|
105 | }
|
106 | }
|
107 | __decorate([
|
108 | HostListener('ionBlur', ['$event.target'])
|
109 | ], ValueAccessor.prototype, "_handleBlurEvent", null);
|
110 | const setIonicClasses = (element) => {
|
111 | raf(() => {
|
112 | const input = element.nativeElement;
|
113 | const classes = getClasses(input);
|
114 | setClasses(input, classes);
|
115 | const item = input.closest('ion-item');
|
116 | if (item) {
|
117 | setClasses(item, classes);
|
118 | }
|
119 | });
|
120 | };
|
121 | const getClasses = (element) => {
|
122 | const classList = element.classList;
|
123 | const classes = [];
|
124 | for (let i = 0; i < classList.length; i++) {
|
125 | const item = classList.item(i);
|
126 | if (item !== null && startsWith(item, 'ng-')) {
|
127 | classes.push(`ion-${item.substr(3)}`);
|
128 | }
|
129 | }
|
130 | return classes;
|
131 | };
|
132 | const ɵ0 = getClasses;
|
133 | const setClasses = (element, classes) => {
|
134 | const classList = element.classList;
|
135 | [
|
136 | 'ion-valid',
|
137 | 'ion-invalid',
|
138 | 'ion-touched',
|
139 | 'ion-untouched',
|
140 | 'ion-dirty',
|
141 | 'ion-pristine'
|
142 | ].forEach(c => classList.remove(c));
|
143 | classes.forEach(c => classList.add(c));
|
144 | };
|
145 | const ɵ1 = setClasses;
|
146 | const startsWith = (input, search) => {
|
147 | return input.substr(0, search.length) === search;
|
148 | };
|
149 | const ɵ2 = startsWith;
|
150 |
|
151 | var BooleanValueAccessor_1;
|
152 | let BooleanValueAccessor = BooleanValueAccessor_1 = class BooleanValueAccessor extends ValueAccessor {
|
153 | constructor(injector, el) {
|
154 | super(injector, el);
|
155 | }
|
156 | writeValue(value) {
|
157 | this.el.nativeElement.checked = this.lastValue = value == null ? false : value;
|
158 | setIonicClasses(this.el);
|
159 | }
|
160 | _handleIonChange(el) {
|
161 | this.handleChangeEvent(el, el.checked);
|
162 | }
|
163 | };
|
164 | BooleanValueAccessor.ctorParameters = () => [
|
165 | { type: Injector },
|
166 | { type: ElementRef }
|
167 | ];
|
168 | __decorate([
|
169 | HostListener('ionChange', ['$event.target'])
|
170 | ], BooleanValueAccessor.prototype, "_handleIonChange", null);
|
171 | BooleanValueAccessor = BooleanValueAccessor_1 = __decorate([
|
172 | Directive({
|
173 |
|
174 | selector: 'ion-checkbox,ion-toggle',
|
175 | providers: [
|
176 | {
|
177 | provide: NG_VALUE_ACCESSOR,
|
178 | useExisting: BooleanValueAccessor_1,
|
179 | multi: true
|
180 | }
|
181 | ]
|
182 | })
|
183 | ], BooleanValueAccessor);
|
184 |
|
185 | var NumericValueAccessor_1;
|
186 | let NumericValueAccessor = NumericValueAccessor_1 = class NumericValueAccessor extends ValueAccessor {
|
187 | constructor(injector, el) {
|
188 | super(injector, el);
|
189 | }
|
190 | _handleIonChange(el) {
|
191 | this.handleChangeEvent(el, el.value);
|
192 | }
|
193 | registerOnChange(fn) {
|
194 | super.registerOnChange(value => {
|
195 | fn(value === '' ? null : parseFloat(value));
|
196 | });
|
197 | }
|
198 | };
|
199 | NumericValueAccessor.ctorParameters = () => [
|
200 | { type: Injector },
|
201 | { type: ElementRef }
|
202 | ];
|
203 | __decorate([
|
204 | HostListener('ionChange', ['$event.target'])
|
205 | ], NumericValueAccessor.prototype, "_handleIonChange", null);
|
206 | NumericValueAccessor = NumericValueAccessor_1 = __decorate([
|
207 | Directive({
|
208 |
|
209 | selector: 'ion-input[type=number]',
|
210 | providers: [
|
211 | {
|
212 | provide: NG_VALUE_ACCESSOR,
|
213 | useExisting: NumericValueAccessor_1,
|
214 | multi: true
|
215 | }
|
216 | ]
|
217 | })
|
218 | ], NumericValueAccessor);
|
219 |
|
220 | var RadioValueAccessor_1;
|
221 | let RadioValueAccessor = RadioValueAccessor_1 = class RadioValueAccessor extends ValueAccessor {
|
222 | constructor(injector, el) {
|
223 | super(injector, el);
|
224 | }
|
225 | _handleIonSelect(el) {
|
226 | this.handleChangeEvent(el, el.checked);
|
227 | }
|
228 | };
|
229 | RadioValueAccessor.ctorParameters = () => [
|
230 | { type: Injector },
|
231 | { type: ElementRef }
|
232 | ];
|
233 | __decorate([
|
234 | HostListener('ionSelect', ['$event.target'])
|
235 | ], RadioValueAccessor.prototype, "_handleIonSelect", null);
|
236 | RadioValueAccessor = RadioValueAccessor_1 = __decorate([
|
237 | Directive({
|
238 |
|
239 | selector: 'ion-radio',
|
240 | providers: [
|
241 | {
|
242 | provide: NG_VALUE_ACCESSOR,
|
243 | useExisting: RadioValueAccessor_1,
|
244 | multi: true
|
245 | }
|
246 | ]
|
247 | })
|
248 | ], RadioValueAccessor);
|
249 |
|
250 | var SelectValueAccessor_1;
|
251 | let SelectValueAccessor = SelectValueAccessor_1 = class SelectValueAccessor extends ValueAccessor {
|
252 | constructor(injector, el) {
|
253 | super(injector, el);
|
254 | }
|
255 | _handleChangeEvent(el) {
|
256 | this.handleChangeEvent(el, el.value);
|
257 | }
|
258 | };
|
259 | SelectValueAccessor.ctorParameters = () => [
|
260 | { type: Injector },
|
261 | { type: ElementRef }
|
262 | ];
|
263 | __decorate([
|
264 | HostListener('ionChange', ['$event.target'])
|
265 | ], SelectValueAccessor.prototype, "_handleChangeEvent", null);
|
266 | SelectValueAccessor = SelectValueAccessor_1 = __decorate([
|
267 | Directive({
|
268 |
|
269 | selector: 'ion-range, ion-select, ion-radio-group, ion-segment, ion-datetime',
|
270 | providers: [
|
271 | {
|
272 | provide: NG_VALUE_ACCESSOR,
|
273 | useExisting: SelectValueAccessor_1,
|
274 | multi: true
|
275 | }
|
276 | ]
|
277 | })
|
278 | ], SelectValueAccessor);
|
279 |
|
280 | var TextValueAccessor_1;
|
281 | let TextValueAccessor = TextValueAccessor_1 = class TextValueAccessor extends ValueAccessor {
|
282 | constructor(injector, el) {
|
283 | super(injector, el);
|
284 | }
|
285 | _handleInputEvent(el) {
|
286 | this.handleChangeEvent(el, el.value);
|
287 | }
|
288 | };
|
289 | TextValueAccessor.ctorParameters = () => [
|
290 | { type: Injector },
|
291 | { type: ElementRef }
|
292 | ];
|
293 | __decorate([
|
294 | HostListener('ionChange', ['$event.target'])
|
295 | ], TextValueAccessor.prototype, "_handleInputEvent", null);
|
296 | TextValueAccessor = TextValueAccessor_1 = __decorate([
|
297 | Directive({
|
298 |
|
299 | selector: 'ion-input:not([type=number]),ion-textarea,ion-searchbar',
|
300 | providers: [
|
301 | {
|
302 | provide: NG_VALUE_ACCESSOR,
|
303 | useExisting: TextValueAccessor_1,
|
304 | multi: true
|
305 | }
|
306 | ]
|
307 | })
|
308 | ], TextValueAccessor);
|
309 |
|
310 | let Platform = class Platform {
|
311 | constructor(doc, zone) {
|
312 | this.doc = doc;
|
313 | |
314 |
|
315 |
|
316 | this.backButton = new Subject();
|
317 | |
318 |
|
319 |
|
320 |
|
321 | this.keyboardDidShow = new Subject();
|
322 | |
323 |
|
324 |
|
325 |
|
326 | this.keyboardDidHide = new Subject();
|
327 | |
328 |
|
329 |
|
330 |
|
331 |
|
332 |
|
333 | this.pause = new Subject();
|
334 | |
335 |
|
336 |
|
337 |
|
338 |
|
339 | this.resume = new Subject();
|
340 | |
341 |
|
342 |
|
343 |
|
344 |
|
345 | this.resize = new Subject();
|
346 | zone.run(() => {
|
347 | this.win = doc.defaultView;
|
348 | this.backButton.subscribeWithPriority = function (priority, callback) {
|
349 | return this.subscribe(ev => {
|
350 | return ev.register(priority, processNextHandler => zone.run(() => callback(processNextHandler)));
|
351 | });
|
352 | };
|
353 | proxyEvent(this.pause, doc, 'pause');
|
354 | proxyEvent(this.resume, doc, 'resume');
|
355 | proxyEvent(this.backButton, doc, 'ionBackButton');
|
356 | proxyEvent(this.resize, this.win, 'resize');
|
357 | proxyEvent(this.keyboardDidShow, this.win, 'ionKeyboardDidShow');
|
358 | proxyEvent(this.keyboardDidHide, this.win, 'ionKeyboardDidHide');
|
359 | let readyResolve;
|
360 | this._readyPromise = new Promise(res => { readyResolve = res; });
|
361 | if (this.win && this.win['cordova']) {
|
362 | doc.addEventListener('deviceready', () => {
|
363 | readyResolve('cordova');
|
364 | }, { once: true });
|
365 | }
|
366 | else {
|
367 | readyResolve('dom');
|
368 | }
|
369 | });
|
370 | }
|
371 | |
372 |
|
373 |
|
374 |
|
375 |
|
376 |
|
377 |
|
378 |
|
379 |
|
380 |
|
381 |
|
382 |
|
383 |
|
384 |
|
385 |
|
386 |
|
387 |
|
388 |
|
389 |
|
390 |
|
391 |
|
392 |
|
393 |
|
394 |
|
395 |
|
396 |
|
397 |
|
398 |
|
399 |
|
400 |
|
401 |
|
402 |
|
403 |
|
404 |
|
405 |
|
406 |
|
407 |
|
408 |
|
409 |
|
410 |
|
411 |
|
412 |
|
413 |
|
414 | is(platformName) {
|
415 | return isPlatform(this.win, platformName);
|
416 | }
|
417 | |
418 |
|
419 |
|
420 |
|
421 |
|
422 |
|
423 |
|
424 |
|
425 |
|
426 |
|
427 |
|
428 |
|
429 |
|
430 |
|
431 |
|
432 |
|
433 |
|
434 |
|
435 |
|
436 | platforms() {
|
437 | return getPlatforms(this.win);
|
438 | }
|
439 | |
440 |
|
441 |
|
442 |
|
443 |
|
444 |
|
445 |
|
446 |
|
447 |
|
448 |
|
449 |
|
450 |
|
451 |
|
452 |
|
453 |
|
454 |
|
455 |
|
456 |
|
457 |
|
458 |
|
459 |
|
460 |
|
461 |
|
462 |
|
463 |
|
464 |
|
465 |
|
466 |
|
467 |
|
468 | ready() {
|
469 | return this._readyPromise;
|
470 | }
|
471 | |
472 |
|
473 |
|
474 |
|
475 |
|
476 |
|
477 | get isRTL() {
|
478 | return this.doc.dir === 'rtl';
|
479 | }
|
480 | |
481 |
|
482 |
|
483 | getQueryParam(key) {
|
484 | return readQueryParam(this.win.location.href, key);
|
485 | }
|
486 | |
487 |
|
488 |
|
489 | isLandscape() {
|
490 | return !this.isPortrait();
|
491 | }
|
492 | |
493 |
|
494 |
|
495 | isPortrait() {
|
496 | return this.win.matchMedia && this.win.matchMedia('(orientation: portrait)').matches;
|
497 | }
|
498 | testUserAgent(expression) {
|
499 | const nav = this.win.navigator;
|
500 | return !!(nav && nav.userAgent && nav.userAgent.indexOf(expression) >= 0);
|
501 | }
|
502 | |
503 |
|
504 |
|
505 | url() {
|
506 | return this.win.location.href;
|
507 | }
|
508 | |
509 |
|
510 |
|
511 | width() {
|
512 | return this.win.innerWidth;
|
513 | }
|
514 | |
515 |
|
516 |
|
517 | height() {
|
518 | return this.win.innerHeight;
|
519 | }
|
520 | };
|
521 | Platform.ctorParameters = () => [
|
522 | { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] },
|
523 | { type: NgZone }
|
524 | ];
|
525 | Platform.ngInjectableDef = ɵɵdefineInjectable({ factory: function Platform_Factory() { return new Platform(ɵɵinject(DOCUMENT), ɵɵinject(NgZone)); }, token: Platform, providedIn: "root" });
|
526 | Platform = __decorate([
|
527 | Injectable({
|
528 | providedIn: 'root',
|
529 | }),
|
530 | __param(0, Inject(DOCUMENT))
|
531 | ], Platform);
|
532 | const readQueryParam = (url, key) => {
|
533 | key = key.replace(/[\[]/, '\\[').replace(/[\]]/, '\\]');
|
534 | const regex = new RegExp('[\\?&]' + key + '=([^&#]*)');
|
535 | const results = regex.exec(url);
|
536 | return results ? decodeURIComponent(results[1].replace(/\+/g, ' ')) : null;
|
537 | };
|
538 | const ɵ0$1 = readQueryParam;
|
539 | const proxyEvent = (emitter, el, eventName) => {
|
540 | if (el) {
|
541 | el.addEventListener(eventName, (ev) => {
|
542 |
|
543 | emitter.next(ev != null ? ev.detail : undefined);
|
544 | });
|
545 | }
|
546 | };
|
547 | const ɵ1$1 = proxyEvent;
|
548 |
|
549 | let NavController = class NavController {
|
550 | constructor(platform, location, serializer, router) {
|
551 | this.location = location;
|
552 | this.serializer = serializer;
|
553 | this.router = router;
|
554 | this.direction = DEFAULT_DIRECTION;
|
555 | this.animated = DEFAULT_ANIMATED;
|
556 | this.guessDirection = 'forward';
|
557 | this.lastNavId = -1;
|
558 |
|
559 | if (router) {
|
560 | router.events.subscribe(ev => {
|
561 | if (ev instanceof NavigationStart) {
|
562 | const id = (ev.restoredState) ? ev.restoredState.navigationId : ev.id;
|
563 | this.guessDirection = id < this.lastNavId ? 'back' : 'forward';
|
564 | this.guessAnimation = !ev.restoredState ? this.guessDirection : undefined;
|
565 | this.lastNavId = this.guessDirection === 'forward' ? ev.id : id;
|
566 | }
|
567 | });
|
568 | }
|
569 |
|
570 | platform.backButton.subscribeWithPriority(0, processNextHandler => {
|
571 | this.pop();
|
572 | processNextHandler();
|
573 | });
|
574 | }
|
575 | |
576 |
|
577 |
|
578 |
|
579 |
|
580 |
|
581 |
|
582 |
|
583 |
|
584 |
|
585 |
|
586 |
|
587 |
|
588 | navigateForward(url, options = {}) {
|
589 | this.setDirection('forward', options.animated, options.animationDirection, options.animation);
|
590 | return this.navigate(url, options);
|
591 | }
|
592 | |
593 |
|
594 |
|
595 |
|
596 |
|
597 |
|
598 |
|
599 |
|
600 |
|
601 |
|
602 |
|
603 |
|
604 |
|
605 |
|
606 |
|
607 |
|
608 |
|
609 |
|
610 | navigateBack(url, options = {}) {
|
611 | this.setDirection('back', options.animated, options.animationDirection, options.animation);
|
612 | return this.navigate(url, options);
|
613 | }
|
614 | |
615 |
|
616 |
|
617 |
|
618 |
|
619 |
|
620 |
|
621 |
|
622 |
|
623 |
|
624 |
|
625 |
|
626 |
|
627 |
|
628 |
|
629 |
|
630 |
|
631 |
|
632 | navigateRoot(url, options = {}) {
|
633 | this.setDirection('root', options.animated, options.animationDirection, options.animation);
|
634 | return this.navigate(url, options);
|
635 | }
|
636 | |
637 |
|
638 |
|
639 |
|
640 |
|
641 | back(options = { animated: true, animationDirection: 'back' }) {
|
642 | this.setDirection('back', options.animated, options.animationDirection, options.animation);
|
643 | return this.location.back();
|
644 | }
|
645 | |
646 |
|
647 |
|
648 |
|
649 |
|
650 |
|
651 | pop() {
|
652 | return __awaiter(this, void 0, void 0, function* () {
|
653 | let outlet = this.topOutlet;
|
654 | while (outlet) {
|
655 | if (yield outlet.pop()) {
|
656 | break;
|
657 | }
|
658 | else {
|
659 | outlet = outlet.parentOutlet;
|
660 | }
|
661 | }
|
662 | });
|
663 | }
|
664 | |
665 |
|
666 |
|
667 |
|
668 |
|
669 |
|
670 |
|
671 | setDirection(direction, animated, animationDirection, animationBuilder) {
|
672 | this.direction = direction;
|
673 | this.animated = getAnimation(direction, animated, animationDirection);
|
674 | this.animationBuilder = animationBuilder;
|
675 | }
|
676 | |
677 |
|
678 |
|
679 | setTopOutlet(outlet) {
|
680 | this.topOutlet = outlet;
|
681 | }
|
682 | |
683 |
|
684 |
|
685 | consumeTransition() {
|
686 | let direction = 'root';
|
687 | let animation;
|
688 | const animationBuilder = this.animationBuilder;
|
689 | if (this.direction === 'auto') {
|
690 | direction = this.guessDirection;
|
691 | animation = this.guessAnimation;
|
692 | }
|
693 | else {
|
694 | animation = this.animated;
|
695 | direction = this.direction;
|
696 | }
|
697 | this.direction = DEFAULT_DIRECTION;
|
698 | this.animated = DEFAULT_ANIMATED;
|
699 | this.animationBuilder = undefined;
|
700 | return {
|
701 | direction,
|
702 | animation,
|
703 | animationBuilder
|
704 | };
|
705 | }
|
706 | navigate(url, options) {
|
707 | if (Array.isArray(url)) {
|
708 | return this.router.navigate(url, options);
|
709 | }
|
710 | else {
|
711 | |
712 |
|
713 |
|
714 |
|
715 |
|
716 |
|
717 | const urlTree = this.serializer.parse(url.toString());
|
718 | if (options.queryParams !== undefined) {
|
719 | urlTree.queryParams = Object.assign({}, options.queryParams);
|
720 | }
|
721 | if (options.fragment !== undefined) {
|
722 | urlTree.fragment = options.fragment;
|
723 | }
|
724 | |
725 |
|
726 |
|
727 |
|
728 |
|
729 | return this.router.navigateByUrl(urlTree, options);
|
730 | }
|
731 | }
|
732 | };
|
733 | NavController.ctorParameters = () => [
|
734 | { type: Platform },
|
735 | { type: Location },
|
736 | { type: UrlSerializer },
|
737 | { type: Router, decorators: [{ type: Optional }] }
|
738 | ];
|
739 | NavController.ngInjectableDef = ɵɵdefineInjectable({ factory: function NavController_Factory() { return new NavController(ɵɵinject(Platform), ɵɵinject(Location), ɵɵinject(UrlSerializer), ɵɵinject(Router, 8)); }, token: NavController, providedIn: "root" });
|
740 | NavController = __decorate([
|
741 | Injectable({
|
742 | providedIn: 'root',
|
743 | }),
|
744 | __param(3, Optional())
|
745 | ], NavController);
|
746 | const getAnimation = (direction, animated, animationDirection) => {
|
747 | if (animated === false) {
|
748 | return undefined;
|
749 | }
|
750 | if (animationDirection !== undefined) {
|
751 | return animationDirection;
|
752 | }
|
753 | if (direction === 'forward' || direction === 'back') {
|
754 | return direction;
|
755 | }
|
756 | else if (direction === 'root' && animated === true) {
|
757 | return 'forward';
|
758 | }
|
759 | return undefined;
|
760 | };
|
761 | const ɵ0$2 = getAnimation;
|
762 | const DEFAULT_DIRECTION = 'auto';
|
763 | const DEFAULT_ANIMATED = undefined;
|
764 |
|
765 |
|
766 | const proxyInputs = (Cmp, inputs) => {
|
767 | const Prototype = Cmp.prototype;
|
768 | inputs.forEach(item => {
|
769 | Object.defineProperty(Prototype, item, {
|
770 | get() {
|
771 | return this.el[item];
|
772 | },
|
773 | set(val) {
|
774 | this.z.runOutsideAngular(() => (this.el[item] = val));
|
775 | }
|
776 | });
|
777 | });
|
778 | };
|
779 | const proxyMethods = (Cmp, methods) => {
|
780 | const Prototype = Cmp.prototype;
|
781 | methods.forEach(methodName => {
|
782 | Prototype[methodName] = function () {
|
783 | const args = arguments;
|
784 | return this.z.runOutsideAngular(() => this.el[methodName].apply(this.el, args));
|
785 | };
|
786 | });
|
787 | };
|
788 | const proxyOutputs = (instance, el, events) => {
|
789 | events.forEach(eventName => instance[eventName] = fromEvent(el, eventName));
|
790 | };
|
791 | function ProxyCmp(opts) {
|
792 | const decorator = function (cls) {
|
793 | if (opts.inputs) {
|
794 | proxyInputs(cls, opts.inputs);
|
795 | }
|
796 | if (opts.methods) {
|
797 | proxyMethods(cls, opts.methods);
|
798 | }
|
799 | return cls;
|
800 | };
|
801 | return decorator;
|
802 | }
|
803 |
|
804 | let IonApp = class IonApp {
|
805 | constructor(c, r, z) {
|
806 | this.z = z;
|
807 | c.detach();
|
808 | this.el = r.nativeElement;
|
809 | }
|
810 | };
|
811 | IonApp.ctorParameters = () => [
|
812 | { type: ChangeDetectorRef },
|
813 | { type: ElementRef },
|
814 | { type: NgZone }
|
815 | ];
|
816 | IonApp = __decorate([
|
817 | Component({ selector: "ion-app", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>" })
|
818 | ], IonApp);
|
819 | let IonAvatar = class IonAvatar {
|
820 | constructor(c, r, z) {
|
821 | this.z = z;
|
822 | c.detach();
|
823 | this.el = r.nativeElement;
|
824 | }
|
825 | };
|
826 | IonAvatar.ctorParameters = () => [
|
827 | { type: ChangeDetectorRef },
|
828 | { type: ElementRef },
|
829 | { type: NgZone }
|
830 | ];
|
831 | IonAvatar = __decorate([
|
832 | Component({ selector: "ion-avatar", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>" })
|
833 | ], IonAvatar);
|
834 | let IonBackButton = class IonBackButton {
|
835 | constructor(c, r, z) {
|
836 | this.z = z;
|
837 | c.detach();
|
838 | this.el = r.nativeElement;
|
839 | }
|
840 | };
|
841 | IonBackButton.ctorParameters = () => [
|
842 | { type: ChangeDetectorRef },
|
843 | { type: ElementRef },
|
844 | { type: NgZone }
|
845 | ];
|
846 | IonBackButton = __decorate([
|
847 | ProxyCmp({ inputs: ["color", "defaultHref", "disabled", "icon", "mode", "routerAnimation", "text", "type"] }),
|
848 | Component({ selector: "ion-back-button", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["color", "defaultHref", "disabled", "icon", "mode", "routerAnimation", "text", "type"] })
|
849 | ], IonBackButton);
|
850 | let IonBackdrop = class IonBackdrop {
|
851 | constructor(c, r, z) {
|
852 | this.z = z;
|
853 | c.detach();
|
854 | this.el = r.nativeElement;
|
855 | proxyOutputs(this, this.el, ["ionBackdropTap"]);
|
856 | }
|
857 | };
|
858 | IonBackdrop.ctorParameters = () => [
|
859 | { type: ChangeDetectorRef },
|
860 | { type: ElementRef },
|
861 | { type: NgZone }
|
862 | ];
|
863 | IonBackdrop = __decorate([
|
864 | ProxyCmp({ inputs: ["stopPropagation", "tappable", "visible"] }),
|
865 | Component({ selector: "ion-backdrop", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["stopPropagation", "tappable", "visible"] })
|
866 | ], IonBackdrop);
|
867 | let IonBadge = class IonBadge {
|
868 | constructor(c, r, z) {
|
869 | this.z = z;
|
870 | c.detach();
|
871 | this.el = r.nativeElement;
|
872 | }
|
873 | };
|
874 | IonBadge.ctorParameters = () => [
|
875 | { type: ChangeDetectorRef },
|
876 | { type: ElementRef },
|
877 | { type: NgZone }
|
878 | ];
|
879 | IonBadge = __decorate([
|
880 | ProxyCmp({ inputs: ["color", "mode"] }),
|
881 | Component({ selector: "ion-badge", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["color", "mode"] })
|
882 | ], IonBadge);
|
883 | let IonButton = class IonButton {
|
884 | constructor(c, r, z) {
|
885 | this.z = z;
|
886 | c.detach();
|
887 | this.el = r.nativeElement;
|
888 | proxyOutputs(this, this.el, ["ionFocus", "ionBlur"]);
|
889 | }
|
890 | };
|
891 | IonButton.ctorParameters = () => [
|
892 | { type: ChangeDetectorRef },
|
893 | { type: ElementRef },
|
894 | { type: NgZone }
|
895 | ];
|
896 | IonButton = __decorate([
|
897 | ProxyCmp({ inputs: ["buttonType", "color", "disabled", "download", "expand", "fill", "href", "mode", "rel", "routerAnimation", "routerDirection", "shape", "size", "strong", "target", "type"] }),
|
898 | Component({ selector: "ion-button", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["buttonType", "color", "disabled", "download", "expand", "fill", "href", "mode", "rel", "routerAnimation", "routerDirection", "shape", "size", "strong", "target", "type"] })
|
899 | ], IonButton);
|
900 | let IonButtons = class IonButtons {
|
901 | constructor(c, r, z) {
|
902 | this.z = z;
|
903 | c.detach();
|
904 | this.el = r.nativeElement;
|
905 | }
|
906 | };
|
907 | IonButtons.ctorParameters = () => [
|
908 | { type: ChangeDetectorRef },
|
909 | { type: ElementRef },
|
910 | { type: NgZone }
|
911 | ];
|
912 | IonButtons = __decorate([
|
913 | ProxyCmp({ inputs: ["collapse"] }),
|
914 | Component({ selector: "ion-buttons", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["collapse"] })
|
915 | ], IonButtons);
|
916 | let IonCard = class IonCard {
|
917 | constructor(c, r, z) {
|
918 | this.z = z;
|
919 | c.detach();
|
920 | this.el = r.nativeElement;
|
921 | }
|
922 | };
|
923 | IonCard.ctorParameters = () => [
|
924 | { type: ChangeDetectorRef },
|
925 | { type: ElementRef },
|
926 | { type: NgZone }
|
927 | ];
|
928 | IonCard = __decorate([
|
929 | ProxyCmp({ inputs: ["button", "color", "disabled", "download", "href", "mode", "rel", "routerAnimation", "routerDirection", "target", "type"] }),
|
930 | Component({ selector: "ion-card", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["button", "color", "disabled", "download", "href", "mode", "rel", "routerAnimation", "routerDirection", "target", "type"] })
|
931 | ], IonCard);
|
932 | let IonCardContent = class IonCardContent {
|
933 | constructor(c, r, z) {
|
934 | this.z = z;
|
935 | c.detach();
|
936 | this.el = r.nativeElement;
|
937 | }
|
938 | };
|
939 | IonCardContent.ctorParameters = () => [
|
940 | { type: ChangeDetectorRef },
|
941 | { type: ElementRef },
|
942 | { type: NgZone }
|
943 | ];
|
944 | IonCardContent = __decorate([
|
945 | ProxyCmp({ inputs: ["mode"] }),
|
946 | Component({ selector: "ion-card-content", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["mode"] })
|
947 | ], IonCardContent);
|
948 | let IonCardHeader = class IonCardHeader {
|
949 | constructor(c, r, z) {
|
950 | this.z = z;
|
951 | c.detach();
|
952 | this.el = r.nativeElement;
|
953 | }
|
954 | };
|
955 | IonCardHeader.ctorParameters = () => [
|
956 | { type: ChangeDetectorRef },
|
957 | { type: ElementRef },
|
958 | { type: NgZone }
|
959 | ];
|
960 | IonCardHeader = __decorate([
|
961 | ProxyCmp({ inputs: ["color", "mode", "translucent"] }),
|
962 | Component({ selector: "ion-card-header", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["color", "mode", "translucent"] })
|
963 | ], IonCardHeader);
|
964 | let IonCardSubtitle = class IonCardSubtitle {
|
965 | constructor(c, r, z) {
|
966 | this.z = z;
|
967 | c.detach();
|
968 | this.el = r.nativeElement;
|
969 | }
|
970 | };
|
971 | IonCardSubtitle.ctorParameters = () => [
|
972 | { type: ChangeDetectorRef },
|
973 | { type: ElementRef },
|
974 | { type: NgZone }
|
975 | ];
|
976 | IonCardSubtitle = __decorate([
|
977 | ProxyCmp({ inputs: ["color", "mode"] }),
|
978 | Component({ selector: "ion-card-subtitle", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["color", "mode"] })
|
979 | ], IonCardSubtitle);
|
980 | let IonCardTitle = class IonCardTitle {
|
981 | constructor(c, r, z) {
|
982 | this.z = z;
|
983 | c.detach();
|
984 | this.el = r.nativeElement;
|
985 | }
|
986 | };
|
987 | IonCardTitle.ctorParameters = () => [
|
988 | { type: ChangeDetectorRef },
|
989 | { type: ElementRef },
|
990 | { type: NgZone }
|
991 | ];
|
992 | IonCardTitle = __decorate([
|
993 | ProxyCmp({ inputs: ["color", "mode"] }),
|
994 | Component({ selector: "ion-card-title", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["color", "mode"] })
|
995 | ], IonCardTitle);
|
996 | let IonCheckbox = class IonCheckbox {
|
997 | constructor(c, r, z) {
|
998 | this.z = z;
|
999 | c.detach();
|
1000 | this.el = r.nativeElement;
|
1001 | proxyOutputs(this, this.el, ["ionChange", "ionFocus", "ionBlur"]);
|
1002 | }
|
1003 | };
|
1004 | IonCheckbox.ctorParameters = () => [
|
1005 | { type: ChangeDetectorRef },
|
1006 | { type: ElementRef },
|
1007 | { type: NgZone }
|
1008 | ];
|
1009 | IonCheckbox = __decorate([
|
1010 | ProxyCmp({ inputs: ["checked", "color", "disabled", "indeterminate", "mode", "name", "value"] }),
|
1011 | Component({ selector: "ion-checkbox", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["checked", "color", "disabled", "indeterminate", "mode", "name", "value"] })
|
1012 | ], IonCheckbox);
|
1013 | let IonChip = class IonChip {
|
1014 | constructor(c, r, z) {
|
1015 | this.z = z;
|
1016 | c.detach();
|
1017 | this.el = r.nativeElement;
|
1018 | }
|
1019 | };
|
1020 | IonChip.ctorParameters = () => [
|
1021 | { type: ChangeDetectorRef },
|
1022 | { type: ElementRef },
|
1023 | { type: NgZone }
|
1024 | ];
|
1025 | IonChip = __decorate([
|
1026 | ProxyCmp({ inputs: ["color", "disabled", "mode", "outline"] }),
|
1027 | Component({ selector: "ion-chip", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["color", "disabled", "mode", "outline"] })
|
1028 | ], IonChip);
|
1029 | let IonCol = class IonCol {
|
1030 | constructor(c, r, z) {
|
1031 | this.z = z;
|
1032 | c.detach();
|
1033 | this.el = r.nativeElement;
|
1034 | }
|
1035 | };
|
1036 | IonCol.ctorParameters = () => [
|
1037 | { type: ChangeDetectorRef },
|
1038 | { type: ElementRef },
|
1039 | { type: NgZone }
|
1040 | ];
|
1041 | IonCol = __decorate([
|
1042 | ProxyCmp({ inputs: ["offset", "offsetLg", "offsetMd", "offsetSm", "offsetXl", "offsetXs", "pull", "pullLg", "pullMd", "pullSm", "pullXl", "pullXs", "push", "pushLg", "pushMd", "pushSm", "pushXl", "pushXs", "size", "sizeLg", "sizeMd", "sizeSm", "sizeXl", "sizeXs"] }),
|
1043 | Component({ selector: "ion-col", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["offset", "offsetLg", "offsetMd", "offsetSm", "offsetXl", "offsetXs", "pull", "pullLg", "pullMd", "pullSm", "pullXl", "pullXs", "push", "pushLg", "pushMd", "pushSm", "pushXl", "pushXs", "size", "sizeLg", "sizeMd", "sizeSm", "sizeXl", "sizeXs"] })
|
1044 | ], IonCol);
|
1045 | let IonContent = class IonContent {
|
1046 | constructor(c, r, z) {
|
1047 | this.z = z;
|
1048 | c.detach();
|
1049 | this.el = r.nativeElement;
|
1050 | proxyOutputs(this, this.el, ["ionScrollStart", "ionScroll", "ionScrollEnd"]);
|
1051 | }
|
1052 | };
|
1053 | IonContent.ctorParameters = () => [
|
1054 | { type: ChangeDetectorRef },
|
1055 | { type: ElementRef },
|
1056 | { type: NgZone }
|
1057 | ];
|
1058 | IonContent = __decorate([
|
1059 | ProxyCmp({ inputs: ["color", "forceOverscroll", "fullscreen", "scrollEvents", "scrollX", "scrollY"], "methods": ["getScrollElement", "scrollToTop", "scrollToBottom", "scrollByPoint", "scrollToPoint"] }),
|
1060 | Component({ selector: "ion-content", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["color", "forceOverscroll", "fullscreen", "scrollEvents", "scrollX", "scrollY"] })
|
1061 | ], IonContent);
|
1062 | let IonDatetime = class IonDatetime {
|
1063 | constructor(c, r, z) {
|
1064 | this.z = z;
|
1065 | c.detach();
|
1066 | this.el = r.nativeElement;
|
1067 | proxyOutputs(this, this.el, ["ionCancel", "ionChange", "ionFocus", "ionBlur"]);
|
1068 | }
|
1069 | };
|
1070 | IonDatetime.ctorParameters = () => [
|
1071 | { type: ChangeDetectorRef },
|
1072 | { type: ElementRef },
|
1073 | { type: NgZone }
|
1074 | ];
|
1075 | IonDatetime = __decorate([
|
1076 | ProxyCmp({ inputs: ["cancelText", "dayNames", "dayShortNames", "dayValues", "disabled", "displayFormat", "displayTimezone", "doneText", "hourValues", "max", "min", "minuteValues", "mode", "monthNames", "monthShortNames", "monthValues", "name", "pickerFormat", "pickerOptions", "placeholder", "readonly", "value", "yearValues"], "methods": ["open"] }),
|
1077 | Component({ selector: "ion-datetime", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["cancelText", "dayNames", "dayShortNames", "dayValues", "disabled", "displayFormat", "displayTimezone", "doneText", "hourValues", "max", "min", "minuteValues", "mode", "monthNames", "monthShortNames", "monthValues", "name", "pickerFormat", "pickerOptions", "placeholder", "readonly", "value", "yearValues"] })
|
1078 | ], IonDatetime);
|
1079 | let IonFab = class IonFab {
|
1080 | constructor(c, r, z) {
|
1081 | this.z = z;
|
1082 | c.detach();
|
1083 | this.el = r.nativeElement;
|
1084 | }
|
1085 | };
|
1086 | IonFab.ctorParameters = () => [
|
1087 | { type: ChangeDetectorRef },
|
1088 | { type: ElementRef },
|
1089 | { type: NgZone }
|
1090 | ];
|
1091 | IonFab = __decorate([
|
1092 | ProxyCmp({ inputs: ["activated", "edge", "horizontal", "vertical"], "methods": ["close"] }),
|
1093 | Component({ selector: "ion-fab", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["activated", "edge", "horizontal", "vertical"] })
|
1094 | ], IonFab);
|
1095 | let IonFabButton = class IonFabButton {
|
1096 | constructor(c, r, z) {
|
1097 | this.z = z;
|
1098 | c.detach();
|
1099 | this.el = r.nativeElement;
|
1100 | proxyOutputs(this, this.el, ["ionFocus", "ionBlur"]);
|
1101 | }
|
1102 | };
|
1103 | IonFabButton.ctorParameters = () => [
|
1104 | { type: ChangeDetectorRef },
|
1105 | { type: ElementRef },
|
1106 | { type: NgZone }
|
1107 | ];
|
1108 | IonFabButton = __decorate([
|
1109 | ProxyCmp({ inputs: ["activated", "closeIcon", "color", "disabled", "download", "href", "mode", "rel", "routerAnimation", "routerDirection", "show", "size", "target", "translucent", "type"] }),
|
1110 | Component({ selector: "ion-fab-button", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["activated", "closeIcon", "color", "disabled", "download", "href", "mode", "rel", "routerAnimation", "routerDirection", "show", "size", "target", "translucent", "type"] })
|
1111 | ], IonFabButton);
|
1112 | let IonFabList = class IonFabList {
|
1113 | constructor(c, r, z) {
|
1114 | this.z = z;
|
1115 | c.detach();
|
1116 | this.el = r.nativeElement;
|
1117 | }
|
1118 | };
|
1119 | IonFabList.ctorParameters = () => [
|
1120 | { type: ChangeDetectorRef },
|
1121 | { type: ElementRef },
|
1122 | { type: NgZone }
|
1123 | ];
|
1124 | IonFabList = __decorate([
|
1125 | ProxyCmp({ inputs: ["activated", "side"] }),
|
1126 | Component({ selector: "ion-fab-list", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["activated", "side"] })
|
1127 | ], IonFabList);
|
1128 | let IonFooter = class IonFooter {
|
1129 | constructor(c, r, z) {
|
1130 | this.z = z;
|
1131 | c.detach();
|
1132 | this.el = r.nativeElement;
|
1133 | }
|
1134 | };
|
1135 | IonFooter.ctorParameters = () => [
|
1136 | { type: ChangeDetectorRef },
|
1137 | { type: ElementRef },
|
1138 | { type: NgZone }
|
1139 | ];
|
1140 | IonFooter = __decorate([
|
1141 | ProxyCmp({ inputs: ["mode", "translucent"] }),
|
1142 | Component({ selector: "ion-footer", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["mode", "translucent"] })
|
1143 | ], IonFooter);
|
1144 | let IonGrid = class IonGrid {
|
1145 | constructor(c, r, z) {
|
1146 | this.z = z;
|
1147 | c.detach();
|
1148 | this.el = r.nativeElement;
|
1149 | }
|
1150 | };
|
1151 | IonGrid.ctorParameters = () => [
|
1152 | { type: ChangeDetectorRef },
|
1153 | { type: ElementRef },
|
1154 | { type: NgZone }
|
1155 | ];
|
1156 | IonGrid = __decorate([
|
1157 | ProxyCmp({ inputs: ["fixed"] }),
|
1158 | Component({ selector: "ion-grid", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["fixed"] })
|
1159 | ], IonGrid);
|
1160 | let IonHeader = class IonHeader {
|
1161 | constructor(c, r, z) {
|
1162 | this.z = z;
|
1163 | c.detach();
|
1164 | this.el = r.nativeElement;
|
1165 | }
|
1166 | };
|
1167 | IonHeader.ctorParameters = () => [
|
1168 | { type: ChangeDetectorRef },
|
1169 | { type: ElementRef },
|
1170 | { type: NgZone }
|
1171 | ];
|
1172 | IonHeader = __decorate([
|
1173 | ProxyCmp({ inputs: ["collapse", "mode", "translucent"] }),
|
1174 | Component({ selector: "ion-header", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["collapse", "mode", "translucent"] })
|
1175 | ], IonHeader);
|
1176 | let IonIcon = class IonIcon {
|
1177 | constructor(c, r, z) {
|
1178 | this.z = z;
|
1179 | c.detach();
|
1180 | this.el = r.nativeElement;
|
1181 | }
|
1182 | };
|
1183 | IonIcon.ctorParameters = () => [
|
1184 | { type: ChangeDetectorRef },
|
1185 | { type: ElementRef },
|
1186 | { type: NgZone }
|
1187 | ];
|
1188 | IonIcon = __decorate([
|
1189 | ProxyCmp({ inputs: ["ariaHidden", "ariaLabel", "color", "flipRtl", "icon", "ios", "lazy", "md", "mode", "name", "sanitize", "size", "src"] }),
|
1190 | Component({ selector: "ion-icon", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["ariaHidden", "ariaLabel", "color", "flipRtl", "icon", "ios", "lazy", "md", "mode", "name", "sanitize", "size", "src"] })
|
1191 | ], IonIcon);
|
1192 | let IonImg = class IonImg {
|
1193 | constructor(c, r, z) {
|
1194 | this.z = z;
|
1195 | c.detach();
|
1196 | this.el = r.nativeElement;
|
1197 | proxyOutputs(this, this.el, ["ionImgWillLoad", "ionImgDidLoad", "ionError"]);
|
1198 | }
|
1199 | };
|
1200 | IonImg.ctorParameters = () => [
|
1201 | { type: ChangeDetectorRef },
|
1202 | { type: ElementRef },
|
1203 | { type: NgZone }
|
1204 | ];
|
1205 | IonImg = __decorate([
|
1206 | ProxyCmp({ inputs: ["alt", "src"] }),
|
1207 | Component({ selector: "ion-img", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["alt", "src"] })
|
1208 | ], IonImg);
|
1209 | let IonInfiniteScroll = class IonInfiniteScroll {
|
1210 | constructor(c, r, z) {
|
1211 | this.z = z;
|
1212 | c.detach();
|
1213 | this.el = r.nativeElement;
|
1214 | proxyOutputs(this, this.el, ["ionInfinite"]);
|
1215 | }
|
1216 | };
|
1217 | IonInfiniteScroll.ctorParameters = () => [
|
1218 | { type: ChangeDetectorRef },
|
1219 | { type: ElementRef },
|
1220 | { type: NgZone }
|
1221 | ];
|
1222 | IonInfiniteScroll = __decorate([
|
1223 | ProxyCmp({ inputs: ["disabled", "position", "threshold"], "methods": ["complete"] }),
|
1224 | Component({ selector: "ion-infinite-scroll", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["disabled", "position", "threshold"] })
|
1225 | ], IonInfiniteScroll);
|
1226 | let IonInfiniteScrollContent = class IonInfiniteScrollContent {
|
1227 | constructor(c, r, z) {
|
1228 | this.z = z;
|
1229 | c.detach();
|
1230 | this.el = r.nativeElement;
|
1231 | }
|
1232 | };
|
1233 | IonInfiniteScrollContent.ctorParameters = () => [
|
1234 | { type: ChangeDetectorRef },
|
1235 | { type: ElementRef },
|
1236 | { type: NgZone }
|
1237 | ];
|
1238 | IonInfiniteScrollContent = __decorate([
|
1239 | ProxyCmp({ inputs: ["loadingSpinner", "loadingText"] }),
|
1240 | Component({ selector: "ion-infinite-scroll-content", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["loadingSpinner", "loadingText"] })
|
1241 | ], IonInfiniteScrollContent);
|
1242 | let IonInput = class IonInput {
|
1243 | constructor(c, r, z) {
|
1244 | this.z = z;
|
1245 | c.detach();
|
1246 | this.el = r.nativeElement;
|
1247 | proxyOutputs(this, this.el, ["ionInput", "ionChange", "ionBlur", "ionFocus"]);
|
1248 | }
|
1249 | };
|
1250 | IonInput.ctorParameters = () => [
|
1251 | { type: ChangeDetectorRef },
|
1252 | { type: ElementRef },
|
1253 | { type: NgZone }
|
1254 | ];
|
1255 | IonInput = __decorate([
|
1256 | ProxyCmp({ inputs: ["accept", "autocapitalize", "autocomplete", "autocorrect", "autofocus", "clearInput", "clearOnEdit", "color", "debounce", "disabled", "enterkeyhint", "inputmode", "max", "maxlength", "min", "minlength", "mode", "multiple", "name", "pattern", "placeholder", "readonly", "required", "size", "spellcheck", "step", "type", "value"], "methods": ["setFocus", "getInputElement"] }),
|
1257 | Component({ selector: "ion-input", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["accept", "autocapitalize", "autocomplete", "autocorrect", "autofocus", "clearInput", "clearOnEdit", "color", "debounce", "disabled", "enterkeyhint", "inputmode", "max", "maxlength", "min", "minlength", "mode", "multiple", "name", "pattern", "placeholder", "readonly", "required", "size", "spellcheck", "step", "type", "value"] })
|
1258 | ], IonInput);
|
1259 | let IonItem = class IonItem {
|
1260 | constructor(c, r, z) {
|
1261 | this.z = z;
|
1262 | c.detach();
|
1263 | this.el = r.nativeElement;
|
1264 | }
|
1265 | };
|
1266 | IonItem.ctorParameters = () => [
|
1267 | { type: ChangeDetectorRef },
|
1268 | { type: ElementRef },
|
1269 | { type: NgZone }
|
1270 | ];
|
1271 | IonItem = __decorate([
|
1272 | ProxyCmp({ inputs: ["button", "color", "detail", "detailIcon", "disabled", "download", "href", "lines", "mode", "rel", "routerAnimation", "routerDirection", "target", "type"] }),
|
1273 | Component({ selector: "ion-item", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["button", "color", "detail", "detailIcon", "disabled", "download", "href", "lines", "mode", "rel", "routerAnimation", "routerDirection", "target", "type"] })
|
1274 | ], IonItem);
|
1275 | let IonItemDivider = class IonItemDivider {
|
1276 | constructor(c, r, z) {
|
1277 | this.z = z;
|
1278 | c.detach();
|
1279 | this.el = r.nativeElement;
|
1280 | }
|
1281 | };
|
1282 | IonItemDivider.ctorParameters = () => [
|
1283 | { type: ChangeDetectorRef },
|
1284 | { type: ElementRef },
|
1285 | { type: NgZone }
|
1286 | ];
|
1287 | IonItemDivider = __decorate([
|
1288 | ProxyCmp({ inputs: ["color", "mode", "sticky"] }),
|
1289 | Component({ selector: "ion-item-divider", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["color", "mode", "sticky"] })
|
1290 | ], IonItemDivider);
|
1291 | let IonItemGroup = class IonItemGroup {
|
1292 | constructor(c, r, z) {
|
1293 | this.z = z;
|
1294 | c.detach();
|
1295 | this.el = r.nativeElement;
|
1296 | }
|
1297 | };
|
1298 | IonItemGroup.ctorParameters = () => [
|
1299 | { type: ChangeDetectorRef },
|
1300 | { type: ElementRef },
|
1301 | { type: NgZone }
|
1302 | ];
|
1303 | IonItemGroup = __decorate([
|
1304 | Component({ selector: "ion-item-group", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>" })
|
1305 | ], IonItemGroup);
|
1306 | let IonItemOption = class IonItemOption {
|
1307 | constructor(c, r, z) {
|
1308 | this.z = z;
|
1309 | c.detach();
|
1310 | this.el = r.nativeElement;
|
1311 | }
|
1312 | };
|
1313 | IonItemOption.ctorParameters = () => [
|
1314 | { type: ChangeDetectorRef },
|
1315 | { type: ElementRef },
|
1316 | { type: NgZone }
|
1317 | ];
|
1318 | IonItemOption = __decorate([
|
1319 | ProxyCmp({ inputs: ["color", "disabled", "download", "expandable", "href", "mode", "rel", "target", "type"] }),
|
1320 | Component({ selector: "ion-item-option", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["color", "disabled", "download", "expandable", "href", "mode", "rel", "target", "type"] })
|
1321 | ], IonItemOption);
|
1322 | let IonItemOptions = class IonItemOptions {
|
1323 | constructor(c, r, z) {
|
1324 | this.z = z;
|
1325 | c.detach();
|
1326 | this.el = r.nativeElement;
|
1327 | proxyOutputs(this, this.el, ["ionSwipe"]);
|
1328 | }
|
1329 | };
|
1330 | IonItemOptions.ctorParameters = () => [
|
1331 | { type: ChangeDetectorRef },
|
1332 | { type: ElementRef },
|
1333 | { type: NgZone }
|
1334 | ];
|
1335 | IonItemOptions = __decorate([
|
1336 | ProxyCmp({ inputs: ["side"] }),
|
1337 | Component({ selector: "ion-item-options", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["side"] })
|
1338 | ], IonItemOptions);
|
1339 | let IonItemSliding = class IonItemSliding {
|
1340 | constructor(c, r, z) {
|
1341 | this.z = z;
|
1342 | c.detach();
|
1343 | this.el = r.nativeElement;
|
1344 | proxyOutputs(this, this.el, ["ionDrag"]);
|
1345 | }
|
1346 | };
|
1347 | IonItemSliding.ctorParameters = () => [
|
1348 | { type: ChangeDetectorRef },
|
1349 | { type: ElementRef },
|
1350 | { type: NgZone }
|
1351 | ];
|
1352 | IonItemSliding = __decorate([
|
1353 | ProxyCmp({ inputs: ["disabled"], "methods": ["getOpenAmount", "getSlidingRatio", "open", "close", "closeOpened"] }),
|
1354 | Component({ selector: "ion-item-sliding", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["disabled"] })
|
1355 | ], IonItemSliding);
|
1356 | let IonLabel = class IonLabel {
|
1357 | constructor(c, r, z) {
|
1358 | this.z = z;
|
1359 | c.detach();
|
1360 | this.el = r.nativeElement;
|
1361 | }
|
1362 | };
|
1363 | IonLabel.ctorParameters = () => [
|
1364 | { type: ChangeDetectorRef },
|
1365 | { type: ElementRef },
|
1366 | { type: NgZone }
|
1367 | ];
|
1368 | IonLabel = __decorate([
|
1369 | ProxyCmp({ inputs: ["color", "mode", "position"] }),
|
1370 | Component({ selector: "ion-label", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["color", "mode", "position"] })
|
1371 | ], IonLabel);
|
1372 | let IonList = class IonList {
|
1373 | constructor(c, r, z) {
|
1374 | this.z = z;
|
1375 | c.detach();
|
1376 | this.el = r.nativeElement;
|
1377 | }
|
1378 | };
|
1379 | IonList.ctorParameters = () => [
|
1380 | { type: ChangeDetectorRef },
|
1381 | { type: ElementRef },
|
1382 | { type: NgZone }
|
1383 | ];
|
1384 | IonList = __decorate([
|
1385 | ProxyCmp({ inputs: ["inset", "lines", "mode"], "methods": ["closeSlidingItems"] }),
|
1386 | Component({ selector: "ion-list", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["inset", "lines", "mode"] })
|
1387 | ], IonList);
|
1388 | let IonListHeader = class IonListHeader {
|
1389 | constructor(c, r, z) {
|
1390 | this.z = z;
|
1391 | c.detach();
|
1392 | this.el = r.nativeElement;
|
1393 | }
|
1394 | };
|
1395 | IonListHeader.ctorParameters = () => [
|
1396 | { type: ChangeDetectorRef },
|
1397 | { type: ElementRef },
|
1398 | { type: NgZone }
|
1399 | ];
|
1400 | IonListHeader = __decorate([
|
1401 | ProxyCmp({ inputs: ["color", "lines", "mode"] }),
|
1402 | Component({ selector: "ion-list-header", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["color", "lines", "mode"] })
|
1403 | ], IonListHeader);
|
1404 | let IonMenu = class IonMenu {
|
1405 | constructor(c, r, z) {
|
1406 | this.z = z;
|
1407 | c.detach();
|
1408 | this.el = r.nativeElement;
|
1409 | proxyOutputs(this, this.el, ["ionWillOpen", "ionWillClose", "ionDidOpen", "ionDidClose"]);
|
1410 | }
|
1411 | };
|
1412 | IonMenu.ctorParameters = () => [
|
1413 | { type: ChangeDetectorRef },
|
1414 | { type: ElementRef },
|
1415 | { type: NgZone }
|
1416 | ];
|
1417 | IonMenu = __decorate([
|
1418 | ProxyCmp({ inputs: ["contentId", "disabled", "maxEdgeStart", "menuId", "side", "swipeGesture", "type"], "methods": ["isOpen", "isActive", "open", "close", "toggle", "setOpen"] }),
|
1419 | Component({ selector: "ion-menu", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["contentId", "disabled", "maxEdgeStart", "menuId", "side", "swipeGesture", "type"] })
|
1420 | ], IonMenu);
|
1421 | let IonMenuButton = class IonMenuButton {
|
1422 | constructor(c, r, z) {
|
1423 | this.z = z;
|
1424 | c.detach();
|
1425 | this.el = r.nativeElement;
|
1426 | }
|
1427 | };
|
1428 | IonMenuButton.ctorParameters = () => [
|
1429 | { type: ChangeDetectorRef },
|
1430 | { type: ElementRef },
|
1431 | { type: NgZone }
|
1432 | ];
|
1433 | IonMenuButton = __decorate([
|
1434 | ProxyCmp({ inputs: ["autoHide", "color", "disabled", "menu", "mode", "type"] }),
|
1435 | Component({ selector: "ion-menu-button", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["autoHide", "color", "disabled", "menu", "mode", "type"] })
|
1436 | ], IonMenuButton);
|
1437 | let IonMenuToggle = class IonMenuToggle {
|
1438 | constructor(c, r, z) {
|
1439 | this.z = z;
|
1440 | c.detach();
|
1441 | this.el = r.nativeElement;
|
1442 | }
|
1443 | };
|
1444 | IonMenuToggle.ctorParameters = () => [
|
1445 | { type: ChangeDetectorRef },
|
1446 | { type: ElementRef },
|
1447 | { type: NgZone }
|
1448 | ];
|
1449 | IonMenuToggle = __decorate([
|
1450 | ProxyCmp({ inputs: ["autoHide", "menu"] }),
|
1451 | Component({ selector: "ion-menu-toggle", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["autoHide", "menu"] })
|
1452 | ], IonMenuToggle);
|
1453 | let IonNav = class IonNav {
|
1454 | constructor(c, r, z) {
|
1455 | this.z = z;
|
1456 | c.detach();
|
1457 | this.el = r.nativeElement;
|
1458 | proxyOutputs(this, this.el, ["ionNavWillChange", "ionNavDidChange"]);
|
1459 | }
|
1460 | };
|
1461 | IonNav.ctorParameters = () => [
|
1462 | { type: ChangeDetectorRef },
|
1463 | { type: ElementRef },
|
1464 | { type: NgZone }
|
1465 | ];
|
1466 | IonNav = __decorate([
|
1467 | ProxyCmp({ inputs: ["animated", "animation", "root", "rootParams", "swipeGesture"], "methods": ["push", "insert", "insertPages", "pop", "popTo", "popToRoot", "removeIndex", "setRoot", "setPages", "getActive", "getByIndex", "canGoBack", "getPrevious"] }),
|
1468 | Component({ selector: "ion-nav", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["animated", "animation", "root", "rootParams", "swipeGesture"] })
|
1469 | ], IonNav);
|
1470 | let IonNavLink = class IonNavLink {
|
1471 | constructor(c, r, z) {
|
1472 | this.z = z;
|
1473 | c.detach();
|
1474 | this.el = r.nativeElement;
|
1475 | }
|
1476 | };
|
1477 | IonNavLink.ctorParameters = () => [
|
1478 | { type: ChangeDetectorRef },
|
1479 | { type: ElementRef },
|
1480 | { type: NgZone }
|
1481 | ];
|
1482 | IonNavLink = __decorate([
|
1483 | ProxyCmp({ inputs: ["component", "componentProps", "routerAnimation", "routerDirection"] }),
|
1484 | Component({ selector: "ion-nav-link", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["component", "componentProps", "routerAnimation", "routerDirection"] })
|
1485 | ], IonNavLink);
|
1486 | let IonNote = class IonNote {
|
1487 | constructor(c, r, z) {
|
1488 | this.z = z;
|
1489 | c.detach();
|
1490 | this.el = r.nativeElement;
|
1491 | }
|
1492 | };
|
1493 | IonNote.ctorParameters = () => [
|
1494 | { type: ChangeDetectorRef },
|
1495 | { type: ElementRef },
|
1496 | { type: NgZone }
|
1497 | ];
|
1498 | IonNote = __decorate([
|
1499 | ProxyCmp({ inputs: ["color", "mode"] }),
|
1500 | Component({ selector: "ion-note", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["color", "mode"] })
|
1501 | ], IonNote);
|
1502 | let IonProgressBar = class IonProgressBar {
|
1503 | constructor(c, r, z) {
|
1504 | this.z = z;
|
1505 | c.detach();
|
1506 | this.el = r.nativeElement;
|
1507 | }
|
1508 | };
|
1509 | IonProgressBar.ctorParameters = () => [
|
1510 | { type: ChangeDetectorRef },
|
1511 | { type: ElementRef },
|
1512 | { type: NgZone }
|
1513 | ];
|
1514 | IonProgressBar = __decorate([
|
1515 | ProxyCmp({ inputs: ["buffer", "color", "mode", "reversed", "type", "value"] }),
|
1516 | Component({ selector: "ion-progress-bar", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["buffer", "color", "mode", "reversed", "type", "value"] })
|
1517 | ], IonProgressBar);
|
1518 | let IonRadio = class IonRadio {
|
1519 | constructor(c, r, z) {
|
1520 | this.z = z;
|
1521 | c.detach();
|
1522 | this.el = r.nativeElement;
|
1523 | proxyOutputs(this, this.el, ["ionFocus", "ionBlur"]);
|
1524 | }
|
1525 | };
|
1526 | IonRadio.ctorParameters = () => [
|
1527 | { type: ChangeDetectorRef },
|
1528 | { type: ElementRef },
|
1529 | { type: NgZone }
|
1530 | ];
|
1531 | IonRadio = __decorate([
|
1532 | ProxyCmp({ inputs: ["color", "disabled", "mode", "name", "value"] }),
|
1533 | Component({ selector: "ion-radio", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["color", "disabled", "mode", "name", "value"] })
|
1534 | ], IonRadio);
|
1535 | let IonRadioGroup = class IonRadioGroup {
|
1536 | constructor(c, r, z) {
|
1537 | this.z = z;
|
1538 | c.detach();
|
1539 | this.el = r.nativeElement;
|
1540 | proxyOutputs(this, this.el, ["ionChange"]);
|
1541 | }
|
1542 | };
|
1543 | IonRadioGroup.ctorParameters = () => [
|
1544 | { type: ChangeDetectorRef },
|
1545 | { type: ElementRef },
|
1546 | { type: NgZone }
|
1547 | ];
|
1548 | IonRadioGroup = __decorate([
|
1549 | ProxyCmp({ inputs: ["allowEmptySelection", "name", "value"] }),
|
1550 | Component({ selector: "ion-radio-group", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["allowEmptySelection", "name", "value"] })
|
1551 | ], IonRadioGroup);
|
1552 | let IonRange = class IonRange {
|
1553 | constructor(c, r, z) {
|
1554 | this.z = z;
|
1555 | c.detach();
|
1556 | this.el = r.nativeElement;
|
1557 | proxyOutputs(this, this.el, ["ionChange", "ionFocus", "ionBlur"]);
|
1558 | }
|
1559 | };
|
1560 | IonRange.ctorParameters = () => [
|
1561 | { type: ChangeDetectorRef },
|
1562 | { type: ElementRef },
|
1563 | { type: NgZone }
|
1564 | ];
|
1565 | IonRange = __decorate([
|
1566 | ProxyCmp({ inputs: ["color", "debounce", "disabled", "dualKnobs", "max", "min", "mode", "name", "pin", "snaps", "step", "ticks", "value"] }),
|
1567 | Component({ selector: "ion-range", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["color", "debounce", "disabled", "dualKnobs", "max", "min", "mode", "name", "pin", "snaps", "step", "ticks", "value"] })
|
1568 | ], IonRange);
|
1569 | let IonRefresher = class IonRefresher {
|
1570 | constructor(c, r, z) {
|
1571 | this.z = z;
|
1572 | c.detach();
|
1573 | this.el = r.nativeElement;
|
1574 | proxyOutputs(this, this.el, ["ionRefresh", "ionPull", "ionStart"]);
|
1575 | }
|
1576 | };
|
1577 | IonRefresher.ctorParameters = () => [
|
1578 | { type: ChangeDetectorRef },
|
1579 | { type: ElementRef },
|
1580 | { type: NgZone }
|
1581 | ];
|
1582 | IonRefresher = __decorate([
|
1583 | ProxyCmp({ inputs: ["closeDuration", "disabled", "pullFactor", "pullMax", "pullMin", "snapbackDuration"], "methods": ["complete", "cancel", "getProgress"] }),
|
1584 | Component({ selector: "ion-refresher", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["closeDuration", "disabled", "pullFactor", "pullMax", "pullMin", "snapbackDuration"] })
|
1585 | ], IonRefresher);
|
1586 | let IonRefresherContent = class IonRefresherContent {
|
1587 | constructor(c, r, z) {
|
1588 | this.z = z;
|
1589 | c.detach();
|
1590 | this.el = r.nativeElement;
|
1591 | }
|
1592 | };
|
1593 | IonRefresherContent.ctorParameters = () => [
|
1594 | { type: ChangeDetectorRef },
|
1595 | { type: ElementRef },
|
1596 | { type: NgZone }
|
1597 | ];
|
1598 | IonRefresherContent = __decorate([
|
1599 | ProxyCmp({ inputs: ["pullingIcon", "pullingText", "refreshingSpinner", "refreshingText"] }),
|
1600 | Component({ selector: "ion-refresher-content", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["pullingIcon", "pullingText", "refreshingSpinner", "refreshingText"] })
|
1601 | ], IonRefresherContent);
|
1602 | let IonReorder = class IonReorder {
|
1603 | constructor(c, r, z) {
|
1604 | this.z = z;
|
1605 | c.detach();
|
1606 | this.el = r.nativeElement;
|
1607 | }
|
1608 | };
|
1609 | IonReorder.ctorParameters = () => [
|
1610 | { type: ChangeDetectorRef },
|
1611 | { type: ElementRef },
|
1612 | { type: NgZone }
|
1613 | ];
|
1614 | IonReorder = __decorate([
|
1615 | Component({ selector: "ion-reorder", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>" })
|
1616 | ], IonReorder);
|
1617 | let IonReorderGroup = class IonReorderGroup {
|
1618 | constructor(c, r, z) {
|
1619 | this.z = z;
|
1620 | c.detach();
|
1621 | this.el = r.nativeElement;
|
1622 | proxyOutputs(this, this.el, ["ionItemReorder"]);
|
1623 | }
|
1624 | };
|
1625 | IonReorderGroup.ctorParameters = () => [
|
1626 | { type: ChangeDetectorRef },
|
1627 | { type: ElementRef },
|
1628 | { type: NgZone }
|
1629 | ];
|
1630 | IonReorderGroup = __decorate([
|
1631 | ProxyCmp({ inputs: ["disabled"], "methods": ["complete"] }),
|
1632 | Component({ selector: "ion-reorder-group", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["disabled"] })
|
1633 | ], IonReorderGroup);
|
1634 | let IonRippleEffect = class IonRippleEffect {
|
1635 | constructor(c, r, z) {
|
1636 | this.z = z;
|
1637 | c.detach();
|
1638 | this.el = r.nativeElement;
|
1639 | }
|
1640 | };
|
1641 | IonRippleEffect.ctorParameters = () => [
|
1642 | { type: ChangeDetectorRef },
|
1643 | { type: ElementRef },
|
1644 | { type: NgZone }
|
1645 | ];
|
1646 | IonRippleEffect = __decorate([
|
1647 | ProxyCmp({ inputs: ["type"], "methods": ["addRipple"] }),
|
1648 | Component({ selector: "ion-ripple-effect", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["type"] })
|
1649 | ], IonRippleEffect);
|
1650 | let IonRow = class IonRow {
|
1651 | constructor(c, r, z) {
|
1652 | this.z = z;
|
1653 | c.detach();
|
1654 | this.el = r.nativeElement;
|
1655 | }
|
1656 | };
|
1657 | IonRow.ctorParameters = () => [
|
1658 | { type: ChangeDetectorRef },
|
1659 | { type: ElementRef },
|
1660 | { type: NgZone }
|
1661 | ];
|
1662 | IonRow = __decorate([
|
1663 | Component({ selector: "ion-row", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>" })
|
1664 | ], IonRow);
|
1665 | let IonSearchbar = class IonSearchbar {
|
1666 | constructor(c, r, z) {
|
1667 | this.z = z;
|
1668 | c.detach();
|
1669 | this.el = r.nativeElement;
|
1670 | proxyOutputs(this, this.el, ["ionInput", "ionChange", "ionCancel", "ionClear", "ionBlur", "ionFocus"]);
|
1671 | }
|
1672 | };
|
1673 | IonSearchbar.ctorParameters = () => [
|
1674 | { type: ChangeDetectorRef },
|
1675 | { type: ElementRef },
|
1676 | { type: NgZone }
|
1677 | ];
|
1678 | IonSearchbar = __decorate([
|
1679 | ProxyCmp({ inputs: ["animated", "autocomplete", "autocorrect", "cancelButtonIcon", "cancelButtonText", "clearIcon", "color", "debounce", "disabled", "enterkeyhint", "inputmode", "mode", "placeholder", "searchIcon", "showCancelButton", "showClearButton", "spellcheck", "type", "value"], "methods": ["setFocus", "getInputElement"] }),
|
1680 | Component({ selector: "ion-searchbar", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["animated", "autocomplete", "autocorrect", "cancelButtonIcon", "cancelButtonText", "clearIcon", "color", "debounce", "disabled", "enterkeyhint", "inputmode", "mode", "placeholder", "searchIcon", "showCancelButton", "showClearButton", "spellcheck", "type", "value"] })
|
1681 | ], IonSearchbar);
|
1682 | let IonSegment = class IonSegment {
|
1683 | constructor(c, r, z) {
|
1684 | this.z = z;
|
1685 | c.detach();
|
1686 | this.el = r.nativeElement;
|
1687 | proxyOutputs(this, this.el, ["ionChange"]);
|
1688 | }
|
1689 | };
|
1690 | IonSegment.ctorParameters = () => [
|
1691 | { type: ChangeDetectorRef },
|
1692 | { type: ElementRef },
|
1693 | { type: NgZone }
|
1694 | ];
|
1695 | IonSegment = __decorate([
|
1696 | ProxyCmp({ inputs: ["color", "disabled", "mode", "scrollable", "swipeGesture", "value"] }),
|
1697 | Component({ selector: "ion-segment", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["color", "disabled", "mode", "scrollable", "swipeGesture", "value"] })
|
1698 | ], IonSegment);
|
1699 | let IonSegmentButton = class IonSegmentButton {
|
1700 | constructor(c, r, z) {
|
1701 | this.z = z;
|
1702 | c.detach();
|
1703 | this.el = r.nativeElement;
|
1704 | }
|
1705 | };
|
1706 | IonSegmentButton.ctorParameters = () => [
|
1707 | { type: ChangeDetectorRef },
|
1708 | { type: ElementRef },
|
1709 | { type: NgZone }
|
1710 | ];
|
1711 | IonSegmentButton = __decorate([
|
1712 | ProxyCmp({ inputs: ["disabled", "layout", "mode", "type", "value"] }),
|
1713 | Component({ selector: "ion-segment-button", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["disabled", "layout", "mode", "type", "value"] })
|
1714 | ], IonSegmentButton);
|
1715 | let IonSelect = class IonSelect {
|
1716 | constructor(c, r, z) {
|
1717 | this.z = z;
|
1718 | c.detach();
|
1719 | this.el = r.nativeElement;
|
1720 | proxyOutputs(this, this.el, ["ionChange", "ionCancel", "ionFocus", "ionBlur"]);
|
1721 | }
|
1722 | };
|
1723 | IonSelect.ctorParameters = () => [
|
1724 | { type: ChangeDetectorRef },
|
1725 | { type: ElementRef },
|
1726 | { type: NgZone }
|
1727 | ];
|
1728 | IonSelect = __decorate([
|
1729 | ProxyCmp({ inputs: ["cancelText", "compareWith", "disabled", "interface", "interfaceOptions", "mode", "multiple", "name", "okText", "placeholder", "selectedText", "value"], "methods": ["open"] }),
|
1730 | Component({ selector: "ion-select", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["cancelText", "compareWith", "disabled", "interface", "interfaceOptions", "mode", "multiple", "name", "okText", "placeholder", "selectedText", "value"] })
|
1731 | ], IonSelect);
|
1732 | let IonSelectOption = class IonSelectOption {
|
1733 | constructor(c, r, z) {
|
1734 | this.z = z;
|
1735 | c.detach();
|
1736 | this.el = r.nativeElement;
|
1737 | }
|
1738 | };
|
1739 | IonSelectOption.ctorParameters = () => [
|
1740 | { type: ChangeDetectorRef },
|
1741 | { type: ElementRef },
|
1742 | { type: NgZone }
|
1743 | ];
|
1744 | IonSelectOption = __decorate([
|
1745 | ProxyCmp({ inputs: ["disabled", "value"] }),
|
1746 | Component({ selector: "ion-select-option", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["disabled", "value"] })
|
1747 | ], IonSelectOption);
|
1748 | let IonSkeletonText = class IonSkeletonText {
|
1749 | constructor(c, r, z) {
|
1750 | this.z = z;
|
1751 | c.detach();
|
1752 | this.el = r.nativeElement;
|
1753 | }
|
1754 | };
|
1755 | IonSkeletonText.ctorParameters = () => [
|
1756 | { type: ChangeDetectorRef },
|
1757 | { type: ElementRef },
|
1758 | { type: NgZone }
|
1759 | ];
|
1760 | IonSkeletonText = __decorate([
|
1761 | ProxyCmp({ inputs: ["animated"] }),
|
1762 | Component({ selector: "ion-skeleton-text", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["animated"] })
|
1763 | ], IonSkeletonText);
|
1764 | let IonSlide = class IonSlide {
|
1765 | constructor(c, r, z) {
|
1766 | this.z = z;
|
1767 | c.detach();
|
1768 | this.el = r.nativeElement;
|
1769 | }
|
1770 | };
|
1771 | IonSlide.ctorParameters = () => [
|
1772 | { type: ChangeDetectorRef },
|
1773 | { type: ElementRef },
|
1774 | { type: NgZone }
|
1775 | ];
|
1776 | IonSlide = __decorate([
|
1777 | Component({ selector: "ion-slide", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>" })
|
1778 | ], IonSlide);
|
1779 | let IonSlides = class IonSlides {
|
1780 | constructor(c, r, z) {
|
1781 | this.z = z;
|
1782 | c.detach();
|
1783 | this.el = r.nativeElement;
|
1784 | proxyOutputs(this, this.el, ["ionSlidesDidLoad", "ionSlideTap", "ionSlideDoubleTap", "ionSlideWillChange", "ionSlideDidChange", "ionSlideNextStart", "ionSlidePrevStart", "ionSlideNextEnd", "ionSlidePrevEnd", "ionSlideTransitionStart", "ionSlideTransitionEnd", "ionSlideDrag", "ionSlideReachStart", "ionSlideReachEnd", "ionSlideTouchStart", "ionSlideTouchEnd"]);
|
1785 | }
|
1786 | };
|
1787 | IonSlides.ctorParameters = () => [
|
1788 | { type: ChangeDetectorRef },
|
1789 | { type: ElementRef },
|
1790 | { type: NgZone }
|
1791 | ];
|
1792 | IonSlides = __decorate([
|
1793 | ProxyCmp({ inputs: ["mode", "options", "pager", "scrollbar"], "methods": ["update", "updateAutoHeight", "slideTo", "slideNext", "slidePrev", "getActiveIndex", "getPreviousIndex", "length", "isEnd", "isBeginning", "startAutoplay", "stopAutoplay", "lockSwipeToNext", "lockSwipeToPrev", "lockSwipes", "getSwiper"] }),
|
1794 | Component({ selector: "ion-slides", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["mode", "options", "pager", "scrollbar"] })
|
1795 | ], IonSlides);
|
1796 | let IonSpinner = class IonSpinner {
|
1797 | constructor(c, r, z) {
|
1798 | this.z = z;
|
1799 | c.detach();
|
1800 | this.el = r.nativeElement;
|
1801 | }
|
1802 | };
|
1803 | IonSpinner.ctorParameters = () => [
|
1804 | { type: ChangeDetectorRef },
|
1805 | { type: ElementRef },
|
1806 | { type: NgZone }
|
1807 | ];
|
1808 | IonSpinner = __decorate([
|
1809 | ProxyCmp({ inputs: ["color", "duration", "name", "paused"] }),
|
1810 | Component({ selector: "ion-spinner", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["color", "duration", "name", "paused"] })
|
1811 | ], IonSpinner);
|
1812 | let IonSplitPane = class IonSplitPane {
|
1813 | constructor(c, r, z) {
|
1814 | this.z = z;
|
1815 | c.detach();
|
1816 | this.el = r.nativeElement;
|
1817 | proxyOutputs(this, this.el, ["ionSplitPaneVisible"]);
|
1818 | }
|
1819 | };
|
1820 | IonSplitPane.ctorParameters = () => [
|
1821 | { type: ChangeDetectorRef },
|
1822 | { type: ElementRef },
|
1823 | { type: NgZone }
|
1824 | ];
|
1825 | IonSplitPane = __decorate([
|
1826 | ProxyCmp({ inputs: ["contentId", "disabled", "when"] }),
|
1827 | Component({ selector: "ion-split-pane", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["contentId", "disabled", "when"] })
|
1828 | ], IonSplitPane);
|
1829 | let IonTabBar = class IonTabBar {
|
1830 | constructor(c, r, z) {
|
1831 | this.z = z;
|
1832 | c.detach();
|
1833 | this.el = r.nativeElement;
|
1834 | }
|
1835 | };
|
1836 | IonTabBar.ctorParameters = () => [
|
1837 | { type: ChangeDetectorRef },
|
1838 | { type: ElementRef },
|
1839 | { type: NgZone }
|
1840 | ];
|
1841 | IonTabBar = __decorate([
|
1842 | ProxyCmp({ inputs: ["color", "mode", "selectedTab", "translucent"] }),
|
1843 | Component({ selector: "ion-tab-bar", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["color", "mode", "selectedTab", "translucent"] })
|
1844 | ], IonTabBar);
|
1845 | let IonTabButton = class IonTabButton {
|
1846 | constructor(c, r, z) {
|
1847 | this.z = z;
|
1848 | c.detach();
|
1849 | this.el = r.nativeElement;
|
1850 | }
|
1851 | };
|
1852 | IonTabButton.ctorParameters = () => [
|
1853 | { type: ChangeDetectorRef },
|
1854 | { type: ElementRef },
|
1855 | { type: NgZone }
|
1856 | ];
|
1857 | IonTabButton = __decorate([
|
1858 | ProxyCmp({ inputs: ["disabled", "download", "href", "layout", "mode", "rel", "selected", "tab", "target"] }),
|
1859 | Component({ selector: "ion-tab-button", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["disabled", "download", "href", "layout", "mode", "rel", "selected", "tab", "target"] })
|
1860 | ], IonTabButton);
|
1861 | let IonText = class IonText {
|
1862 | constructor(c, r, z) {
|
1863 | this.z = z;
|
1864 | c.detach();
|
1865 | this.el = r.nativeElement;
|
1866 | }
|
1867 | };
|
1868 | IonText.ctorParameters = () => [
|
1869 | { type: ChangeDetectorRef },
|
1870 | { type: ElementRef },
|
1871 | { type: NgZone }
|
1872 | ];
|
1873 | IonText = __decorate([
|
1874 | ProxyCmp({ inputs: ["color", "mode"] }),
|
1875 | Component({ selector: "ion-text", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["color", "mode"] })
|
1876 | ], IonText);
|
1877 | let IonTextarea = class IonTextarea {
|
1878 | constructor(c, r, z) {
|
1879 | this.z = z;
|
1880 | c.detach();
|
1881 | this.el = r.nativeElement;
|
1882 | proxyOutputs(this, this.el, ["ionChange", "ionInput", "ionBlur", "ionFocus"]);
|
1883 | }
|
1884 | };
|
1885 | IonTextarea.ctorParameters = () => [
|
1886 | { type: ChangeDetectorRef },
|
1887 | { type: ElementRef },
|
1888 | { type: NgZone }
|
1889 | ];
|
1890 | IonTextarea = __decorate([
|
1891 | ProxyCmp({ inputs: ["autoGrow", "autocapitalize", "autofocus", "clearOnEdit", "color", "cols", "debounce", "disabled", "enterkeyhint", "inputmode", "maxlength", "minlength", "mode", "name", "placeholder", "readonly", "required", "rows", "spellcheck", "value", "wrap"], "methods": ["setFocus", "getInputElement"] }),
|
1892 | Component({ selector: "ion-textarea", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["autoGrow", "autocapitalize", "autofocus", "clearOnEdit", "color", "cols", "debounce", "disabled", "enterkeyhint", "inputmode", "maxlength", "minlength", "mode", "name", "placeholder", "readonly", "required", "rows", "spellcheck", "value", "wrap"] })
|
1893 | ], IonTextarea);
|
1894 | let IonThumbnail = class IonThumbnail {
|
1895 | constructor(c, r, z) {
|
1896 | this.z = z;
|
1897 | c.detach();
|
1898 | this.el = r.nativeElement;
|
1899 | }
|
1900 | };
|
1901 | IonThumbnail.ctorParameters = () => [
|
1902 | { type: ChangeDetectorRef },
|
1903 | { type: ElementRef },
|
1904 | { type: NgZone }
|
1905 | ];
|
1906 | IonThumbnail = __decorate([
|
1907 | Component({ selector: "ion-thumbnail", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>" })
|
1908 | ], IonThumbnail);
|
1909 | let IonTitle = class IonTitle {
|
1910 | constructor(c, r, z) {
|
1911 | this.z = z;
|
1912 | c.detach();
|
1913 | this.el = r.nativeElement;
|
1914 | }
|
1915 | };
|
1916 | IonTitle.ctorParameters = () => [
|
1917 | { type: ChangeDetectorRef },
|
1918 | { type: ElementRef },
|
1919 | { type: NgZone }
|
1920 | ];
|
1921 | IonTitle = __decorate([
|
1922 | ProxyCmp({ inputs: ["color", "size"] }),
|
1923 | Component({ selector: "ion-title", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["color", "size"] })
|
1924 | ], IonTitle);
|
1925 | let IonToggle = class IonToggle {
|
1926 | constructor(c, r, z) {
|
1927 | this.z = z;
|
1928 | c.detach();
|
1929 | this.el = r.nativeElement;
|
1930 | proxyOutputs(this, this.el, ["ionChange", "ionFocus", "ionBlur"]);
|
1931 | }
|
1932 | };
|
1933 | IonToggle.ctorParameters = () => [
|
1934 | { type: ChangeDetectorRef },
|
1935 | { type: ElementRef },
|
1936 | { type: NgZone }
|
1937 | ];
|
1938 | IonToggle = __decorate([
|
1939 | ProxyCmp({ inputs: ["checked", "color", "disabled", "mode", "name", "value"] }),
|
1940 | Component({ selector: "ion-toggle", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["checked", "color", "disabled", "mode", "name", "value"] })
|
1941 | ], IonToggle);
|
1942 | let IonToolbar = class IonToolbar {
|
1943 | constructor(c, r, z) {
|
1944 | this.z = z;
|
1945 | c.detach();
|
1946 | this.el = r.nativeElement;
|
1947 | }
|
1948 | };
|
1949 | IonToolbar.ctorParameters = () => [
|
1950 | { type: ChangeDetectorRef },
|
1951 | { type: ElementRef },
|
1952 | { type: NgZone }
|
1953 | ];
|
1954 | IonToolbar = __decorate([
|
1955 | ProxyCmp({ inputs: ["color", "mode"] }),
|
1956 | Component({ selector: "ion-toolbar", changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>", inputs: ["color", "mode"] })
|
1957 | ], IonToolbar);
|
1958 |
|
1959 | let Config = class Config {
|
1960 | get(key, fallback) {
|
1961 | const c = getConfig();
|
1962 | if (c) {
|
1963 | return c.get(key, fallback);
|
1964 | }
|
1965 | return null;
|
1966 | }
|
1967 | getBoolean(key, fallback) {
|
1968 | const c = getConfig();
|
1969 | if (c) {
|
1970 | return c.getBoolean(key, fallback);
|
1971 | }
|
1972 | return false;
|
1973 | }
|
1974 | getNumber(key, fallback) {
|
1975 | const c = getConfig();
|
1976 | if (c) {
|
1977 | return c.getNumber(key, fallback);
|
1978 | }
|
1979 | return 0;
|
1980 | }
|
1981 | set(key, value) {
|
1982 | console.warn(`[DEPRECATION][Config]: The Config.set() method is deprecated and will be removed in Ionic Framework 6.0. Please see https://ionicframework.com/docs/angular/config for alternatives.`);
|
1983 | const c = getConfig();
|
1984 | if (c) {
|
1985 | c.set(key, value);
|
1986 | }
|
1987 | }
|
1988 | };
|
1989 | Config.ngInjectableDef = ɵɵdefineInjectable({ factory: function Config_Factory() { return new Config(); }, token: Config, providedIn: "root" });
|
1990 | Config = __decorate([
|
1991 | Injectable({
|
1992 | providedIn: 'root'
|
1993 | })
|
1994 | ], Config);
|
1995 | const ConfigToken = new InjectionToken('USERCONFIG');
|
1996 | const getConfig = () => {
|
1997 | if (typeof window !== 'undefined') {
|
1998 | const Ionic = window.Ionic;
|
1999 | if (Ionic && Ionic.config) {
|
2000 | return Ionic.config;
|
2001 | }
|
2002 | }
|
2003 | return null;
|
2004 | };
|
2005 | const ɵ0$3 = getConfig;
|
2006 |
|
2007 |
|
2008 |
|
2009 |
|
2010 |
|
2011 |
|
2012 |
|
2013 |
|
2014 |
|
2015 |
|
2016 |
|
2017 |
|
2018 |
|
2019 |
|
2020 |
|
2021 |
|
2022 |
|
2023 |
|
2024 |
|
2025 |
|
2026 |
|
2027 | class NavParams {
|
2028 | constructor(data = {}) {
|
2029 | this.data = data;
|
2030 | }
|
2031 | |
2032 |
|
2033 |
|
2034 |
|
2035 |
|
2036 |
|
2037 |
|
2038 |
|
2039 |
|
2040 |
|
2041 |
|
2042 |
|
2043 |
|
2044 |
|
2045 |
|
2046 |
|
2047 | get(param) {
|
2048 | return this.data[param];
|
2049 | }
|
2050 | }
|
2051 |
|
2052 | let AngularDelegate = class AngularDelegate {
|
2053 | constructor(zone, appRef) {
|
2054 | this.zone = zone;
|
2055 | this.appRef = appRef;
|
2056 | }
|
2057 | create(resolver, injector, location) {
|
2058 | return new AngularFrameworkDelegate(resolver, injector, location, this.appRef, this.zone);
|
2059 | }
|
2060 | };
|
2061 | AngularDelegate.ctorParameters = () => [
|
2062 | { type: NgZone },
|
2063 | { type: ApplicationRef }
|
2064 | ];
|
2065 | AngularDelegate = __decorate([
|
2066 | Injectable()
|
2067 | ], AngularDelegate);
|
2068 | class AngularFrameworkDelegate {
|
2069 | constructor(resolver, injector, location, appRef, zone) {
|
2070 | this.resolver = resolver;
|
2071 | this.injector = injector;
|
2072 | this.location = location;
|
2073 | this.appRef = appRef;
|
2074 | this.zone = zone;
|
2075 | this.elRefMap = new WeakMap();
|
2076 | this.elEventsMap = new WeakMap();
|
2077 | }
|
2078 | attachViewToDom(container, component, params, cssClasses) {
|
2079 | return this.zone.run(() => {
|
2080 | return new Promise(resolve => {
|
2081 | const el = attachView(this.zone, this.resolver, this.injector, this.location, this.appRef, this.elRefMap, this.elEventsMap, container, component, params, cssClasses);
|
2082 | resolve(el);
|
2083 | });
|
2084 | });
|
2085 | }
|
2086 | removeViewFromDom(_container, component) {
|
2087 | return this.zone.run(() => {
|
2088 | return new Promise(resolve => {
|
2089 | const componentRef = this.elRefMap.get(component);
|
2090 | if (componentRef) {
|
2091 | componentRef.destroy();
|
2092 | this.elRefMap.delete(component);
|
2093 | const unbindEvents = this.elEventsMap.get(component);
|
2094 | if (unbindEvents) {
|
2095 | unbindEvents();
|
2096 | this.elEventsMap.delete(component);
|
2097 | }
|
2098 | }
|
2099 | resolve();
|
2100 | });
|
2101 | });
|
2102 | }
|
2103 | }
|
2104 | const attachView = (zone, resolver, injector, location, appRef, elRefMap, elEventsMap, container, component, params, cssClasses) => {
|
2105 | const factory = resolver.resolveComponentFactory(component);
|
2106 | const childInjector = Injector.create({
|
2107 | providers: getProviders(params),
|
2108 | parent: injector
|
2109 | });
|
2110 | const componentRef = (location)
|
2111 | ? location.createComponent(factory, location.length, childInjector)
|
2112 | : factory.create(childInjector);
|
2113 | const instance = componentRef.instance;
|
2114 | const hostElement = componentRef.location.nativeElement;
|
2115 | if (params) {
|
2116 | Object.assign(instance, params);
|
2117 | }
|
2118 | if (cssClasses) {
|
2119 | for (const clazz of cssClasses) {
|
2120 | hostElement.classList.add(clazz);
|
2121 | }
|
2122 | }
|
2123 | const unbindEvents = bindLifecycleEvents(zone, instance, hostElement);
|
2124 | container.appendChild(hostElement);
|
2125 | if (!location) {
|
2126 | appRef.attachView(componentRef.hostView);
|
2127 | }
|
2128 | componentRef.changeDetectorRef.reattach();
|
2129 | elRefMap.set(hostElement, componentRef);
|
2130 | elEventsMap.set(hostElement, unbindEvents);
|
2131 | return hostElement;
|
2132 | };
|
2133 | const LIFECYCLES = [
|
2134 | LIFECYCLE_WILL_ENTER,
|
2135 | LIFECYCLE_DID_ENTER,
|
2136 | LIFECYCLE_WILL_LEAVE,
|
2137 | LIFECYCLE_DID_LEAVE,
|
2138 | LIFECYCLE_WILL_UNLOAD
|
2139 | ];
|
2140 | const bindLifecycleEvents = (zone, instance, element) => {
|
2141 | return zone.run(() => {
|
2142 | const unregisters = LIFECYCLES
|
2143 | .filter(eventName => typeof instance[eventName] === 'function')
|
2144 | .map(eventName => {
|
2145 | const handler = (ev) => instance[eventName](ev.detail);
|
2146 | element.addEventListener(eventName, handler);
|
2147 | return () => element.removeEventListener(eventName, handler);
|
2148 | });
|
2149 | return () => unregisters.forEach(fn => fn());
|
2150 | });
|
2151 | };
|
2152 | const NavParamsToken = new InjectionToken('NavParamsToken');
|
2153 | const getProviders = (params) => {
|
2154 | return [
|
2155 | {
|
2156 | provide: NavParamsToken, useValue: params
|
2157 | },
|
2158 | {
|
2159 | provide: NavParams, useFactory: provideNavParamsInjectable, deps: [NavParamsToken]
|
2160 | }
|
2161 | ];
|
2162 | };
|
2163 | const ɵ0$4 = getProviders;
|
2164 | const provideNavParamsInjectable = (params) => {
|
2165 | return new NavParams(params);
|
2166 | };
|
2167 | const ɵ1$2 = provideNavParamsInjectable;
|
2168 |
|
2169 | const insertView = (views, view, direction) => {
|
2170 | if (direction === 'root') {
|
2171 | return setRoot(views, view);
|
2172 | }
|
2173 | else if (direction === 'forward') {
|
2174 | return setForward(views, view);
|
2175 | }
|
2176 | else {
|
2177 | return setBack(views, view);
|
2178 | }
|
2179 | };
|
2180 | const setRoot = (views, view) => {
|
2181 | views = views.filter(v => v.stackId !== view.stackId);
|
2182 | views.push(view);
|
2183 | return views;
|
2184 | };
|
2185 | const ɵ0$5 = setRoot;
|
2186 | const setForward = (views, view) => {
|
2187 | const index = views.indexOf(view);
|
2188 | if (index >= 0) {
|
2189 | views = views.filter(v => v.stackId !== view.stackId || v.id <= view.id);
|
2190 | }
|
2191 | else {
|
2192 | views.push(view);
|
2193 | }
|
2194 | return views;
|
2195 | };
|
2196 | const ɵ1$3 = setForward;
|
2197 | const setBack = (views, view) => {
|
2198 | const index = views.indexOf(view);
|
2199 | if (index >= 0) {
|
2200 | return views.filter(v => v.stackId !== view.stackId || v.id <= view.id);
|
2201 | }
|
2202 | else {
|
2203 | return setRoot(views, view);
|
2204 | }
|
2205 | };
|
2206 | const ɵ2$1 = setBack;
|
2207 | const getUrl = (router, activatedRoute) => {
|
2208 | const urlTree = router.createUrlTree(['.'], { relativeTo: activatedRoute });
|
2209 | return router.serializeUrl(urlTree);
|
2210 | };
|
2211 | const isTabSwitch = (enteringView, leavingView) => {
|
2212 | if (!leavingView) {
|
2213 | return true;
|
2214 | }
|
2215 | return enteringView.stackId !== leavingView.stackId;
|
2216 | };
|
2217 | const computeStackId = (prefixUrl, url) => {
|
2218 | if (!prefixUrl) {
|
2219 | return undefined;
|
2220 | }
|
2221 | const segments = toSegments(url);
|
2222 | for (let i = 0; i < segments.length; i++) {
|
2223 | if (i >= prefixUrl.length) {
|
2224 | return segments[i];
|
2225 | }
|
2226 | if (segments[i] !== prefixUrl[i]) {
|
2227 | return undefined;
|
2228 | }
|
2229 | }
|
2230 | return undefined;
|
2231 | };
|
2232 | const toSegments = (path) => {
|
2233 | return path
|
2234 | .split('/')
|
2235 | .map(s => s.trim())
|
2236 | .filter(s => s !== '');
|
2237 | };
|
2238 | const destroyView = (view) => {
|
2239 | if (view) {
|
2240 |
|
2241 | view.ref.destroy();
|
2242 | view.unlistenEvents();
|
2243 | }
|
2244 | };
|
2245 |
|
2246 | class StackController {
|
2247 | constructor(tabsPrefix, containerEl, router, navCtrl, zone, location) {
|
2248 | this.containerEl = containerEl;
|
2249 | this.router = router;
|
2250 | this.navCtrl = navCtrl;
|
2251 | this.zone = zone;
|
2252 | this.location = location;
|
2253 | this.views = [];
|
2254 | this.skipTransition = false;
|
2255 | this.nextId = 0;
|
2256 | this.tabsPrefix = tabsPrefix !== undefined ? toSegments(tabsPrefix) : undefined;
|
2257 | }
|
2258 | createView(ref, activatedRoute) {
|
2259 | const url = getUrl(this.router, activatedRoute);
|
2260 | const element = (ref && ref.location && ref.location.nativeElement);
|
2261 | const unlistenEvents = bindLifecycleEvents(this.zone, ref.instance, element);
|
2262 | return {
|
2263 | id: this.nextId++,
|
2264 | stackId: computeStackId(this.tabsPrefix, url),
|
2265 | unlistenEvents,
|
2266 | element,
|
2267 | ref,
|
2268 | url,
|
2269 | };
|
2270 | }
|
2271 | getExistingView(activatedRoute) {
|
2272 | const activatedUrlKey = getUrl(this.router, activatedRoute);
|
2273 | const view = this.views.find(vw => vw.url === activatedUrlKey);
|
2274 | if (view) {
|
2275 | view.ref.changeDetectorRef.reattach();
|
2276 | }
|
2277 | return view;
|
2278 | }
|
2279 | setActive(enteringView) {
|
2280 | const consumeResult = this.navCtrl.consumeTransition();
|
2281 | let { direction, animation, animationBuilder } = consumeResult;
|
2282 | const leavingView = this.activeView;
|
2283 | const tabSwitch = isTabSwitch(enteringView, leavingView);
|
2284 | if (tabSwitch) {
|
2285 | direction = 'back';
|
2286 | animation = undefined;
|
2287 | }
|
2288 | const viewsSnapshot = this.views.slice();
|
2289 | let currentNavigation;
|
2290 | const router = this.router;
|
2291 |
|
2292 | if (router.getCurrentNavigation) {
|
2293 | currentNavigation = router.getCurrentNavigation();
|
2294 |
|
2295 | }
|
2296 | else if (router.navigations &&
|
2297 | router.navigations.value) {
|
2298 | currentNavigation = router.navigations.value;
|
2299 | }
|
2300 | |
2301 |
|
2302 |
|
2303 |
|
2304 |
|
2305 |
|
2306 |
|
2307 | if (currentNavigation &&
|
2308 | currentNavigation.extras &&
|
2309 | currentNavigation.extras.replaceUrl) {
|
2310 | if (this.views.length > 0) {
|
2311 | this.views.splice(-1, 1);
|
2312 | }
|
2313 | }
|
2314 | const reused = this.views.includes(enteringView);
|
2315 | const views = this.insertView(enteringView, direction);
|
2316 |
|
2317 |
|
2318 |
|
2319 | if (!reused) {
|
2320 | enteringView.ref.changeDetectorRef.detectChanges();
|
2321 | }
|
2322 | |
2323 |
|
2324 |
|
2325 |
|
2326 |
|
2327 |
|
2328 |
|
2329 | const customAnimation = enteringView.animationBuilder;
|
2330 | if (animationBuilder === undefined &&
|
2331 | direction === 'back' &&
|
2332 | !tabSwitch &&
|
2333 | customAnimation !== undefined) {
|
2334 | animationBuilder = customAnimation;
|
2335 | }
|
2336 | |
2337 |
|
2338 |
|
2339 |
|
2340 | if (leavingView) {
|
2341 | leavingView.animationBuilder = animationBuilder;
|
2342 | }
|
2343 |
|
2344 | return this.zone.runOutsideAngular(() => {
|
2345 | return this.wait(() => {
|
2346 |
|
2347 |
|
2348 | if (leavingView) {
|
2349 | leavingView.ref.changeDetectorRef.detach();
|
2350 | }
|
2351 |
|
2352 | enteringView.ref.changeDetectorRef.reattach();
|
2353 | return this.transition(enteringView, leavingView, animation, this.canGoBack(1), false, animationBuilder)
|
2354 | .then(() => cleanupAsync(enteringView, views, viewsSnapshot, this.location))
|
2355 | .then(() => ({
|
2356 | enteringView,
|
2357 | direction,
|
2358 | animation,
|
2359 | tabSwitch
|
2360 | }));
|
2361 | });
|
2362 | });
|
2363 | }
|
2364 | canGoBack(deep, stackId = this.getActiveStackId()) {
|
2365 | return this.getStack(stackId).length > deep;
|
2366 | }
|
2367 | pop(deep, stackId = this.getActiveStackId()) {
|
2368 | return this.zone.run(() => {
|
2369 | const views = this.getStack(stackId);
|
2370 | if (views.length <= deep) {
|
2371 | return Promise.resolve(false);
|
2372 | }
|
2373 | const view = views[views.length - deep - 1];
|
2374 | let url = view.url;
|
2375 | const viewSavedData = view.savedData;
|
2376 | if (viewSavedData) {
|
2377 | const primaryOutlet = viewSavedData.get('primary');
|
2378 | if (primaryOutlet &&
|
2379 | primaryOutlet.route &&
|
2380 | primaryOutlet.route._routerState &&
|
2381 | primaryOutlet.route._routerState.snapshot &&
|
2382 | primaryOutlet.route._routerState.snapshot.url) {
|
2383 | url = primaryOutlet.route._routerState.snapshot.url;
|
2384 | }
|
2385 | }
|
2386 | const { animationBuilder } = this.navCtrl.consumeTransition();
|
2387 | return this.navCtrl.navigateBack(url, Object.assign({}, view.savedExtras, { animation: animationBuilder })).then(() => true);
|
2388 | });
|
2389 | }
|
2390 | startBackTransition() {
|
2391 | const leavingView = this.activeView;
|
2392 | if (leavingView) {
|
2393 | const views = this.getStack(leavingView.stackId);
|
2394 | const enteringView = views[views.length - 2];
|
2395 | const customAnimation = enteringView.animationBuilder;
|
2396 | return this.wait(() => {
|
2397 | return this.transition(enteringView,
|
2398 | leavingView,
|
2399 | 'back', this.canGoBack(2), true, customAnimation);
|
2400 | });
|
2401 | }
|
2402 | return Promise.resolve();
|
2403 | }
|
2404 | endBackTransition(shouldComplete) {
|
2405 | if (shouldComplete) {
|
2406 | this.skipTransition = true;
|
2407 | this.pop(1);
|
2408 | }
|
2409 | else if (this.activeView) {
|
2410 | cleanup(this.activeView, this.views, this.views, this.location);
|
2411 | }
|
2412 | }
|
2413 | getLastUrl(stackId) {
|
2414 | const views = this.getStack(stackId);
|
2415 | return views.length > 0 ? views[views.length - 1] : undefined;
|
2416 | }
|
2417 | |
2418 |
|
2419 |
|
2420 | getRootUrl(stackId) {
|
2421 | const views = this.getStack(stackId);
|
2422 | return views.length > 0 ? views[0] : undefined;
|
2423 | }
|
2424 | getActiveStackId() {
|
2425 | return this.activeView ? this.activeView.stackId : undefined;
|
2426 | }
|
2427 | hasRunningTask() {
|
2428 | return this.runningTask !== undefined;
|
2429 | }
|
2430 | destroy() {
|
2431 | this.containerEl = undefined;
|
2432 | this.views.forEach(destroyView);
|
2433 | this.activeView = undefined;
|
2434 | this.views = [];
|
2435 | }
|
2436 | getStack(stackId) {
|
2437 | return this.views.filter(v => v.stackId === stackId);
|
2438 | }
|
2439 | insertView(enteringView, direction) {
|
2440 | this.activeView = enteringView;
|
2441 | this.views = insertView(this.views, enteringView, direction);
|
2442 | return this.views.slice();
|
2443 | }
|
2444 | transition(enteringView, leavingView, direction, showGoBack, progressAnimation, animationBuilder) {
|
2445 | if (this.skipTransition) {
|
2446 | this.skipTransition = false;
|
2447 | return Promise.resolve(false);
|
2448 | }
|
2449 | if (leavingView === enteringView) {
|
2450 | return Promise.resolve(false);
|
2451 | }
|
2452 | const enteringEl = enteringView ? enteringView.element : undefined;
|
2453 | const leavingEl = leavingView ? leavingView.element : undefined;
|
2454 | const containerEl = this.containerEl;
|
2455 | if (enteringEl && enteringEl !== leavingEl) {
|
2456 | enteringEl.classList.add('ion-page');
|
2457 | enteringEl.classList.add('ion-page-invisible');
|
2458 | if (enteringEl.parentElement !== containerEl) {
|
2459 | containerEl.appendChild(enteringEl);
|
2460 | }
|
2461 | if (containerEl.commit) {
|
2462 | return containerEl.commit(enteringEl, leavingEl, {
|
2463 | deepWait: true,
|
2464 | duration: direction === undefined ? 0 : undefined,
|
2465 | direction,
|
2466 | showGoBack,
|
2467 | progressAnimation,
|
2468 | animationBuilder
|
2469 | });
|
2470 | }
|
2471 | }
|
2472 | return Promise.resolve(false);
|
2473 | }
|
2474 | wait(task) {
|
2475 | return __awaiter(this, void 0, void 0, function* () {
|
2476 | if (this.runningTask !== undefined) {
|
2477 | yield this.runningTask;
|
2478 | this.runningTask = undefined;
|
2479 | }
|
2480 | const promise = this.runningTask = task();
|
2481 | promise.finally(() => this.runningTask = undefined);
|
2482 | return promise;
|
2483 | });
|
2484 | }
|
2485 | }
|
2486 | const cleanupAsync = (activeRoute, views, viewsSnapshot, location) => {
|
2487 | if (typeof requestAnimationFrame === 'function') {
|
2488 | return new Promise(resolve => {
|
2489 | requestAnimationFrame(() => {
|
2490 | cleanup(activeRoute, views, viewsSnapshot, location);
|
2491 | resolve();
|
2492 | });
|
2493 | });
|
2494 | }
|
2495 | return Promise.resolve();
|
2496 | };
|
2497 | const ɵ0$6 = cleanupAsync;
|
2498 | const cleanup = (activeRoute, views, viewsSnapshot, location) => {
|
2499 | viewsSnapshot
|
2500 | .filter(view => !views.includes(view))
|
2501 | .forEach(destroyView);
|
2502 | views.forEach(view => {
|
2503 | |
2504 |
|
2505 |
|
2506 |
|
2507 |
|
2508 |
|
2509 |
|
2510 |
|
2511 |
|
2512 | const locationWithoutParams = location.path().split('?')[0];
|
2513 | const locationWithoutFragment = locationWithoutParams.split('#')[0];
|
2514 | if (view !== activeRoute && view.url !== locationWithoutFragment) {
|
2515 | const element = view.element;
|
2516 | element.setAttribute('aria-hidden', 'true');
|
2517 | element.classList.add('ion-page-hidden');
|
2518 | view.ref.changeDetectorRef.detach();
|
2519 | }
|
2520 | });
|
2521 | };
|
2522 | const ɵ1$4 = cleanup;
|
2523 |
|
2524 | let IonRouterOutlet = class IonRouterOutlet {
|
2525 | constructor(parentContexts, location, resolver, name, tabs, config, navCtrl, commonLocation, elementRef, router, zone, activatedRoute, parentOutlet) {
|
2526 | this.parentContexts = parentContexts;
|
2527 | this.location = location;
|
2528 | this.resolver = resolver;
|
2529 | this.config = config;
|
2530 | this.navCtrl = navCtrl;
|
2531 | this.parentOutlet = parentOutlet;
|
2532 | this.activated = null;
|
2533 | this.activatedView = null;
|
2534 | this._activatedRoute = null;
|
2535 |
|
2536 | this.proxyMap = new WeakMap();
|
2537 |
|
2538 | this.currentActivatedRoute$ = new BehaviorSubject(null);
|
2539 | this.stackEvents = new EventEmitter();
|
2540 | this.activateEvents = new EventEmitter();
|
2541 | this.deactivateEvents = new EventEmitter();
|
2542 | this.nativeEl = elementRef.nativeElement;
|
2543 | this.name = name || PRIMARY_OUTLET;
|
2544 | this.tabsPrefix = tabs === 'true' ? getUrl(router, activatedRoute) : undefined;
|
2545 | this.stackCtrl = new StackController(this.tabsPrefix, this.nativeEl, router, navCtrl, zone, commonLocation);
|
2546 | parentContexts.onChildOutletCreated(this.name, this);
|
2547 | }
|
2548 | set animation(animation) {
|
2549 | this.nativeEl.animation = animation;
|
2550 | }
|
2551 | set animated(animated) {
|
2552 | this.nativeEl.animated = animated;
|
2553 | }
|
2554 | set swipeGesture(swipe) {
|
2555 | this._swipeGesture = swipe;
|
2556 | this.nativeEl.swipeHandler = swipe ? {
|
2557 | canStart: () => this.stackCtrl.canGoBack(1) && !this.stackCtrl.hasRunningTask(),
|
2558 | onStart: () => this.stackCtrl.startBackTransition(),
|
2559 | onEnd: shouldContinue => this.stackCtrl.endBackTransition(shouldContinue)
|
2560 | } : undefined;
|
2561 | }
|
2562 | ngOnDestroy() {
|
2563 | this.stackCtrl.destroy();
|
2564 | }
|
2565 | getContext() {
|
2566 | return this.parentContexts.getContext(this.name);
|
2567 | }
|
2568 | ngOnInit() {
|
2569 | if (!this.activated) {
|
2570 |
|
2571 |
|
2572 | const context = this.getContext();
|
2573 | if (context && context.route) {
|
2574 | this.activateWith(context.route, context.resolver || null);
|
2575 | }
|
2576 | }
|
2577 | new Promise(resolve => componentOnReady(this.nativeEl, resolve)).then(() => {
|
2578 | if (this._swipeGesture === undefined) {
|
2579 | this.swipeGesture = this.config.getBoolean('swipeBackEnabled', this.nativeEl.mode === 'ios');
|
2580 | }
|
2581 | });
|
2582 | }
|
2583 | get isActivated() {
|
2584 | return !!this.activated;
|
2585 | }
|
2586 | get component() {
|
2587 | if (!this.activated) {
|
2588 | throw new Error('Outlet is not activated');
|
2589 | }
|
2590 | return this.activated.instance;
|
2591 | }
|
2592 | get activatedRoute() {
|
2593 | if (!this.activated) {
|
2594 | throw new Error('Outlet is not activated');
|
2595 | }
|
2596 | return this._activatedRoute;
|
2597 | }
|
2598 | get activatedRouteData() {
|
2599 | if (this._activatedRoute) {
|
2600 | return this._activatedRoute.snapshot.data;
|
2601 | }
|
2602 | return {};
|
2603 | }
|
2604 | |
2605 |
|
2606 |
|
2607 | detach() {
|
2608 | throw new Error('incompatible reuse strategy');
|
2609 | }
|
2610 | |
2611 |
|
2612 |
|
2613 | attach(_ref, _activatedRoute) {
|
2614 | throw new Error('incompatible reuse strategy');
|
2615 | }
|
2616 | deactivate() {
|
2617 | if (this.activated) {
|
2618 | if (this.activatedView) {
|
2619 | const context = this.getContext();
|
2620 | this.activatedView.savedData = new Map(context.children['contexts']);
|
2621 | |
2622 |
|
2623 |
|
2624 |
|
2625 |
|
2626 |
|
2627 |
|
2628 |
|
2629 | const primaryOutlet = this.activatedView.savedData.get('primary');
|
2630 | if (primaryOutlet && context.route) {
|
2631 | primaryOutlet.route = Object.assign({}, context.route);
|
2632 | }
|
2633 | |
2634 |
|
2635 |
|
2636 |
|
2637 | this.activatedView.savedExtras = {};
|
2638 | if (context.route) {
|
2639 | const contextSnapshot = context.route.snapshot;
|
2640 | this.activatedView.savedExtras.queryParams = contextSnapshot.queryParams;
|
2641 | this.activatedView.savedExtras.fragment = contextSnapshot.fragment;
|
2642 | }
|
2643 | }
|
2644 | const c = this.component;
|
2645 | this.activatedView = null;
|
2646 | this.activated = null;
|
2647 | this._activatedRoute = null;
|
2648 | this.deactivateEvents.emit(c);
|
2649 | }
|
2650 | }
|
2651 | activateWith(activatedRoute, resolver) {
|
2652 | if (this.isActivated) {
|
2653 | throw new Error('Cannot activate an already activated outlet');
|
2654 | }
|
2655 | this._activatedRoute = activatedRoute;
|
2656 | let cmpRef;
|
2657 | let enteringView = this.stackCtrl.getExistingView(activatedRoute);
|
2658 | if (enteringView) {
|
2659 | cmpRef = this.activated = enteringView.ref;
|
2660 | const saved = enteringView.savedData;
|
2661 | if (saved) {
|
2662 |
|
2663 | const context = this.getContext();
|
2664 | context.children['contexts'] = saved;
|
2665 | }
|
2666 |
|
2667 | this.updateActivatedRouteProxy(cmpRef.instance, activatedRoute);
|
2668 | }
|
2669 | else {
|
2670 | const snapshot = activatedRoute._futureSnapshot;
|
2671 | const component = snapshot.routeConfig.component;
|
2672 | resolver = resolver || this.resolver;
|
2673 | const factory = resolver.resolveComponentFactory(component);
|
2674 | const childContexts = this.parentContexts.getOrCreateContext(this.name).children;
|
2675 |
|
2676 |
|
2677 | const component$ = new BehaviorSubject(null);
|
2678 | const activatedRouteProxy = this.createActivatedRouteProxy(component$, activatedRoute);
|
2679 | const injector = new OutletInjector(activatedRouteProxy, childContexts, this.location.injector);
|
2680 | cmpRef = this.activated = this.location.createComponent(factory, this.location.length, injector);
|
2681 |
|
2682 | component$.next(cmpRef.instance);
|
2683 |
|
2684 |
|
2685 | enteringView = this.stackCtrl.createView(this.activated, activatedRoute);
|
2686 |
|
2687 | this.proxyMap.set(cmpRef.instance, activatedRouteProxy);
|
2688 | this.currentActivatedRoute$.next({ component: cmpRef.instance, activatedRoute });
|
2689 | }
|
2690 | this.activatedView = enteringView;
|
2691 | this.stackCtrl.setActive(enteringView).then(data => {
|
2692 | this.navCtrl.setTopOutlet(this);
|
2693 | this.activateEvents.emit(cmpRef.instance);
|
2694 | this.stackEvents.emit(data);
|
2695 | });
|
2696 | }
|
2697 | |
2698 |
|
2699 |
|
2700 | canGoBack(deep = 1, stackId) {
|
2701 | return this.stackCtrl.canGoBack(deep, stackId);
|
2702 | }
|
2703 | |
2704 |
|
2705 |
|
2706 | pop(deep = 1, stackId) {
|
2707 | return this.stackCtrl.pop(deep, stackId);
|
2708 | }
|
2709 | |
2710 |
|
2711 |
|
2712 | getLastUrl(stackId) {
|
2713 | const active = this.stackCtrl.getLastUrl(stackId);
|
2714 | return active ? active.url : undefined;
|
2715 | }
|
2716 | |
2717 |
|
2718 |
|
2719 |
|
2720 | getLastRouteView(stackId) {
|
2721 | return this.stackCtrl.getLastUrl(stackId);
|
2722 | }
|
2723 | |
2724 |
|
2725 |
|
2726 |
|
2727 | getRootView(stackId) {
|
2728 | return this.stackCtrl.getRootUrl(stackId);
|
2729 | }
|
2730 | |
2731 |
|
2732 |
|
2733 | getActiveStackId() {
|
2734 | return this.stackCtrl.getActiveStackId();
|
2735 | }
|
2736 | |
2737 |
|
2738 |
|
2739 |
|
2740 | createActivatedRouteProxy(component$, activatedRoute) {
|
2741 | const proxy = new ActivatedRoute();
|
2742 | proxy._futureSnapshot = activatedRoute._futureSnapshot;
|
2743 | proxy._routerState = activatedRoute._routerState;
|
2744 | proxy.snapshot = activatedRoute.snapshot;
|
2745 | proxy.outlet = activatedRoute.outlet;
|
2746 | proxy.component = activatedRoute.component;
|
2747 |
|
2748 | proxy._paramMap = this.proxyObservable(component$, 'paramMap');
|
2749 | proxy._queryParamMap = this.proxyObservable(component$, 'queryParamMap');
|
2750 | proxy.url = this.proxyObservable(component$, 'url');
|
2751 | proxy.params = this.proxyObservable(component$, 'params');
|
2752 | proxy.queryParams = this.proxyObservable(component$, 'queryParams');
|
2753 | proxy.fragment = this.proxyObservable(component$, 'fragment');
|
2754 | proxy.data = this.proxyObservable(component$, 'data');
|
2755 | return proxy;
|
2756 | }
|
2757 | |
2758 |
|
2759 |
|
2760 | proxyObservable(component$, path) {
|
2761 | return component$.pipe(
|
2762 |
|
2763 | filter(component => !!component), switchMap(component => this.currentActivatedRoute$.pipe(filter(current => current !== null && current.component === component), switchMap(current => current && current.activatedRoute[path]), distinctUntilChanged())));
|
2764 | }
|
2765 | |
2766 |
|
2767 |
|
2768 | updateActivatedRouteProxy(component, activatedRoute) {
|
2769 | const proxy = this.proxyMap.get(component);
|
2770 | if (!proxy) {
|
2771 | throw new Error(`Could not find activated route proxy for view`);
|
2772 | }
|
2773 | proxy._futureSnapshot = activatedRoute._futureSnapshot;
|
2774 | proxy._routerState = activatedRoute._routerState;
|
2775 | proxy.snapshot = activatedRoute.snapshot;
|
2776 | proxy.outlet = activatedRoute.outlet;
|
2777 | proxy.component = activatedRoute.component;
|
2778 | this.currentActivatedRoute$.next({ component, activatedRoute });
|
2779 | }
|
2780 | };
|
2781 | IonRouterOutlet.ctorParameters = () => [
|
2782 | { type: ChildrenOutletContexts },
|
2783 | { type: ViewContainerRef },
|
2784 | { type: ComponentFactoryResolver },
|
2785 | { type: String, decorators: [{ type: Attribute, args: ['name',] }] },
|
2786 | { type: String, decorators: [{ type: Optional }, { type: Attribute, args: ['tabs',] }] },
|
2787 | { type: Config },
|
2788 | { type: NavController },
|
2789 | { type: Location },
|
2790 | { type: ElementRef },
|
2791 | { type: Router },
|
2792 | { type: NgZone },
|
2793 | { type: ActivatedRoute },
|
2794 | { type: IonRouterOutlet, decorators: [{ type: SkipSelf }, { type: Optional }] }
|
2795 | ];
|
2796 | __decorate([
|
2797 | Output()
|
2798 | ], IonRouterOutlet.prototype, "stackEvents", void 0);
|
2799 | __decorate([
|
2800 | Output('activate')
|
2801 | ], IonRouterOutlet.prototype, "activateEvents", void 0);
|
2802 | __decorate([
|
2803 | Output('deactivate')
|
2804 | ], IonRouterOutlet.prototype, "deactivateEvents", void 0);
|
2805 | IonRouterOutlet = __decorate([
|
2806 | Directive({
|
2807 | selector: 'ion-router-outlet',
|
2808 | exportAs: 'outlet',
|
2809 | inputs: ['animated', 'animation', 'swipeGesture']
|
2810 | }),
|
2811 | __param(3, Attribute('name')),
|
2812 | __param(4, Optional()), __param(4, Attribute('tabs')),
|
2813 | __param(12, SkipSelf()), __param(12, Optional())
|
2814 | ], IonRouterOutlet);
|
2815 | class OutletInjector {
|
2816 | constructor(route, childContexts, parent) {
|
2817 | this.route = route;
|
2818 | this.childContexts = childContexts;
|
2819 | this.parent = parent;
|
2820 | }
|
2821 | get(token, notFoundValue) {
|
2822 | if (token === ActivatedRoute) {
|
2823 | return this.route;
|
2824 | }
|
2825 | if (token === ChildrenOutletContexts) {
|
2826 | return this.childContexts;
|
2827 | }
|
2828 |
|
2829 | return this.parent.get(token, notFoundValue);
|
2830 | }
|
2831 | }
|
2832 |
|
2833 | let IonTabs = class IonTabs {
|
2834 | constructor(navCtrl) {
|
2835 | this.navCtrl = navCtrl;
|
2836 | this.ionTabsWillChange = new EventEmitter();
|
2837 | this.ionTabsDidChange = new EventEmitter();
|
2838 | }
|
2839 | |
2840 |
|
2841 |
|
2842 | onPageSelected(detail) {
|
2843 | const stackId = detail.enteringView.stackId;
|
2844 | if (detail.tabSwitch && stackId !== undefined) {
|
2845 | if (this.tabBar) {
|
2846 | this.tabBar.selectedTab = stackId;
|
2847 | }
|
2848 | this.ionTabsWillChange.emit({ tab: stackId });
|
2849 | this.ionTabsDidChange.emit({ tab: stackId });
|
2850 | }
|
2851 | }
|
2852 | |
2853 |
|
2854 |
|
2855 |
|
2856 |
|
2857 |
|
2858 |
|
2859 |
|
2860 |
|
2861 |
|
2862 |
|
2863 |
|
2864 |
|
2865 |
|
2866 |
|
2867 |
|
2868 |
|
2869 |
|
2870 |
|
2871 |
|
2872 | select(tab) {
|
2873 | const alreadySelected = this.outlet.getActiveStackId() === tab;
|
2874 | const tabRootUrl = `${this.outlet.tabsPrefix}/${tab}`;
|
2875 | if (alreadySelected) {
|
2876 | const activeStackId = this.outlet.getActiveStackId();
|
2877 | const activeView = this.outlet.getLastRouteView(activeStackId);
|
2878 |
|
2879 | if (activeView.url === tabRootUrl) {
|
2880 | return;
|
2881 | }
|
2882 | const rootView = this.outlet.getRootView(tab);
|
2883 | const navigationExtras = rootView && tabRootUrl === rootView.url && rootView.savedExtras;
|
2884 | return this.navCtrl.navigateRoot(tabRootUrl, Object.assign({}, (navigationExtras), { animated: true, animationDirection: 'back' }));
|
2885 | }
|
2886 | else {
|
2887 | const lastRoute = this.outlet.getLastRouteView(tab);
|
2888 | |
2889 |
|
2890 |
|
2891 |
|
2892 | const url = lastRoute && lastRoute.url || tabRootUrl;
|
2893 | const navigationExtras = lastRoute && lastRoute.savedExtras;
|
2894 | return this.navCtrl.navigateRoot(url, Object.assign({}, (navigationExtras), { animated: true, animationDirection: 'back' }));
|
2895 | }
|
2896 | }
|
2897 | getSelected() {
|
2898 | return this.outlet.getActiveStackId();
|
2899 | }
|
2900 | };
|
2901 | IonTabs.ctorParameters = () => [
|
2902 | { type: NavController }
|
2903 | ];
|
2904 | __decorate([
|
2905 | ViewChild('outlet', { read: IonRouterOutlet, static: false })
|
2906 | ], IonTabs.prototype, "outlet", void 0);
|
2907 | __decorate([
|
2908 | ContentChild(IonTabBar, { static: false })
|
2909 | ], IonTabs.prototype, "tabBar", void 0);
|
2910 | __decorate([
|
2911 | Output()
|
2912 | ], IonTabs.prototype, "ionTabsWillChange", void 0);
|
2913 | __decorate([
|
2914 | Output()
|
2915 | ], IonTabs.prototype, "ionTabsDidChange", void 0);
|
2916 | __decorate([
|
2917 | HostListener('ionTabButtonClick', ['$event.detail.tab'])
|
2918 | ], IonTabs.prototype, "select", null);
|
2919 | IonTabs = __decorate([
|
2920 | Component({
|
2921 | selector: 'ion-tabs',
|
2922 | template: `
|
2923 | <ng-content select="[slot=top]"></ng-content>
|
2924 | <div class="tabs-inner">
|
2925 | <ion-router-outlet #outlet tabs="true" (stackEvents)="onPageSelected($event)"></ion-router-outlet>
|
2926 | </div>
|
2927 | <ng-content></ng-content>`,
|
2928 | styles: [`
|
2929 | :host {
|
2930 | display: flex;
|
2931 | position: absolute;
|
2932 | top: 0;
|
2933 | left: 0;
|
2934 | right: 0;
|
2935 | bottom: 0;
|
2936 |
|
2937 | flex-direction: column;
|
2938 |
|
2939 | width: 100%;
|
2940 | height: 100%;
|
2941 |
|
2942 | contain: layout size style;
|
2943 | z-index: $z-index-page-container;
|
2944 | }
|
2945 | .tabs-inner {
|
2946 | position: relative;
|
2947 |
|
2948 | flex: 1;
|
2949 |
|
2950 | contain: layout size style;
|
2951 | }`]
|
2952 | })
|
2953 | ], IonTabs);
|
2954 |
|
2955 | let IonBackButtonDelegate = class IonBackButtonDelegate {
|
2956 | constructor(routerOutlet, navCtrl, config) {
|
2957 | this.routerOutlet = routerOutlet;
|
2958 | this.navCtrl = navCtrl;
|
2959 | this.config = config;
|
2960 | }
|
2961 | |
2962 |
|
2963 |
|
2964 | onClick(ev) {
|
2965 | const defaultHref = this.defaultHref || this.config.get('backButtonDefaultHref');
|
2966 | if (this.routerOutlet && this.routerOutlet.canGoBack()) {
|
2967 | this.navCtrl.setDirection('back', undefined, undefined, this.routerAnimation);
|
2968 | this.routerOutlet.pop();
|
2969 | ev.preventDefault();
|
2970 | }
|
2971 | else if (defaultHref != null) {
|
2972 | this.navCtrl.navigateBack(defaultHref, { animation: this.routerAnimation });
|
2973 | ev.preventDefault();
|
2974 | }
|
2975 | }
|
2976 | };
|
2977 | IonBackButtonDelegate.ctorParameters = () => [
|
2978 | { type: IonRouterOutlet, decorators: [{ type: Optional }] },
|
2979 | { type: NavController },
|
2980 | { type: Config }
|
2981 | ];
|
2982 | __decorate([
|
2983 | HostListener('click', ['$event'])
|
2984 | ], IonBackButtonDelegate.prototype, "onClick", null);
|
2985 | IonBackButtonDelegate = __decorate([
|
2986 | Directive({
|
2987 | selector: 'ion-back-button',
|
2988 | inputs: ['defaultHref', 'routerAnimation'],
|
2989 | }),
|
2990 | __param(0, Optional())
|
2991 | ], IonBackButtonDelegate);
|
2992 |
|
2993 | let NavDelegate = class NavDelegate {
|
2994 | constructor(ref, resolver, injector, angularDelegate, location) {
|
2995 | this.el = ref.nativeElement;
|
2996 | ref.nativeElement.delegate = angularDelegate.create(resolver, injector, location);
|
2997 | proxyOutputs(this, this.el, ['ionNavDidChange', 'ionNavWillChange']);
|
2998 | }
|
2999 | };
|
3000 | NavDelegate.ctorParameters = () => [
|
3001 | { type: ElementRef },
|
3002 | { type: ComponentFactoryResolver },
|
3003 | { type: Injector },
|
3004 | { type: AngularDelegate },
|
3005 | { type: ViewContainerRef }
|
3006 | ];
|
3007 | NavDelegate = __decorate([
|
3008 | ProxyCmp({
|
3009 | inputs: ['animated', 'animation', 'root', 'rootParams', 'swipeGesture'],
|
3010 | methods: ['push', 'insert', 'insertPages', 'pop', 'popTo', 'popToRoot', 'removeIndex', 'setRoot', 'setPages', 'getActive', 'getByIndex', 'canGoBack', 'getPrevious']
|
3011 | }),
|
3012 | Directive({
|
3013 | selector: 'ion-nav'
|
3014 | })
|
3015 | ], NavDelegate);
|
3016 |
|
3017 | let RouterLinkDelegate = class RouterLinkDelegate {
|
3018 | constructor(locationStrategy, navCtrl, elementRef, router, routerLink) {
|
3019 | this.locationStrategy = locationStrategy;
|
3020 | this.navCtrl = navCtrl;
|
3021 | this.elementRef = elementRef;
|
3022 | this.router = router;
|
3023 | this.routerLink = routerLink;
|
3024 | this.routerDirection = 'forward';
|
3025 | }
|
3026 | ngOnInit() {
|
3027 | this.updateTargetUrlAndHref();
|
3028 | }
|
3029 | ngOnChanges() {
|
3030 | this.updateTargetUrlAndHref();
|
3031 | }
|
3032 | ngOnDestroy() {
|
3033 | if (this.subscription) {
|
3034 | this.subscription.unsubscribe();
|
3035 | }
|
3036 | }
|
3037 | updateTargetUrlAndHref() {
|
3038 | if (this.routerLink) {
|
3039 | const href = this.locationStrategy.prepareExternalUrl(this.router.serializeUrl(this.routerLink.urlTree));
|
3040 | this.elementRef.nativeElement.href = href;
|
3041 | }
|
3042 | }
|
3043 | |
3044 |
|
3045 |
|
3046 | onClick(ev) {
|
3047 | this.navCtrl.setDirection(this.routerDirection, undefined, undefined, this.routerAnimation);
|
3048 | ev.preventDefault();
|
3049 | }
|
3050 | };
|
3051 | RouterLinkDelegate.ctorParameters = () => [
|
3052 | { type: LocationStrategy },
|
3053 | { type: NavController },
|
3054 | { type: ElementRef },
|
3055 | { type: Router },
|
3056 | { type: RouterLink, decorators: [{ type: Optional }] }
|
3057 | ];
|
3058 | __decorate([
|
3059 | HostListener('click', ['$event'])
|
3060 | ], RouterLinkDelegate.prototype, "onClick", null);
|
3061 | RouterLinkDelegate = __decorate([
|
3062 | Directive({
|
3063 | selector: '[routerLink]',
|
3064 | inputs: ['routerDirection', 'routerAnimation']
|
3065 | }),
|
3066 | __param(4, Optional())
|
3067 | ], RouterLinkDelegate);
|
3068 |
|
3069 |
|
3070 |
|
3071 |
|
3072 | let VirtualFooter = class VirtualFooter {
|
3073 | constructor(templateRef) {
|
3074 | this.templateRef = templateRef;
|
3075 | }
|
3076 | };
|
3077 | VirtualFooter.ctorParameters = () => [
|
3078 | { type: TemplateRef }
|
3079 | ];
|
3080 | VirtualFooter = __decorate([
|
3081 | Directive({ selector: '[virtualFooter]' })
|
3082 | ], VirtualFooter);
|
3083 |
|
3084 |
|
3085 |
|
3086 |
|
3087 | let VirtualHeader = class VirtualHeader {
|
3088 | constructor(templateRef) {
|
3089 | this.templateRef = templateRef;
|
3090 | }
|
3091 | };
|
3092 | VirtualHeader.ctorParameters = () => [
|
3093 | { type: TemplateRef }
|
3094 | ];
|
3095 | VirtualHeader = __decorate([
|
3096 | Directive({ selector: '[virtualHeader]' })
|
3097 | ], VirtualHeader);
|
3098 |
|
3099 |
|
3100 |
|
3101 |
|
3102 | let VirtualItem = class VirtualItem {
|
3103 | constructor(templateRef, viewContainer) {
|
3104 | this.templateRef = templateRef;
|
3105 | this.viewContainer = viewContainer;
|
3106 | }
|
3107 | };
|
3108 | VirtualItem.ctorParameters = () => [
|
3109 | { type: TemplateRef },
|
3110 | { type: ViewContainerRef }
|
3111 | ];
|
3112 | VirtualItem = __decorate([
|
3113 | Directive({ selector: '[virtualItem]' })
|
3114 | ], VirtualItem);
|
3115 |
|
3116 | let IonVirtualScroll = class IonVirtualScroll {
|
3117 | constructor(z, iterableDiffers, elementRef) {
|
3118 | this.z = z;
|
3119 | this.iterableDiffers = iterableDiffers;
|
3120 | this.refMap = new WeakMap();
|
3121 | this.el = elementRef.nativeElement;
|
3122 | this.el.nodeRender = this.nodeRender.bind(this);
|
3123 | }
|
3124 | ngOnChanges(changes) {
|
3125 | if (this.trackBy && 'items' in changes) {
|
3126 |
|
3127 | const value = changes['items'].currentValue;
|
3128 | if (this.differ === undefined && value != null) {
|
3129 | try {
|
3130 | this.differ = this.iterableDiffers.find(value).create(this.trackBy);
|
3131 | }
|
3132 | catch (e) {
|
3133 | throw new Error(`Cannot find a differ supporting object '${value}'. VirtualScroll only supports binding to Iterables such as Arrays.`);
|
3134 | }
|
3135 | }
|
3136 | }
|
3137 | }
|
3138 | ngDoCheck() {
|
3139 |
|
3140 | const changes = this.differ !== undefined && this.items ? this.differ.diff(this.items) : null;
|
3141 | if (changes === null) {
|
3142 | return;
|
3143 | }
|
3144 |
|
3145 | this.checkRange(0);
|
3146 | }
|
3147 | nodeRender(el, cell, index) {
|
3148 | return this.z.run(() => {
|
3149 | let node;
|
3150 | if (!el) {
|
3151 | node = this.itmTmp.viewContainer.createEmbeddedView(this.getComponent(cell.type), { $implicit: cell.value, index }, index);
|
3152 | el = getElement(node);
|
3153 | this.refMap.set(el, node);
|
3154 | }
|
3155 | else {
|
3156 | node = this.refMap.get(el);
|
3157 | const ctx = node.context;
|
3158 | ctx.$implicit = cell.value;
|
3159 | ctx.index = cell.index;
|
3160 | }
|
3161 |
|
3162 | node.detectChanges();
|
3163 | return el;
|
3164 | });
|
3165 | }
|
3166 | getComponent(type) {
|
3167 | switch (type) {
|
3168 | case 'item': return this.itmTmp.templateRef;
|
3169 | case 'header': return this.hdrTmp.templateRef;
|
3170 | case 'footer': return this.ftrTmp.templateRef;
|
3171 | }
|
3172 | throw new Error('template for virtual item was not provided');
|
3173 | }
|
3174 | };
|
3175 | IonVirtualScroll.ctorParameters = () => [
|
3176 | { type: NgZone },
|
3177 | { type: IterableDiffers },
|
3178 | { type: ElementRef }
|
3179 | ];
|
3180 | __decorate([
|
3181 | ContentChild(VirtualItem, { static: false })
|
3182 | ], IonVirtualScroll.prototype, "itmTmp", void 0);
|
3183 | __decorate([
|
3184 | ContentChild(VirtualHeader, { static: false })
|
3185 | ], IonVirtualScroll.prototype, "hdrTmp", void 0);
|
3186 | __decorate([
|
3187 | ContentChild(VirtualFooter, { static: false })
|
3188 | ], IonVirtualScroll.prototype, "ftrTmp", void 0);
|
3189 | IonVirtualScroll = __decorate([
|
3190 | ProxyCmp({
|
3191 | inputs: ['approxItemHeight', 'approxHeaderHeight', 'approxFooterHeight', 'headerFn', 'footerFn', 'items', 'itemHeight', 'headerHeight', 'footerHeight'],
|
3192 | methods: ['checkEnd', 'checkRange', 'positionForItem']
|
3193 | }),
|
3194 | Component({
|
3195 | selector: 'ion-virtual-scroll',
|
3196 | template: '<ng-content></ng-content>',
|
3197 | changeDetection: ChangeDetectionStrategy.OnPush,
|
3198 | inputs: [
|
3199 | 'approxItemHeight',
|
3200 | 'approxHeaderHeight',
|
3201 | 'approxFooterHeight',
|
3202 | 'headerFn',
|
3203 | 'footerFn',
|
3204 | 'items',
|
3205 | 'itemHeight',
|
3206 | 'headerHeight',
|
3207 | 'footerHeight',
|
3208 | 'trackBy'
|
3209 | ]
|
3210 | })
|
3211 | ], IonVirtualScroll);
|
3212 | const getElement = (view) => {
|
3213 | const rootNodes = view.rootNodes;
|
3214 | for (let i = 0; i < rootNodes.length; i++) {
|
3215 | if (rootNodes[i].nodeType === 1) {
|
3216 | return rootNodes[i];
|
3217 | }
|
3218 | }
|
3219 | throw new Error('virtual element was not created');
|
3220 | };
|
3221 | const ɵ0$7 = getElement;
|
3222 |
|
3223 | class OverlayBaseController {
|
3224 | constructor(ctrl) {
|
3225 | this.ctrl = ctrl;
|
3226 | }
|
3227 | |
3228 |
|
3229 |
|
3230 | create(opts) {
|
3231 |
|
3232 | return this.ctrl.create((opts || {}));
|
3233 | }
|
3234 | |
3235 |
|
3236 |
|
3237 | dismiss(data, role, id) {
|
3238 | return this.ctrl.dismiss(data, role, id);
|
3239 | }
|
3240 | |
3241 |
|
3242 |
|
3243 | getTop() {
|
3244 | return this.ctrl.getTop();
|
3245 | }
|
3246 | }
|
3247 |
|
3248 | let ActionSheetController = class ActionSheetController extends OverlayBaseController {
|
3249 | constructor() {
|
3250 | super(actionSheetController);
|
3251 | }
|
3252 | };
|
3253 | ActionSheetController.ngInjectableDef = ɵɵdefineInjectable({ factory: function ActionSheetController_Factory() { return new ActionSheetController(); }, token: ActionSheetController, providedIn: "root" });
|
3254 | ActionSheetController = __decorate([
|
3255 | Injectable({
|
3256 | providedIn: 'root',
|
3257 | })
|
3258 | ], ActionSheetController);
|
3259 |
|
3260 | let AlertController = class AlertController extends OverlayBaseController {
|
3261 | constructor() {
|
3262 | super(alertController);
|
3263 | }
|
3264 | };
|
3265 | AlertController.ngInjectableDef = ɵɵdefineInjectable({ factory: function AlertController_Factory() { return new AlertController(); }, token: AlertController, providedIn: "root" });
|
3266 | AlertController = __decorate([
|
3267 | Injectable({
|
3268 | providedIn: 'root',
|
3269 | })
|
3270 | ], AlertController);
|
3271 |
|
3272 | let LoadingController = class LoadingController extends OverlayBaseController {
|
3273 | constructor() {
|
3274 | super(loadingController);
|
3275 | }
|
3276 | };
|
3277 | LoadingController.ngInjectableDef = ɵɵdefineInjectable({ factory: function LoadingController_Factory() { return new LoadingController(); }, token: LoadingController, providedIn: "root" });
|
3278 | LoadingController = __decorate([
|
3279 | Injectable({
|
3280 | providedIn: 'root',
|
3281 | })
|
3282 | ], LoadingController);
|
3283 |
|
3284 | let MenuController = class MenuController {
|
3285 | |
3286 |
|
3287 |
|
3288 |
|
3289 |
|
3290 | open(menuId) {
|
3291 | return menuController.open(menuId);
|
3292 | }
|
3293 | |
3294 |
|
3295 |
|
3296 |
|
3297 |
|
3298 |
|
3299 |
|
3300 | close(menuId) {
|
3301 | return menuController.close(menuId);
|
3302 | }
|
3303 | |
3304 |
|
3305 |
|
3306 |
|
3307 |
|
3308 |
|
3309 | toggle(menuId) {
|
3310 | return menuController.toggle(menuId);
|
3311 | }
|
3312 | |
3313 |
|
3314 |
|
3315 |
|
3316 |
|
3317 |
|
3318 |
|
3319 |
|
3320 | enable(shouldEnable, menuId) {
|
3321 | return menuController.enable(shouldEnable, menuId);
|
3322 | }
|
3323 | |
3324 |
|
3325 |
|
3326 |
|
3327 |
|
3328 |
|
3329 | swipeGesture(shouldEnable, menuId) {
|
3330 | return menuController.swipeGesture(shouldEnable, menuId);
|
3331 | }
|
3332 | |
3333 |
|
3334 |
|
3335 |
|
3336 |
|
3337 | isOpen(menuId) {
|
3338 | return menuController.isOpen(menuId);
|
3339 | }
|
3340 | |
3341 |
|
3342 |
|
3343 |
|
3344 | isEnabled(menuId) {
|
3345 | return menuController.isEnabled(menuId);
|
3346 | }
|
3347 | |
3348 |
|
3349 |
|
3350 |
|
3351 |
|
3352 |
|
3353 |
|
3354 |
|
3355 |
|
3356 | get(menuId) {
|
3357 | return menuController.get(menuId);
|
3358 | }
|
3359 | |
3360 |
|
3361 |
|
3362 | getOpen() {
|
3363 | return menuController.getOpen();
|
3364 | }
|
3365 | |
3366 |
|
3367 |
|
3368 | getMenus() {
|
3369 | return menuController.getMenus();
|
3370 | }
|
3371 | };
|
3372 | MenuController.ngInjectableDef = ɵɵdefineInjectable({ factory: function MenuController_Factory() { return new MenuController(); }, token: MenuController, providedIn: "root" });
|
3373 | MenuController = __decorate([
|
3374 | Injectable({
|
3375 | providedIn: 'root',
|
3376 | })
|
3377 | ], MenuController);
|
3378 |
|
3379 | let PickerController = class PickerController extends OverlayBaseController {
|
3380 | constructor() {
|
3381 | super(pickerController);
|
3382 | }
|
3383 | };
|
3384 | PickerController.ngInjectableDef = ɵɵdefineInjectable({ factory: function PickerController_Factory() { return new PickerController(); }, token: PickerController, providedIn: "root" });
|
3385 | PickerController = __decorate([
|
3386 | Injectable({
|
3387 | providedIn: 'root',
|
3388 | })
|
3389 | ], PickerController);
|
3390 |
|
3391 | let ModalController = class ModalController extends OverlayBaseController {
|
3392 | constructor(angularDelegate, resolver, injector) {
|
3393 | super(modalController);
|
3394 | this.angularDelegate = angularDelegate;
|
3395 | this.resolver = resolver;
|
3396 | this.injector = injector;
|
3397 | }
|
3398 | create(opts) {
|
3399 | return super.create(Object.assign({}, opts, { delegate: this.angularDelegate.create(this.resolver, this.injector) }));
|
3400 | }
|
3401 | };
|
3402 | ModalController.ctorParameters = () => [
|
3403 | { type: AngularDelegate },
|
3404 | { type: ComponentFactoryResolver },
|
3405 | { type: Injector }
|
3406 | ];
|
3407 | ModalController = __decorate([
|
3408 | Injectable()
|
3409 | ], ModalController);
|
3410 |
|
3411 | let PopoverController = class PopoverController extends OverlayBaseController {
|
3412 | constructor(angularDelegate, resolver, injector) {
|
3413 | super(popoverController);
|
3414 | this.angularDelegate = angularDelegate;
|
3415 | this.resolver = resolver;
|
3416 | this.injector = injector;
|
3417 | }
|
3418 | create(opts) {
|
3419 | return super.create(Object.assign({}, opts, { delegate: this.angularDelegate.create(this.resolver, this.injector) }));
|
3420 | }
|
3421 | };
|
3422 | PopoverController.ctorParameters = () => [
|
3423 | { type: AngularDelegate },
|
3424 | { type: ComponentFactoryResolver },
|
3425 | { type: Injector }
|
3426 | ];
|
3427 | PopoverController = __decorate([
|
3428 | Injectable()
|
3429 | ], PopoverController);
|
3430 |
|
3431 | let ToastController = class ToastController extends OverlayBaseController {
|
3432 | constructor() {
|
3433 | super(toastController);
|
3434 | }
|
3435 | };
|
3436 | ToastController.ngInjectableDef = ɵɵdefineInjectable({ factory: function ToastController_Factory() { return new ToastController(); }, token: ToastController, providedIn: "root" });
|
3437 | ToastController = __decorate([
|
3438 | Injectable({
|
3439 | providedIn: 'root',
|
3440 | })
|
3441 | ], ToastController);
|
3442 |
|
3443 | let DomController = class DomController {
|
3444 | |
3445 |
|
3446 |
|
3447 |
|
3448 | read(cb) {
|
3449 | getQueue().read(cb);
|
3450 | }
|
3451 | |
3452 |
|
3453 |
|
3454 |
|
3455 | write(cb) {
|
3456 | getQueue().write(cb);
|
3457 | }
|
3458 | };
|
3459 | DomController.ngInjectableDef = ɵɵdefineInjectable({ factory: function DomController_Factory() { return new DomController(); }, token: DomController, providedIn: "root" });
|
3460 | DomController = __decorate([
|
3461 | Injectable({
|
3462 | providedIn: 'root',
|
3463 | })
|
3464 | ], DomController);
|
3465 | const getQueue = () => {
|
3466 | const win = typeof window !== 'undefined' ? window : null;
|
3467 | if (win != null) {
|
3468 | const Ionic = win.Ionic;
|
3469 | if (Ionic && Ionic.queue) {
|
3470 | return Ionic.queue;
|
3471 | }
|
3472 | return {
|
3473 | read: (cb) => win.requestAnimationFrame(cb),
|
3474 | write: (cb) => win.requestAnimationFrame(cb)
|
3475 | };
|
3476 | }
|
3477 | return {
|
3478 | read: (cb) => cb(),
|
3479 | write: (cb) => cb()
|
3480 | };
|
3481 | };
|
3482 | const ɵ0$8 = getQueue;
|
3483 |
|
3484 | let AnimationController = class AnimationController {
|
3485 | |
3486 |
|
3487 |
|
3488 | create(animationId) {
|
3489 | return createAnimation(animationId);
|
3490 | }
|
3491 | |
3492 |
|
3493 |
|
3494 |
|
3495 |
|
3496 |
|
3497 |
|
3498 |
|
3499 |
|
3500 |
|
3501 |
|
3502 |
|
3503 |
|
3504 |
|
3505 | easingTime(p0, p1, p2, p3, progression) {
|
3506 | return getTimeGivenProgression(p0, p1, p2, p3, progression);
|
3507 | }
|
3508 | };
|
3509 | AnimationController.ngInjectableDef = ɵɵdefineInjectable({ factory: function AnimationController_Factory() { return new AnimationController(); }, token: AnimationController, providedIn: "root" });
|
3510 | AnimationController = __decorate([
|
3511 | Injectable({
|
3512 | providedIn: 'root',
|
3513 | })
|
3514 | ], AnimationController);
|
3515 |
|
3516 | let GestureController = class GestureController {
|
3517 | constructor(zone) {
|
3518 | this.zone = zone;
|
3519 | }
|
3520 | |
3521 |
|
3522 |
|
3523 | create(opts, runInsideAngularZone = false) {
|
3524 | if (runInsideAngularZone) {
|
3525 | Object.getOwnPropertyNames(opts).forEach(key => {
|
3526 | if (typeof opts[key] === 'function') {
|
3527 | const fn = opts[key];
|
3528 | opts[key] = (...props) => this.zone.run(() => fn(...props));
|
3529 | }
|
3530 | });
|
3531 | }
|
3532 | return createGesture(opts);
|
3533 | }
|
3534 | };
|
3535 | GestureController.ctorParameters = () => [
|
3536 | { type: NgZone }
|
3537 | ];
|
3538 | GestureController.ngInjectableDef = ɵɵdefineInjectable({ factory: function GestureController_Factory() { return new GestureController(ɵɵinject(NgZone)); }, token: GestureController, providedIn: "root" });
|
3539 | GestureController = __decorate([
|
3540 | Injectable({
|
3541 | providedIn: 'root',
|
3542 | })
|
3543 | ], GestureController);
|
3544 |
|
3545 | class IonicRouteStrategy {
|
3546 | shouldDetach(_route) {
|
3547 | return false;
|
3548 | }
|
3549 | shouldAttach(_route) {
|
3550 | return false;
|
3551 | }
|
3552 | store(_route, _detachedTree) {
|
3553 | return;
|
3554 | }
|
3555 | retrieve(_route) {
|
3556 | return null;
|
3557 | }
|
3558 | shouldReuseRoute(future, curr) {
|
3559 | if (future.routeConfig !== curr.routeConfig) {
|
3560 | return false;
|
3561 | }
|
3562 |
|
3563 | const futureParams = future.params;
|
3564 | const currentParams = curr.params;
|
3565 | const keysA = Object.keys(futureParams);
|
3566 | const keysB = Object.keys(currentParams);
|
3567 | if (keysA.length !== keysB.length) {
|
3568 | return false;
|
3569 | }
|
3570 |
|
3571 | for (const key of keysA) {
|
3572 | if (currentParams[key] !== futureParams[key]) {
|
3573 | return false;
|
3574 | }
|
3575 | }
|
3576 | return true;
|
3577 | }
|
3578 | }
|
3579 |
|
3580 | const appInitialize = (config, doc, zone) => {
|
3581 | return () => {
|
3582 | const win = doc.defaultView;
|
3583 | if (win && typeof window !== 'undefined') {
|
3584 | const Ionic = win.Ionic = win.Ionic || {};
|
3585 | Ionic.config = Object.assign({}, config, { _zoneGate: (h) => zone.run(h) });
|
3586 | const aelFn = '__zone_symbol__addEventListener' in doc.body
|
3587 | ? '__zone_symbol__addEventListener'
|
3588 | : 'addEventListener';
|
3589 | return applyPolyfills().then(() => {
|
3590 | return defineCustomElements(win, {
|
3591 | exclude: ['ion-tabs', 'ion-tab'],
|
3592 | syncQueue: true,
|
3593 | raf,
|
3594 | jmp: (h) => zone.runOutsideAngular(h),
|
3595 | ael(elm, eventName, cb, opts) {
|
3596 | elm[aelFn](eventName, cb, opts);
|
3597 | },
|
3598 | rel(elm, eventName, cb, opts) {
|
3599 | elm.removeEventListener(eventName, cb, opts);
|
3600 | }
|
3601 | });
|
3602 | });
|
3603 | }
|
3604 | };
|
3605 | };
|
3606 |
|
3607 | var IonicModule_1;
|
3608 | const DECLARATIONS = [
|
3609 |
|
3610 | IonApp,
|
3611 | IonAvatar,
|
3612 | IonBackButton,
|
3613 | IonBackdrop,
|
3614 | IonBadge,
|
3615 | IonButton,
|
3616 | IonButtons,
|
3617 | IonCard,
|
3618 | IonCardContent,
|
3619 | IonCardHeader,
|
3620 | IonCardSubtitle,
|
3621 | IonCardTitle,
|
3622 | IonCheckbox,
|
3623 | IonChip,
|
3624 | IonCol,
|
3625 | IonContent,
|
3626 | IonDatetime,
|
3627 | IonFab,
|
3628 | IonFabButton,
|
3629 | IonFabList,
|
3630 | IonFooter,
|
3631 | IonGrid,
|
3632 | IonHeader,
|
3633 | IonIcon,
|
3634 | IonImg,
|
3635 | IonInfiniteScroll,
|
3636 | IonInfiniteScrollContent,
|
3637 | IonInput,
|
3638 | IonItem,
|
3639 | IonItemDivider,
|
3640 | IonItemGroup,
|
3641 | IonItemOption,
|
3642 | IonItemOptions,
|
3643 | IonItemSliding,
|
3644 | IonLabel,
|
3645 | IonList,
|
3646 | IonListHeader,
|
3647 | IonMenu,
|
3648 | IonMenuButton,
|
3649 | IonMenuToggle,
|
3650 | IonNav,
|
3651 | IonNavLink,
|
3652 | IonNote,
|
3653 | IonProgressBar,
|
3654 | IonRadio,
|
3655 | IonRadioGroup,
|
3656 | IonRange,
|
3657 | IonRefresher,
|
3658 | IonRefresherContent,
|
3659 | IonReorder,
|
3660 | IonReorderGroup,
|
3661 | IonRippleEffect,
|
3662 | IonRow,
|
3663 | IonSearchbar,
|
3664 | IonSegment,
|
3665 | IonSegmentButton,
|
3666 | IonSelect,
|
3667 | IonSelectOption,
|
3668 | IonSkeletonText,
|
3669 | IonSlide,
|
3670 | IonSlides,
|
3671 | IonSpinner,
|
3672 | IonSplitPane,
|
3673 | IonTabBar,
|
3674 | IonTabButton,
|
3675 | IonText,
|
3676 | IonTextarea,
|
3677 | IonThumbnail,
|
3678 | IonToggle,
|
3679 | IonToolbar,
|
3680 | IonTitle,
|
3681 | IonTabs,
|
3682 |
|
3683 | BooleanValueAccessor,
|
3684 | NumericValueAccessor,
|
3685 | RadioValueAccessor,
|
3686 | SelectValueAccessor,
|
3687 | TextValueAccessor,
|
3688 |
|
3689 | IonRouterOutlet,
|
3690 | IonBackButtonDelegate,
|
3691 | NavDelegate,
|
3692 | RouterLinkDelegate,
|
3693 |
|
3694 | VirtualFooter,
|
3695 | VirtualHeader,
|
3696 | VirtualItem,
|
3697 | IonVirtualScroll
|
3698 | ];
|
3699 | let IonicModule = IonicModule_1 = class IonicModule {
|
3700 | static forRoot(config) {
|
3701 | return {
|
3702 | ngModule: IonicModule_1,
|
3703 | providers: [
|
3704 | {
|
3705 | provide: ConfigToken,
|
3706 | useValue: config
|
3707 | },
|
3708 | {
|
3709 | provide: APP_INITIALIZER,
|
3710 | useFactory: appInitialize,
|
3711 | multi: true,
|
3712 | deps: [
|
3713 | ConfigToken,
|
3714 | DOCUMENT,
|
3715 | NgZone
|
3716 | ]
|
3717 | }
|
3718 | ]
|
3719 | };
|
3720 | }
|
3721 | };
|
3722 | IonicModule = IonicModule_1 = __decorate([
|
3723 | NgModule({
|
3724 | declarations: DECLARATIONS,
|
3725 | exports: DECLARATIONS,
|
3726 | providers: [AngularDelegate, ModalController, PopoverController],
|
3727 | imports: [CommonModule]
|
3728 | })
|
3729 | ], IonicModule);
|
3730 |
|
3731 |
|
3732 |
|
3733 |
|
3734 |
|
3735 |
|
3736 |
|
3737 | export { ActionSheetController, AlertController, AngularDelegate, AnimationController, BooleanValueAccessor, Config, DomController, GestureController, IonApp, IonAvatar, IonBackButton, IonBackButtonDelegate, IonBackdrop, IonBadge, IonButton, IonButtons, IonCard, IonCardContent, IonCardHeader, IonCardSubtitle, IonCardTitle, IonCheckbox, IonChip, IonCol, IonContent, IonDatetime, IonFab, IonFabButton, IonFabList, IonFooter, IonGrid, IonHeader, IonIcon, IonImg, IonInfiniteScroll, IonInfiniteScrollContent, IonInput, IonItem, IonItemDivider, IonItemGroup, IonItemOption, IonItemOptions, IonItemSliding, IonLabel, IonList, IonListHeader, IonMenu, IonMenuButton, IonMenuToggle, IonNav, IonNavLink, IonNote, IonProgressBar, IonRadio, IonRadioGroup, IonRange, IonRefresher, IonRefresherContent, IonReorder, IonReorderGroup, IonRippleEffect, IonRouterOutlet, IonRow, IonSearchbar, IonSegment, IonSegmentButton, IonSelect, IonSelectOption, IonSkeletonText, IonSlide, IonSlides, IonSpinner, IonSplitPane, IonTabBar, IonTabButton, IonTabs, IonText, IonTextarea, IonThumbnail, IonTitle, IonToggle, IonToolbar, IonVirtualScroll, IonicModule, IonicRouteStrategy, LoadingController, MenuController, ModalController, NavController, NavDelegate, NavParams, NumericValueAccessor, PickerController, Platform, PopoverController, RadioValueAccessor, RouterLinkDelegate, SelectValueAccessor, TextValueAccessor, ToastController, VirtualFooter, VirtualHeader, VirtualItem, ConfigToken as ɵa, ValueAccessor as ɵb, ProxyCmp as ɵc, OverlayBaseController as ɵe, appInitialize as ɵf };
|
3738 |
|