From 3cf10c54688fcd48a5a1110d0bc9f029209b218e Mon Sep 17 00:00:00 2001 From: Maria Hutt Date: Wed, 15 Jul 2026 10:28:41 -0700 Subject: [PATCH 1/6] feat(angular): deprecate IonicModule --- BREAKING.md | 6 + docs/angular/testing.md | 3 + packages/angular/README.md | 3 + .../control-value-accessors/index.js | 1 + .../control-value-accessors/value-accessor.js | 146 ++ .../src/directives/navigation/back-button.js | 45 + .../src/directives/navigation/nav-params.js | 45 + .../common/src/directives/navigation/nav.js | 39 + .../navigation/router-link-delegate.js | 172 ++ .../directives/navigation/router-outlet.js | 462 ++++ .../directives/navigation/stack-controller.js | 276 ++ .../src/directives/navigation/stack-utils.js | 72 + .../common/src/directives/navigation/tabs.js | 277 ++ .../angular/build/es2015/common/src/index.js | 19 + .../build/es2015/common/src/overlays/modal.js | 86 + .../es2015/common/src/overlays/popover.js | 74 + .../common/src/providers/angular-delegate.js | 221 ++ .../es2015/common/src/providers/config.js | 41 + .../common/src/providers/dom-controller.js | 41 + .../common/src/providers/menu-controller.js | 112 + .../common/src/providers/nav-controller.js | 221 ++ .../es2015/common/src/providers/platform.js | 250 ++ .../es2015/common/src/types/interfaces.js | 1 + .../common/src/types/ionic-lifecycle-hooks.js | 4 + .../common/src/types/overlay-options.js | 1 + .../build/es2015/common/src/utils/overlay.js | 24 + .../build/es2015/common/src/utils/proxy.js | 46 + .../build/es2015/common/src/utils/routing.js | 54 + .../build/es2015/common/src/utils/util.js | 9 + .../build/es2015/lazy/src/app-initialize.js | 25 + .../directives/angular-component-lib/utils.js | 58 + .../boolean-value-accessor.js | 38 + .../control-value-accessors/index.js | 4 + .../numeric-value-accessor.js | 45 + .../select-value-accessor.js | 35 + .../text-value-accessor.js | 34 + .../directives/navigation/ion-back-button.js | 18 + .../lazy/src/directives/navigation/ion-nav.js | 17 + .../navigation/ion-router-outlet.js | 31 + .../src/directives/navigation/ion-tabs.js | 66 + .../navigation/router-link-delegate.js | 27 + .../lazy/src/directives/overlays/modal.js | 16 + .../lazy/src/directives/overlays/popover.js | 14 + .../lazy/src/directives/proxies-list.js | 88 + .../es2015/lazy/src/directives/proxies.js | 2272 +++++++++++++++++ .../lazy/src/directives/validators/index.js | 2 + .../directives/validators/max-validator.js | 23 + .../directives/validators/min-validator.js | 23 + .../angular/build/es2015/lazy/src/index.js | 35 + .../build/es2015/lazy/src/ionic-module.js | 81 + .../src/providers/action-sheet-controller.js | 15 + .../lazy/src/providers/alert-controller.js | 15 + .../src/providers/animation-controller.js | 34 + .../lazy/src/providers/gesture-controller.js | 28 + .../lazy/src/providers/loading-controller.js | 15 + .../lazy/src/providers/menu-controller.js | 15 + .../lazy/src/providers/modal-controller.js | 20 + .../lazy/src/providers/popover-controller.js | 16 + .../lazy/src/providers/toast-controller.js | 15 + .../directives/angular-component-lib/utils.js | 58 + .../standalone/src/directives/checkbox.js | 67 + .../standalone/src/directives/datetime.js | 86 + .../es2015/standalone/src/directives/icon.js | 26 + .../es2015/standalone/src/directives/index.js | 12 + .../standalone/src/directives/input-otp.js | 81 + .../es2015/standalone/src/directives/input.js | 104 + .../standalone/src/directives/proxies.js | 1914 ++++++++++++++ .../standalone/src/directives/radio-group.js | 51 + .../es2015/standalone/src/directives/range.js | 69 + .../standalone/src/directives/searchbar.js | 73 + .../standalone/src/directives/segment.js | 51 + .../standalone/src/directives/select.js | 75 + .../standalone/src/directives/textarea.js | 82 + .../standalone/src/directives/toggle.js | 67 + .../build/es2015/standalone/src/index.js | 23 + .../standalone/src/navigation/back-button.js | 22 + .../es2015/standalone/src/navigation/nav.js | 20 + .../src/navigation/router-link-delegate.js | 21 + .../src/navigation/router-outlet.js | 35 + .../es2015/standalone/src/navigation/tabs.js | 68 + .../es2015/standalone/src/overlays/modal.js | 22 + .../es2015/standalone/src/overlays/popover.js | 20 + .../src/providers/action-sheet-controller.js | 17 + .../src/providers/alert-controller.js | 17 + .../src/providers/animation-controller.js | 34 + .../src/providers/gesture-controller.js | 28 + .../standalone/src/providers/ionic-angular.js | 37 + .../src/providers/loading-controller.js | 17 + .../src/providers/menu-controller.js | 15 + .../src/providers/modal-controller.js | 22 + .../src/providers/popover-controller.js | 18 + .../src/providers/toast-controller.js | 17 + packages/angular/lazy/src/index.ts | 7 +- packages/angular/lazy/src/ionic-module.ts | 13 + packages/react/src/components/components.ts | 1433 ++++------- 95 files changed, 9679 insertions(+), 919 deletions(-) create mode 100644 packages/angular/build/es2015/common/src/directives/control-value-accessors/index.js create mode 100644 packages/angular/build/es2015/common/src/directives/control-value-accessors/value-accessor.js create mode 100644 packages/angular/build/es2015/common/src/directives/navigation/back-button.js create mode 100644 packages/angular/build/es2015/common/src/directives/navigation/nav-params.js create mode 100644 packages/angular/build/es2015/common/src/directives/navigation/nav.js create mode 100644 packages/angular/build/es2015/common/src/directives/navigation/router-link-delegate.js create mode 100644 packages/angular/build/es2015/common/src/directives/navigation/router-outlet.js create mode 100644 packages/angular/build/es2015/common/src/directives/navigation/stack-controller.js create mode 100644 packages/angular/build/es2015/common/src/directives/navigation/stack-utils.js create mode 100644 packages/angular/build/es2015/common/src/directives/navigation/tabs.js create mode 100644 packages/angular/build/es2015/common/src/index.js create mode 100644 packages/angular/build/es2015/common/src/overlays/modal.js create mode 100644 packages/angular/build/es2015/common/src/overlays/popover.js create mode 100644 packages/angular/build/es2015/common/src/providers/angular-delegate.js create mode 100644 packages/angular/build/es2015/common/src/providers/config.js create mode 100644 packages/angular/build/es2015/common/src/providers/dom-controller.js create mode 100644 packages/angular/build/es2015/common/src/providers/menu-controller.js create mode 100644 packages/angular/build/es2015/common/src/providers/nav-controller.js create mode 100644 packages/angular/build/es2015/common/src/providers/platform.js create mode 100644 packages/angular/build/es2015/common/src/types/interfaces.js create mode 100644 packages/angular/build/es2015/common/src/types/ionic-lifecycle-hooks.js create mode 100644 packages/angular/build/es2015/common/src/types/overlay-options.js create mode 100644 packages/angular/build/es2015/common/src/utils/overlay.js create mode 100644 packages/angular/build/es2015/common/src/utils/proxy.js create mode 100644 packages/angular/build/es2015/common/src/utils/routing.js create mode 100644 packages/angular/build/es2015/common/src/utils/util.js create mode 100644 packages/angular/build/es2015/lazy/src/app-initialize.js create mode 100644 packages/angular/build/es2015/lazy/src/directives/angular-component-lib/utils.js create mode 100644 packages/angular/build/es2015/lazy/src/directives/control-value-accessors/boolean-value-accessor.js create mode 100644 packages/angular/build/es2015/lazy/src/directives/control-value-accessors/index.js create mode 100644 packages/angular/build/es2015/lazy/src/directives/control-value-accessors/numeric-value-accessor.js create mode 100644 packages/angular/build/es2015/lazy/src/directives/control-value-accessors/select-value-accessor.js create mode 100644 packages/angular/build/es2015/lazy/src/directives/control-value-accessors/text-value-accessor.js create mode 100644 packages/angular/build/es2015/lazy/src/directives/navigation/ion-back-button.js create mode 100644 packages/angular/build/es2015/lazy/src/directives/navigation/ion-nav.js create mode 100644 packages/angular/build/es2015/lazy/src/directives/navigation/ion-router-outlet.js create mode 100644 packages/angular/build/es2015/lazy/src/directives/navigation/ion-tabs.js create mode 100644 packages/angular/build/es2015/lazy/src/directives/navigation/router-link-delegate.js create mode 100644 packages/angular/build/es2015/lazy/src/directives/overlays/modal.js create mode 100644 packages/angular/build/es2015/lazy/src/directives/overlays/popover.js create mode 100644 packages/angular/build/es2015/lazy/src/directives/proxies-list.js create mode 100644 packages/angular/build/es2015/lazy/src/directives/proxies.js create mode 100644 packages/angular/build/es2015/lazy/src/directives/validators/index.js create mode 100644 packages/angular/build/es2015/lazy/src/directives/validators/max-validator.js create mode 100644 packages/angular/build/es2015/lazy/src/directives/validators/min-validator.js create mode 100644 packages/angular/build/es2015/lazy/src/index.js create mode 100644 packages/angular/build/es2015/lazy/src/ionic-module.js create mode 100644 packages/angular/build/es2015/lazy/src/providers/action-sheet-controller.js create mode 100644 packages/angular/build/es2015/lazy/src/providers/alert-controller.js create mode 100644 packages/angular/build/es2015/lazy/src/providers/animation-controller.js create mode 100644 packages/angular/build/es2015/lazy/src/providers/gesture-controller.js create mode 100644 packages/angular/build/es2015/lazy/src/providers/loading-controller.js create mode 100644 packages/angular/build/es2015/lazy/src/providers/menu-controller.js create mode 100644 packages/angular/build/es2015/lazy/src/providers/modal-controller.js create mode 100644 packages/angular/build/es2015/lazy/src/providers/popover-controller.js create mode 100644 packages/angular/build/es2015/lazy/src/providers/toast-controller.js create mode 100644 packages/angular/build/es2015/standalone/src/directives/angular-component-lib/utils.js create mode 100644 packages/angular/build/es2015/standalone/src/directives/checkbox.js create mode 100644 packages/angular/build/es2015/standalone/src/directives/datetime.js create mode 100644 packages/angular/build/es2015/standalone/src/directives/icon.js create mode 100644 packages/angular/build/es2015/standalone/src/directives/index.js create mode 100644 packages/angular/build/es2015/standalone/src/directives/input-otp.js create mode 100644 packages/angular/build/es2015/standalone/src/directives/input.js create mode 100644 packages/angular/build/es2015/standalone/src/directives/proxies.js create mode 100644 packages/angular/build/es2015/standalone/src/directives/radio-group.js create mode 100644 packages/angular/build/es2015/standalone/src/directives/range.js create mode 100644 packages/angular/build/es2015/standalone/src/directives/searchbar.js create mode 100644 packages/angular/build/es2015/standalone/src/directives/segment.js create mode 100644 packages/angular/build/es2015/standalone/src/directives/select.js create mode 100644 packages/angular/build/es2015/standalone/src/directives/textarea.js create mode 100644 packages/angular/build/es2015/standalone/src/directives/toggle.js create mode 100644 packages/angular/build/es2015/standalone/src/index.js create mode 100644 packages/angular/build/es2015/standalone/src/navigation/back-button.js create mode 100644 packages/angular/build/es2015/standalone/src/navigation/nav.js create mode 100644 packages/angular/build/es2015/standalone/src/navigation/router-link-delegate.js create mode 100644 packages/angular/build/es2015/standalone/src/navigation/router-outlet.js create mode 100644 packages/angular/build/es2015/standalone/src/navigation/tabs.js create mode 100644 packages/angular/build/es2015/standalone/src/overlays/modal.js create mode 100644 packages/angular/build/es2015/standalone/src/overlays/popover.js create mode 100644 packages/angular/build/es2015/standalone/src/providers/action-sheet-controller.js create mode 100644 packages/angular/build/es2015/standalone/src/providers/alert-controller.js create mode 100644 packages/angular/build/es2015/standalone/src/providers/animation-controller.js create mode 100644 packages/angular/build/es2015/standalone/src/providers/gesture-controller.js create mode 100644 packages/angular/build/es2015/standalone/src/providers/ionic-angular.js create mode 100644 packages/angular/build/es2015/standalone/src/providers/loading-controller.js create mode 100644 packages/angular/build/es2015/standalone/src/providers/menu-controller.js create mode 100644 packages/angular/build/es2015/standalone/src/providers/modal-controller.js create mode 100644 packages/angular/build/es2015/standalone/src/providers/popover-controller.js create mode 100644 packages/angular/build/es2015/standalone/src/providers/toast-controller.js diff --git a/BREAKING.md b/BREAKING.md index 8076a0dc981..19dd275fb11 100644 --- a/BREAKING.md +++ b/BREAKING.md @@ -165,6 +165,12 @@ Ionic 9 requires Angular 18 or later. Angular 16 and 17 are no longer supported. Following industry standards, Ionic 9 makes standalone components the default import path. Standalone component imports have changed from `@ionic/angular/standalone` to `@ionic/angular`. Lazy-loaded component imports have changed from `@ionic/angular` to `@ionic/angular/lazy`. +**IonicModule Deprecation** + +`IonicModule` is deprecated in Ionic 9 and will be removed in a future major version. It remains fully functional in Ionic 9, so existing applications continue to work without changes. + +Applications should migrate to `provideIonicAngular()`, which works in both standalone and NgModule-based applications. For an NgModule-based app, replace `IonicModule.forRoot(config)` in the `imports` array with `provideIonicAngular(config)` in the `providers` array. Any config passed to `IonicModule.forRoot()` can be passed as an object to `provideIonicAngular()`. Refer to the [build options guide](https://ionicframework.com/docs/angular/build-options) for migration steps. + **Zoneless Change Detection by Default** Ionic 9 defaults to zoneless change detection. Angular 21 bootstraps zoneless out of the box, so a new Ionic 9 app on Angular 21 runs without Zone.js and requires no change-detection provider. The `ng add @ionic/angular` schematic no longer registers `provideZoneChangeDetection()`. diff --git a/docs/angular/testing.md b/docs/angular/testing.md index ccfe4de8edd..be1819ffc94 100644 --- a/docs/angular/testing.md +++ b/docs/angular/testing.md @@ -82,6 +82,9 @@ If you need to add E2E tests that are only run on a specific version of the JS F Tests for lazy loaded Ionic UI components should only be added under the `/lazy` route. This ensures the `IonicModule` is added. +> [!CAUTION] +> The lazy loaded build and its `IonicModule` are deprecated and will be removed in a future major version. New components should be tested as standalone components (see below). These lazy tests remain to verify that the deprecated build keeps working while it is still supported. + ### Testing Standalone Ionic Components Tests for standalone Ionic UI components should only be added under the `/standalone` route. This allows for an isolated environment where the lazy loaded `IonicModule` is not initialized. The standalone components use Stencil's custom element bundle instead of the lazy loaded bundle. If `IonicModule` is initialized then the Stencil components will fall back to using the lazy loaded implementation instead of the custom elements bundle implementation. diff --git a/packages/angular/README.md b/packages/angular/README.md index 7076172a9ff..1d23db92827 100644 --- a/packages/angular/README.md +++ b/packages/angular/README.md @@ -112,3 +112,6 @@ Ionic developers can access this by importing from `@ionic/angular`. This is where the lazy loaded component implementations live. Ionic developers can access this by importing from `@ionic/angular/lazy`. + +> [!CAUTION] +> The lazy loaded build and its `IonicModule` are deprecated and will be removed in a future major version. New code should use the standalone components and `provideIonicAngular()` imported from `@ionic/angular`. diff --git a/packages/angular/build/es2015/common/src/directives/control-value-accessors/index.js b/packages/angular/build/es2015/common/src/directives/control-value-accessors/index.js new file mode 100644 index 00000000000..e00caae1aca --- /dev/null +++ b/packages/angular/build/es2015/common/src/directives/control-value-accessors/index.js @@ -0,0 +1 @@ +export * from './value-accessor'; diff --git a/packages/angular/build/es2015/common/src/directives/control-value-accessors/value-accessor.js b/packages/angular/build/es2015/common/src/directives/control-value-accessors/value-accessor.js new file mode 100644 index 00000000000..06c2d002a9d --- /dev/null +++ b/packages/angular/build/es2015/common/src/directives/control-value-accessors/value-accessor.js @@ -0,0 +1,146 @@ +import { __decorate } from "tslib"; +import { Directive, HostListener } from '@angular/core'; +import { NgControl } from '@angular/forms'; +import { raf } from '../../utils/util'; +// TODO(FW-2827): types +let ValueAccessor = class ValueAccessor { + constructor(injector, elementRef) { + this.injector = injector; + this.elementRef = elementRef; + this.onChange = () => { + /**/ + }; + this.onTouched = () => { + /**/ + }; + } + writeValue(value) { + this.elementRef.nativeElement.value = this.lastValue = value; + setIonicClasses(this.elementRef); + } + /** + * Notifies the ControlValueAccessor of a change in the value of the control. + * + * This is called by each of the ValueAccessor directives when we want to update + * the status and validity of the form control. For example with text components this + * is called when the ionInput event is fired. For select components this is called + * when the ionChange event is fired. + * + * This also updates the Ionic form status classes on the element. + * + * @param el The component element. + * @param value The new value of the control. + */ + handleValueChange(el, value) { + if (el === this.elementRef.nativeElement) { + if (value !== this.lastValue) { + this.lastValue = value; + this.onChange(value); + } + setIonicClasses(this.elementRef); + } + } + _handleBlurEvent(el) { + if (el === this.elementRef.nativeElement) { + this.onTouched(); + setIonicClasses(this.elementRef); + // When ion-radio is blurred, el and this.elementRef.nativeElement are + // different so we need to check if the closest ion-radio-group is the same + // as this.elementRef.nativeElement and if so, we need to mark the radio group + // as touched + } + else if (el.closest('ion-radio-group') === this.elementRef.nativeElement) { + this.onTouched(); + } + } + registerOnChange(fn) { + this.onChange = fn; + } + registerOnTouched(fn) { + this.onTouched = fn; + } + setDisabledState(isDisabled) { + this.elementRef.nativeElement.disabled = isDisabled; + } + ngOnDestroy() { + if (this.statusChanges) { + this.statusChanges.unsubscribe(); + } + } + ngAfterViewInit() { + let ngControl; + try { + ngControl = this.injector.get(NgControl); + } + catch (_a) { + /* No FormControl or ngModel binding */ + } + if (!ngControl) { + return; + } + // Listen for changes in validity, disabled, or pending states + if (ngControl.statusChanges) { + this.statusChanges = ngControl.statusChanges.subscribe(() => setIonicClasses(this.elementRef)); + } + /** + * TODO FW-2787: Remove this in favor of https://github.com/angular/angular/issues/10887 + * whenever it is implemented. + */ + const formControl = ngControl.control; + if (formControl) { + const methodsToPatch = ['markAsTouched', 'markAllAsTouched', 'markAsUntouched', 'markAsDirty', 'markAsPristine']; + methodsToPatch.forEach((method) => { + if (typeof formControl[method] !== 'undefined') { + const oldFn = formControl[method].bind(formControl); + formControl[method] = (...params) => { + oldFn(...params); + setIonicClasses(this.elementRef); + }; + } + }); + } + } +}; +__decorate([ + HostListener('ionBlur', ['$event.target']) +], ValueAccessor.prototype, "_handleBlurEvent", null); +ValueAccessor = __decorate([ + Directive() +], ValueAccessor); +export { ValueAccessor }; +export const setIonicClasses = (element) => { + raf(() => { + const input = element.nativeElement; + const hasValue = input.value != null && input.value.toString().length > 0; + const classes = getClasses(input); + setClasses(input, classes); + const item = input.closest('ion-item'); + if (item) { + if (hasValue) { + setClasses(item, [...classes, 'item-has-value']); + } + else { + setClasses(item, classes); + } + } + }); +}; +const getClasses = (element) => { + const classList = element.classList; + const classes = []; + for (let i = 0; i < classList.length; i++) { + const item = classList.item(i); + if (item !== null && startsWith(item, 'ng-')) { + classes.push(`ion-${item.substring(3)}`); + } + } + return classes; +}; +const setClasses = (element, classes) => { + const classList = element.classList; + classList.remove('ion-valid', 'ion-invalid', 'ion-touched', 'ion-untouched', 'ion-dirty', 'ion-pristine'); + classList.add(...classes); +}; +const startsWith = (input, search) => { + return input.substring(0, search.length) === search; +}; diff --git a/packages/angular/build/es2015/common/src/directives/navigation/back-button.js b/packages/angular/build/es2015/common/src/directives/navigation/back-button.js new file mode 100644 index 00000000000..d3e245dbe3c --- /dev/null +++ b/packages/angular/build/es2015/common/src/directives/navigation/back-button.js @@ -0,0 +1,45 @@ +import { __decorate, __param } from "tslib"; +import { HostListener, Optional, Directive } from '@angular/core'; +import { ProxyCmp } from '../../utils/proxy'; +const BACK_BUTTON_INPUTS = ['color', 'defaultHref', 'disabled', 'icon', 'mode', 'routerAnimation', 'text', 'type']; +let IonBackButton = class IonBackButton { + constructor(routerOutlet, navCtrl, config, r, z, c) { + this.routerOutlet = routerOutlet; + this.navCtrl = navCtrl; + this.config = config; + this.r = r; + this.z = z; + c.detach(); + this.el = this.r.nativeElement; + } + /** + * @internal + */ + onClick(ev) { + var _a; + const defaultHref = this.defaultHref || this.config.get('backButtonDefaultHref'); + if ((_a = this.routerOutlet) === null || _a === void 0 ? void 0 : _a.canGoBack()) { + this.navCtrl.setDirection('back', undefined, undefined, this.routerAnimation); + this.routerOutlet.pop(); + ev.preventDefault(); + } + else if (defaultHref != null) { + this.navCtrl.navigateBack(defaultHref, { animation: this.routerAnimation }); + ev.preventDefault(); + } + } +}; +__decorate([ + HostListener('click', ['$event']) +], IonBackButton.prototype, "onClick", null); +IonBackButton = __decorate([ + ProxyCmp({ + inputs: BACK_BUTTON_INPUTS, + }), + Directive({ + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: BACK_BUTTON_INPUTS, + }), + __param(0, Optional()) +], IonBackButton); +export { IonBackButton }; diff --git a/packages/angular/build/es2015/common/src/directives/navigation/nav-params.js b/packages/angular/build/es2015/common/src/directives/navigation/nav-params.js new file mode 100644 index 00000000000..9c274ae4f49 --- /dev/null +++ b/packages/angular/build/es2015/common/src/directives/navigation/nav-params.js @@ -0,0 +1,45 @@ +/** + * @description + * NavParams are an object that exists on a page and can contain data for that particular view. + * Similar to how data was pass to a view in V1 with `$stateParams`, NavParams offer a much more flexible + * option with a simple `get` method. + * + * @usage + * ```ts + * import { NavParams } from '@ionic/angular'; + * + * export class MyClass{ + * + * constructor(navParams: NavParams){ + * // userParams is an object we have in our nav-parameters + * navParams.get('userParams'); + * } + * + * } + * ``` + */ +export class NavParams { + constructor(data = {}) { + this.data = data; + console.warn(`[Ionic Warning]: NavParams has been deprecated in favor of using Angular's input API. Developers should migrate to either the @Input decorator or the Signals-based input API.`); + } + /** + * Get the value of a nav-parameter for the current view + * + * ```ts + * import { NavParams } from 'ionic-angular'; + * + * export class MyClass{ + * constructor(public navParams: NavParams){ + * // userParams is an object we have in our nav-parameters + * this.navParams.get('userParams'); + * } + * } + * ``` + * + * @param param Which param you want to look up + */ + get(param) { + return this.data[param]; + } +} diff --git a/packages/angular/build/es2015/common/src/directives/navigation/nav.js b/packages/angular/build/es2015/common/src/directives/navigation/nav.js new file mode 100644 index 00000000000..9a5c62f4a81 --- /dev/null +++ b/packages/angular/build/es2015/common/src/directives/navigation/nav.js @@ -0,0 +1,39 @@ +import { __decorate } from "tslib"; +import { Directive, } from '@angular/core'; +import { ProxyCmp, proxyOutputs } from '../../utils/proxy'; +const NAV_INPUTS = ['animated', 'animation', 'root', 'rootParams', 'swipeGesture']; +const NAV_METHODS = [ + 'push', + 'insert', + 'insertPages', + 'pop', + 'popTo', + 'popToRoot', + 'removeIndex', + 'setRoot', + 'setPages', + 'getActive', + 'getByIndex', + 'canGoBack', + 'getPrevious', +]; +let IonNav = class IonNav { + constructor(ref, environmentInjector, injector, angularDelegate, z, c) { + this.z = z; + c.detach(); + this.el = ref.nativeElement; + ref.nativeElement.delegate = angularDelegate.create(environmentInjector, injector); + proxyOutputs(this, this.el, ['ionNavDidChange', 'ionNavWillChange']); + } +}; +IonNav = __decorate([ + ProxyCmp({ + inputs: NAV_INPUTS, + methods: NAV_METHODS, + }), + Directive({ + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: NAV_INPUTS, + }) +], IonNav); +export { IonNav }; diff --git a/packages/angular/build/es2015/common/src/directives/navigation/router-link-delegate.js b/packages/angular/build/es2015/common/src/directives/navigation/router-link-delegate.js new file mode 100644 index 00000000000..a1231552e7d --- /dev/null +++ b/packages/angular/build/es2015/common/src/directives/navigation/router-link-delegate.js @@ -0,0 +1,172 @@ +import { __decorate, __param } from "tslib"; +import { Directive, HostListener, Input, Optional } from '@angular/core'; +/** + * Adds support for Ionic routing directions and animations to the base Angular router link directive. + * + * When the router link is clicked, the directive will assign the direction and + * animation so that the routing integration will transition correctly. + */ +let RouterLinkDelegateDirective = class RouterLinkDelegateDirective { + constructor(locationStrategy, navCtrl, elementRef, router, routerLink) { + this.locationStrategy = locationStrategy; + this.navCtrl = navCtrl; + this.elementRef = elementRef; + this.router = router; + this.routerLink = routerLink; + this.routerDirection = 'forward'; + this.onCaptureClick = (ev) => { + if (this.opensNatively(ev)) { + ev.stopImmediatePropagation(); + } + }; + } + ngOnInit() { + this.updateTargetUrlAndHref(); + this.updateTabindex(); + /** + * Ionic components like `ion-item` render a native anchor in their shadow DOM, + * so a modifier click (ctrl/meta/shift/alt) or a non-`_self` target should let + * the browser handle the navigation natively (new tab, new window, download) + * instead of navigating in-app. + * + * We listen in the capture phase so this runs before Angular's `RouterLink` + * handler and our own bubble-phase `onClick`. On a native-navigation intent it + * stops propagation to cancel the in-app navigation, but leaves `preventDefault` + * alone so the native anchor can still act. + */ + this.elementRef.nativeElement.addEventListener('click', this.onCaptureClick, { capture: true }); + } + ngOnChanges() { + this.updateTargetUrlAndHref(); + } + ngOnDestroy() { + this.elementRef.nativeElement.removeEventListener('click', this.onCaptureClick, { capture: true }); + } + /** + * True when the browser should handle the click natively instead of routing + * in-app: a modifier was held (ctrl/meta/shift/alt), or the host targets + * something other than `_self`. This mirrors the modifier set Angular's own + * `RouterLink` guards on, so an Ionic `routerLink` behaves like a plain anchor + * for new-tab, new-window, and download intents. + */ + opensNatively(ev) { + if (ev instanceof MouseEvent && (ev.ctrlKey || ev.metaKey || ev.shiftKey || ev.altKey)) { + return true; + } + const target = this.elementRef.nativeElement.target; + return target != null && target !== '' && target !== '_self'; + } + /** + * The `tabindex` is set to `0` by default on the host element when + * the `routerLink` directive is used. This causes issues with Ionic + * components that wrap an `a` or `button` element, such as `ion-item`. + * See issue https://github.com/angular/angular/issues/28345 + * + * This method removes the `tabindex` attribute from the host element + * to allow the Ionic component to manage the focus state correctly. + */ + updateTabindex() { + // Ionic components that render a native anchor or button element + const ionicComponents = [ + 'ION-BACK-BUTTON', + 'ION-BREADCRUMB', + 'ION-BUTTON', + 'ION-CARD', + 'ION-FAB-BUTTON', + 'ION-ITEM', + 'ION-ITEM-OPTION', + 'ION-MENU-BUTTON', + 'ION-SEGMENT-BUTTON', + 'ION-TAB-BUTTON', + ]; + const hostElement = this.elementRef.nativeElement; + if (ionicComponents.includes(hostElement.tagName)) { + if (hostElement.getAttribute('tabindex') === '0') { + hostElement.removeAttribute('tabindex'); + } + } + } + updateTargetUrlAndHref() { + var _a; + if ((_a = this.routerLink) === null || _a === void 0 ? void 0 : _a.urlTree) { + const href = this.locationStrategy.prepareExternalUrl(this.router.serializeUrl(this.routerLink.urlTree)); + this.elementRef.nativeElement.href = href; + } + } + /** + * @internal + */ + onClick(ev) { + this.navCtrl.setDirection(this.routerDirection, undefined, undefined, this.routerAnimation); + /** + * This prevents the browser from + * performing a page reload when pressing + * an Ionic component with routerLink. + * The page reload interferes with routing + * and causes ion-back-button to disappear + * since the local history is wiped on reload. + */ + ev.preventDefault(); + } +}; +__decorate([ + Input() +], RouterLinkDelegateDirective.prototype, "routerDirection", void 0); +__decorate([ + Input() +], RouterLinkDelegateDirective.prototype, "routerAnimation", void 0); +__decorate([ + HostListener('click', ['$event']) +], RouterLinkDelegateDirective.prototype, "onClick", null); +RouterLinkDelegateDirective = __decorate([ + Directive({ + selector: ':not(a):not(area)[routerLink]', + }), + __param(4, Optional()) +], RouterLinkDelegateDirective); +export { RouterLinkDelegateDirective }; +let RouterLinkWithHrefDelegateDirective = class RouterLinkWithHrefDelegateDirective { + constructor(locationStrategy, navCtrl, elementRef, router, routerLink) { + this.locationStrategy = locationStrategy; + this.navCtrl = navCtrl; + this.elementRef = elementRef; + this.router = router; + this.routerLink = routerLink; + this.routerDirection = 'forward'; + } + ngOnInit() { + this.updateTargetUrlAndHref(); + } + ngOnChanges() { + this.updateTargetUrlAndHref(); + } + updateTargetUrlAndHref() { + var _a; + if ((_a = this.routerLink) === null || _a === void 0 ? void 0 : _a.urlTree) { + const href = this.locationStrategy.prepareExternalUrl(this.router.serializeUrl(this.routerLink.urlTree)); + this.elementRef.nativeElement.href = href; + } + } + /** + * @internal + */ + onClick() { + this.navCtrl.setDirection(this.routerDirection, undefined, undefined, this.routerAnimation); + } +}; +__decorate([ + Input() +], RouterLinkWithHrefDelegateDirective.prototype, "routerDirection", void 0); +__decorate([ + Input() +], RouterLinkWithHrefDelegateDirective.prototype, "routerAnimation", void 0); +__decorate([ + HostListener('click') +], RouterLinkWithHrefDelegateDirective.prototype, "onClick", null); +RouterLinkWithHrefDelegateDirective = __decorate([ + Directive({ + selector: 'a[routerLink],area[routerLink]', + }), + __param(4, Optional()) +], RouterLinkWithHrefDelegateDirective); +export { RouterLinkWithHrefDelegateDirective }; diff --git a/packages/angular/build/es2015/common/src/directives/navigation/router-outlet.js b/packages/angular/build/es2015/common/src/directives/navigation/router-outlet.js new file mode 100644 index 00000000000..1e05bbadb5b --- /dev/null +++ b/packages/angular/build/es2015/common/src/directives/navigation/router-outlet.js @@ -0,0 +1,462 @@ +import { __decorate, __param } from "tslib"; +import { ViewContainerRef, inject, Attribute, Directive, EventEmitter, Optional, Output, SkipSelf, EnvironmentInjector, Input, InjectionToken, Injectable, reflectComponentType, } from '@angular/core'; +import { Router, ActivatedRoute, ChildrenOutletContexts, PRIMARY_OUTLET } from '@angular/router'; +import { componentOnReady } from '@ionic/core/components'; +import { BehaviorSubject, combineLatest, of } from 'rxjs'; +import { distinctUntilChanged, filter, switchMap } from 'rxjs/operators'; +import { Config } from '../../providers/config'; +import { NavController } from '../../providers/nav-controller'; +import { StackController } from './stack-controller'; +import { getUrl, isTabSwitch } from './stack-utils'; +// TODO(FW-2827): types +let IonRouterOutlet = class IonRouterOutlet { + /** @internal */ + get activatedComponentRef() { + return this.activated; + } + set animation(animation) { + this.nativeEl.animation = animation; + } + set animated(animated) { + this.nativeEl.animated = animated; + } + set swipeGesture(swipe) { + this._swipeGesture = swipe; + this.nativeEl.swipeHandler = swipe + ? { + canStart: () => this.stackCtrl.canGoBack(1) && !this.stackCtrl.hasRunningTask(), + onStart: () => this.stackCtrl.startBackTransition(), + onEnd: (shouldContinue) => this.stackCtrl.endBackTransition(shouldContinue), + } + : undefined; + this.nativeEl.swipeGesture = swipe; + } + constructor(name, tabs, commonLocation, elementRef, router, zone, activatedRoute, parentOutlet) { + this.parentOutlet = parentOutlet; + this.activatedView = null; + // Maintain map of activated route proxies for each component instance + this.proxyMap = new WeakMap(); + // Keep the latest activated route in a subject for the proxy routes to switch map to + this.currentActivatedRoute$ = new BehaviorSubject(null); + this.activated = null; + this._activatedRoute = null; + /** + * The name of the outlet + */ + this.name = PRIMARY_OUTLET; + /** @internal */ + this.stackWillChange = new EventEmitter(); + /** @internal */ + this.stackDidChange = new EventEmitter(); + // eslint-disable-next-line @angular-eslint/no-output-rename + this.activateEvents = new EventEmitter(); + // eslint-disable-next-line @angular-eslint/no-output-rename + this.deactivateEvents = new EventEmitter(); + this.parentContexts = inject(ChildrenOutletContexts); + this.location = inject(ViewContainerRef); + this.environmentInjector = inject(EnvironmentInjector); + this.inputBinder = inject(INPUT_BINDER, { optional: true }); + /** @nodoc */ + this.supportsBindingToComponentInputs = true; + // Ionic providers + this.config = inject(Config); + this.navCtrl = inject(NavController); + this.nativeEl = elementRef.nativeElement; + this.name = name || PRIMARY_OUTLET; + this.tabsPrefix = tabs === 'true' ? getUrl(router, activatedRoute) : undefined; + this.stackCtrl = new StackController(this.tabsPrefix, this.nativeEl, router, this.navCtrl, zone, commonLocation); + this.parentContexts.onChildOutletCreated(this.name, this); + } + ngOnDestroy() { + var _a; + this.stackCtrl.destroy(); + (_a = this.inputBinder) === null || _a === void 0 ? void 0 : _a.unsubscribeFromRouteData(this); + } + getContext() { + return this.parentContexts.getContext(this.name); + } + ngOnInit() { + this.initializeOutletWithName(); + } + // Note: Ionic deviates from the Angular Router implementation here + initializeOutletWithName() { + if (!this.activated) { + // If the outlet was not instantiated at the time the route got activated we need to populate + // the outlet when it is initialized (ie inside a NgIf) + const context = this.getContext(); + if (context === null || context === void 0 ? void 0 : context.route) { + this.activateWith(context.route, context.injector); + } + } + new Promise((resolve) => componentOnReady(this.nativeEl, resolve)).then(() => { + if (this._swipeGesture === undefined) { + this.swipeGesture = this.config.getBoolean('swipeBackEnabled', this.nativeEl.mode === 'ios'); + } + }); + } + get isActivated() { + return !!this.activated; + } + get component() { + if (!this.activated) { + throw new Error('Outlet is not activated'); + } + return this.activated.instance; + } + get activatedRoute() { + if (!this.activated) { + throw new Error('Outlet is not activated'); + } + return this._activatedRoute; + } + get activatedRouteData() { + if (this._activatedRoute) { + return this._activatedRoute.snapshot.data; + } + return {}; + } + /** + * Called when the `RouteReuseStrategy` instructs to detach the subtree + */ + detach() { + throw new Error('incompatible reuse strategy'); + } + /** + * Called when the `RouteReuseStrategy` instructs to re-attach a previously detached subtree + */ + // eslint-disable-next-line @typescript-eslint/no-unused-vars + attach(_ref, _activatedRoute) { + throw new Error('incompatible reuse strategy'); + } + deactivate() { + if (this.activated) { + if (this.activatedView) { + const context = this.getContext(); + this.activatedView.savedData = new Map(context.children['contexts']); + /** + * Angular v11.2.10 introduced a change + * where this route context is cleared out when + * a router-outlet is deactivated, However, + * we need this route information in order to + * return a user back to the correct tab when + * leaving and then going back to the tab context. + */ + const primaryOutlet = this.activatedView.savedData.get('primary'); + if (primaryOutlet && context.route) { + primaryOutlet.route = Object.assign({}, context.route); + } + /** + * Ensure we are saving the NavigationExtras + * data otherwise it will be lost + */ + this.activatedView.savedExtras = {}; + if (context.route) { + const contextSnapshot = context.route.snapshot; + this.activatedView.savedExtras.queryParams = contextSnapshot.queryParams; + this.activatedView.savedExtras.fragment = contextSnapshot.fragment; + } + } + const c = this.component; + this.activatedView = null; + this.activated = null; + this._activatedRoute = null; + this.deactivateEvents.emit(c); + } + } + activateWith(activatedRoute, environmentInjector) { + var _a, _b; + if (this.isActivated) { + throw new Error('Cannot activate an already activated outlet'); + } + this._activatedRoute = activatedRoute; + let cmpRef; + let enteringView = this.stackCtrl.getExistingView(activatedRoute); + if (enteringView) { + cmpRef = this.activated = enteringView.ref; + const saved = enteringView.savedData; + if (saved) { + // self-restore + const context = this.getContext(); + context.children['contexts'] = saved; + } + // Updated activated route proxy for this component + this.updateActivatedRouteProxy(cmpRef.instance, activatedRoute); + } + else { + const snapshot = activatedRoute._futureSnapshot; + /** + * Angular 14 introduces a new `loadComponent` property to the route config. + * This function will assign a `component` property to the route snapshot. + * We check for the presence of this property to determine if the route is + * using standalone components. + */ + const childContexts = this.parentContexts.getOrCreateContext(this.name).children; + // We create an activated route proxy object that will maintain future updates for this component + // over its lifecycle in the stack. + const component$ = new BehaviorSubject(null); + const activatedRouteProxy = this.createActivatedRouteProxy(component$, activatedRoute); + const injector = new OutletInjector(activatedRouteProxy, childContexts, this.location.injector); + const component = (_a = snapshot.routeConfig.component) !== null && _a !== void 0 ? _a : snapshot.component; + /** + * View components need to be added as a child of ion-router-outlet + * for page transitions and swipe to go back. + * However, createComponent mounts components as siblings of the + * ViewContainerRef. As a result, outletContent must reference + * an ng-container inside of ion-router-outlet and not + * ion-router-outlet itself. + */ + cmpRef = this.activated = this.outletContent.createComponent(component, { + index: this.outletContent.length, + injector, + environmentInjector: environmentInjector !== null && environmentInjector !== void 0 ? environmentInjector : this.environmentInjector, + }); + // Once the component is created we can push it to our local subject supplied to the proxy + component$.next(cmpRef.instance); + // Calling `markForCheck` to make sure we will run the change detection when the + // `RouterOutlet` is inside a `ChangeDetectionStrategy.OnPush` component. + /** + * At this point this.activated has been set earlier + * in this function, so it is guaranteed to be non-null. + */ + enteringView = this.stackCtrl.createView(this.activated, activatedRoute); + // Store references to the proxy by component + this.proxyMap.set(cmpRef.instance, activatedRouteProxy); + this.currentActivatedRoute$.next({ component: cmpRef.instance, activatedRoute }); + } + (_b = this.inputBinder) === null || _b === void 0 ? void 0 : _b.bindActivatedRouteToOutletComponent(this); + this.activatedView = enteringView; + /** + * The top outlet is set prior to the entering view's transition completing, + * so that when we have nested outlets (e.g. ion-tabs inside an ion-router-outlet), + * the tabs outlet will be assigned as the top outlet when a view inside tabs is + * activated. + * + * In this scenario, activeWith is called for both the tabs and the root router outlet. + * To avoid a race condition, we assign the top outlet synchronously. + */ + this.navCtrl.setTopOutlet(this); + const leavingView = this.stackCtrl.getActiveView(); + this.stackWillChange.emit({ + enteringView, + tabSwitch: isTabSwitch(enteringView, leavingView), + }); + this.stackCtrl.setActive(enteringView).then((data) => { + this.activateEvents.emit(cmpRef.instance); + this.stackDidChange.emit(data); + }); + } + /** + * Returns `true` if there are pages in the stack to go back. + */ + canGoBack(deep = 1, stackId) { + return this.stackCtrl.canGoBack(deep, stackId); + } + /** + * Resolves to `true` if it the outlet was able to sucessfully pop the last N pages. + */ + pop(deep = 1, stackId) { + return this.stackCtrl.pop(deep, stackId); + } + /** + * Returns the URL of the active page of each stack. + */ + getLastUrl(stackId) { + const active = this.stackCtrl.getLastUrl(stackId); + return active ? active.url : undefined; + } + /** + * Returns the RouteView of the active page of each stack. + * @internal + */ + getLastRouteView(stackId) { + return this.stackCtrl.getLastUrl(stackId); + } + /** + * Returns the root view in the tab stack. + * @internal + */ + getRootView(stackId) { + return this.stackCtrl.getRootUrl(stackId); + } + /** + * Returns the active stack ID. In the context of ion-tabs, it means the active tab. + */ + getActiveStackId() { + return this.stackCtrl.getActiveStackId(); + } + /** + * Since the activated route can change over the life time of a component in an ion router outlet, we create + * a proxy so that we can update the values over time as a user navigates back to components already in the stack. + */ + createActivatedRouteProxy(component$, activatedRoute) { + const proxy = new ActivatedRoute(); + proxy._futureSnapshot = activatedRoute._futureSnapshot; + proxy._routerState = activatedRoute._routerState; + proxy.snapshot = activatedRoute.snapshot; + proxy.outlet = activatedRoute.outlet; + proxy.component = activatedRoute.component; + // Setup wrappers for the observables so consumers don't have to worry about switching to new observables as the state updates + proxy._paramMap = this.proxyObservable(component$, 'paramMap'); + proxy._queryParamMap = this.proxyObservable(component$, 'queryParamMap'); + proxy.url = this.proxyObservable(component$, 'url'); + proxy.params = this.proxyObservable(component$, 'params'); + proxy.queryParams = this.proxyObservable(component$, 'queryParams'); + proxy.fragment = this.proxyObservable(component$, 'fragment'); + proxy.data = this.proxyObservable(component$, 'data'); + return proxy; + } + /** + * Create a wrapped observable that will switch to the latest activated route matched by the given component + */ + proxyObservable(component$, path) { + return component$.pipe( + // First wait until the component instance is pushed + filter((component) => !!component), switchMap((component) => this.currentActivatedRoute$.pipe(filter((current) => current !== null && current.component === component), switchMap((current) => current && current.activatedRoute[path]), distinctUntilChanged()))); + } + /** + * Updates the activated route proxy for the given component to the new incoming router state + */ + updateActivatedRouteProxy(component, activatedRoute) { + const proxy = this.proxyMap.get(component); + if (!proxy) { + throw new Error(`Could not find activated route proxy for view`); + } + proxy._futureSnapshot = activatedRoute._futureSnapshot; + proxy._routerState = activatedRoute._routerState; + proxy.snapshot = activatedRoute.snapshot; + proxy.outlet = activatedRoute.outlet; + proxy.component = activatedRoute.component; + this.currentActivatedRoute$.next({ component, activatedRoute }); + } +}; +__decorate([ + Input() +], IonRouterOutlet.prototype, "name", void 0); +__decorate([ + Output() +], IonRouterOutlet.prototype, "stackWillChange", void 0); +__decorate([ + Output() +], IonRouterOutlet.prototype, "stackDidChange", void 0); +__decorate([ + Output('activate') +], IonRouterOutlet.prototype, "activateEvents", void 0); +__decorate([ + Output('deactivate') +], IonRouterOutlet.prototype, "deactivateEvents", void 0); +IonRouterOutlet = __decorate([ + Directive({ + selector: 'ion-router-outlet', + exportAs: 'outlet', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['animated', 'animation', 'mode', 'swipeGesture'], + }), + __param(0, Attribute('name')), + __param(1, Optional()), + __param(1, Attribute('tabs')), + __param(7, SkipSelf()), + __param(7, Optional()) +], IonRouterOutlet); +export { IonRouterOutlet }; +class OutletInjector { + constructor(route, childContexts, parent) { + this.route = route; + this.childContexts = childContexts; + this.parent = parent; + } + get(token, notFoundValue) { + if (token === ActivatedRoute) { + return this.route; + } + if (token === ChildrenOutletContexts) { + return this.childContexts; + } + return this.parent.get(token, notFoundValue); + } +} +// TODO: FW-4785 - Remove this once Angular 15 support is dropped +const INPUT_BINDER = new InjectionToken(''); +/** + * Injectable used as a tree-shakable provider for opting in to binding router data to component + * inputs. + * + * The RouterOutlet registers itself with this service when an `ActivatedRoute` is attached or + * activated. When this happens, the service subscribes to the `ActivatedRoute` observables (params, + * queryParams, data) and sets the inputs of the component using `ComponentRef.setInput`. + * Importantly, when an input does not have an item in the route data with a matching key, this + * input is set to `undefined`. If it were not done this way, the previous information would be + * retained if the data got removed from the route (i.e. if a query parameter is removed). + * + * The `RouterOutlet` should unregister itself when destroyed via `unsubscribeFromRouteData` so that + * the subscriptions are cleaned up. + */ +let RoutedComponentInputBinder = class RoutedComponentInputBinder { + constructor() { + this.outletDataSubscriptions = new Map(); + } + bindActivatedRouteToOutletComponent(outlet) { + this.unsubscribeFromRouteData(outlet); + this.subscribeToRouteData(outlet); + } + unsubscribeFromRouteData(outlet) { + var _a; + (_a = this.outletDataSubscriptions.get(outlet)) === null || _a === void 0 ? void 0 : _a.unsubscribe(); + this.outletDataSubscriptions.delete(outlet); + } + subscribeToRouteData(outlet) { + const { activatedRoute } = outlet; + const dataSubscription = combineLatest([activatedRoute.queryParams, activatedRoute.params, activatedRoute.data]) + .pipe(switchMap(([queryParams, params, data], index) => { + data = Object.assign(Object.assign(Object.assign({}, queryParams), params), data); + // Get the first result from the data subscription synchronously so it's available to + // the component as soon as possible (and doesn't require a second change detection). + if (index === 0) { + return of(data); + } + // Promise.resolve is used to avoid synchronously writing the wrong data when + // two of the Observables in the `combineLatest` stream emit one after + // another. + return Promise.resolve(data); + })) + .subscribe((data) => { + // Outlet may have been deactivated or changed names to be associated with a different + // route + if (!outlet.isActivated || + !outlet.activatedComponentRef || + outlet.activatedRoute !== activatedRoute || + activatedRoute.component === null) { + this.unsubscribeFromRouteData(outlet); + return; + } + const mirror = reflectComponentType(activatedRoute.component); + if (!mirror) { + this.unsubscribeFromRouteData(outlet); + return; + } + for (const { templateName } of mirror.inputs) { + outlet.activatedComponentRef.setInput(templateName, data[templateName]); + } + }); + this.outletDataSubscriptions.set(outlet, dataSubscription); + } +}; +RoutedComponentInputBinder = __decorate([ + Injectable() +], RoutedComponentInputBinder); +export const provideComponentInputBinding = () => { + return { + provide: INPUT_BINDER, + useFactory: componentInputBindingFactory, + deps: [Router], + }; +}; +function componentInputBindingFactory(router) { + /** + * We cast the router to any here, since the componentInputBindingEnabled + * property is not available until Angular v16. + */ + if (router === null || router === void 0 ? void 0 : router.componentInputBindingEnabled) { + return new RoutedComponentInputBinder(); + } + return null; +} diff --git a/packages/angular/build/es2015/common/src/directives/navigation/stack-controller.js b/packages/angular/build/es2015/common/src/directives/navigation/stack-controller.js new file mode 100644 index 00000000000..a0572ffeda9 --- /dev/null +++ b/packages/angular/build/es2015/common/src/directives/navigation/stack-controller.js @@ -0,0 +1,276 @@ +import { __awaiter } from "tslib"; +import { bindLifecycleEvents } from '../../providers/angular-delegate'; +import { computeStackId, destroyView, getUrl, insertView, isTabSwitch, toSegments, } from './stack-utils'; +// TODO(FW-2827): types +export class StackController { + constructor(tabsPrefix, containerEl, router, navCtrl, zone, location) { + this.containerEl = containerEl; + this.router = router; + this.navCtrl = navCtrl; + this.zone = zone; + this.location = location; + this.views = []; + this.skipTransition = false; + this.nextId = 0; + this.tabsPrefix = tabsPrefix !== undefined ? toSegments(tabsPrefix) : undefined; + } + createView(ref, activatedRoute) { + var _a; + const url = getUrl(this.router, activatedRoute); + const element = (_a = ref === null || ref === void 0 ? void 0 : ref.location) === null || _a === void 0 ? void 0 : _a.nativeElement; + const unlistenEvents = bindLifecycleEvents(this.zone, ref.changeDetectorRef, ref.instance, element); + return { + id: this.nextId++, + stackId: computeStackId(this.tabsPrefix, url), + unlistenEvents, + element, + ref, + url, + }; + } + getExistingView(activatedRoute) { + const activatedUrlKey = getUrl(this.router, activatedRoute); + const view = this.views.find((vw) => vw.url === activatedUrlKey); + if (view) { + view.ref.changeDetectorRef.reattach(); + } + return view; + } + setActive(enteringView) { + var _a, _b; + const consumeResult = this.navCtrl.consumeTransition(); + let { direction, animation, animationBuilder } = consumeResult; + const leavingView = this.activeView; + const tabSwitch = isTabSwitch(enteringView, leavingView); + if (tabSwitch) { + direction = 'back'; + animation = undefined; + } + const viewsSnapshot = this.views.slice(); + let currentNavigation; + const router = this.router; + // Angular >= 7.2.0 + if (router.getCurrentNavigation) { + currentNavigation = router.getCurrentNavigation(); + // Angular < 7.2.0 + } + else if ((_a = router.navigations) === null || _a === void 0 ? void 0 : _a.value) { + currentNavigation = router.navigations.value; + } + /** + * If the navigation action + * sets `replaceUrl: true` + * then we need to make sure + * we remove the last item + * from our views stack + */ + if ((_b = currentNavigation === null || currentNavigation === void 0 ? void 0 : currentNavigation.extras) === null || _b === void 0 ? void 0 : _b.replaceUrl) { + if (this.views.length > 0) { + this.views.splice(-1, 1); + } + } + const reused = this.views.includes(enteringView); + const views = this.insertView(enteringView, direction); + // Trigger change detection before transition starts + // This will call ngOnInit() the first time too, just after the view + // was attached to the dom, but BEFORE the transition starts + if (!reused) { + enteringView.ref.changeDetectorRef.detectChanges(); + } + /** + * If we are going back from a page that + * was presented using a custom animation + * we should default to using that + * unless the developer explicitly + * provided another animation. + */ + const customAnimation = enteringView.animationBuilder; + if (animationBuilder === undefined && direction === 'back' && !tabSwitch && customAnimation !== undefined) { + animationBuilder = customAnimation; + } + /** + * Save any custom animation so that navigating + * back will use this custom animation by default. + */ + if (leavingView) { + leavingView.animationBuilder = animationBuilder; + } + // Wait until previous transitions finish + return this.zone.runOutsideAngular(() => { + return this.wait(() => { + // disconnect leaving page from change detection to + // reduce jank during the page transition + if (leavingView) { + leavingView.ref.changeDetectorRef.detach(); + } + // In case the enteringView is the same as the leavingPage we need to reattach() + enteringView.ref.changeDetectorRef.reattach(); + return this.transition(enteringView, leavingView, animation, this.canGoBack(1), false, animationBuilder) + .then(() => cleanupAsync(enteringView, views, viewsSnapshot, this.location, this.zone)) + .then(() => ({ + enteringView, + direction, + animation, + tabSwitch, + })); + }); + }); + } + canGoBack(deep, stackId = this.getActiveStackId()) { + return this.getStack(stackId).length > deep; + } + pop(deep, stackId = this.getActiveStackId()) { + return this.zone.run(() => { + var _a, _b; + const views = this.getStack(stackId); + if (views.length <= deep) { + return Promise.resolve(false); + } + const view = views[views.length - deep - 1]; + let url = view.url; + const viewSavedData = view.savedData; + if (viewSavedData) { + const primaryOutlet = viewSavedData.get('primary'); + if ((_b = (_a = primaryOutlet === null || primaryOutlet === void 0 ? void 0 : primaryOutlet.route) === null || _a === void 0 ? void 0 : _a._routerState) === null || _b === void 0 ? void 0 : _b.snapshot.url) { + url = primaryOutlet.route._routerState.snapshot.url; + } + } + const { animationBuilder } = this.navCtrl.consumeTransition(); + return this.navCtrl.navigateBack(url, Object.assign(Object.assign({}, view.savedExtras), { animation: animationBuilder })).then(() => true); + }); + } + startBackTransition() { + const leavingView = this.activeView; + if (leavingView) { + const views = this.getStack(leavingView.stackId); + const enteringView = views[views.length - 2]; + const customAnimation = enteringView.animationBuilder; + return this.wait(() => { + return this.transition(enteringView, // entering view + leavingView, // leaving view + 'back', this.canGoBack(2), true, customAnimation); + }); + } + return Promise.resolve(); + } + endBackTransition(shouldComplete) { + if (shouldComplete) { + this.skipTransition = true; + this.pop(1); + } + else if (this.activeView) { + cleanup(this.activeView, this.views, this.views, this.location, this.zone); + } + } + getLastUrl(stackId) { + const views = this.getStack(stackId); + return views.length > 0 ? views[views.length - 1] : undefined; + } + /** + * @internal + */ + getRootUrl(stackId) { + const views = this.getStack(stackId); + return views.length > 0 ? views[0] : undefined; + } + getActiveStackId() { + return this.activeView ? this.activeView.stackId : undefined; + } + /** + * @internal + */ + getActiveView() { + return this.activeView; + } + hasRunningTask() { + return this.runningTask !== undefined; + } + destroy() { + this.containerEl = undefined; + this.views.forEach(destroyView); + this.activeView = undefined; + this.views = []; + } + getStack(stackId) { + return this.views.filter((v) => v.stackId === stackId); + } + insertView(enteringView, direction) { + this.activeView = enteringView; + this.views = insertView(this.views, enteringView, direction); + return this.views.slice(); + } + transition(enteringView, leavingView, direction, showGoBack, progressAnimation, animationBuilder) { + if (this.skipTransition) { + this.skipTransition = false; + return Promise.resolve(false); + } + if (leavingView === enteringView) { + return Promise.resolve(false); + } + const enteringEl = enteringView ? enteringView.element : undefined; + const leavingEl = leavingView ? leavingView.element : undefined; + const containerEl = this.containerEl; + if (enteringEl && enteringEl !== leavingEl) { + enteringEl.classList.add('ion-page'); + enteringEl.classList.add('ion-page-invisible'); + if (containerEl.commit) { + return containerEl.commit(enteringEl, leavingEl, { + duration: direction === undefined ? 0 : undefined, + direction, + showGoBack, + progressAnimation, + animationBuilder, + }); + } + } + return Promise.resolve(false); + } + wait(task) { + return __awaiter(this, void 0, void 0, function* () { + if (this.runningTask !== undefined) { + yield this.runningTask; + this.runningTask = undefined; + } + const promise = (this.runningTask = task()); + promise.finally(() => (this.runningTask = undefined)); + return promise; + }); + } +} +const cleanupAsync = (activeRoute, views, viewsSnapshot, location, zone) => { + if (typeof requestAnimationFrame === 'function') { + return new Promise((resolve) => { + requestAnimationFrame(() => { + cleanup(activeRoute, views, viewsSnapshot, location, zone); + resolve(); + }); + }); + } + return Promise.resolve(); +}; +const cleanup = (activeRoute, views, viewsSnapshot, location, zone) => { + /** + * Re-enter the Angular zone when destroying page components. This will allow + * lifecycle events (`ngOnDestroy`) to be run inside the Angular zone. + */ + zone.run(() => viewsSnapshot.filter((view) => !views.includes(view)).forEach(destroyView)); + views.forEach((view) => { + /** + * In the event that a user navigated multiple + * times in rapid succession, we want to make sure + * we don't pre-emptively detach a view while + * it is in mid-transition. + * + * In this instance we also do not care about query + * params or fragments as it will be the same view regardless + */ + const locationWithoutParams = location.path().split('?')[0]; + const locationWithoutFragment = locationWithoutParams.split('#')[0]; + if (view !== activeRoute && view.url !== locationWithoutFragment) { + const element = view.element; + element.setAttribute('aria-hidden', 'true'); + element.classList.add('ion-page-hidden'); + view.ref.changeDetectorRef.detach(); + } + }); +}; diff --git a/packages/angular/build/es2015/common/src/directives/navigation/stack-utils.js b/packages/angular/build/es2015/common/src/directives/navigation/stack-utils.js new file mode 100644 index 00000000000..28307e82711 --- /dev/null +++ b/packages/angular/build/es2015/common/src/directives/navigation/stack-utils.js @@ -0,0 +1,72 @@ +export const insertView = (views, view, direction) => { + if (direction === 'root') { + return setRoot(views, view); + } + else if (direction === 'forward') { + return setForward(views, view); + } + else { + return setBack(views, view); + } +}; +const setRoot = (views, view) => { + views = views.filter((v) => v.stackId !== view.stackId); + views.push(view); + return views; +}; +const setForward = (views, view) => { + const index = views.indexOf(view); + if (index >= 0) { + views = views.filter((v) => v.stackId !== view.stackId || v.id <= view.id); + } + else { + views.push(view); + } + return views; +}; +const setBack = (views, view) => { + const index = views.indexOf(view); + if (index >= 0) { + return views.filter((v) => v.stackId !== view.stackId || v.id <= view.id); + } + else { + return setRoot(views, view); + } +}; +export const getUrl = (router, activatedRoute) => { + const urlTree = router.createUrlTree(['.'], { relativeTo: activatedRoute }); + return router.serializeUrl(urlTree); +}; +export const isTabSwitch = (enteringView, leavingView) => { + if (!leavingView) { + return true; + } + return enteringView.stackId !== leavingView.stackId; +}; +export const computeStackId = (prefixUrl, url) => { + if (!prefixUrl) { + return undefined; + } + const segments = toSegments(url); + for (let i = 0; i < segments.length; i++) { + if (i >= prefixUrl.length) { + return segments[i]; + } + if (segments[i] !== prefixUrl[i]) { + return undefined; + } + } + return undefined; +}; +export const toSegments = (path) => { + return path + .split('/') + .map((s) => s.trim()) + .filter((s) => s !== ''); +}; +export const destroyView = (view) => { + if (view) { + view.ref.destroy(); + view.unlistenEvents(); + } +}; diff --git a/packages/angular/build/es2015/common/src/directives/navigation/tabs.js b/packages/angular/build/es2015/common/src/directives/navigation/tabs.js new file mode 100644 index 00000000000..1dcebfe28ac --- /dev/null +++ b/packages/angular/build/es2015/common/src/directives/navigation/tabs.js @@ -0,0 +1,277 @@ +import { __decorate } from "tslib"; +import { Directive, ElementRef, EventEmitter, HostListener, Output, ViewChild, } from '@angular/core'; +/** + * Extracts `queryParams` and `fragment` from a tab button's href for use + * as Angular `NavigationExtras`. Returns `undefined` when neither is present. + */ +const parseHrefExtras = (href) => { + if (!href) { + return undefined; + } + const hashIndex = href.indexOf('#'); + // Treat a bare `#` (no fragment text) as no fragment. + const fragment = hashIndex >= 0 && hashIndex < href.length - 1 ? href.slice(hashIndex + 1) : undefined; + const beforeHash = hashIndex >= 0 ? href.slice(0, hashIndex) : href; + const queryIndex = beforeHash.indexOf('?'); + const search = queryIndex >= 0 ? beforeHash.slice(queryIndex + 1) : ''; + let queryParams; + if (search) { + const params = new URLSearchParams(search); + queryParams = {}; + for (const key of new Set(params.keys())) { + const all = params.getAll(key); + queryParams[key] = all.length > 1 ? all : all[0]; + } + } + if (!queryParams && fragment === undefined) { + return undefined; + } + /** + * Build the result with only the populated keys so that a spread of the + * returned object does not overwrite saved `queryParams`/`fragment` with + * `undefined` (which `Object.assign`/spread would copy as a real key). + */ + const extras = {}; + if (queryParams) + extras.queryParams = queryParams; + if (fragment !== undefined) + extras.fragment = fragment; + return extras; +}; +let IonTabs = class IonTabs { + constructor(navCtrl) { + this.navCtrl = navCtrl; + /** + * Emitted before the tab view is changed. + */ + this.ionTabsWillChange = new EventEmitter(); + /** + * Emitted after the tab view is changed. + */ + this.ionTabsDidChange = new EventEmitter(); + this.tabBarSlot = 'bottom'; + this.hasTab = false; + } + ngAfterViewInit() { + /** + * Developers must pass at least one ion-tab + * inside of ion-tabs if they want to use a + * basic tab-based navigation without the + * history stack or URL updates associated + * with the router. + */ + const firstTab = this.tabs.length > 0 ? this.tabs.first : undefined; + if (firstTab) { + this.hasTab = true; + this.setActiveTab(firstTab.tab); + this.tabSwitch(); + } + } + ngAfterContentInit() { + this.detectSlotChanges(); + } + ngAfterContentChecked() { + this.detectSlotChanges(); + } + /** + * @internal + */ + onStackWillChange({ enteringView, tabSwitch }) { + const stackId = enteringView.stackId; + if (tabSwitch && stackId !== undefined) { + this.ionTabsWillChange.emit({ tab: stackId }); + } + } + /** + * @internal + */ + onStackDidChange({ enteringView, tabSwitch }) { + const stackId = enteringView.stackId; + if (tabSwitch && stackId !== undefined) { + if (this.tabBar) { + this.tabBar.selectedTab = stackId; + } + this.ionTabsDidChange.emit({ tab: stackId }); + } + } + /** + * Host listener for the `ionTabButtonClick` event. Angular 22 enabled stricter + * host-binding type checking, which types `$event` as the DOM `Event`. That is + * not assignable to `select`'s public `string | CustomEvent` parameter, so this + * thin wrapper narrows the event before forwarding to keep `select`'s public + * signature intact. + */ + onTabButtonClick(ev) { + return this.select(ev); + } + /** + * When a tab button is clicked, there are several scenarios: + * 1. If the selected tab is currently active (the tab button has been clicked + * again), then it should go to the root view for that tab. + * + * a. Get the saved root view from the router outlet. If the saved root view + * matches the tabRootUrl, set the route view to this view including the + * navigation extras. Any `queryParams` or `fragment` declared on the tab + * button's `href` are also forwarded. + * b. If the saved root view from the router outlet does not match, navigate + * to the tabRootUrl, forwarding any `queryParams`/`fragment` declared on + * the tab button's `href`. + * + * 2. If the current tab tab is not currently selected, get the last route + * view from the router outlet. + * + * a. If the last route view exists, navigate to that view including any + * navigation extras. + * b. If the last route view doesn't exist, then navigate to the default + * tabRootUrl, forwarding any `queryParams`/`fragment` declared on the + * tab button's `href`. + */ + select(tabOrEvent) { + var _a; + const isTabString = typeof tabOrEvent === 'string'; + const tab = isTabString ? tabOrEvent : tabOrEvent.detail.tab; + const href = isTabString ? undefined : tabOrEvent.detail.href; + /** + * If the tabs are not using the router, then + * the tab switch logic is handled by the tabs + * component itself. + */ + if (this.hasTab) { + this.setActiveTab(tab); + this.tabSwitch(); + return; + } + const alreadySelected = this.outlet.getActiveStackId() === tab; + const tabRootUrl = `${this.outlet.tabsPrefix}/${tab}`; + /** + * The href pathname is ignored here; tab routing is driven by `tabsPrefix/tab`. + * Only the query and fragment are forwarded as navigation extras. + */ + const hrefExtras = parseHrefExtras(href); + /** + * If this is a nested tab, prevent the event + * from bubbling otherwise the outer tabs + * will respond to this event too, causing + * the app to get directed to the wrong place. + */ + if (!isTabString) { + tabOrEvent.stopPropagation(); + } + if (alreadySelected) { + const activeStackId = this.outlet.getActiveStackId(); + const activeView = this.outlet.getLastRouteView(activeStackId); + // If on root tab, do not navigate to root tab again + if ((activeView === null || activeView === void 0 ? void 0 : activeView.url) === tabRootUrl) { + return; + } + const rootView = this.outlet.getRootView(tab); + // Keep the explicit rootView null-guard; an optional-chain rewrite changes the short-circuit value spread below. + // eslint-disable-next-line @typescript-eslint/prefer-optional-chain + const navigationExtras = rootView && tabRootUrl === rootView.url && rootView.savedExtras; + return this.navCtrl.navigateRoot(tabRootUrl, Object.assign(Object.assign(Object.assign({}, navigationExtras), hrefExtras), { animated: true, animationDirection: 'back' })); + } + else { + const lastRoute = this.outlet.getLastRouteView(tab); + /** + * If there is a lastRoute, goto that, otherwise goto the fallback url of the + * selected tab. When falling back to the tab root, honor query params and + * fragment declared on the tab button's href. + */ + const url = (lastRoute === null || lastRoute === void 0 ? void 0 : lastRoute.url) || tabRootUrl; + const navigationExtras = (_a = lastRoute === null || lastRoute === void 0 ? void 0 : lastRoute.savedExtras) !== null && _a !== void 0 ? _a : (url === tabRootUrl ? hrefExtras : undefined); + return this.navCtrl.navigateRoot(url, Object.assign(Object.assign({}, navigationExtras), { animated: true, animationDirection: 'back' })); + } + } + setActiveTab(tab) { + const tabs = this.tabs; + const selectedTab = tabs.find((t) => t.tab === tab); + if (!selectedTab) { + console.error(`[Ionic Error]: Tab with id: "${tab}" does not exist`); + return; + } + this.leavingTab = this.selectedTab; + this.selectedTab = selectedTab; + this.ionTabsWillChange.emit({ tab }); + selectedTab.el.active = true; + } + tabSwitch() { + const { selectedTab, leavingTab } = this; + if (this.tabBar && selectedTab) { + this.tabBar.selectedTab = selectedTab.tab; + } + if ((leavingTab === null || leavingTab === void 0 ? void 0 : leavingTab.tab) !== (selectedTab === null || selectedTab === void 0 ? void 0 : selectedTab.tab)) { + if (leavingTab === null || leavingTab === void 0 ? void 0 : leavingTab.el) { + leavingTab.el.active = false; + } + } + if (selectedTab) { + this.ionTabsDidChange.emit({ tab: selectedTab.tab }); + } + } + getSelected() { + var _a; + if (this.hasTab) { + return (_a = this.selectedTab) === null || _a === void 0 ? void 0 : _a.tab; + } + return this.outlet.getActiveStackId(); + } + /** + * Detects changes to the slot attribute of the tab bar. + * + * If the slot attribute has changed, then the tab bar + * should be relocated to the new slot position. + */ + detectSlotChanges() { + this.tabBars.forEach((tabBar) => { + // el is a protected attribute from the generated component wrapper + const currentSlot = tabBar.el.getAttribute('slot'); + if (currentSlot !== this.tabBarSlot) { + this.tabBarSlot = currentSlot; + this.relocateTabBar(); + } + }); + } + /** + * Relocates the tab bar to the new slot position. + */ + relocateTabBar() { + /** + * `el` is a protected attribute from the generated component wrapper. + * To avoid having to manually create the wrapper for tab bar, we + * cast the tab bar to any and access the protected attribute. + */ + const tabBar = this.tabBar.el; + if (this.tabBarSlot === 'top') { + /** + * A tab bar with a slot of "top" should be inserted + * at the top of the container. + */ + this.tabsInner.nativeElement.before(tabBar); + } + else { + /** + * A tab bar with a slot of "bottom" or without a slot + * should be inserted at the end of the container. + */ + this.tabsInner.nativeElement.after(tabBar); + } + } +}; +__decorate([ + ViewChild('tabsInner', { read: ElementRef, static: true }) +], IonTabs.prototype, "tabsInner", void 0); +__decorate([ + Output() +], IonTabs.prototype, "ionTabsWillChange", void 0); +__decorate([ + Output() +], IonTabs.prototype, "ionTabsDidChange", void 0); +__decorate([ + HostListener('ionTabButtonClick', ['$event']) +], IonTabs.prototype, "onTabButtonClick", null); +IonTabs = __decorate([ + Directive({ + selector: 'ion-tabs', + }) +], IonTabs); +export { IonTabs }; diff --git a/packages/angular/build/es2015/common/src/index.js b/packages/angular/build/es2015/common/src/index.js new file mode 100644 index 00000000000..5f65e2a135b --- /dev/null +++ b/packages/angular/build/es2015/common/src/index.js @@ -0,0 +1,19 @@ +export { DomController } from './providers/dom-controller'; +export { MenuController } from './providers/menu-controller'; +export { NavController } from './providers/nav-controller'; +export { Config, ConfigToken } from './providers/config'; +export { Platform } from './providers/platform'; +export { AngularDelegate, IonModalToken } from './providers/angular-delegate'; +export { NavParams } from './directives/navigation/nav-params'; +export { IonModal } from './overlays/modal'; +export { IonPopover } from './overlays/popover'; +export { IonRouterOutlet, provideComponentInputBinding } from './directives/navigation/router-outlet'; +export * from './directives/control-value-accessors'; +export { IonBackButton } from './directives/navigation/back-button'; +export { IonNav } from './directives/navigation/nav'; +export { RouterLinkDelegateDirective, RouterLinkWithHrefDelegateDirective, } from './directives/navigation/router-link-delegate'; +export { IonTabs } from './directives/navigation/tabs'; +export { ProxyCmp } from './utils/proxy'; +export { OverlayBaseController } from './utils/overlay'; +export { IonicRouteStrategy } from './utils/routing'; +export { raf } from './utils/util'; diff --git a/packages/angular/build/es2015/common/src/overlays/modal.js b/packages/angular/build/es2015/common/src/overlays/modal.js new file mode 100644 index 00000000000..6d78b0b516d --- /dev/null +++ b/packages/angular/build/es2015/common/src/overlays/modal.js @@ -0,0 +1,86 @@ +import { __decorate } from "tslib"; +import { ContentChild, Directive, TemplateRef, } from '@angular/core'; +import { ProxyCmp, proxyOutputs } from '../utils/proxy'; +const MODAL_INPUTS = [ + 'animated', + 'keepContentsMounted', + 'backdropBreakpoint', + 'backdropDismiss', + 'breakpoints', + 'canDismiss', + 'cssClass', + 'enterAnimation', + 'expandToScroll', + 'event', + 'focusTrap', + 'handle', + 'handleBehavior', + 'initialBreakpoint', + 'isOpen', + 'keyboardClose', + 'leaveAnimation', + 'mode', + 'presentingElement', + 'showBackdrop', + 'translucent', + 'trigger', +]; +const MODAL_METHODS = [ + 'present', + 'dismiss', + 'onDidDismiss', + 'onWillDismiss', + 'setCurrentBreakpoint', + 'getCurrentBreakpoint', +]; +let IonModal = class IonModal { + constructor(c, r, z) { + this.z = z; + this.isCmpOpen = false; + this.el = r.nativeElement; + this.el.addEventListener('ionMount', () => { + this.isCmpOpen = true; + c.detectChanges(); + }); + this.el.addEventListener('didDismiss', () => { + this.isCmpOpen = false; + c.detectChanges(); + }); + proxyOutputs(this, this.el, [ + 'ionModalDidPresent', + 'ionModalWillPresent', + 'ionModalWillDismiss', + 'ionModalDidDismiss', + 'ionBreakpointDidChange', + 'didPresent', + 'willPresent', + 'willDismiss', + 'didDismiss', + 'ionDragStart', + 'ionDragMove', + 'ionDragEnd', + ]); + } +}; +__decorate([ + ContentChild(TemplateRef, { static: false }) +], IonModal.prototype, "template", void 0); +IonModal = __decorate([ + ProxyCmp({ + inputs: MODAL_INPUTS, + methods: MODAL_METHODS, + }) + /** + * @Component extends from @Directive + * so by defining the inputs here we + * do not need to re-define them for the + * lazy loaded popover. + */ + , + Directive({ + selector: 'ion-modal', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: MODAL_INPUTS, + }) +], IonModal); +export { IonModal }; diff --git a/packages/angular/build/es2015/common/src/overlays/popover.js b/packages/angular/build/es2015/common/src/overlays/popover.js new file mode 100644 index 00000000000..c02874deef3 --- /dev/null +++ b/packages/angular/build/es2015/common/src/overlays/popover.js @@ -0,0 +1,74 @@ +import { __decorate } from "tslib"; +import { ContentChild, Directive, TemplateRef, } from '@angular/core'; +import { ProxyCmp, proxyOutputs } from '../utils/proxy'; +const POPOVER_INPUTS = [ + 'alignment', + 'animated', + 'arrow', + 'keepContentsMounted', + 'backdropDismiss', + 'cssClass', + 'dismissOnSelect', + 'enterAnimation', + 'event', + 'focusTrap', + 'isOpen', + 'keyboardClose', + 'leaveAnimation', + 'mode', + 'showBackdrop', + 'translucent', + 'trigger', + 'triggerAction', + 'reference', + 'size', + 'side', +]; +const POPOVER_METHODS = ['present', 'dismiss', 'onDidDismiss', 'onWillDismiss']; +let IonPopover = class IonPopover { + constructor(c, r, z) { + this.z = z; + this.isCmpOpen = false; + this.el = r.nativeElement; + this.el.addEventListener('ionMount', () => { + this.isCmpOpen = true; + c.detectChanges(); + }); + this.el.addEventListener('didDismiss', () => { + this.isCmpOpen = false; + c.detectChanges(); + }); + proxyOutputs(this, this.el, [ + 'ionPopoverDidPresent', + 'ionPopoverWillPresent', + 'ionPopoverWillDismiss', + 'ionPopoverDidDismiss', + 'didPresent', + 'willPresent', + 'willDismiss', + 'didDismiss', + ]); + } +}; +__decorate([ + ContentChild(TemplateRef, { static: false }) +], IonPopover.prototype, "template", void 0); +IonPopover = __decorate([ + ProxyCmp({ + inputs: POPOVER_INPUTS, + methods: POPOVER_METHODS, + }) + /** + * @Component extends from @Directive + * so by defining the inputs here we + * do not need to re-define them for the + * lazy loaded popover. + */ + , + Directive({ + selector: 'ion-popover', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: POPOVER_INPUTS, + }) +], IonPopover); +export { IonPopover }; diff --git a/packages/angular/build/es2015/common/src/providers/angular-delegate.js b/packages/angular/build/es2015/common/src/providers/angular-delegate.js new file mode 100644 index 00000000000..3a8f0274f93 --- /dev/null +++ b/packages/angular/build/es2015/common/src/providers/angular-delegate.js @@ -0,0 +1,221 @@ +import { __decorate, __rest } from "tslib"; +import { ApplicationRef, createComponent, inject, Injectable, InjectionToken, Injector, NgZone, } from '@angular/core'; +import { LIFECYCLE_DID_ENTER, LIFECYCLE_DID_LEAVE, LIFECYCLE_WILL_ENTER, LIFECYCLE_WILL_LEAVE, LIFECYCLE_WILL_UNLOAD, } from '@ionic/core/components'; +import { NavParams } from '../directives/navigation/nav-params'; +import { ConfigToken } from './config'; +// Token for injecting the modal element +export const IonModalToken = new InjectionToken('IonModalToken'); +// TODO(FW-2827): types +let AngularDelegate = class AngularDelegate { + constructor() { + this.zone = inject(NgZone); + this.applicationRef = inject(ApplicationRef); + this.config = inject(ConfigToken); + } + create(environmentInjector, injector, elementReferenceKey, customInjector) { + var _a; + return new AngularFrameworkDelegate(environmentInjector, injector, this.applicationRef, this.zone, elementReferenceKey, (_a = this.config.useSetInputAPI) !== null && _a !== void 0 ? _a : false, customInjector); + } +}; +AngularDelegate = __decorate([ + Injectable() +], AngularDelegate); +export { AngularDelegate }; +export class AngularFrameworkDelegate { + constructor(environmentInjector, injector, applicationRef, zone, elementReferenceKey, enableSignalsSupport, customInjector) { + this.environmentInjector = environmentInjector; + this.injector = injector; + this.applicationRef = applicationRef; + this.zone = zone; + this.elementReferenceKey = elementReferenceKey; + this.enableSignalsSupport = enableSignalsSupport; + this.customInjector = customInjector; + this.elRefMap = new WeakMap(); + this.elEventsMap = new WeakMap(); + } + attachViewToDom(container, component, params, cssClasses) { + return this.zone.run(() => { + return new Promise((resolve) => { + const componentProps = Object.assign({}, params); + /** + * Ionic Angular passes a reference to a modal + * or popover that can be accessed using a + * variable in the overlay component. If + * elementReferenceKey is defined, then we should + * pass a reference to the component using + * elementReferenceKey as the key. + */ + if (this.elementReferenceKey !== undefined) { + componentProps[this.elementReferenceKey] = container; + } + const el = attachView(this.zone, this.environmentInjector, this.injector, this.applicationRef, this.elRefMap, this.elEventsMap, container, component, componentProps, cssClasses, this.elementReferenceKey, this.enableSignalsSupport, this.customInjector); + resolve(el); + }); + }); + } + removeViewFromDom(_container, component) { + return this.zone.run(() => { + return new Promise((resolve) => { + const componentRef = this.elRefMap.get(component); + if (componentRef) { + componentRef.destroy(); + this.elRefMap.delete(component); + const unbindEvents = this.elEventsMap.get(component); + if (unbindEvents) { + unbindEvents(); + this.elEventsMap.delete(component); + } + } + resolve(); + }); + }); + } +} +export const attachView = (zone, environmentInjector, injector, applicationRef, elRefMap, elEventsMap, container, component, params, cssClasses, elementReferenceKey, enableSignalsSupport, customInjector) => { + /** + * Wraps the injector with a custom injector that + * provides NavParams to the component. + * + * NavParams is a legacy feature from Ionic v3 that allows + * Angular developers to provide data to a component + * and access it by providing NavParams as a dependency + * in the constructor. + * + * The modern approach is to access the data directly + * from the component's class instance. + */ + const providers = getProviders(params); + // If this is an ion-modal, provide the modal element as an injectable + // so components inside the modal can inject it directly + if (container.tagName.toLowerCase() === 'ion-modal') { + providers.push({ + provide: IonModalToken, + useValue: container, + }); + } + const childInjector = Injector.create({ + providers, + parent: customInjector !== null && customInjector !== void 0 ? customInjector : injector, + }); + const componentRef = createComponent(component, { + environmentInjector, + elementInjector: childInjector, + }); + const instance = componentRef.instance; + const hostElement = componentRef.location.nativeElement; + if (params) { + /** + * For modals and popovers, a reference to the component is + * added to `params` during the call to attachViewToDom. If + * a reference using this name is already set, this means + * the app is trying to use the name as a component prop, + * which will cause collisions. + */ + if (elementReferenceKey && instance[elementReferenceKey] !== undefined) { + console.error(`[Ionic Error]: ${elementReferenceKey} is a reserved property when using ${container.tagName.toLowerCase()}. Rename or remove the "${elementReferenceKey}" property from ${component.name}.`); + } + /** + * Angular 14.1 added support for setInput + * so we need to fall back to Object.assign + * for Angular 14.0. + */ + if (enableSignalsSupport === true && componentRef.setInput !== undefined) { + const { modal, popover } = params, otherParams = __rest(params, ["modal", "popover"]); + /** + * Any key/value pairs set in componentProps + * must be set as inputs on the component instance. + */ + for (const key in otherParams) { + componentRef.setInput(key, otherParams[key]); + } + /** + * Using setInput will cause an error when + * setting modal/popover on a component that + * does not define them as an input. For backwards + * compatibility purposes we fall back to using + * Object.assign for these properties. + */ + if (modal !== undefined) { + Object.assign(instance, { modal }); + } + if (popover !== undefined) { + Object.assign(instance, { popover }); + } + } + else { + Object.assign(instance, params); + } + } + if (cssClasses) { + for (const cssClass of cssClasses) { + hostElement.classList.add(cssClass); + } + } + const unbindEvents = bindLifecycleEvents(zone, componentRef.changeDetectorRef, instance, hostElement); + container.appendChild(hostElement); + applicationRef.attachView(componentRef.hostView); + /** + * Run change detection on the freshly attached view so Angular's init hooks + * (`ngOnInit`, `ngAfterViewInit`) fire and template bindings (e.g. + * ``) apply during this synchronous pass, before the + * web component runs its load lifecycle and dispatches its Ionic lifecycle events + * (`ionViewWillEnter`, etc.). `createComponent` only runs the creation pass; the + * init hooks and binding updates run during an update pass. Under Zone.js an + * implicit tick used to cover this, but zoneless Angular schedules no such tick, + * so without this the binding could land after the element has loaded (too late + * for `ion-nav` to read it) and the first `ionViewWillEnter` could run before + * `ngOnInit`. + */ + componentRef.changeDetectorRef.detectChanges(); + elRefMap.set(hostElement, componentRef); + elEventsMap.set(hostElement, unbindEvents); + return hostElement; +}; +const LIFECYCLES = [ + LIFECYCLE_WILL_ENTER, + LIFECYCLE_DID_ENTER, + LIFECYCLE_WILL_LEAVE, + LIFECYCLE_DID_LEAVE, + LIFECYCLE_WILL_UNLOAD, +]; +export const bindLifecycleEvents = (zone, changeDetectorRef, instance, element) => { + /** + * `zone.run` keeps the listener registration (and, under Zone.js, the handler + * execution) inside the Angular zone, so async work started inside a lifecycle + * hook is still zone-tracked. Under zoneless Angular it is a passthrough. + */ + return zone.run(() => { + const unregisters = LIFECYCLES.filter((eventName) => typeof instance[eventName] === 'function').map((eventName) => { + const handler = (ev) => { + instance[eventName](ev.detail); + /** + * Ionic lifecycle events (`ionViewWillEnter`, etc.) are dispatched from + * the web component via a native event listener, so under zoneless + * Angular nothing schedules change detection for state the hook mutates. + * Mark the view dirty explicitly. This is a no-op-or-better under Zone.js. + */ + changeDetectorRef.markForCheck(); + }; + element.addEventListener(eventName, handler); + return () => element.removeEventListener(eventName, handler); + }); + return () => unregisters.forEach((fn) => fn()); + }); +}; +const NavParamsToken = new InjectionToken('NavParamsToken'); +const getProviders = (params) => { + return [ + { + provide: NavParamsToken, + useValue: params, + }, + { + provide: NavParams, + useFactory: provideNavParamsInjectable, + deps: [NavParamsToken], + }, + ]; +}; +const provideNavParamsInjectable = (params) => { + return new NavParams(params); +}; diff --git a/packages/angular/build/es2015/common/src/providers/config.js b/packages/angular/build/es2015/common/src/providers/config.js new file mode 100644 index 00000000000..a69c669caa6 --- /dev/null +++ b/packages/angular/build/es2015/common/src/providers/config.js @@ -0,0 +1,41 @@ +import { __decorate } from "tslib"; +import { Injectable, InjectionToken } from '@angular/core'; +let Config = class Config { + get(key, fallback) { + const c = getConfig(); + if (c) { + return c.get(key, fallback); + } + return null; + } + getBoolean(key, fallback) { + const c = getConfig(); + if (c) { + return c.getBoolean(key, fallback); + } + return false; + } + getNumber(key, fallback) { + const c = getConfig(); + if (c) { + return c.getNumber(key, fallback); + } + return 0; + } +}; +Config = __decorate([ + Injectable({ + providedIn: 'root', + }) +], Config); +export { Config }; +export const ConfigToken = new InjectionToken('USERCONFIG'); +const getConfig = () => { + if (typeof window !== 'undefined') { + const Ionic = window.Ionic; + if (Ionic === null || Ionic === void 0 ? void 0 : Ionic.config) { + return Ionic.config; + } + } + return null; +}; diff --git a/packages/angular/build/es2015/common/src/providers/dom-controller.js b/packages/angular/build/es2015/common/src/providers/dom-controller.js new file mode 100644 index 00000000000..b91895997f3 --- /dev/null +++ b/packages/angular/build/es2015/common/src/providers/dom-controller.js @@ -0,0 +1,41 @@ +import { __decorate } from "tslib"; +import { Injectable } from '@angular/core'; +let DomController = class DomController { + /** + * Schedules a task to run during the READ phase of the next frame. + * This task should only read the DOM, but never modify it. + */ + read(cb) { + getQueue().read(cb); + } + /** + * Schedules a task to run during the WRITE phase of the next frame. + * This task should write the DOM, but never READ it. + */ + write(cb) { + getQueue().write(cb); + } +}; +DomController = __decorate([ + Injectable({ + providedIn: 'root', + }) +], DomController); +export { DomController }; +const getQueue = () => { + const win = typeof window !== 'undefined' ? window : null; + if (win != null) { + const Ionic = win.Ionic; + if (Ionic === null || Ionic === void 0 ? void 0 : Ionic.queue) { + return Ionic.queue; + } + return { + read: (cb) => win.requestAnimationFrame(cb), + write: (cb) => win.requestAnimationFrame(cb), + }; + } + return { + read: (cb) => cb(), + write: (cb) => cb(), + }; +}; diff --git a/packages/angular/build/es2015/common/src/providers/menu-controller.js b/packages/angular/build/es2015/common/src/providers/menu-controller.js new file mode 100644 index 00000000000..b9758f912d3 --- /dev/null +++ b/packages/angular/build/es2015/common/src/providers/menu-controller.js @@ -0,0 +1,112 @@ +export class MenuController { + constructor(menuController) { + this.menuController = menuController; + } + /** + * Programmatically open the Menu. + * @param [menuId] Optionally get the menu by its id, or side. + * @return returns a promise when the menu is fully opened + */ + open(menuId) { + return this.menuController.open(menuId); + } + /** + * Programmatically close the Menu. If no `menuId` is given as the first + * argument then it'll close any menu which is open. If a `menuId` + * is given then it'll close that exact menu. + * @param [menuId] Optionally get the menu by its id, or side. + * @return returns a promise when the menu is fully closed + */ + close(menuId) { + return this.menuController.close(menuId); + } + /** + * Toggle the menu. If it's closed, it will open, and if opened, it + * will close. + * @param [menuId] Optionally get the menu by its id, or side. + * @return returns a promise when the menu has been toggled + */ + toggle(menuId) { + return this.menuController.toggle(menuId); + } + /** + * Used to enable or disable a menu. For example, there could be multiple + * left menus, but only one of them should be able to be opened at the same + * time. If there are multiple menus on the same side, then enabling one menu + * will also automatically disable all the others that are on the same side. + * @param [menuId] Optionally get the menu by its id, or side. + * @return Returns the instance of the menu, which is useful for chaining. + */ + enable(shouldEnable, menuId) { + return this.menuController.enable(shouldEnable, menuId); + } + /** + * Used to enable or disable the ability to swipe open the menu. + * @param shouldEnable True if it should be swipe-able, false if not. + * @param [menuId] Optionally get the menu by its id, or side. + * @return Returns the instance of the menu, which is useful for chaining. + */ + swipeGesture(shouldEnable, menuId) { + return this.menuController.swipeGesture(shouldEnable, menuId); + } + /** + * @param [menuId] Optionally get the menu by its id, or side. + * @return Returns true if the specified menu is currently open, otherwise false. + * If the menuId is not specified, it returns true if ANY menu is currenly open. + */ + isOpen(menuId) { + return this.menuController.isOpen(menuId); + } + /** + * @param [menuId] Optionally get the menu by its id, or side. + * @return Returns true if the menu is currently enabled, otherwise false. + */ + isEnabled(menuId) { + return this.menuController.isEnabled(menuId); + } + /** + * Used to get a menu instance. If a `menuId` is not provided then it'll + * return the first menu found. If a `menuId` is `left` or `right`, then + * it'll return the enabled menu on that side. Otherwise, if a `menuId` is + * provided, then it'll try to find the menu using the menu's `id` + * property. If a menu is not found then it'll return `null`. + * @param [menuId] Optionally get the menu by its id, or side. + * @return Returns the instance of the menu if found, otherwise `null`. + */ + get(menuId) { + return this.menuController.get(menuId); + } + /** + * @return Returns the instance of the menu already opened, otherwise `null`. + */ + getOpen() { + return this.menuController.getOpen(); + } + /** + * @return Returns an array of all menu instances. + */ + getMenus() { + return this.menuController.getMenus(); + } + registerAnimation(name, animation) { + return this.menuController.registerAnimation(name, animation); + } + isAnimating() { + return this.menuController.isAnimating(); + } + _getOpenSync() { + return this.menuController._getOpenSync(); + } + _createAnimation(type, menuCmp) { + return this.menuController._createAnimation(type, menuCmp); + } + _register(menu) { + return this.menuController._register(menu); + } + _unregister(menu) { + return this.menuController._unregister(menu); + } + _setOpen(menu, shouldOpen, animated) { + return this.menuController._setOpen(menu, shouldOpen, animated); + } +} diff --git a/packages/angular/build/es2015/common/src/providers/nav-controller.js b/packages/angular/build/es2015/common/src/providers/nav-controller.js new file mode 100644 index 00000000000..f0d197a2d83 --- /dev/null +++ b/packages/angular/build/es2015/common/src/providers/nav-controller.js @@ -0,0 +1,221 @@ +import { __awaiter, __decorate, __param } from "tslib"; +import { Injectable, Optional } from '@angular/core'; +import { NavigationStart, NavigationCancel, NavigationError, } from '@angular/router'; +let NavController = class NavController { + constructor(platform, location, serializer, router) { + this.location = location; + this.serializer = serializer; + this.router = router; + this.direction = DEFAULT_DIRECTION; + this.animated = DEFAULT_ANIMATED; + this.guessDirection = 'forward'; + this.lastNavId = -1; + // Subscribe to router events to detect direction + if (router) { + router.events.subscribe((ev) => { + if (ev instanceof NavigationStart) { + // restoredState is set if the browser back/forward button is used + const id = ev.restoredState ? ev.restoredState.navigationId : ev.id; + this.guessDirection = this.guessAnimation = id < this.lastNavId ? 'back' : 'forward'; + this.lastNavId = this.guessDirection === 'forward' ? ev.id : id; + } + // Reset explicit direction when navigation is canceled (e.g., guard rejection) + // to prevent stale direction from leaking into the next navigation + if (ev instanceof NavigationCancel || ev instanceof NavigationError) { + this.direction = DEFAULT_DIRECTION; + this.animated = DEFAULT_ANIMATED; + this.animationBuilder = undefined; + } + }); + } + // Subscribe to backButton events + platform.backButton.subscribeWithPriority(0, (processNextHandler) => { + this.pop(); + processNextHandler(); + }); + } + /** + * This method uses Angular's [Router](https://angular.io/api/router/Router) under the hood, + * it's equivalent to calling `this.router.navigateByUrl()`, but it's explicit about the **direction** of the transition. + * + * Going **forward** means that a new page is going to be pushed to the stack of the outlet (ion-router-outlet), + * and that it will show a "forward" animation by default. + * + * Navigating forward can also be triggered in a declarative manner by using the `[routerDirection]` directive: + * + * ```html + * Link + * ``` + */ + navigateForward(url, options = {}) { + this.setDirection('forward', options.animated, options.animationDirection, options.animation); + return this.navigate(url, options); + } + /** + * This method uses Angular's [Router](https://angular.io/api/router/Router) under the hood, + * it's equivalent to calling: + * + * ```ts + * this.navController.setDirection('back'); + * this.router.navigateByUrl(path); + * ``` + * + * Going **back** means that all the pages in the stack until the navigated page is found will be popped, + * and that it will show a "back" animation by default. + * + * Navigating back can also be triggered in a declarative manner by using the `[routerDirection]` directive: + * + * ```html + * Link + * ``` + */ + navigateBack(url, options = {}) { + this.setDirection('back', options.animated, options.animationDirection, options.animation); + return this.navigate(url, options); + } + /** + * This method uses Angular's [Router](https://angular.io/api/router/Router) under the hood, + * it's equivalent to calling: + * + * ```ts + * this.navController.setDirection('root'); + * this.router.navigateByUrl(path); + * ``` + * + * Going **root** means that all existing pages in the stack will be removed, + * and the navigated page will become the single page in the stack. + * + * Navigating root can also be triggered in a declarative manner by using the `[routerDirection]` directive: + * + * ```html + * Link + * ``` + */ + navigateRoot(url, options = {}) { + this.setDirection('root', options.animated, options.animationDirection, options.animation); + return this.navigate(url, options); + } + /** + * Same as [Location](https://angular.io/api/common/Location)'s back() method. + * It will use the standard `window.history.back()` under the hood, but featuring a `back` animation + * by default. + */ + back(options = { animated: true, animationDirection: 'back' }) { + this.setDirection('back', options.animated, options.animationDirection, options.animation); + return this.location.back(); + } + /** + * This methods goes back in the context of Ionic's stack navigation. + * + * It recursively finds the top active `ion-router-outlet` and calls `pop()`. + * This is the recommended way to go back when you are using `ion-router-outlet`. + * + * Resolves to `true` if it was able to pop. + */ + pop() { + return __awaiter(this, void 0, void 0, function* () { + let outlet = this.topOutlet; + while (outlet) { + if (yield outlet.pop()) { + return true; + } + else { + outlet = outlet.parentOutlet; + } + } + return false; + }); + } + /** + * This methods specifies the direction of the next navigation performed by the Angular router. + * + * `setDirection()` does not trigger any transition, it just sets some flags to be consumed by `ion-router-outlet`. + * + * It's recommended to use `navigateForward()`, `navigateBack()` and `navigateRoot()` instead of `setDirection()`. + */ + setDirection(direction, animated, animationDirection, animationBuilder) { + this.direction = direction; + this.animated = getAnimation(direction, animated, animationDirection); + this.animationBuilder = animationBuilder; + } + /** + * @internal + */ + setTopOutlet(outlet) { + this.topOutlet = outlet; + } + /** + * @internal + */ + consumeTransition() { + let direction = 'root'; + let animation; + const animationBuilder = this.animationBuilder; + if (this.direction === 'auto') { + direction = this.guessDirection; + animation = this.guessAnimation; + } + else { + animation = this.animated; + direction = this.direction; + } + this.direction = DEFAULT_DIRECTION; + this.animated = DEFAULT_ANIMATED; + this.animationBuilder = undefined; + return { + direction, + animation, + animationBuilder, + }; + } + navigate(url, options) { + if (Array.isArray(url)) { + return this.router.navigate(url, options); + } + else { + /** + * navigateByUrl ignores any properties that + * would change the url, so things like queryParams + * would be ignored unless we create a url tree + * More Info: https://github.com/angular/angular/issues/18798 + */ + const urlTree = this.serializer.parse(url.toString()); + if (options.queryParams !== undefined) { + urlTree.queryParams = Object.assign({}, options.queryParams); + } + if (options.fragment !== undefined) { + urlTree.fragment = options.fragment; + } + /** + * `navigateByUrl` will still apply `NavigationExtras` properties + * that do not modify the url, such as `replaceUrl` which is why + * `options` is passed in here. + */ + return this.router.navigateByUrl(urlTree, options); + } + } +}; +NavController = __decorate([ + Injectable({ + providedIn: 'root', + }), + __param(3, Optional()) +], NavController); +export { NavController }; +const getAnimation = (direction, animated, animationDirection) => { + if (animated === false) { + return undefined; + } + if (animationDirection !== undefined) { + return animationDirection; + } + if (direction === 'forward' || direction === 'back') { + return direction; + } + else if (direction === 'root' && animated === true) { + return 'forward'; + } + return undefined; +}; +const DEFAULT_DIRECTION = 'auto'; +const DEFAULT_ANIMATED = undefined; diff --git a/packages/angular/build/es2015/common/src/providers/platform.js b/packages/angular/build/es2015/common/src/providers/platform.js new file mode 100644 index 00000000000..0ca805ea993 --- /dev/null +++ b/packages/angular/build/es2015/common/src/providers/platform.js @@ -0,0 +1,250 @@ +import { __decorate, __param } from "tslib"; +import { DOCUMENT } from '@angular/common'; +import { Inject, Injectable } from '@angular/core'; +import { getPlatforms, isPlatform } from '@ionic/core/components'; +import { Subject } from 'rxjs'; +let Platform = class Platform { + constructor(doc, zone) { + this.doc = doc; + /** + * @hidden + */ + this.backButton = new Subject(); + /** + * The keyboardDidShow event emits when the + * on-screen keyboard is presented. + */ + this.keyboardDidShow = new Subject(); + /** + * The keyboardDidHide event emits when the + * on-screen keyboard is hidden. + */ + this.keyboardDidHide = new Subject(); + /** + * The pause event emits when the native platform puts the application + * into the background, typically when the user switches to a different + * application. This event would emit when a Cordova app is put into + * the background, however, it would not fire on a standard web browser. + */ + this.pause = new Subject(); + /** + * The resume event emits when the native platform pulls the application + * out from the background. This event would emit when a Cordova app comes + * out from the background, however, it would not fire on a standard web browser. + */ + this.resume = new Subject(); + /** + * The resize event emits when the browser window has changed dimensions. This + * could be from a browser window being physically resized, or from a device + * changing orientation. + */ + this.resize = new Subject(); + zone.run(() => { + var _a; + this.win = doc.defaultView; + this.backButton.subscribeWithPriority = function (priority, callback) { + return this.subscribe((ev) => { + return ev.register(priority, (processNextHandler) => zone.run(() => callback(processNextHandler))); + }); + }; + proxyEvent(this.pause, doc, 'pause', zone); + proxyEvent(this.resume, doc, 'resume', zone); + proxyEvent(this.backButton, doc, 'ionBackButton', zone); + proxyEvent(this.resize, this.win, 'resize', zone); + proxyEvent(this.keyboardDidShow, this.win, 'ionKeyboardDidShow', zone); + proxyEvent(this.keyboardDidHide, this.win, 'ionKeyboardDidHide', zone); + let readyResolve; + this._readyPromise = new Promise((res) => { + readyResolve = res; + }); + if ((_a = this.win) === null || _a === void 0 ? void 0 : _a['cordova']) { + doc.addEventListener('deviceready', () => { + readyResolve('cordova'); + }, { once: true }); + } + else { + readyResolve('dom'); + } + }); + } + /** + * @returns returns true/false based on platform. + * @description + * Depending on the platform the user is on, `is(platformName)` will + * return `true` or `false`. Note that the same app can return `true` + * for more than one platform name. For example, an app running from + * an iPad would return `true` for the platform names: `mobile`, + * `ios`, `ipad`, and `tablet`. Additionally, if the app was running + * from Cordova then `cordova` would be true, and if it was running + * from a web browser on the iPad then `mobileweb` would be `true`. + * + * ``` + * import { Platform } from 'ionic-angular'; + * + * @Component({...}) + * export MyPage { + * constructor(public platform: Platform) { + * if (this.platform.is('ios')) { + * // This will only print when on iOS + * console.log('I am an iOS device!'); + * } + * } + * } + * ``` + * + * | Platform Name | Description | + * |-----------------|------------------------------------| + * | android | on a device running Android. | + * | capacitor | on a device running Capacitor. | + * | cordova | on a device running Cordova. | + * | ios | on a device running iOS. | + * | ipad | on an iPad device. | + * | iphone | on an iPhone device. | + * | phablet | on a phablet device. | + * | tablet | on a tablet device. | + * | electron | in Electron on a desktop device. | + * | pwa | as a PWA app. | + * | mobile | on a mobile device. | + * | mobileweb | on a mobile device in a browser. | + * | desktop | on a desktop device. | + * | hybrid | is a cordova or capacitor app. | + * + */ + is(platformName) { + return isPlatform(this.win, platformName); + } + /** + * @returns the array of platforms + * @description + * Depending on what device you are on, `platforms` can return multiple values. + * Each possible value is a hierarchy of platforms. For example, on an iPhone, + * it would return `mobile`, `ios`, and `iphone`. + * + * ``` + * import { Platform } from 'ionic-angular'; + * + * @Component({...}) + * export MyPage { + * constructor(public platform: Platform) { + * // This will print an array of the current platforms + * console.log(this.platform.platforms()); + * } + * } + * ``` + */ + platforms() { + return getPlatforms(this.win); + } + /** + * Returns a promise when the platform is ready and native functionality + * can be called. If the app is running from within a web browser, then + * the promise will resolve when the DOM is ready. When the app is running + * from an application engine such as Cordova, then the promise will + * resolve when Cordova triggers the `deviceready` event. + * + * The resolved value is the `readySource`, which states which platform + * ready was used. For example, when Cordova is ready, the resolved ready + * source is `cordova`. The default ready source value will be `dom`. The + * `readySource` is useful if different logic should run depending on the + * platform the app is running from. For example, only Cordova can execute + * the status bar plugin, so the web should not run status bar plugin logic. + * + * ``` + * import { Component } from '@angular/core'; + * import { Platform } from 'ionic-angular'; + * + * @Component({...}) + * export MyApp { + * constructor(public platform: Platform) { + * this.platform.ready().then((readySource) => { + * console.log('Platform ready from', readySource); + * // Platform now ready, execute any required native code + * }); + * } + * } + * ``` + */ + ready() { + return this._readyPromise; + } + /** + * Returns if this app is using right-to-left language direction or not. + * We recommend the app's `index.html` file already has the correct `dir` + * attribute value set, such as `` or ``. + * [W3C: Structural markup and right-to-left text in HTML](http://www.w3.org/International/questions/qa-html-dir) + */ + get isRTL() { + return this.doc.dir === 'rtl'; + } + /** + * Get the query string parameter + */ + getQueryParam(key) { + return readQueryParam(this.win.location.href, key); + } + /** + * Returns `true` if the app is in landscape mode. + */ + isLandscape() { + return !this.isPortrait(); + } + /** + * Returns `true` if the app is in portrait mode. + */ + isPortrait() { + var _a, _b; + return (_b = (_a = this.win).matchMedia) === null || _b === void 0 ? void 0 : _b.call(_a, '(orientation: portrait)').matches; + } + testUserAgent(expression) { + const nav = this.win.navigator; + return !!((nav === null || nav === void 0 ? void 0 : nav.userAgent) && nav.userAgent.indexOf(expression) >= 0); + } + /** + * Get the current url. + */ + url() { + return this.win.location.href; + } + /** + * Gets the width of the platform's viewport using `window.innerWidth`. + */ + width() { + return this.win.innerWidth; + } + /** + * Gets the height of the platform's viewport using `window.innerHeight`. + */ + height() { + return this.win.innerHeight; + } +}; +Platform = __decorate([ + Injectable({ + providedIn: 'root', + }), + __param(0, Inject(DOCUMENT)) +], Platform); +export { Platform }; +const readQueryParam = (url, key) => { + key = key.replace(/[[\]\\]/g, '\\$&'); + const regex = new RegExp('[\\?&]' + key + '=([^&#]*)'); + const results = regex.exec(url); + return results ? decodeURIComponent(results[1].replace(/\+/g, ' ')) : null; +}; +const proxyEvent = (emitter, el, eventName, zone) => { + if (el) { + el.addEventListener(eventName, (ev) => { + /** + * `zone.run` is required to make sure that we are running inside the Angular zone + * at all times. This is necessary since an app that has Capacitor will + * override the `document.addEventListener` with its own implementation. + * The override causes the event to no longer be in the Angular zone. + */ + zone.run(() => { + // ?? cordova might emit "null" events + const value = ev != null ? ev.detail : undefined; + emitter.next(value); + }); + }); + } +}; diff --git a/packages/angular/build/es2015/common/src/types/interfaces.js b/packages/angular/build/es2015/common/src/types/interfaces.js new file mode 100644 index 00000000000..cb0ff5c3b54 --- /dev/null +++ b/packages/angular/build/es2015/common/src/types/interfaces.js @@ -0,0 +1 @@ +export {}; diff --git a/packages/angular/build/es2015/common/src/types/ionic-lifecycle-hooks.js b/packages/angular/build/es2015/common/src/types/ionic-lifecycle-hooks.js new file mode 100644 index 00000000000..dd0671d39cb --- /dev/null +++ b/packages/angular/build/es2015/common/src/types/ionic-lifecycle-hooks.js @@ -0,0 +1,4 @@ +/** + * https://ionicframework.com/docs/api/router-outlet#life-cycle-hooks + */ +export {}; diff --git a/packages/angular/build/es2015/common/src/types/overlay-options.js b/packages/angular/build/es2015/common/src/types/overlay-options.js new file mode 100644 index 00000000000..cb0ff5c3b54 --- /dev/null +++ b/packages/angular/build/es2015/common/src/types/overlay-options.js @@ -0,0 +1 @@ +export {}; diff --git a/packages/angular/build/es2015/common/src/utils/overlay.js b/packages/angular/build/es2015/common/src/utils/overlay.js new file mode 100644 index 00000000000..7f3b05889ec --- /dev/null +++ b/packages/angular/build/es2015/common/src/utils/overlay.js @@ -0,0 +1,24 @@ +// TODO(FW-2827): types +export class OverlayBaseController { + constructor(ctrl) { + this.ctrl = ctrl; + } + /** + * Creates a new overlay + */ + create(opts) { + return this.ctrl.create((opts || {})); + } + /** + * When `id` is not provided, it dismisses the top overlay. + */ + dismiss(data, role, id) { + return this.ctrl.dismiss(data, role, id); + } + /** + * Returns the top overlay. + */ + getTop() { + return this.ctrl.getTop(); + } +} diff --git a/packages/angular/build/es2015/common/src/utils/proxy.js b/packages/angular/build/es2015/common/src/utils/proxy.js new file mode 100644 index 00000000000..58f76a37e1c --- /dev/null +++ b/packages/angular/build/es2015/common/src/utils/proxy.js @@ -0,0 +1,46 @@ +// TODO: Is there a way we can grab this from angular-component-lib instead? +/* eslint-disable */ +/* tslint:disable */ +import { fromEvent } from 'rxjs'; +export const proxyInputs = (Cmp, inputs) => { + const Prototype = Cmp.prototype; + inputs.forEach((item) => { + Object.defineProperty(Prototype, item, { + get() { + return this.el[item]; + }, + set(val) { + this.z.runOutsideAngular(() => (this.el[item] = val)); + }, + }); + }); +}; +export const proxyMethods = (Cmp, methods) => { + const Prototype = Cmp.prototype; + methods.forEach((methodName) => { + Prototype[methodName] = function () { + const args = arguments; + return this.z.runOutsideAngular(() => this.el[methodName].apply(this.el, args)); + }; + }); +}; +export const proxyOutputs = (instance, el, events) => { + events.forEach((eventName) => (instance[eventName] = fromEvent(el, eventName))); +}; +// tslint:disable-next-line: only-arrow-functions +export function ProxyCmp(opts) { + const decorator = function (cls) { + const { defineCustomElementFn, inputs, methods } = opts; + if (defineCustomElementFn !== undefined) { + defineCustomElementFn(); + } + if (inputs) { + proxyInputs(cls, inputs); + } + if (methods) { + proxyMethods(cls, methods); + } + return cls; + }; + return decorator; +} diff --git a/packages/angular/build/es2015/common/src/utils/routing.js b/packages/angular/build/es2015/common/src/utils/routing.js new file mode 100644 index 00000000000..dab356197b5 --- /dev/null +++ b/packages/angular/build/es2015/common/src/utils/routing.js @@ -0,0 +1,54 @@ +/** + * Provides a way to customize when activated routes get reused. + */ +export class IonicRouteStrategy { + /** + * Whether the given route should detach for later reuse. + */ + shouldDetach(_route) { + return false; + } + /** + * Returns `false`, meaning the route (and its subtree) is never reattached + */ + shouldAttach(_route) { + return false; + } + /** + * A no-op; the route is never stored since this strategy never detaches routes for later re-use. + */ + store(_route, _detachedTree) { + return; + } + /** + * Returns `null` because this strategy does not store routes for later re-use. + */ + retrieve(_route) { + return null; + } + /** + * Determines if a route should be reused. + * This strategy returns `true` when the future route config and + * current route config are identical and all route parameters are identical. + */ + shouldReuseRoute(future, curr) { + if (future.routeConfig !== curr.routeConfig) { + return false; + } + // checking router params + const futureParams = future.params; + const currentParams = curr.params; + const keysA = Object.keys(futureParams); + const keysB = Object.keys(currentParams); + if (keysA.length !== keysB.length) { + return false; + } + // Test for A's keys different from B. + for (const key of keysA) { + if (currentParams[key] !== futureParams[key]) { + return false; + } + } + return true; + } +} diff --git a/packages/angular/build/es2015/common/src/utils/util.js b/packages/angular/build/es2015/common/src/utils/util.js new file mode 100644 index 00000000000..861e1910a92 --- /dev/null +++ b/packages/angular/build/es2015/common/src/utils/util.js @@ -0,0 +1,9 @@ +export const raf = (h) => { + if (typeof __zone_symbol__requestAnimationFrame === 'function') { + return __zone_symbol__requestAnimationFrame(h); + } + if (typeof requestAnimationFrame === 'function') { + return requestAnimationFrame(h); + } + return setTimeout(h); +}; diff --git a/packages/angular/build/es2015/lazy/src/app-initialize.js b/packages/angular/build/es2015/lazy/src/app-initialize.js new file mode 100644 index 00000000000..0b8ffcffa1a --- /dev/null +++ b/packages/angular/build/es2015/lazy/src/app-initialize.js @@ -0,0 +1,25 @@ +import { raf } from '@ionic/angular/common'; +import { setupConfig } from '@ionic/core'; +import { defineCustomElements } from '@ionic/core/loader'; +// TODO(FW-2827): types +export const appInitialize = (config, doc, zone) => { + return () => { + const win = doc.defaultView; + if (win && typeof window !== 'undefined') { + setupConfig(Object.assign(Object.assign({}, config), { _zoneGate: (h) => zone.run(h) })); + const aelFn = '__zone_symbol__addEventListener' in doc.body ? '__zone_symbol__addEventListener' : 'addEventListener'; + return defineCustomElements(win, { + exclude: ['ion-tabs'], + syncQueue: true, + raf, + jmp: (h) => zone.runOutsideAngular(h), + ael(elm, eventName, cb, opts) { + elm[aelFn](eventName, cb, opts); + }, + rel(elm, eventName, cb, opts) { + elm.removeEventListener(eventName, cb, opts); + }, + }); + } + }; +}; diff --git a/packages/angular/build/es2015/lazy/src/directives/angular-component-lib/utils.js b/packages/angular/build/es2015/lazy/src/directives/angular-component-lib/utils.js new file mode 100644 index 00000000000..4bfe4ea9066 --- /dev/null +++ b/packages/angular/build/es2015/lazy/src/directives/angular-component-lib/utils.js @@ -0,0 +1,58 @@ +/* eslint-disable */ +/* tslint:disable */ +import { fromEvent } from 'rxjs'; +export const proxyInputs = (Cmp, inputs) => { + const Prototype = Cmp.prototype; + inputs.forEach((item) => { + Object.defineProperty(Prototype, item, { + get() { + return this.el[item]; + }, + set(val) { + this.z.runOutsideAngular(() => (this.el[item] = val)); + }, + /** + * In the event that proxyInputs is called + * multiple times re-defining these inputs + * will cause an error to be thrown. As a result + * we set configurable: true to indicate these + * properties can be changed. + */ + configurable: true, + }); + }); +}; +export const proxyMethods = (Cmp, methods) => { + const Prototype = Cmp.prototype; + methods.forEach((methodName) => { + Prototype[methodName] = function () { + const args = arguments; + return this.z.runOutsideAngular(() => this.el[methodName].apply(this.el, args)); + }; + }); +}; +export const proxyOutputs = (instance, el, events) => { + events.forEach((eventName) => (instance[eventName] = fromEvent(el, eventName))); +}; +export const defineCustomElement = (tagName, customElement) => { + if (customElement !== undefined && typeof customElements !== 'undefined' && !customElements.get(tagName)) { + customElements.define(tagName, customElement); + } +}; +// tslint:disable-next-line: only-arrow-functions +export function ProxyCmp(opts) { + const decorator = function (cls) { + const { defineCustomElementFn, inputs, methods } = opts; + if (defineCustomElementFn !== undefined) { + defineCustomElementFn(); + } + if (inputs) { + proxyInputs(cls, inputs); + } + if (methods) { + proxyMethods(cls, methods); + } + return cls; + }; + return decorator; +} diff --git a/packages/angular/build/es2015/lazy/src/directives/control-value-accessors/boolean-value-accessor.js b/packages/angular/build/es2015/lazy/src/directives/control-value-accessors/boolean-value-accessor.js new file mode 100644 index 00000000000..1387a1d54a9 --- /dev/null +++ b/packages/angular/build/es2015/lazy/src/directives/control-value-accessors/boolean-value-accessor.js @@ -0,0 +1,38 @@ +import { __decorate } from "tslib"; +import { Directive, HostListener } from '@angular/core'; +import { NG_VALUE_ACCESSOR } from '@angular/forms'; +import { ValueAccessor, setIonicClasses } from '@ionic/angular/common'; +let BooleanValueAccessorDirective = class BooleanValueAccessorDirective extends ValueAccessor { + constructor(injector, el) { + super(injector, el); + } + writeValue(value) { + this.elementRef.nativeElement.checked = this.lastValue = value; + setIonicClasses(this.elementRef); + } + // Bind `$event` and cast `.target` in the body rather than `['$event.target']`: + // this directive's multi-element selector makes Angular 22's stricter host-binding + // type checking infer `$event` as the DOM `Event` (target: `EventTarget | null`), + // not the concrete element. The single-element standalone CVAs keep `['$event.target']`. + _handleIonChange(ev) { + const el = ev.target; + this.handleValueChange(el, el.checked); + } +}; +__decorate([ + HostListener('ionChange', ['$event']) +], BooleanValueAccessorDirective.prototype, "_handleIonChange", null); +BooleanValueAccessorDirective = __decorate([ + Directive({ + standalone: false, + selector: 'ion-checkbox,ion-toggle', + providers: [ + { + provide: NG_VALUE_ACCESSOR, + useExisting: BooleanValueAccessorDirective, + multi: true, + }, + ], + }) +], BooleanValueAccessorDirective); +export { BooleanValueAccessorDirective }; diff --git a/packages/angular/build/es2015/lazy/src/directives/control-value-accessors/index.js b/packages/angular/build/es2015/lazy/src/directives/control-value-accessors/index.js new file mode 100644 index 00000000000..84a18e0b925 --- /dev/null +++ b/packages/angular/build/es2015/lazy/src/directives/control-value-accessors/index.js @@ -0,0 +1,4 @@ +export * from './boolean-value-accessor'; +export * from './numeric-value-accessor'; +export * from './select-value-accessor'; +export * from './text-value-accessor'; diff --git a/packages/angular/build/es2015/lazy/src/directives/control-value-accessors/numeric-value-accessor.js b/packages/angular/build/es2015/lazy/src/directives/control-value-accessors/numeric-value-accessor.js new file mode 100644 index 00000000000..027fe915630 --- /dev/null +++ b/packages/angular/build/es2015/lazy/src/directives/control-value-accessors/numeric-value-accessor.js @@ -0,0 +1,45 @@ +import { __decorate } from "tslib"; +import { Directive, HostListener } from '@angular/core'; +import { NG_VALUE_ACCESSOR } from '@angular/forms'; +import { ValueAccessor } from '@ionic/angular/common'; +let NumericValueAccessorDirective = class NumericValueAccessorDirective extends ValueAccessor { + constructor(injector, el) { + super(injector, el); + this.el = el; + } + // Bind `$event` and cast `.target` in the body rather than `['$event.target']`: + // this directive's multi-element selector makes Angular 22's stricter host-binding + // type checking infer `$event` as the DOM `Event` (target: `EventTarget | null`), + // not the concrete element. The single-element standalone CVAs keep `['$event.target']`. + handleInputEvent(ev) { + const el = ev.target; + this.handleValueChange(el, el.value); + } + registerOnChange(fn) { + if (this.el.nativeElement.tagName === 'ION-INPUT' || this.el.nativeElement.tagName === 'ION-INPUT-OTP') { + super.registerOnChange((value) => { + fn(value === '' ? null : parseFloat(value)); + }); + } + else { + super.registerOnChange(fn); + } + } +}; +__decorate([ + HostListener('ionInput', ['$event']) +], NumericValueAccessorDirective.prototype, "handleInputEvent", null); +NumericValueAccessorDirective = __decorate([ + Directive({ + standalone: false, + selector: 'ion-input[type=number],ion-input-otp:not([type=text]),ion-range', + providers: [ + { + provide: NG_VALUE_ACCESSOR, + useExisting: NumericValueAccessorDirective, + multi: true, + }, + ], + }) +], NumericValueAccessorDirective); +export { NumericValueAccessorDirective }; diff --git a/packages/angular/build/es2015/lazy/src/directives/control-value-accessors/select-value-accessor.js b/packages/angular/build/es2015/lazy/src/directives/control-value-accessors/select-value-accessor.js new file mode 100644 index 00000000000..d4cd780c645 --- /dev/null +++ b/packages/angular/build/es2015/lazy/src/directives/control-value-accessors/select-value-accessor.js @@ -0,0 +1,35 @@ +import { __decorate } from "tslib"; +import { Directive, HostListener } from '@angular/core'; +import { NG_VALUE_ACCESSOR } from '@angular/forms'; +import { ValueAccessor } from '@ionic/angular/common'; +let SelectValueAccessorDirective = class SelectValueAccessorDirective extends ValueAccessor { + constructor(injector, el) { + super(injector, el); + } + // Bind `$event` and cast `.target` in the body rather than `['$event.target']`: + // this directive's multi-element selector makes Angular 22's stricter host-binding + // type checking infer `$event` as the DOM `Event` (target: `EventTarget | null`), + // not the concrete element. The single-element standalone CVAs keep `['$event.target']`. + _handleChangeEvent(ev) { + const el = ev.target; + this.handleValueChange(el, el.value); + } +}; +__decorate([ + HostListener('ionChange', ['$event']) +], SelectValueAccessorDirective.prototype, "_handleChangeEvent", null); +SelectValueAccessorDirective = __decorate([ + Directive({ + standalone: false, + /* tslint:disable-next-line:directive-selector */ + selector: 'ion-select, ion-radio-group, ion-segment, ion-datetime', + providers: [ + { + provide: NG_VALUE_ACCESSOR, + useExisting: SelectValueAccessorDirective, + multi: true, + }, + ], + }) +], SelectValueAccessorDirective); +export { SelectValueAccessorDirective }; diff --git a/packages/angular/build/es2015/lazy/src/directives/control-value-accessors/text-value-accessor.js b/packages/angular/build/es2015/lazy/src/directives/control-value-accessors/text-value-accessor.js new file mode 100644 index 00000000000..d97091c6373 --- /dev/null +++ b/packages/angular/build/es2015/lazy/src/directives/control-value-accessors/text-value-accessor.js @@ -0,0 +1,34 @@ +import { __decorate } from "tslib"; +import { Directive, HostListener } from '@angular/core'; +import { NG_VALUE_ACCESSOR } from '@angular/forms'; +import { ValueAccessor } from '@ionic/angular/common'; +let TextValueAccessorDirective = class TextValueAccessorDirective extends ValueAccessor { + constructor(injector, el) { + super(injector, el); + } + // Bind `$event` and cast `.target` in the body rather than `['$event.target']`: + // this directive's multi-element selector makes Angular 22's stricter host-binding + // type checking infer `$event` as the DOM `Event` (target: `EventTarget | null`), + // not the concrete element. The single-element standalone CVAs keep `['$event.target']`. + _handleInputEvent(ev) { + const el = ev.target; + this.handleValueChange(el, el.value); + } +}; +__decorate([ + HostListener('ionInput', ['$event']) +], TextValueAccessorDirective.prototype, "_handleInputEvent", null); +TextValueAccessorDirective = __decorate([ + Directive({ + standalone: false, + selector: 'ion-input:not([type=number]),ion-input-otp[type=text],ion-textarea,ion-searchbar', + providers: [ + { + provide: NG_VALUE_ACCESSOR, + useExisting: TextValueAccessorDirective, + multi: true, + }, + ], + }) +], TextValueAccessorDirective); +export { TextValueAccessorDirective }; diff --git a/packages/angular/build/es2015/lazy/src/directives/navigation/ion-back-button.js b/packages/angular/build/es2015/lazy/src/directives/navigation/ion-back-button.js new file mode 100644 index 00000000000..640b1614164 --- /dev/null +++ b/packages/angular/build/es2015/lazy/src/directives/navigation/ion-back-button.js @@ -0,0 +1,18 @@ +import { __decorate, __param } from "tslib"; +import { Optional, Component, ChangeDetectionStrategy } from '@angular/core'; +import { IonBackButton as IonBackButtonBase } from '@ionic/angular/common'; +let IonBackButton = class IonBackButton extends IonBackButtonBase { + constructor(routerOutlet, navCtrl, config, r, z, c) { + super(routerOutlet, navCtrl, config, r, z, c); + } +}; +IonBackButton = __decorate([ + Component({ + standalone: false, + selector: 'ion-back-button', + template: '', + changeDetection: ChangeDetectionStrategy.OnPush, + }), + __param(0, Optional()) +], IonBackButton); +export { IonBackButton }; diff --git a/packages/angular/build/es2015/lazy/src/directives/navigation/ion-nav.js b/packages/angular/build/es2015/lazy/src/directives/navigation/ion-nav.js new file mode 100644 index 00000000000..7ba45134b96 --- /dev/null +++ b/packages/angular/build/es2015/lazy/src/directives/navigation/ion-nav.js @@ -0,0 +1,17 @@ +import { __decorate } from "tslib"; +import { Component, ChangeDetectionStrategy, } from '@angular/core'; +import { IonNav as IonNavBase } from '@ionic/angular/common'; +let IonNav = class IonNav extends IonNavBase { + constructor(ref, environmentInjector, injector, angularDelegate, z, c) { + super(ref, environmentInjector, injector, angularDelegate, z, c); + } +}; +IonNav = __decorate([ + Component({ + standalone: false, + selector: 'ion-nav', + template: '', + changeDetection: ChangeDetectionStrategy.OnPush, + }) +], IonNav); +export { IonNav }; diff --git a/packages/angular/build/es2015/lazy/src/directives/navigation/ion-router-outlet.js b/packages/angular/build/es2015/lazy/src/directives/navigation/ion-router-outlet.js new file mode 100644 index 00000000000..e26c07e1df0 --- /dev/null +++ b/packages/angular/build/es2015/lazy/src/directives/navigation/ion-router-outlet.js @@ -0,0 +1,31 @@ +import { __decorate, __param } from "tslib"; +import { ViewChild, ViewContainerRef, Component, Attribute, Optional, SkipSelf, } from '@angular/core'; +import { IonRouterOutlet as IonRouterOutletBase } from '@ionic/angular/common'; +let IonRouterOutlet = class IonRouterOutlet extends IonRouterOutletBase { + /** + * We need to pass in the correct instance of IonRouterOutlet + * otherwise parentOutlet will be null in a nested outlet context. + * This results in APIs such as NavController.pop not working + * in nested outlets because the parent outlet cannot be found. + */ + constructor(name, tabs, commonLocation, elementRef, router, zone, activatedRoute, parentOutlet) { + super(name, tabs, commonLocation, elementRef, router, zone, activatedRoute, parentOutlet); + this.parentOutlet = parentOutlet; + } +}; +__decorate([ + ViewChild('outletContent', { read: ViewContainerRef, static: true }) +], IonRouterOutlet.prototype, "outletContent", void 0); +IonRouterOutlet = __decorate([ + Component({ + standalone: false, + selector: 'ion-router-outlet', + template: '', + }), + __param(0, Attribute('name')), + __param(1, Optional()), + __param(1, Attribute('tabs')), + __param(7, SkipSelf()), + __param(7, Optional()) +], IonRouterOutlet); +export { IonRouterOutlet }; diff --git a/packages/angular/build/es2015/lazy/src/directives/navigation/ion-tabs.js b/packages/angular/build/es2015/lazy/src/directives/navigation/ion-tabs.js new file mode 100644 index 00000000000..ee50ce7e387 --- /dev/null +++ b/packages/angular/build/es2015/lazy/src/directives/navigation/ion-tabs.js @@ -0,0 +1,66 @@ +import { __decorate } from "tslib"; +import { Component, ContentChild, ContentChildren, ViewChild } from '@angular/core'; +import { IonTabs as IonTabsBase } from '@ionic/angular/common'; +import { IonTabBar, IonTab } from '../proxies'; +import { IonRouterOutlet } from './ion-router-outlet'; +let IonTabs = class IonTabs extends IonTabsBase { +}; +__decorate([ + ViewChild('outlet', { read: IonRouterOutlet, static: false }) +], IonTabs.prototype, "outlet", void 0); +__decorate([ + ContentChild(IonTabBar, { static: false }) +], IonTabs.prototype, "tabBar", void 0); +__decorate([ + ContentChildren(IonTabBar) +], IonTabs.prototype, "tabBars", void 0); +__decorate([ + ContentChildren(IonTab) +], IonTabs.prototype, "tabs", void 0); +IonTabs = __decorate([ + Component({ + standalone: false, + selector: 'ion-tabs', + template: ` + +
+ + +
+ + `, + styles: [ + ` + :host { + display: flex; + position: absolute; + top: 0; + left: 0; + right: 0; + bottom: 0; + + flex-direction: column; + + width: 100%; + height: 100%; + + contain: layout size style; + } + .tabs-inner { + position: relative; + + flex: 1; + + contain: layout size style; + } + `, + ], + }) +], IonTabs); +export { IonTabs }; diff --git a/packages/angular/build/es2015/lazy/src/directives/navigation/router-link-delegate.js b/packages/angular/build/es2015/lazy/src/directives/navigation/router-link-delegate.js new file mode 100644 index 00000000000..c3544e1358b --- /dev/null +++ b/packages/angular/build/es2015/lazy/src/directives/navigation/router-link-delegate.js @@ -0,0 +1,27 @@ +import { __decorate } from "tslib"; +import { Directive } from '@angular/core'; +import { RouterLinkDelegateDirective as RouterLinkDelegateBase, RouterLinkWithHrefDelegateDirective as RouterLinkHrefDelegateBase, } from '@ionic/angular/common'; +/** + * Adds support for Ionic routing directions and animations to the base Angular router link directive. + * + * When the router link is clicked, the directive will assign the direction and + * animation so that the routing integration will transition correctly. + */ +let RouterLinkDelegateDirective = class RouterLinkDelegateDirective extends RouterLinkDelegateBase { +}; +RouterLinkDelegateDirective = __decorate([ + Directive({ + standalone: false, + selector: ':not(a):not(area)[routerLink]', + }) +], RouterLinkDelegateDirective); +export { RouterLinkDelegateDirective }; +let RouterLinkWithHrefDelegateDirective = class RouterLinkWithHrefDelegateDirective extends RouterLinkHrefDelegateBase { +}; +RouterLinkWithHrefDelegateDirective = __decorate([ + Directive({ + standalone: false, + selector: 'a[routerLink],area[routerLink]', + }) +], RouterLinkWithHrefDelegateDirective); +export { RouterLinkWithHrefDelegateDirective }; diff --git a/packages/angular/build/es2015/lazy/src/directives/overlays/modal.js b/packages/angular/build/es2015/lazy/src/directives/overlays/modal.js new file mode 100644 index 00000000000..22c67b1d573 --- /dev/null +++ b/packages/angular/build/es2015/lazy/src/directives/overlays/modal.js @@ -0,0 +1,16 @@ +import { __decorate } from "tslib"; +import { ChangeDetectionStrategy, Component } from '@angular/core'; +import { IonModal as IonModalBase } from '@ionic/angular/common'; +let IonModal = class IonModal extends IonModalBase { +}; +IonModal = __decorate([ + Component({ + standalone: false, + selector: 'ion-modal', + changeDetection: ChangeDetectionStrategy.OnPush, + template: `
+ +
`, + }) +], IonModal); +export { IonModal }; diff --git a/packages/angular/build/es2015/lazy/src/directives/overlays/popover.js b/packages/angular/build/es2015/lazy/src/directives/overlays/popover.js new file mode 100644 index 00000000000..81bac9d6a1e --- /dev/null +++ b/packages/angular/build/es2015/lazy/src/directives/overlays/popover.js @@ -0,0 +1,14 @@ +import { __decorate } from "tslib"; +import { ChangeDetectionStrategy, Component } from '@angular/core'; +import { IonPopover as IonPopoverBase } from '@ionic/angular/common'; +let IonPopover = class IonPopover extends IonPopoverBase { +}; +IonPopover = __decorate([ + Component({ + standalone: false, + selector: 'ion-popover', + changeDetection: ChangeDetectionStrategy.OnPush, + template: ``, + }) +], IonPopover); +export { IonPopover }; diff --git a/packages/angular/build/es2015/lazy/src/directives/proxies-list.js b/packages/angular/build/es2015/lazy/src/directives/proxies-list.js new file mode 100644 index 00000000000..8e588f754c0 --- /dev/null +++ b/packages/angular/build/es2015/lazy/src/directives/proxies-list.js @@ -0,0 +1,88 @@ +import * as d from './proxies'; +export const DIRECTIVES = [ + d.IonAccordion, + d.IonAccordionGroup, + d.IonActionSheet, + d.IonAlert, + d.IonApp, + d.IonAvatar, + d.IonBackdrop, + d.IonBadge, + d.IonBreadcrumb, + d.IonBreadcrumbs, + d.IonButton, + d.IonButtons, + d.IonCard, + d.IonCardContent, + d.IonCardHeader, + d.IonCardSubtitle, + d.IonCardTitle, + d.IonCheckbox, + d.IonChip, + d.IonCol, + d.IonContent, + d.IonDatetime, + d.IonDatetimeButton, + d.IonFab, + d.IonFabButton, + d.IonFabList, + d.IonFooter, + d.IonGrid, + d.IonHeader, + d.IonIcon, + d.IonImg, + d.IonInfiniteScroll, + d.IonInfiniteScrollContent, + d.IonInput, + d.IonInputOtp, + d.IonInputPasswordToggle, + d.IonItem, + d.IonItemDivider, + d.IonItemGroup, + d.IonItemOption, + d.IonItemOptions, + d.IonItemSliding, + d.IonLabel, + d.IonList, + d.IonListHeader, + d.IonLoading, + d.IonMenu, + d.IonMenuButton, + d.IonMenuToggle, + d.IonNavLink, + d.IonNote, + d.IonPicker, + d.IonPickerColumn, + d.IonPickerColumnOption, + d.IonProgressBar, + d.IonRadio, + d.IonRadioGroup, + d.IonRange, + d.IonRefresher, + d.IonRefresherContent, + d.IonReorder, + d.IonReorderGroup, + d.IonRippleEffect, + d.IonRow, + d.IonSearchbar, + d.IonSegment, + d.IonSegmentButton, + d.IonSegmentContent, + d.IonSegmentView, + d.IonSelect, + d.IonSelectModal, + d.IonSelectOption, + d.IonSkeletonText, + d.IonSpinner, + d.IonSplitPane, + d.IonTab, + d.IonTabBar, + d.IonTabButton, + d.IonText, + d.IonTextarea, + d.IonThumbnail, + d.IonTitle, + d.IonToast, + d.IonToggle, + d.IonToolbar +]; diff --git a/packages/angular/build/es2015/lazy/src/directives/proxies.js b/packages/angular/build/es2015/lazy/src/directives/proxies.js new file mode 100644 index 00000000000..a93098dea6b --- /dev/null +++ b/packages/angular/build/es2015/lazy/src/directives/proxies.js @@ -0,0 +1,2272 @@ +import { __decorate } from "tslib"; +/* tslint:disable */ +/* auto-generated angular directive proxies */ +import { ChangeDetectionStrategy, Component, EventEmitter, Output } from '@angular/core'; +import { ProxyCmp } from './angular-component-lib/utils'; +let IonAccordion = class IonAccordion { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonAccordion = __decorate([ + ProxyCmp({ + inputs: ['disabled', 'mode', 'readonly', 'toggleIcon', 'toggleIconSlot', 'value'] + }), + Component({ + selector: 'ion-accordion', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['disabled', 'mode', 'readonly', 'toggleIcon', 'toggleIconSlot', 'value'], + standalone: false + }) +], IonAccordion); +export { IonAccordion }; +let IonAccordionGroup = class IonAccordionGroup { + constructor(c, r, z) { + this.z = z; + this.ionChange = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonAccordionGroup.prototype, "ionChange", void 0); +IonAccordionGroup = __decorate([ + ProxyCmp({ + inputs: ['animated', 'disabled', 'expand', 'mode', 'multiple', 'readonly', 'value'] + }), + Component({ + selector: 'ion-accordion-group', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['animated', 'disabled', 'expand', 'mode', 'multiple', 'readonly', 'value'], + outputs: ['ionChange'], + standalone: false + }) +], IonAccordionGroup); +export { IonAccordionGroup }; +let IonActionSheet = class IonActionSheet { + constructor(c, r, z) { + this.z = z; + this.ionActionSheetDidPresent = new EventEmitter(); + this.ionActionSheetWillPresent = new EventEmitter(); + this.ionActionSheetWillDismiss = new EventEmitter(); + this.ionActionSheetDidDismiss = new EventEmitter(); + this.didPresent = new EventEmitter(); + this.willPresent = new EventEmitter(); + this.willDismiss = new EventEmitter(); + this.didDismiss = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonActionSheet.prototype, "ionActionSheetDidPresent", void 0); +__decorate([ + Output() +], IonActionSheet.prototype, "ionActionSheetWillPresent", void 0); +__decorate([ + Output() +], IonActionSheet.prototype, "ionActionSheetWillDismiss", void 0); +__decorate([ + Output() +], IonActionSheet.prototype, "ionActionSheetDidDismiss", void 0); +__decorate([ + Output() +], IonActionSheet.prototype, "didPresent", void 0); +__decorate([ + Output() +], IonActionSheet.prototype, "willPresent", void 0); +__decorate([ + Output() +], IonActionSheet.prototype, "willDismiss", void 0); +__decorate([ + Output() +], IonActionSheet.prototype, "didDismiss", void 0); +IonActionSheet = __decorate([ + ProxyCmp({ + inputs: ['animated', 'backdropDismiss', 'buttons', 'cssClass', 'enterAnimation', 'header', 'htmlAttributes', 'isOpen', 'keyboardClose', 'leaveAnimation', 'mode', 'subHeader', 'translucent', 'trigger'], + methods: ['present', 'dismiss', 'onDidDismiss', 'onWillDismiss'] + }), + Component({ + selector: 'ion-action-sheet', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['animated', 'backdropDismiss', 'buttons', 'cssClass', 'enterAnimation', 'header', 'htmlAttributes', 'isOpen', 'keyboardClose', 'leaveAnimation', 'mode', 'subHeader', 'translucent', 'trigger'], + outputs: ['ionActionSheetDidPresent', 'ionActionSheetWillPresent', 'ionActionSheetWillDismiss', 'ionActionSheetDidDismiss', 'didPresent', 'willPresent', 'willDismiss', 'didDismiss'], + standalone: false + }) +], IonActionSheet); +export { IonActionSheet }; +let IonAlert = class IonAlert { + constructor(c, r, z) { + this.z = z; + this.ionAlertDidPresent = new EventEmitter(); + this.ionAlertWillPresent = new EventEmitter(); + this.ionAlertWillDismiss = new EventEmitter(); + this.ionAlertDidDismiss = new EventEmitter(); + this.didPresent = new EventEmitter(); + this.willPresent = new EventEmitter(); + this.willDismiss = new EventEmitter(); + this.didDismiss = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonAlert.prototype, "ionAlertDidPresent", void 0); +__decorate([ + Output() +], IonAlert.prototype, "ionAlertWillPresent", void 0); +__decorate([ + Output() +], IonAlert.prototype, "ionAlertWillDismiss", void 0); +__decorate([ + Output() +], IonAlert.prototype, "ionAlertDidDismiss", void 0); +__decorate([ + Output() +], IonAlert.prototype, "didPresent", void 0); +__decorate([ + Output() +], IonAlert.prototype, "willPresent", void 0); +__decorate([ + Output() +], IonAlert.prototype, "willDismiss", void 0); +__decorate([ + Output() +], IonAlert.prototype, "didDismiss", void 0); +IonAlert = __decorate([ + ProxyCmp({ + inputs: ['animated', 'backdropDismiss', 'buttons', 'cssClass', 'enterAnimation', 'header', 'htmlAttributes', 'inputs', 'isOpen', 'keyboardClose', 'leaveAnimation', 'message', 'mode', 'subHeader', 'translucent', 'trigger'], + methods: ['present', 'dismiss', 'onDidDismiss', 'onWillDismiss'] + }), + Component({ + selector: 'ion-alert', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['animated', 'backdropDismiss', 'buttons', 'cssClass', 'enterAnimation', 'header', 'htmlAttributes', 'inputs', 'isOpen', 'keyboardClose', 'leaveAnimation', 'message', 'mode', 'subHeader', 'translucent', 'trigger'], + outputs: ['ionAlertDidPresent', 'ionAlertWillPresent', 'ionAlertWillDismiss', 'ionAlertDidDismiss', 'didPresent', 'willPresent', 'willDismiss', 'didDismiss'], + standalone: false + }) +], IonAlert); +export { IonAlert }; +let IonApp = class IonApp { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonApp = __decorate([ + ProxyCmp({ + methods: ['setFocus'] + }), + Component({ + selector: 'ion-app', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: [], + standalone: false + }) +], IonApp); +export { IonApp }; +let IonAvatar = class IonAvatar { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonAvatar = __decorate([ + ProxyCmp({}), + Component({ + selector: 'ion-avatar', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: [], + standalone: false + }) +], IonAvatar); +export { IonAvatar }; +let IonBackdrop = class IonBackdrop { + constructor(c, r, z) { + this.z = z; + this.ionBackdropTap = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonBackdrop.prototype, "ionBackdropTap", void 0); +IonBackdrop = __decorate([ + ProxyCmp({ + inputs: ['stopPropagation', 'tappable', 'visible'] + }), + Component({ + selector: 'ion-backdrop', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['stopPropagation', 'tappable', 'visible'], + outputs: ['ionBackdropTap'], + standalone: false + }) +], IonBackdrop); +export { IonBackdrop }; +let IonBadge = class IonBadge { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonBadge = __decorate([ + ProxyCmp({ + inputs: ['color', 'mode'] + }), + Component({ + selector: 'ion-badge', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'mode'], + standalone: false + }) +], IonBadge); +export { IonBadge }; +let IonBreadcrumb = class IonBreadcrumb { + constructor(c, r, z) { + this.z = z; + this.ionFocus = new EventEmitter(); + this.ionBlur = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonBreadcrumb.prototype, "ionFocus", void 0); +__decorate([ + Output() +], IonBreadcrumb.prototype, "ionBlur", void 0); +IonBreadcrumb = __decorate([ + ProxyCmp({ + inputs: ['active', 'color', 'disabled', 'download', 'href', 'mode', 'rel', 'routerAnimation', 'routerDirection', 'separator', 'target'] + }), + Component({ + selector: 'ion-breadcrumb', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['active', 'color', 'disabled', 'download', 'href', 'mode', 'rel', 'routerAnimation', 'routerDirection', 'separator', 'target'], + outputs: ['ionFocus', 'ionBlur'], + standalone: false + }) +], IonBreadcrumb); +export { IonBreadcrumb }; +let IonBreadcrumbs = class IonBreadcrumbs { + constructor(c, r, z) { + this.z = z; + this.ionCollapsedClick = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonBreadcrumbs.prototype, "ionCollapsedClick", void 0); +IonBreadcrumbs = __decorate([ + ProxyCmp({ + inputs: ['color', 'itemsAfterCollapse', 'itemsBeforeCollapse', 'maxItems', 'mode'] + }), + Component({ + selector: 'ion-breadcrumbs', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'itemsAfterCollapse', 'itemsBeforeCollapse', 'maxItems', 'mode'], + outputs: ['ionCollapsedClick'], + standalone: false + }) +], IonBreadcrumbs); +export { IonBreadcrumbs }; +let IonButton = class IonButton { + constructor(c, r, z) { + this.z = z; + this.ionFocus = new EventEmitter(); + this.ionBlur = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonButton.prototype, "ionFocus", void 0); +__decorate([ + Output() +], IonButton.prototype, "ionBlur", void 0); +IonButton = __decorate([ + ProxyCmp({ + inputs: ['buttonType', 'color', 'disabled', 'download', 'expand', 'fill', 'form', 'href', 'mode', 'rel', 'routerAnimation', 'routerDirection', 'shape', 'size', 'strong', 'target', 'type'] + }), + Component({ + selector: 'ion-button', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['buttonType', 'color', 'disabled', 'download', 'expand', 'fill', 'form', 'href', 'mode', 'rel', 'routerAnimation', 'routerDirection', 'shape', 'size', 'strong', 'target', 'type'], + outputs: ['ionFocus', 'ionBlur'], + standalone: false + }) +], IonButton); +export { IonButton }; +let IonButtons = class IonButtons { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonButtons = __decorate([ + ProxyCmp({ + inputs: ['collapse'] + }), + Component({ + selector: 'ion-buttons', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['collapse'], + standalone: false + }) +], IonButtons); +export { IonButtons }; +let IonCard = class IonCard { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonCard = __decorate([ + ProxyCmp({ + inputs: ['button', 'color', 'disabled', 'download', 'href', 'mode', 'rel', 'routerAnimation', 'routerDirection', 'target', 'type'] + }), + Component({ + selector: 'ion-card', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['button', 'color', 'disabled', 'download', 'href', 'mode', 'rel', 'routerAnimation', 'routerDirection', 'target', 'type'], + standalone: false + }) +], IonCard); +export { IonCard }; +let IonCardContent = class IonCardContent { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonCardContent = __decorate([ + ProxyCmp({ + inputs: ['mode'] + }), + Component({ + selector: 'ion-card-content', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['mode'], + standalone: false + }) +], IonCardContent); +export { IonCardContent }; +let IonCardHeader = class IonCardHeader { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonCardHeader = __decorate([ + ProxyCmp({ + inputs: ['color', 'mode', 'translucent'] + }), + Component({ + selector: 'ion-card-header', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'mode', 'translucent'], + standalone: false + }) +], IonCardHeader); +export { IonCardHeader }; +let IonCardSubtitle = class IonCardSubtitle { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonCardSubtitle = __decorate([ + ProxyCmp({ + inputs: ['color', 'mode'] + }), + Component({ + selector: 'ion-card-subtitle', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'mode'], + standalone: false + }) +], IonCardSubtitle); +export { IonCardSubtitle }; +let IonCardTitle = class IonCardTitle { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonCardTitle = __decorate([ + ProxyCmp({ + inputs: ['color', 'mode'] + }), + Component({ + selector: 'ion-card-title', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'mode'], + standalone: false + }) +], IonCardTitle); +export { IonCardTitle }; +let IonCheckbox = class IonCheckbox { + constructor(c, r, z) { + this.z = z; + this.ionChange = new EventEmitter(); + this.ionFocus = new EventEmitter(); + this.ionBlur = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonCheckbox.prototype, "ionChange", void 0); +__decorate([ + Output() +], IonCheckbox.prototype, "ionFocus", void 0); +__decorate([ + Output() +], IonCheckbox.prototype, "ionBlur", void 0); +IonCheckbox = __decorate([ + ProxyCmp({ + inputs: ['alignment', 'checked', 'color', 'disabled', 'errorText', 'helperText', 'indeterminate', 'justify', 'labelPlacement', 'mode', 'name', 'required', 'value'] + }), + Component({ + selector: 'ion-checkbox', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['alignment', 'checked', 'color', 'disabled', 'errorText', 'helperText', 'indeterminate', 'justify', 'labelPlacement', 'mode', 'name', 'required', 'value'], + outputs: ['ionChange', 'ionFocus', 'ionBlur'], + standalone: false + }) +], IonCheckbox); +export { IonCheckbox }; +let IonChip = class IonChip { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonChip = __decorate([ + ProxyCmp({ + inputs: ['color', 'disabled', 'mode', 'outline'] + }), + Component({ + selector: 'ion-chip', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'disabled', 'mode', 'outline'], + standalone: false + }) +], IonChip); +export { IonChip }; +let IonCol = class IonCol { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonCol = __decorate([ + 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'] + }), + Component({ + selector: 'ion-col', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + 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'], + standalone: false + }) +], IonCol); +export { IonCol }; +let IonContent = class IonContent { + constructor(c, r, z) { + this.z = z; + this.ionScrollStart = new EventEmitter(); + this.ionScroll = new EventEmitter(); + this.ionScrollEnd = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonContent.prototype, "ionScrollStart", void 0); +__decorate([ + Output() +], IonContent.prototype, "ionScroll", void 0); +__decorate([ + Output() +], IonContent.prototype, "ionScrollEnd", void 0); +IonContent = __decorate([ + ProxyCmp({ + inputs: ['color', 'fixedSlotPlacement', 'forceOverscroll', 'fullscreen', 'scrollEvents', 'scrollX', 'scrollY'], + methods: ['getScrollElement', 'scrollToTop', 'scrollToBottom', 'scrollByPoint', 'scrollToPoint'] + }), + Component({ + selector: 'ion-content', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'fixedSlotPlacement', 'forceOverscroll', 'fullscreen', 'scrollEvents', 'scrollX', 'scrollY'], + outputs: ['ionScrollStart', 'ionScroll', 'ionScrollEnd'], + standalone: false + }) +], IonContent); +export { IonContent }; +let IonDatetime = class IonDatetime { + constructor(c, r, z) { + this.z = z; + this.ionCancel = new EventEmitter(); + this.ionChange = new EventEmitter(); + this.ionFocus = new EventEmitter(); + this.ionBlur = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonDatetime.prototype, "ionCancel", void 0); +__decorate([ + Output() +], IonDatetime.prototype, "ionChange", void 0); +__decorate([ + Output() +], IonDatetime.prototype, "ionFocus", void 0); +__decorate([ + Output() +], IonDatetime.prototype, "ionBlur", void 0); +IonDatetime = __decorate([ + ProxyCmp({ + inputs: ['cancelText', 'clearText', 'color', 'dayValues', 'disabled', 'doneText', 'firstDayOfWeek', 'formatOptions', 'highlightedDates', 'hourCycle', 'hourValues', 'isDateEnabled', 'locale', 'max', 'min', 'minuteValues', 'mode', 'monthValues', 'multiple', 'name', 'preferWheel', 'presentation', 'readonly', 'showAdjacentDays', 'showClearButton', 'showDefaultButtons', 'showDefaultTimeLabel', 'showDefaultTitle', 'size', 'titleSelectedDatesFormatter', 'value', 'yearValues'], + methods: ['confirm', 'reset', 'cancel'] + }), + Component({ + selector: 'ion-datetime', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['cancelText', 'clearText', 'color', 'dayValues', 'disabled', 'doneText', 'firstDayOfWeek', 'formatOptions', 'highlightedDates', 'hourCycle', 'hourValues', 'isDateEnabled', 'locale', 'max', 'min', 'minuteValues', 'mode', 'monthValues', 'multiple', 'name', 'preferWheel', 'presentation', 'readonly', 'showAdjacentDays', 'showClearButton', 'showDefaultButtons', 'showDefaultTimeLabel', 'showDefaultTitle', 'size', 'titleSelectedDatesFormatter', 'value', 'yearValues'], + outputs: ['ionCancel', 'ionChange', 'ionFocus', 'ionBlur'], + standalone: false + }) +], IonDatetime); +export { IonDatetime }; +let IonDatetimeButton = class IonDatetimeButton { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonDatetimeButton = __decorate([ + ProxyCmp({ + inputs: ['color', 'datetime', 'disabled', 'mode'] + }), + Component({ + selector: 'ion-datetime-button', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'datetime', 'disabled', 'mode'], + standalone: false + }) +], IonDatetimeButton); +export { IonDatetimeButton }; +let IonFab = class IonFab { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonFab = __decorate([ + ProxyCmp({ + inputs: ['activated', 'edge', 'horizontal', 'vertical'], + methods: ['close'] + }), + Component({ + selector: 'ion-fab', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['activated', 'edge', 'horizontal', 'vertical'], + standalone: false + }) +], IonFab); +export { IonFab }; +let IonFabButton = class IonFabButton { + constructor(c, r, z) { + this.z = z; + this.ionFocus = new EventEmitter(); + this.ionBlur = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonFabButton.prototype, "ionFocus", void 0); +__decorate([ + Output() +], IonFabButton.prototype, "ionBlur", void 0); +IonFabButton = __decorate([ + ProxyCmp({ + inputs: ['activated', 'closeIcon', 'color', 'disabled', 'download', 'href', 'mode', 'rel', 'routerAnimation', 'routerDirection', 'show', 'size', 'target', 'translucent', 'type'] + }), + Component({ + selector: 'ion-fab-button', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['activated', 'closeIcon', 'color', 'disabled', 'download', 'href', 'mode', 'rel', 'routerAnimation', 'routerDirection', 'show', 'size', 'target', 'translucent', 'type'], + outputs: ['ionFocus', 'ionBlur'], + standalone: false + }) +], IonFabButton); +export { IonFabButton }; +let IonFabList = class IonFabList { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonFabList = __decorate([ + ProxyCmp({ + inputs: ['activated', 'side'] + }), + Component({ + selector: 'ion-fab-list', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['activated', 'side'], + standalone: false + }) +], IonFabList); +export { IonFabList }; +let IonFooter = class IonFooter { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonFooter = __decorate([ + ProxyCmp({ + inputs: ['collapse', 'mode', 'translucent'] + }), + Component({ + selector: 'ion-footer', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['collapse', 'mode', 'translucent'], + standalone: false + }) +], IonFooter); +export { IonFooter }; +let IonGrid = class IonGrid { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonGrid = __decorate([ + ProxyCmp({ + inputs: ['fixed'] + }), + Component({ + selector: 'ion-grid', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['fixed'], + standalone: false + }) +], IonGrid); +export { IonGrid }; +let IonHeader = class IonHeader { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonHeader = __decorate([ + ProxyCmp({ + inputs: ['collapse', 'mode', 'translucent'] + }), + Component({ + selector: 'ion-header', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['collapse', 'mode', 'translucent'], + standalone: false + }) +], IonHeader); +export { IonHeader }; +let IonIcon = class IonIcon { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonIcon = __decorate([ + ProxyCmp({ + inputs: ['color', 'flipRtl', 'icon', 'ios', 'lazy', 'md', 'mode', 'name', 'sanitize', 'size', 'src'] + }), + Component({ + selector: 'ion-icon', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'flipRtl', 'icon', 'ios', 'lazy', 'md', 'mode', 'name', 'sanitize', 'size', 'src'], + standalone: false + }) +], IonIcon); +export { IonIcon }; +let IonImg = class IonImg { + constructor(c, r, z) { + this.z = z; + this.ionImgWillLoad = new EventEmitter(); + this.ionImgDidLoad = new EventEmitter(); + this.ionError = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonImg.prototype, "ionImgWillLoad", void 0); +__decorate([ + Output() +], IonImg.prototype, "ionImgDidLoad", void 0); +__decorate([ + Output() +], IonImg.prototype, "ionError", void 0); +IonImg = __decorate([ + ProxyCmp({ + inputs: ['alt', 'src'] + }), + Component({ + selector: 'ion-img', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['alt', 'src'], + outputs: ['ionImgWillLoad', 'ionImgDidLoad', 'ionError'], + standalone: false + }) +], IonImg); +export { IonImg }; +let IonInfiniteScroll = class IonInfiniteScroll { + constructor(c, r, z) { + this.z = z; + this.ionInfinite = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonInfiniteScroll.prototype, "ionInfinite", void 0); +IonInfiniteScroll = __decorate([ + ProxyCmp({ + inputs: ['disabled', 'position', 'threshold'], + methods: ['complete'] + }), + Component({ + selector: 'ion-infinite-scroll', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['disabled', 'position', 'threshold'], + outputs: ['ionInfinite'], + standalone: false + }) +], IonInfiniteScroll); +export { IonInfiniteScroll }; +let IonInfiniteScrollContent = class IonInfiniteScrollContent { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonInfiniteScrollContent = __decorate([ + ProxyCmp({ + inputs: ['loadingSpinner', 'loadingText'] + }), + Component({ + selector: 'ion-infinite-scroll-content', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['loadingSpinner', 'loadingText'], + standalone: false + }) +], IonInfiniteScrollContent); +export { IonInfiniteScrollContent }; +let IonInput = class IonInput { + constructor(c, r, z) { + this.z = z; + this.ionInput = new EventEmitter(); + this.ionChange = new EventEmitter(); + this.ionBlur = new EventEmitter(); + this.ionFocus = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonInput.prototype, "ionInput", void 0); +__decorate([ + Output() +], IonInput.prototype, "ionChange", void 0); +__decorate([ + Output() +], IonInput.prototype, "ionBlur", void 0); +__decorate([ + Output() +], IonInput.prototype, "ionFocus", void 0); +IonInput = __decorate([ + ProxyCmp({ + inputs: ['autocapitalize', 'autocomplete', 'autocorrect', 'autofocus', 'clearInput', 'clearInputIcon', 'clearOnEdit', 'color', 'counter', 'counterFormatter', 'debounce', 'disabled', 'enterkeyhint', 'errorText', 'fill', 'helperText', 'inputmode', 'label', 'labelPlacement', 'max', 'maxlength', 'min', 'minlength', 'mode', 'multiple', 'name', 'pattern', 'placeholder', 'readonly', 'required', 'shape', 'spellcheck', 'step', 'type', 'value'], + methods: ['setFocus', 'getInputElement'] + }), + Component({ + selector: 'ion-input', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['autocapitalize', 'autocomplete', 'autocorrect', 'autofocus', 'clearInput', 'clearInputIcon', 'clearOnEdit', 'color', 'counter', 'counterFormatter', 'debounce', 'disabled', 'enterkeyhint', 'errorText', 'fill', 'helperText', 'inputmode', 'label', 'labelPlacement', 'max', 'maxlength', 'min', 'minlength', 'mode', 'multiple', 'name', 'pattern', 'placeholder', 'readonly', 'required', 'shape', 'spellcheck', 'step', 'type', 'value'], + outputs: ['ionInput', 'ionChange', 'ionBlur', 'ionFocus'], + standalone: false + }) +], IonInput); +export { IonInput }; +let IonInputOtp = class IonInputOtp { + constructor(c, r, z) { + this.z = z; + this.ionInput = new EventEmitter(); + this.ionChange = new EventEmitter(); + this.ionComplete = new EventEmitter(); + this.ionBlur = new EventEmitter(); + this.ionFocus = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonInputOtp.prototype, "ionInput", void 0); +__decorate([ + Output() +], IonInputOtp.prototype, "ionChange", void 0); +__decorate([ + Output() +], IonInputOtp.prototype, "ionComplete", void 0); +__decorate([ + Output() +], IonInputOtp.prototype, "ionBlur", void 0); +__decorate([ + Output() +], IonInputOtp.prototype, "ionFocus", void 0); +IonInputOtp = __decorate([ + ProxyCmp({ + inputs: ['autocapitalize', 'color', 'disabled', 'fill', 'inputmode', 'length', 'pattern', 'readonly', 'separators', 'shape', 'size', 'type', 'value'], + methods: ['setFocus'] + }), + Component({ + selector: 'ion-input-otp', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['autocapitalize', 'color', 'disabled', 'fill', 'inputmode', 'length', 'pattern', 'readonly', 'separators', 'shape', 'size', 'type', 'value'], + outputs: ['ionInput', 'ionChange', 'ionComplete', 'ionBlur', 'ionFocus'], + standalone: false + }) +], IonInputOtp); +export { IonInputOtp }; +let IonInputPasswordToggle = class IonInputPasswordToggle { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonInputPasswordToggle = __decorate([ + ProxyCmp({ + inputs: ['color', 'hideIcon', 'mode', 'showIcon'] + }), + Component({ + selector: 'ion-input-password-toggle', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'hideIcon', 'mode', 'showIcon'], + standalone: false + }) +], IonInputPasswordToggle); +export { IonInputPasswordToggle }; +let IonItem = class IonItem { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonItem = __decorate([ + ProxyCmp({ + inputs: ['button', 'color', 'detail', 'detailIcon', 'disabled', 'download', 'href', 'lines', 'mode', 'rel', 'routerAnimation', 'routerDirection', 'target', 'type'] + }), + Component({ + selector: 'ion-item', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['button', 'color', 'detail', 'detailIcon', 'disabled', 'download', 'href', 'lines', 'mode', 'rel', 'routerAnimation', 'routerDirection', 'target', 'type'], + standalone: false + }) +], IonItem); +export { IonItem }; +let IonItemDivider = class IonItemDivider { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonItemDivider = __decorate([ + ProxyCmp({ + inputs: ['color', 'mode', 'sticky'] + }), + Component({ + selector: 'ion-item-divider', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'mode', 'sticky'], + standalone: false + }) +], IonItemDivider); +export { IonItemDivider }; +let IonItemGroup = class IonItemGroup { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonItemGroup = __decorate([ + ProxyCmp({}), + Component({ + selector: 'ion-item-group', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: [], + standalone: false + }) +], IonItemGroup); +export { IonItemGroup }; +let IonItemOption = class IonItemOption { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonItemOption = __decorate([ + ProxyCmp({ + inputs: ['color', 'disabled', 'download', 'expandable', 'href', 'mode', 'rel', 'target', 'type'] + }), + Component({ + selector: 'ion-item-option', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'disabled', 'download', 'expandable', 'href', 'mode', 'rel', 'target', 'type'], + standalone: false + }) +], IonItemOption); +export { IonItemOption }; +let IonItemOptions = class IonItemOptions { + constructor(c, r, z) { + this.z = z; + this.ionSwipe = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonItemOptions.prototype, "ionSwipe", void 0); +IonItemOptions = __decorate([ + ProxyCmp({ + inputs: ['side'] + }), + Component({ + selector: 'ion-item-options', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['side'], + outputs: ['ionSwipe'], + standalone: false + }) +], IonItemOptions); +export { IonItemOptions }; +let IonItemSliding = class IonItemSliding { + constructor(c, r, z) { + this.z = z; + this.ionDrag = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonItemSliding.prototype, "ionDrag", void 0); +IonItemSliding = __decorate([ + ProxyCmp({ + inputs: ['disabled'], + methods: ['getOpenAmount', 'getSlidingRatio', 'open', 'close', 'closeOpened'] + }), + Component({ + selector: 'ion-item-sliding', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['disabled'], + outputs: ['ionDrag'], + standalone: false + }) +], IonItemSliding); +export { IonItemSliding }; +let IonLabel = class IonLabel { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonLabel = __decorate([ + ProxyCmp({ + inputs: ['color', 'mode', 'position'] + }), + Component({ + selector: 'ion-label', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'mode', 'position'], + standalone: false + }) +], IonLabel); +export { IonLabel }; +let IonList = class IonList { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonList = __decorate([ + ProxyCmp({ + inputs: ['inset', 'lines', 'mode'], + methods: ['closeSlidingItems'] + }), + Component({ + selector: 'ion-list', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['inset', 'lines', 'mode'], + standalone: false + }) +], IonList); +export { IonList }; +let IonListHeader = class IonListHeader { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonListHeader = __decorate([ + ProxyCmp({ + inputs: ['color', 'lines', 'mode'] + }), + Component({ + selector: 'ion-list-header', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'lines', 'mode'], + standalone: false + }) +], IonListHeader); +export { IonListHeader }; +let IonLoading = class IonLoading { + constructor(c, r, z) { + this.z = z; + this.ionLoadingDidPresent = new EventEmitter(); + this.ionLoadingWillPresent = new EventEmitter(); + this.ionLoadingWillDismiss = new EventEmitter(); + this.ionLoadingDidDismiss = new EventEmitter(); + this.didPresent = new EventEmitter(); + this.willPresent = new EventEmitter(); + this.willDismiss = new EventEmitter(); + this.didDismiss = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonLoading.prototype, "ionLoadingDidPresent", void 0); +__decorate([ + Output() +], IonLoading.prototype, "ionLoadingWillPresent", void 0); +__decorate([ + Output() +], IonLoading.prototype, "ionLoadingWillDismiss", void 0); +__decorate([ + Output() +], IonLoading.prototype, "ionLoadingDidDismiss", void 0); +__decorate([ + Output() +], IonLoading.prototype, "didPresent", void 0); +__decorate([ + Output() +], IonLoading.prototype, "willPresent", void 0); +__decorate([ + Output() +], IonLoading.prototype, "willDismiss", void 0); +__decorate([ + Output() +], IonLoading.prototype, "didDismiss", void 0); +IonLoading = __decorate([ + ProxyCmp({ + inputs: ['animated', 'backdropDismiss', 'cssClass', 'duration', 'enterAnimation', 'htmlAttributes', 'isOpen', 'keyboardClose', 'leaveAnimation', 'message', 'mode', 'showBackdrop', 'spinner', 'translucent', 'trigger'], + methods: ['present', 'dismiss', 'onDidDismiss', 'onWillDismiss'] + }), + Component({ + selector: 'ion-loading', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['animated', 'backdropDismiss', 'cssClass', 'duration', 'enterAnimation', 'htmlAttributes', 'isOpen', 'keyboardClose', 'leaveAnimation', 'message', 'mode', 'showBackdrop', 'spinner', 'translucent', 'trigger'], + outputs: ['ionLoadingDidPresent', 'ionLoadingWillPresent', 'ionLoadingWillDismiss', 'ionLoadingDidDismiss', 'didPresent', 'willPresent', 'willDismiss', 'didDismiss'], + standalone: false + }) +], IonLoading); +export { IonLoading }; +let IonMenu = class IonMenu { + constructor(c, r, z) { + this.z = z; + this.ionWillOpen = new EventEmitter(); + this.ionWillClose = new EventEmitter(); + this.ionDidOpen = new EventEmitter(); + this.ionDidClose = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonMenu.prototype, "ionWillOpen", void 0); +__decorate([ + Output() +], IonMenu.prototype, "ionWillClose", void 0); +__decorate([ + Output() +], IonMenu.prototype, "ionDidOpen", void 0); +__decorate([ + Output() +], IonMenu.prototype, "ionDidClose", void 0); +IonMenu = __decorate([ + ProxyCmp({ + inputs: ['contentId', 'disabled', 'maxEdgeStart', 'menuId', 'side', 'swipeGesture', 'type'], + methods: ['isOpen', 'isActive', 'open', 'close', 'toggle', 'setOpen'] + }), + Component({ + selector: 'ion-menu', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['contentId', 'disabled', 'maxEdgeStart', 'menuId', 'side', 'swipeGesture', 'type'], + outputs: ['ionWillOpen', 'ionWillClose', 'ionDidOpen', 'ionDidClose'], + standalone: false + }) +], IonMenu); +export { IonMenu }; +let IonMenuButton = class IonMenuButton { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonMenuButton = __decorate([ + ProxyCmp({ + inputs: ['autoHide', 'color', 'disabled', 'menu', 'mode', 'type'] + }), + Component({ + selector: 'ion-menu-button', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['autoHide', 'color', 'disabled', 'menu', 'mode', 'type'], + standalone: false + }) +], IonMenuButton); +export { IonMenuButton }; +let IonMenuToggle = class IonMenuToggle { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonMenuToggle = __decorate([ + ProxyCmp({ + inputs: ['autoHide', 'menu'] + }), + Component({ + selector: 'ion-menu-toggle', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['autoHide', 'menu'], + standalone: false + }) +], IonMenuToggle); +export { IonMenuToggle }; +let IonNavLink = class IonNavLink { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonNavLink = __decorate([ + ProxyCmp({ + inputs: ['component', 'componentProps', 'routerAnimation', 'routerDirection'] + }), + Component({ + selector: 'ion-nav-link', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['component', 'componentProps', 'routerAnimation', 'routerDirection'], + standalone: false + }) +], IonNavLink); +export { IonNavLink }; +let IonNote = class IonNote { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonNote = __decorate([ + ProxyCmp({ + inputs: ['color', 'mode'] + }), + Component({ + selector: 'ion-note', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'mode'], + standalone: false + }) +], IonNote); +export { IonNote }; +let IonPicker = class IonPicker { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonPicker = __decorate([ + ProxyCmp({ + inputs: ['mode'] + }), + Component({ + selector: 'ion-picker', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['mode'], + standalone: false + }) +], IonPicker); +export { IonPicker }; +let IonPickerColumn = class IonPickerColumn { + constructor(c, r, z) { + this.z = z; + this.ionChange = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonPickerColumn.prototype, "ionChange", void 0); +IonPickerColumn = __decorate([ + ProxyCmp({ + inputs: ['color', 'disabled', 'mode', 'value'], + methods: ['setFocus'] + }), + Component({ + selector: 'ion-picker-column', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'disabled', 'mode', 'value'], + outputs: ['ionChange'], + standalone: false + }) +], IonPickerColumn); +export { IonPickerColumn }; +let IonPickerColumnOption = class IonPickerColumnOption { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonPickerColumnOption = __decorate([ + ProxyCmp({ + inputs: ['color', 'disabled', 'value'] + }), + Component({ + selector: 'ion-picker-column-option', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'disabled', 'value'], + standalone: false + }) +], IonPickerColumnOption); +export { IonPickerColumnOption }; +let IonProgressBar = class IonProgressBar { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonProgressBar = __decorate([ + ProxyCmp({ + inputs: ['buffer', 'color', 'mode', 'reversed', 'type', 'value'] + }), + Component({ + selector: 'ion-progress-bar', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['buffer', 'color', 'mode', 'reversed', 'type', 'value'], + standalone: false + }) +], IonProgressBar); +export { IonProgressBar }; +let IonRadio = class IonRadio { + constructor(c, r, z) { + this.z = z; + this.ionFocus = new EventEmitter(); + this.ionBlur = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonRadio.prototype, "ionFocus", void 0); +__decorate([ + Output() +], IonRadio.prototype, "ionBlur", void 0); +IonRadio = __decorate([ + ProxyCmp({ + inputs: ['alignment', 'color', 'disabled', 'justify', 'labelPlacement', 'mode', 'name', 'value'] + }), + Component({ + selector: 'ion-radio', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['alignment', 'color', 'disabled', 'justify', 'labelPlacement', 'mode', 'name', 'value'], + outputs: ['ionFocus', 'ionBlur'], + standalone: false + }) +], IonRadio); +export { IonRadio }; +let IonRadioGroup = class IonRadioGroup { + constructor(c, r, z) { + this.z = z; + this.ionChange = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonRadioGroup.prototype, "ionChange", void 0); +IonRadioGroup = __decorate([ + ProxyCmp({ + inputs: ['allowEmptySelection', 'compareWith', 'errorText', 'helperText', 'name', 'value'] + }), + Component({ + selector: 'ion-radio-group', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['allowEmptySelection', 'compareWith', 'errorText', 'helperText', 'name', 'value'], + outputs: ['ionChange'], + standalone: false + }) +], IonRadioGroup); +export { IonRadioGroup }; +let IonRange = class IonRange { + constructor(c, r, z) { + this.z = z; + this.ionChange = new EventEmitter(); + this.ionInput = new EventEmitter(); + this.ionFocus = new EventEmitter(); + this.ionBlur = new EventEmitter(); + this.ionKnobMoveStart = new EventEmitter(); + this.ionKnobMoveEnd = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonRange.prototype, "ionChange", void 0); +__decorate([ + Output() +], IonRange.prototype, "ionInput", void 0); +__decorate([ + Output() +], IonRange.prototype, "ionFocus", void 0); +__decorate([ + Output() +], IonRange.prototype, "ionBlur", void 0); +__decorate([ + Output() +], IonRange.prototype, "ionKnobMoveStart", void 0); +__decorate([ + Output() +], IonRange.prototype, "ionKnobMoveEnd", void 0); +IonRange = __decorate([ + ProxyCmp({ + inputs: ['activeBarStart', 'color', 'debounce', 'disabled', 'dualKnobs', 'label', 'labelPlacement', 'max', 'min', 'mode', 'name', 'pin', 'pinFormatter', 'snaps', 'step', 'ticks', 'value'] + }), + Component({ + selector: 'ion-range', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['activeBarStart', 'color', 'debounce', 'disabled', 'dualKnobs', 'label', 'labelPlacement', 'max', 'min', 'mode', 'name', 'pin', 'pinFormatter', 'snaps', 'step', 'ticks', 'value'], + outputs: ['ionChange', 'ionInput', 'ionFocus', 'ionBlur', 'ionKnobMoveStart', 'ionKnobMoveEnd'], + standalone: false + }) +], IonRange); +export { IonRange }; +let IonRefresher = class IonRefresher { + constructor(c, r, z) { + this.z = z; + this.ionRefresh = new EventEmitter(); + this.ionPull = new EventEmitter(); + this.ionStart = new EventEmitter(); + this.ionPullStart = new EventEmitter(); + this.ionPullEnd = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonRefresher.prototype, "ionRefresh", void 0); +__decorate([ + Output() +], IonRefresher.prototype, "ionPull", void 0); +__decorate([ + Output() +], IonRefresher.prototype, "ionStart", void 0); +__decorate([ + Output() +], IonRefresher.prototype, "ionPullStart", void 0); +__decorate([ + Output() +], IonRefresher.prototype, "ionPullEnd", void 0); +IonRefresher = __decorate([ + ProxyCmp({ + inputs: ['closeDuration', 'disabled', 'mode', 'pullFactor', 'pullMax', 'pullMin', 'snapbackDuration'], + methods: ['complete', 'cancel', 'getProgress'] + }), + Component({ + selector: 'ion-refresher', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['closeDuration', 'disabled', 'mode', 'pullFactor', 'pullMax', 'pullMin', 'snapbackDuration'], + outputs: ['ionRefresh', 'ionPull', 'ionStart', 'ionPullStart', 'ionPullEnd'], + standalone: false + }) +], IonRefresher); +export { IonRefresher }; +let IonRefresherContent = class IonRefresherContent { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonRefresherContent = __decorate([ + ProxyCmp({ + inputs: ['pullingIcon', 'pullingText', 'refreshingSpinner', 'refreshingText'] + }), + Component({ + selector: 'ion-refresher-content', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['pullingIcon', 'pullingText', 'refreshingSpinner', 'refreshingText'], + standalone: false + }) +], IonRefresherContent); +export { IonRefresherContent }; +let IonReorder = class IonReorder { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonReorder = __decorate([ + ProxyCmp({}), + Component({ + selector: 'ion-reorder', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: [], + standalone: false + }) +], IonReorder); +export { IonReorder }; +let IonReorderGroup = class IonReorderGroup { + constructor(c, r, z) { + this.z = z; + this.ionItemReorder = new EventEmitter(); + this.ionReorderStart = new EventEmitter(); + this.ionReorderMove = new EventEmitter(); + this.ionReorderEnd = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonReorderGroup.prototype, "ionItemReorder", void 0); +__decorate([ + Output() +], IonReorderGroup.prototype, "ionReorderStart", void 0); +__decorate([ + Output() +], IonReorderGroup.prototype, "ionReorderMove", void 0); +__decorate([ + Output() +], IonReorderGroup.prototype, "ionReorderEnd", void 0); +IonReorderGroup = __decorate([ + ProxyCmp({ + inputs: ['disabled'], + methods: ['complete'] + }), + Component({ + selector: 'ion-reorder-group', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['disabled'], + outputs: ['ionItemReorder', 'ionReorderStart', 'ionReorderMove', 'ionReorderEnd'], + standalone: false + }) +], IonReorderGroup); +export { IonReorderGroup }; +let IonRippleEffect = class IonRippleEffect { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonRippleEffect = __decorate([ + ProxyCmp({ + inputs: ['type'], + methods: ['addRipple'] + }), + Component({ + selector: 'ion-ripple-effect', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['type'], + standalone: false + }) +], IonRippleEffect); +export { IonRippleEffect }; +let IonRow = class IonRow { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonRow = __decorate([ + ProxyCmp({}), + Component({ + selector: 'ion-row', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: [], + standalone: false + }) +], IonRow); +export { IonRow }; +let IonSearchbar = class IonSearchbar { + constructor(c, r, z) { + this.z = z; + this.ionInput = new EventEmitter(); + this.ionChange = new EventEmitter(); + this.ionCancel = new EventEmitter(); + this.ionClear = new EventEmitter(); + this.ionBlur = new EventEmitter(); + this.ionFocus = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonSearchbar.prototype, "ionInput", void 0); +__decorate([ + Output() +], IonSearchbar.prototype, "ionChange", void 0); +__decorate([ + Output() +], IonSearchbar.prototype, "ionCancel", void 0); +__decorate([ + Output() +], IonSearchbar.prototype, "ionClear", void 0); +__decorate([ + Output() +], IonSearchbar.prototype, "ionBlur", void 0); +__decorate([ + Output() +], IonSearchbar.prototype, "ionFocus", void 0); +IonSearchbar = __decorate([ + ProxyCmp({ + inputs: ['animated', 'autocapitalize', 'autocomplete', 'autocorrect', 'cancelButtonIcon', 'cancelButtonText', 'clearIcon', 'color', 'debounce', 'disabled', 'enterkeyhint', 'inputmode', 'maxlength', 'minlength', 'mode', 'name', 'placeholder', 'searchIcon', 'showCancelButton', 'showClearButton', 'spellcheck', 'type', 'value'], + methods: ['setFocus', 'getInputElement'] + }), + Component({ + selector: 'ion-searchbar', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['animated', 'autocapitalize', 'autocomplete', 'autocorrect', 'cancelButtonIcon', 'cancelButtonText', 'clearIcon', 'color', 'debounce', 'disabled', 'enterkeyhint', 'inputmode', 'maxlength', 'minlength', 'mode', 'name', 'placeholder', 'searchIcon', 'showCancelButton', 'showClearButton', 'spellcheck', 'type', 'value'], + outputs: ['ionInput', 'ionChange', 'ionCancel', 'ionClear', 'ionBlur', 'ionFocus'], + standalone: false + }) +], IonSearchbar); +export { IonSearchbar }; +let IonSegment = class IonSegment { + constructor(c, r, z) { + this.z = z; + this.ionChange = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonSegment.prototype, "ionChange", void 0); +IonSegment = __decorate([ + ProxyCmp({ + inputs: ['color', 'disabled', 'mode', 'scrollable', 'selectOnFocus', 'swipeGesture', 'value'] + }), + Component({ + selector: 'ion-segment', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'disabled', 'mode', 'scrollable', 'selectOnFocus', 'swipeGesture', 'value'], + outputs: ['ionChange'], + standalone: false + }) +], IonSegment); +export { IonSegment }; +let IonSegmentButton = class IonSegmentButton { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonSegmentButton = __decorate([ + ProxyCmp({ + inputs: ['contentId', 'disabled', 'layout', 'mode', 'type', 'value'] + }), + Component({ + selector: 'ion-segment-button', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['contentId', 'disabled', 'layout', 'mode', 'type', 'value'], + standalone: false + }) +], IonSegmentButton); +export { IonSegmentButton }; +let IonSegmentContent = class IonSegmentContent { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonSegmentContent = __decorate([ + ProxyCmp({}), + Component({ + selector: 'ion-segment-content', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: [], + standalone: false + }) +], IonSegmentContent); +export { IonSegmentContent }; +let IonSegmentView = class IonSegmentView { + constructor(c, r, z) { + this.z = z; + this.ionSegmentViewScroll = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonSegmentView.prototype, "ionSegmentViewScroll", void 0); +IonSegmentView = __decorate([ + ProxyCmp({ + inputs: ['disabled', 'swipeGesture'] + }), + Component({ + selector: 'ion-segment-view', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['disabled', 'swipeGesture'], + outputs: ['ionSegmentViewScroll'], + standalone: false + }) +], IonSegmentView); +export { IonSegmentView }; +let IonSelect = class IonSelect { + constructor(c, r, z) { + this.z = z; + this.ionChange = new EventEmitter(); + this.ionCancel = new EventEmitter(); + this.ionDismiss = new EventEmitter(); + this.ionFocus = new EventEmitter(); + this.ionBlur = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonSelect.prototype, "ionChange", void 0); +__decorate([ + Output() +], IonSelect.prototype, "ionCancel", void 0); +__decorate([ + Output() +], IonSelect.prototype, "ionDismiss", void 0); +__decorate([ + Output() +], IonSelect.prototype, "ionFocus", void 0); +__decorate([ + Output() +], IonSelect.prototype, "ionBlur", void 0); +IonSelect = __decorate([ + ProxyCmp({ + inputs: ['cancelText', 'color', 'compareWith', 'disabled', 'errorText', 'expandedIcon', 'fill', 'helperText', 'interface', 'interfaceOptions', 'justify', 'label', 'labelPlacement', 'mode', 'multiple', 'name', 'okText', 'placeholder', 'required', 'selectedText', 'shape', 'toggleIcon', 'value'], + methods: ['open'] + }), + Component({ + selector: 'ion-select', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['cancelText', 'color', 'compareWith', 'disabled', 'errorText', 'expandedIcon', 'fill', 'helperText', 'interface', 'interfaceOptions', 'justify', 'label', 'labelPlacement', 'mode', 'multiple', 'name', 'okText', 'placeholder', 'required', 'selectedText', 'shape', 'toggleIcon', 'value'], + outputs: ['ionChange', 'ionCancel', 'ionDismiss', 'ionFocus', 'ionBlur'], + standalone: false + }) +], IonSelect); +export { IonSelect }; +let IonSelectModal = class IonSelectModal { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonSelectModal = __decorate([ + ProxyCmp({ + inputs: ['cancelText', 'header', 'multiple', 'options'] + }), + Component({ + selector: 'ion-select-modal', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['cancelText', 'header', 'multiple', 'options'], + standalone: false + }) +], IonSelectModal); +export { IonSelectModal }; +let IonSelectOption = class IonSelectOption { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonSelectOption = __decorate([ + ProxyCmp({ + inputs: ['description', 'disabled', 'justify', 'labelPlacement', 'mode', 'value'] + }), + Component({ + selector: 'ion-select-option', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['description', 'disabled', 'justify', 'labelPlacement', 'mode', 'value'], + standalone: false + }) +], IonSelectOption); +export { IonSelectOption }; +let IonSkeletonText = class IonSkeletonText { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonSkeletonText = __decorate([ + ProxyCmp({ + inputs: ['animated'] + }), + Component({ + selector: 'ion-skeleton-text', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['animated'], + standalone: false + }) +], IonSkeletonText); +export { IonSkeletonText }; +let IonSpinner = class IonSpinner { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonSpinner = __decorate([ + ProxyCmp({ + inputs: ['color', 'duration', 'name', 'paused'] + }), + Component({ + selector: 'ion-spinner', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'duration', 'name', 'paused'], + standalone: false + }) +], IonSpinner); +export { IonSpinner }; +let IonSplitPane = class IonSplitPane { + constructor(c, r, z) { + this.z = z; + this.ionSplitPaneVisible = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonSplitPane.prototype, "ionSplitPaneVisible", void 0); +IonSplitPane = __decorate([ + ProxyCmp({ + inputs: ['contentId', 'disabled', 'when'] + }), + Component({ + selector: 'ion-split-pane', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['contentId', 'disabled', 'when'], + outputs: ['ionSplitPaneVisible'], + standalone: false + }) +], IonSplitPane); +export { IonSplitPane }; +let IonTab = class IonTab { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonTab = __decorate([ + ProxyCmp({ + inputs: ['component', 'tab'], + methods: ['setActive'] + }), + Component({ + selector: 'ion-tab', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['component', { name: 'tab', required: true }], + standalone: false + }) +], IonTab); +export { IonTab }; +let IonTabBar = class IonTabBar { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonTabBar = __decorate([ + ProxyCmp({ + inputs: ['color', 'mode', 'selectedTab', 'translucent'] + }), + Component({ + selector: 'ion-tab-bar', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'mode', 'selectedTab', 'translucent'], + standalone: false + }) +], IonTabBar); +export { IonTabBar }; +let IonTabButton = class IonTabButton { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonTabButton = __decorate([ + ProxyCmp({ + inputs: ['disabled', 'download', 'href', 'layout', 'mode', 'rel', 'selected', 'tab', 'target'] + }), + Component({ + selector: 'ion-tab-button', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['disabled', 'download', 'href', 'layout', 'mode', 'rel', 'selected', 'tab', 'target'], + standalone: false + }) +], IonTabButton); +export { IonTabButton }; +let IonText = class IonText { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonText = __decorate([ + ProxyCmp({ + inputs: ['color', 'mode'] + }), + Component({ + selector: 'ion-text', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'mode'], + standalone: false + }) +], IonText); +export { IonText }; +let IonTextarea = class IonTextarea { + constructor(c, r, z) { + this.z = z; + this.ionChange = new EventEmitter(); + this.ionInput = new EventEmitter(); + this.ionBlur = new EventEmitter(); + this.ionFocus = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonTextarea.prototype, "ionChange", void 0); +__decorate([ + Output() +], IonTextarea.prototype, "ionInput", void 0); +__decorate([ + Output() +], IonTextarea.prototype, "ionBlur", void 0); +__decorate([ + Output() +], IonTextarea.prototype, "ionFocus", void 0); +IonTextarea = __decorate([ + ProxyCmp({ + inputs: ['autoGrow', 'autocapitalize', 'autofocus', 'clearOnEdit', 'color', 'cols', 'counter', 'counterFormatter', 'debounce', 'disabled', 'enterkeyhint', 'errorText', 'fill', 'helperText', 'inputmode', 'label', 'labelPlacement', 'maxlength', 'minlength', 'mode', 'name', 'placeholder', 'readonly', 'required', 'rows', 'shape', 'spellcheck', 'value', 'wrap'], + methods: ['setFocus', 'getInputElement'] + }), + Component({ + selector: 'ion-textarea', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['autoGrow', 'autocapitalize', 'autofocus', 'clearOnEdit', 'color', 'cols', 'counter', 'counterFormatter', 'debounce', 'disabled', 'enterkeyhint', 'errorText', 'fill', 'helperText', 'inputmode', 'label', 'labelPlacement', 'maxlength', 'minlength', 'mode', 'name', 'placeholder', 'readonly', 'required', 'rows', 'shape', 'spellcheck', 'value', 'wrap'], + outputs: ['ionChange', 'ionInput', 'ionBlur', 'ionFocus'], + standalone: false + }) +], IonTextarea); +export { IonTextarea }; +let IonThumbnail = class IonThumbnail { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonThumbnail = __decorate([ + ProxyCmp({}), + Component({ + selector: 'ion-thumbnail', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: [], + standalone: false + }) +], IonThumbnail); +export { IonThumbnail }; +let IonTitle = class IonTitle { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonTitle = __decorate([ + ProxyCmp({ + inputs: ['color', 'size'] + }), + Component({ + selector: 'ion-title', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'size'], + standalone: false + }) +], IonTitle); +export { IonTitle }; +let IonToast = class IonToast { + constructor(c, r, z) { + this.z = z; + this.ionToastDidPresent = new EventEmitter(); + this.ionToastWillPresent = new EventEmitter(); + this.ionToastWillDismiss = new EventEmitter(); + this.ionToastDidDismiss = new EventEmitter(); + this.didPresent = new EventEmitter(); + this.willPresent = new EventEmitter(); + this.willDismiss = new EventEmitter(); + this.didDismiss = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonToast.prototype, "ionToastDidPresent", void 0); +__decorate([ + Output() +], IonToast.prototype, "ionToastWillPresent", void 0); +__decorate([ + Output() +], IonToast.prototype, "ionToastWillDismiss", void 0); +__decorate([ + Output() +], IonToast.prototype, "ionToastDidDismiss", void 0); +__decorate([ + Output() +], IonToast.prototype, "didPresent", void 0); +__decorate([ + Output() +], IonToast.prototype, "willPresent", void 0); +__decorate([ + Output() +], IonToast.prototype, "willDismiss", void 0); +__decorate([ + Output() +], IonToast.prototype, "didDismiss", void 0); +IonToast = __decorate([ + ProxyCmp({ + inputs: ['animated', 'buttons', 'color', 'cssClass', 'duration', 'enterAnimation', 'header', 'htmlAttributes', 'icon', 'isOpen', 'keyboardClose', 'layout', 'leaveAnimation', 'message', 'mode', 'position', 'positionAnchor', 'swipeGesture', 'translucent', 'trigger'], + methods: ['present', 'dismiss', 'onDidDismiss', 'onWillDismiss'] + }), + Component({ + selector: 'ion-toast', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['animated', 'buttons', 'color', 'cssClass', 'duration', 'enterAnimation', 'header', 'htmlAttributes', 'icon', 'isOpen', 'keyboardClose', 'layout', 'leaveAnimation', 'message', 'mode', 'position', 'positionAnchor', 'swipeGesture', 'translucent', 'trigger'], + outputs: ['ionToastDidPresent', 'ionToastWillPresent', 'ionToastWillDismiss', 'ionToastDidDismiss', 'didPresent', 'willPresent', 'willDismiss', 'didDismiss'], + standalone: false + }) +], IonToast); +export { IonToast }; +let IonToggle = class IonToggle { + constructor(c, r, z) { + this.z = z; + this.ionChange = new EventEmitter(); + this.ionFocus = new EventEmitter(); + this.ionBlur = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonToggle.prototype, "ionChange", void 0); +__decorate([ + Output() +], IonToggle.prototype, "ionFocus", void 0); +__decorate([ + Output() +], IonToggle.prototype, "ionBlur", void 0); +IonToggle = __decorate([ + ProxyCmp({ + inputs: ['alignment', 'checked', 'color', 'disabled', 'enableOnOffLabels', 'errorText', 'helperText', 'justify', 'labelPlacement', 'mode', 'name', 'required', 'value'] + }), + Component({ + selector: 'ion-toggle', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['alignment', 'checked', 'color', 'disabled', 'enableOnOffLabels', 'errorText', 'helperText', 'justify', 'labelPlacement', 'mode', 'name', 'required', 'value'], + outputs: ['ionChange', 'ionFocus', 'ionBlur'], + standalone: false + }) +], IonToggle); +export { IonToggle }; +let IonToolbar = class IonToolbar { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonToolbar = __decorate([ + ProxyCmp({ + inputs: ['color', 'mode'] + }), + Component({ + selector: 'ion-toolbar', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'mode'], + standalone: false + }) +], IonToolbar); +export { IonToolbar }; diff --git a/packages/angular/build/es2015/lazy/src/directives/validators/index.js b/packages/angular/build/es2015/lazy/src/directives/validators/index.js new file mode 100644 index 00000000000..50edda4ec57 --- /dev/null +++ b/packages/angular/build/es2015/lazy/src/directives/validators/index.js @@ -0,0 +1,2 @@ +export * from './max-validator'; +export * from './min-validator'; diff --git a/packages/angular/build/es2015/lazy/src/directives/validators/max-validator.js b/packages/angular/build/es2015/lazy/src/directives/validators/max-validator.js new file mode 100644 index 00000000000..1c194ac2539 --- /dev/null +++ b/packages/angular/build/es2015/lazy/src/directives/validators/max-validator.js @@ -0,0 +1,23 @@ +import { __decorate } from "tslib"; +import { Directive, forwardRef } from '@angular/core'; +import { MaxValidator, NG_VALIDATORS } from '@angular/forms'; +/** + * @description + * Provider which adds `MaxValidator` to the `NG_VALIDATORS` multi-provider list. + */ +export const ION_MAX_VALIDATOR = { + provide: NG_VALIDATORS, + useExisting: forwardRef(() => IonMaxValidator), + multi: true, +}; +let IonMaxValidator = class IonMaxValidator extends MaxValidator { +}; +IonMaxValidator = __decorate([ + Directive({ + standalone: false, + selector: 'ion-input[type=number][max][formControlName],ion-input[type=number][max][formControl],ion-input[type=number][max][ngModel]', + providers: [ION_MAX_VALIDATOR], + host: { '[attr.max]': 'enabled(max) ? max : null' }, + }) +], IonMaxValidator); +export { IonMaxValidator }; diff --git a/packages/angular/build/es2015/lazy/src/directives/validators/min-validator.js b/packages/angular/build/es2015/lazy/src/directives/validators/min-validator.js new file mode 100644 index 00000000000..a4a0eeede53 --- /dev/null +++ b/packages/angular/build/es2015/lazy/src/directives/validators/min-validator.js @@ -0,0 +1,23 @@ +import { __decorate } from "tslib"; +import { Directive, forwardRef } from '@angular/core'; +import { MinValidator, NG_VALIDATORS } from '@angular/forms'; +/** + * @description + * Provider which adds `MinValidator` to the `NG_VALIDATORS` multi-provider list. + */ +export const ION_MIN_VALIDATOR = { + provide: NG_VALIDATORS, + useExisting: forwardRef(() => IonMinValidator), + multi: true, +}; +let IonMinValidator = class IonMinValidator extends MinValidator { +}; +IonMinValidator = __decorate([ + Directive({ + standalone: false, + selector: 'ion-input[type=number][min][formControlName],ion-input[type=number][min][formControl],ion-input[type=number][min][ngModel]', + providers: [ION_MIN_VALIDATOR], + host: { '[attr.min]': 'enabled(min) ? min : null' }, + }) +], IonMinValidator); +export { IonMinValidator }; diff --git a/packages/angular/build/es2015/lazy/src/index.js b/packages/angular/build/es2015/lazy/src/index.js new file mode 100644 index 00000000000..c636c0dace7 --- /dev/null +++ b/packages/angular/build/es2015/lazy/src/index.js @@ -0,0 +1,35 @@ +// DIRECTIVES +export { BooleanValueAccessorDirective as BooleanValueAccessor } from './directives/control-value-accessors/boolean-value-accessor'; +export { NumericValueAccessorDirective as NumericValueAccessor } from './directives/control-value-accessors/numeric-value-accessor'; +export { SelectValueAccessorDirective as SelectValueAccessor } from './directives/control-value-accessors/select-value-accessor'; +export { TextValueAccessorDirective as TextValueAccessor } from './directives/control-value-accessors/text-value-accessor'; +export { IonTabs } from './directives/navigation/ion-tabs'; +export { IonBackButton } from './directives/navigation/ion-back-button'; +export { IonNav } from './directives/navigation/ion-nav'; +export { IonRouterOutlet } from './directives/navigation/ion-router-outlet'; +export { RouterLinkDelegateDirective as RouterLinkDelegate, RouterLinkWithHrefDelegateDirective as RouterLinkWithHrefDelegate, } from './directives/navigation/router-link-delegate'; +export { IonModal } from './directives/overlays/modal'; +export { IonPopover } from './directives/overlays/popover'; +export * from './directives/proxies'; +export * from './directives/validators'; +// PROVIDERS +export { DomController, NavController, Config, Platform, AngularDelegate, NavParams, IonicRouteStrategy, IonModalToken, } from '@ionic/angular/common'; +export { AlertController } from './providers/alert-controller'; +export { AnimationController } from './providers/animation-controller'; +export { ActionSheetController } from './providers/action-sheet-controller'; +export { GestureController } from './providers/gesture-controller'; +export { LoadingController } from './providers/loading-controller'; +export { MenuController } from './providers/menu-controller'; +export { ModalController } from './providers/modal-controller'; +export { PopoverController } from './providers/popover-controller'; +export { ToastController } from './providers/toast-controller'; +/* + * PACKAGE MODULE + * `IonicModule` is deprecated and will be removed in a future major version. + * Use `provideIonicAngular()` from `@ionic/angular` instead. The deprecation is + * declared on the class itself, so consumers importing it here see the notice. + */ +export { IonicModule } from './ionic-module'; +export { +// UTILS +createAnimation, createGesture, iosTransitionAnimation, mdTransitionAnimation, IonicSlides, getPlatforms, isPlatform, getTimeGivenProgression, getIonPageElement, IonicSafeString, openURL, } from '@ionic/core'; diff --git a/packages/angular/build/es2015/lazy/src/ionic-module.js b/packages/angular/build/es2015/lazy/src/ionic-module.js new file mode 100644 index 00000000000..0d126bf6b8c --- /dev/null +++ b/packages/angular/build/es2015/lazy/src/ionic-module.js @@ -0,0 +1,81 @@ +var IonicModule_1; +import { __decorate } from "tslib"; +import { CommonModule, DOCUMENT } from '@angular/common'; +import { APP_INITIALIZER, NgModule, NgZone } from '@angular/core'; +import { ConfigToken, AngularDelegate, provideComponentInputBinding } from '@ionic/angular/common'; +import { appInitialize } from './app-initialize'; +import { BooleanValueAccessorDirective, NumericValueAccessorDirective, SelectValueAccessorDirective, TextValueAccessorDirective, } from './directives/control-value-accessors'; +import { IonBackButton } from './directives/navigation/ion-back-button'; +import { IonNav } from './directives/navigation/ion-nav'; +import { IonRouterOutlet } from './directives/navigation/ion-router-outlet'; +import { IonTabs } from './directives/navigation/ion-tabs'; +import { RouterLinkDelegateDirective, RouterLinkWithHrefDelegateDirective, } from './directives/navigation/router-link-delegate'; +import { IonModal } from './directives/overlays/modal'; +import { IonPopover } from './directives/overlays/popover'; +import { DIRECTIVES } from './directives/proxies-list'; +import { IonMaxValidator, IonMinValidator } from './directives/validators'; +import { ModalController } from './providers/modal-controller'; +import { PopoverController } from './providers/popover-controller'; +const DECLARATIONS = [ + // generated proxies + ...DIRECTIVES, + // manual proxies + IonModal, + IonPopover, + // ngModel accessors + BooleanValueAccessorDirective, + NumericValueAccessorDirective, + SelectValueAccessorDirective, + TextValueAccessorDirective, + // navigation + IonTabs, + IonRouterOutlet, + IonBackButton, + IonNav, + RouterLinkDelegateDirective, + RouterLinkWithHrefDelegateDirective, + // validators + IonMinValidator, + IonMaxValidator, +]; +/** + * @deprecated `IonicModule` is deprecated and will be removed in a future major version. + * Use `provideIonicAngular()` instead, which works in both standalone and NgModule-based + * applications. Refer to https://ionicframework.com/docs/angular/build-options for migration steps. + */ +let IonicModule = IonicModule_1 = class IonicModule { + /** + * @deprecated `IonicModule.forRoot()` is deprecated and will be removed in a future major version. + * Use `provideIonicAngular()` instead. Any config passed here can be passed as an object to that + * function. Refer to https://ionicframework.com/docs/angular/build-options for migration steps. + */ + static forRoot(config = {}) { + console.warn(`[Ionic Warning]: IonicModule has been deprecated in favor of provideIonicAngular() and will be removed in a future major version. Refer to https://ionicframework.com/docs/angular/build-options for migration steps.`); + return { + ngModule: IonicModule_1, + providers: [ + { + provide: ConfigToken, + useValue: config, + }, + { + provide: APP_INITIALIZER, + useFactory: appInitialize, + multi: true, + deps: [ConfigToken, DOCUMENT, NgZone], + }, + AngularDelegate, + provideComponentInputBinding(), + ], + }; + } +}; +IonicModule = IonicModule_1 = __decorate([ + NgModule({ + declarations: DECLARATIONS, + exports: DECLARATIONS, + providers: [ModalController, PopoverController], + imports: [CommonModule], + }) +], IonicModule); +export { IonicModule }; diff --git a/packages/angular/build/es2015/lazy/src/providers/action-sheet-controller.js b/packages/angular/build/es2015/lazy/src/providers/action-sheet-controller.js new file mode 100644 index 00000000000..048fa9fb491 --- /dev/null +++ b/packages/angular/build/es2015/lazy/src/providers/action-sheet-controller.js @@ -0,0 +1,15 @@ +import { __decorate } from "tslib"; +import { Injectable } from '@angular/core'; +import { OverlayBaseController } from '@ionic/angular/common'; +import { actionSheetController } from '@ionic/core'; +let ActionSheetController = class ActionSheetController extends OverlayBaseController { + constructor() { + super(actionSheetController); + } +}; +ActionSheetController = __decorate([ + Injectable({ + providedIn: 'root', + }) +], ActionSheetController); +export { ActionSheetController }; diff --git a/packages/angular/build/es2015/lazy/src/providers/alert-controller.js b/packages/angular/build/es2015/lazy/src/providers/alert-controller.js new file mode 100644 index 00000000000..92e0d8f63e2 --- /dev/null +++ b/packages/angular/build/es2015/lazy/src/providers/alert-controller.js @@ -0,0 +1,15 @@ +import { __decorate } from "tslib"; +import { Injectable } from '@angular/core'; +import { OverlayBaseController } from '@ionic/angular/common'; +import { alertController } from '@ionic/core'; +let AlertController = class AlertController extends OverlayBaseController { + constructor() { + super(alertController); + } +}; +AlertController = __decorate([ + Injectable({ + providedIn: 'root', + }) +], AlertController); +export { AlertController }; diff --git a/packages/angular/build/es2015/lazy/src/providers/animation-controller.js b/packages/angular/build/es2015/lazy/src/providers/animation-controller.js new file mode 100644 index 00000000000..167e338d52c --- /dev/null +++ b/packages/angular/build/es2015/lazy/src/providers/animation-controller.js @@ -0,0 +1,34 @@ +import { __decorate } from "tslib"; +import { Injectable } from '@angular/core'; +import { createAnimation, getTimeGivenProgression } from '@ionic/core'; +let AnimationController = class AnimationController { + /** + * Create a new animation + */ + create(animationId) { + return createAnimation(animationId); + } + /** + * EXPERIMENTAL + * + * Given a progression and a cubic bezier function, + * this utility returns the time value(s) at which the + * cubic bezier reaches the given time progression. + * + * If the cubic bezier never reaches the progression + * the result will be an empty array. + * + * This is most useful for switching between easing curves + * when doing a gesture animation (i.e. going from linear easing + * during a drag, to another easing when `progressEnd` is called) + */ + easingTime(p0, p1, p2, p3, progression) { + return getTimeGivenProgression(p0, p1, p2, p3, progression); + } +}; +AnimationController = __decorate([ + Injectable({ + providedIn: 'root', + }) +], AnimationController); +export { AnimationController }; diff --git a/packages/angular/build/es2015/lazy/src/providers/gesture-controller.js b/packages/angular/build/es2015/lazy/src/providers/gesture-controller.js new file mode 100644 index 00000000000..b57b81286bf --- /dev/null +++ b/packages/angular/build/es2015/lazy/src/providers/gesture-controller.js @@ -0,0 +1,28 @@ +import { __decorate } from "tslib"; +import { Injectable } from '@angular/core'; +import { createGesture } from '@ionic/core'; +let GestureController = class GestureController { + constructor(zone) { + this.zone = zone; + } + /** + * Create a new gesture + */ + create(opts, runInsideAngularZone = false) { + if (runInsideAngularZone) { + Object.getOwnPropertyNames(opts).forEach((key) => { + if (typeof opts[key] === 'function') { + const fn = opts[key]; + opts[key] = (...props) => this.zone.run(() => fn(...props)); + } + }); + } + return createGesture(opts); + } +}; +GestureController = __decorate([ + Injectable({ + providedIn: 'root', + }) +], GestureController); +export { GestureController }; diff --git a/packages/angular/build/es2015/lazy/src/providers/loading-controller.js b/packages/angular/build/es2015/lazy/src/providers/loading-controller.js new file mode 100644 index 00000000000..29d4ae9227b --- /dev/null +++ b/packages/angular/build/es2015/lazy/src/providers/loading-controller.js @@ -0,0 +1,15 @@ +import { __decorate } from "tslib"; +import { Injectable } from '@angular/core'; +import { OverlayBaseController } from '@ionic/angular/common'; +import { loadingController } from '@ionic/core'; +let LoadingController = class LoadingController extends OverlayBaseController { + constructor() { + super(loadingController); + } +}; +LoadingController = __decorate([ + Injectable({ + providedIn: 'root', + }) +], LoadingController); +export { LoadingController }; diff --git a/packages/angular/build/es2015/lazy/src/providers/menu-controller.js b/packages/angular/build/es2015/lazy/src/providers/menu-controller.js new file mode 100644 index 00000000000..acbcb1a69b6 --- /dev/null +++ b/packages/angular/build/es2015/lazy/src/providers/menu-controller.js @@ -0,0 +1,15 @@ +import { __decorate } from "tslib"; +import { Injectable } from '@angular/core'; +import { MenuController as MenuControllerBase } from '@ionic/angular/common'; +import { menuController } from '@ionic/core'; +let MenuController = class MenuController extends MenuControllerBase { + constructor() { + super(menuController); + } +}; +MenuController = __decorate([ + Injectable({ + providedIn: 'root', + }) +], MenuController); +export { MenuController }; diff --git a/packages/angular/build/es2015/lazy/src/providers/modal-controller.js b/packages/angular/build/es2015/lazy/src/providers/modal-controller.js new file mode 100644 index 00000000000..e315f7928cc --- /dev/null +++ b/packages/angular/build/es2015/lazy/src/providers/modal-controller.js @@ -0,0 +1,20 @@ +import { __decorate, __rest } from "tslib"; +import { Injector, Injectable, EnvironmentInjector, inject } from '@angular/core'; +import { AngularDelegate, OverlayBaseController } from '@ionic/angular/common'; +import { modalController } from '@ionic/core'; +let ModalController = class ModalController extends OverlayBaseController { + constructor() { + super(modalController); + this.angularDelegate = inject(AngularDelegate); + this.injector = inject(Injector); + this.environmentInjector = inject(EnvironmentInjector); + } + create(opts) { + const { injector: customInjector } = opts, restOpts = __rest(opts, ["injector"]); + return super.create(Object.assign(Object.assign({}, restOpts), { delegate: this.angularDelegate.create(this.environmentInjector, this.injector, 'modal', customInjector) })); + } +}; +ModalController = __decorate([ + Injectable() +], ModalController); +export { ModalController }; diff --git a/packages/angular/build/es2015/lazy/src/providers/popover-controller.js b/packages/angular/build/es2015/lazy/src/providers/popover-controller.js new file mode 100644 index 00000000000..79e9cb0f8ba --- /dev/null +++ b/packages/angular/build/es2015/lazy/src/providers/popover-controller.js @@ -0,0 +1,16 @@ +import { __rest } from "tslib"; +import { Injector, inject, EnvironmentInjector } from '@angular/core'; +import { AngularDelegate, OverlayBaseController } from '@ionic/angular/common'; +import { popoverController } from '@ionic/core'; +export class PopoverController extends OverlayBaseController { + constructor() { + super(popoverController); + this.angularDelegate = inject(AngularDelegate); + this.injector = inject(Injector); + this.environmentInjector = inject(EnvironmentInjector); + } + create(opts) { + const { injector: customInjector } = opts, restOpts = __rest(opts, ["injector"]); + return super.create(Object.assign(Object.assign({}, restOpts), { delegate: this.angularDelegate.create(this.environmentInjector, this.injector, 'popover', customInjector) })); + } +} diff --git a/packages/angular/build/es2015/lazy/src/providers/toast-controller.js b/packages/angular/build/es2015/lazy/src/providers/toast-controller.js new file mode 100644 index 00000000000..994e4bb428a --- /dev/null +++ b/packages/angular/build/es2015/lazy/src/providers/toast-controller.js @@ -0,0 +1,15 @@ +import { __decorate } from "tslib"; +import { Injectable } from '@angular/core'; +import { OverlayBaseController } from '@ionic/angular/common'; +import { toastController } from '@ionic/core'; +let ToastController = class ToastController extends OverlayBaseController { + constructor() { + super(toastController); + } +}; +ToastController = __decorate([ + Injectable({ + providedIn: 'root', + }) +], ToastController); +export { ToastController }; diff --git a/packages/angular/build/es2015/standalone/src/directives/angular-component-lib/utils.js b/packages/angular/build/es2015/standalone/src/directives/angular-component-lib/utils.js new file mode 100644 index 00000000000..4bfe4ea9066 --- /dev/null +++ b/packages/angular/build/es2015/standalone/src/directives/angular-component-lib/utils.js @@ -0,0 +1,58 @@ +/* eslint-disable */ +/* tslint:disable */ +import { fromEvent } from 'rxjs'; +export const proxyInputs = (Cmp, inputs) => { + const Prototype = Cmp.prototype; + inputs.forEach((item) => { + Object.defineProperty(Prototype, item, { + get() { + return this.el[item]; + }, + set(val) { + this.z.runOutsideAngular(() => (this.el[item] = val)); + }, + /** + * In the event that proxyInputs is called + * multiple times re-defining these inputs + * will cause an error to be thrown. As a result + * we set configurable: true to indicate these + * properties can be changed. + */ + configurable: true, + }); + }); +}; +export const proxyMethods = (Cmp, methods) => { + const Prototype = Cmp.prototype; + methods.forEach((methodName) => { + Prototype[methodName] = function () { + const args = arguments; + return this.z.runOutsideAngular(() => this.el[methodName].apply(this.el, args)); + }; + }); +}; +export const proxyOutputs = (instance, el, events) => { + events.forEach((eventName) => (instance[eventName] = fromEvent(el, eventName))); +}; +export const defineCustomElement = (tagName, customElement) => { + if (customElement !== undefined && typeof customElements !== 'undefined' && !customElements.get(tagName)) { + customElements.define(tagName, customElement); + } +}; +// tslint:disable-next-line: only-arrow-functions +export function ProxyCmp(opts) { + const decorator = function (cls) { + const { defineCustomElementFn, inputs, methods } = opts; + if (defineCustomElementFn !== undefined) { + defineCustomElementFn(); + } + if (inputs) { + proxyInputs(cls, inputs); + } + if (methods) { + proxyMethods(cls, methods); + } + return cls; + }; + return decorator; +} diff --git a/packages/angular/build/es2015/standalone/src/directives/checkbox.js b/packages/angular/build/es2015/standalone/src/directives/checkbox.js new file mode 100644 index 00000000000..94949152a75 --- /dev/null +++ b/packages/angular/build/es2015/standalone/src/directives/checkbox.js @@ -0,0 +1,67 @@ +import { __decorate } from "tslib"; +import { ChangeDetectionStrategy, Component, HostListener, forwardRef, } from '@angular/core'; +import { NG_VALUE_ACCESSOR } from '@angular/forms'; +import { ValueAccessor, setIonicClasses } from '@ionic/angular/common'; +import { defineCustomElement } from '@ionic/core/components/ion-checkbox.js'; +import { ProxyCmp, proxyOutputs } from './angular-component-lib/utils'; +const CHECKBOX_INPUTS = [ + 'checked', + 'color', + 'disabled', + 'errorText', + 'helperText', + 'indeterminate', + 'justify', + 'labelPlacement', + 'mode', + 'name', + 'value', +]; +/** + * Pulling the provider into an object and using PURE works + * around an ng-packagr issue that causes + * components with multiple decorators and + * a provider to be re-assigned. This re-assignment + * is not supported by Webpack and causes treeshaking + * to not work on these kinds of components. + */ +const accessorProvider = { + provide: NG_VALUE_ACCESSOR, + useExisting: /*@__PURE__*/ forwardRef(() => IonCheckbox), + multi: true, +}; +let IonCheckbox = class IonCheckbox extends ValueAccessor { + constructor(c, r, z, injector) { + super(injector, r); + this.z = z; + c.detach(); + this.el = r.nativeElement; + proxyOutputs(this, this.el, ['ionChange', 'ionFocus', 'ionBlur']); + } + writeValue(value) { + this.elementRef.nativeElement.checked = this.lastValue = value; + setIonicClasses(this.elementRef); + } + handleIonChange(el) { + this.handleValueChange(el, el.checked); + } +}; +__decorate([ + HostListener('ionChange', ['$event.target']) +], IonCheckbox.prototype, "handleIonChange", null); +IonCheckbox = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineCustomElement, + inputs: CHECKBOX_INPUTS, + }), + Component({ + selector: 'ion-checkbox', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: CHECKBOX_INPUTS, + providers: [accessorProvider], + standalone: true, + }) +], IonCheckbox); +export { IonCheckbox }; diff --git a/packages/angular/build/es2015/standalone/src/directives/datetime.js b/packages/angular/build/es2015/standalone/src/directives/datetime.js new file mode 100644 index 00000000000..9d436ca9d13 --- /dev/null +++ b/packages/angular/build/es2015/standalone/src/directives/datetime.js @@ -0,0 +1,86 @@ +import { __decorate } from "tslib"; +import { ChangeDetectionStrategy, Component, HostListener, forwardRef, } from '@angular/core'; +import { NG_VALUE_ACCESSOR } from '@angular/forms'; +import { ValueAccessor } from '@ionic/angular/common'; +import { defineCustomElement } from '@ionic/core/components/ion-datetime.js'; +import { ProxyCmp, proxyOutputs } from './angular-component-lib/utils'; +const DATETIME_INPUTS = [ + 'cancelText', + 'clearText', + 'color', + 'dayValues', + 'disabled', + 'doneText', + 'firstDayOfWeek', + 'formatOptions', + 'highlightedDates', + 'hourCycle', + 'hourValues', + 'isDateEnabled', + 'locale', + 'max', + 'min', + 'minuteValues', + 'mode', + 'monthValues', + 'multiple', + 'name', + 'preferWheel', + 'presentation', + 'readonly', + 'showAdjacentDays', + 'showClearButton', + 'showDefaultButtons', + 'showDefaultTimeLabel', + 'showDefaultTitle', + 'size', + 'titleSelectedDatesFormatter', + 'value', + 'yearValues', +]; +/** + * Pulling the provider into an object and using PURE works + * around an ng-packagr issue that causes + * components with multiple decorators and + * a provider to be re-assigned. This re-assignment + * is not supported by Webpack and causes treeshaking + * to not work on these kinds of components. + + */ +const accessorProvider = { + provide: NG_VALUE_ACCESSOR, + useExisting: /*@__PURE__*/ forwardRef(() => IonDatetime), + multi: true, +}; +let IonDatetime = class IonDatetime extends ValueAccessor { + constructor(c, r, z, injector) { + super(injector, r); + this.z = z; + c.detach(); + this.el = r.nativeElement; + proxyOutputs(this, this.el, ['ionCancel', 'ionChange', 'ionFocus', 'ionBlur']); + } + handleIonChange(el) { + this.handleValueChange(el, el.value); + } +}; +__decorate([ + HostListener('ionChange', ['$event.target']) +], IonDatetime.prototype, "handleIonChange", null); +IonDatetime = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineCustomElement, + inputs: DATETIME_INPUTS, + methods: ['confirm', 'reset', 'cancel'], + }), + Component({ + selector: 'ion-datetime', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: DATETIME_INPUTS, + providers: [accessorProvider], + standalone: true, + }) +], IonDatetime); +export { IonDatetime }; diff --git a/packages/angular/build/es2015/standalone/src/directives/icon.js b/packages/angular/build/es2015/standalone/src/directives/icon.js new file mode 100644 index 00000000000..ac54a2367a4 --- /dev/null +++ b/packages/angular/build/es2015/standalone/src/directives/icon.js @@ -0,0 +1,26 @@ +import { __decorate } from "tslib"; +import { ChangeDetectionStrategy, Component } from '@angular/core'; +import { defineCustomElement as defineIonIcon } from 'ionicons/components/ion-icon.js'; +import { ProxyCmp } from './angular-component-lib/utils'; +let IonIcon = class IonIcon { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonIcon = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonIcon, + inputs: ['color', 'flipRtl', 'icon', 'ios', 'lazy', 'md', 'mode', 'name', 'sanitize', 'size', 'src'], + }), + Component({ + selector: 'ion-icon', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'flipRtl', 'icon', 'ios', 'lazy', 'md', 'mode', 'name', 'sanitize', 'size', 'src'], + standalone: true, + }) +], IonIcon); +export { IonIcon }; diff --git a/packages/angular/build/es2015/standalone/src/directives/index.js b/packages/angular/build/es2015/standalone/src/directives/index.js new file mode 100644 index 00000000000..95ce727fe0b --- /dev/null +++ b/packages/angular/build/es2015/standalone/src/directives/index.js @@ -0,0 +1,12 @@ +export * from './checkbox'; +export * from './datetime'; +export * from './icon'; +export * from './input'; +export * from './input-otp'; +export * from './radio-group'; +export * from './range'; +export * from './searchbar'; +export * from './segment'; +export * from './select'; +export * from './textarea'; +export * from './toggle'; diff --git a/packages/angular/build/es2015/standalone/src/directives/input-otp.js b/packages/angular/build/es2015/standalone/src/directives/input-otp.js new file mode 100644 index 00000000000..c6627525df4 --- /dev/null +++ b/packages/angular/build/es2015/standalone/src/directives/input-otp.js @@ -0,0 +1,81 @@ +import { __decorate } from "tslib"; +import { ChangeDetectionStrategy, Component, HostListener, forwardRef, } from '@angular/core'; +import { NG_VALUE_ACCESSOR } from '@angular/forms'; +import { ValueAccessor } from '@ionic/angular/common'; +import { defineCustomElement } from '@ionic/core/components/ion-input-otp.js'; +import { ProxyCmp, proxyOutputs } from './angular-component-lib/utils'; +const INPUT_OTP_INPUTS = [ + 'autocapitalize', + 'color', + 'disabled', + 'fill', + 'inputmode', + 'length', + 'pattern', + 'readonly', + 'separators', + 'shape', + 'size', + 'type', + 'value', +]; +/** + * Pulling the provider into an object and using PURE works + * around an ng-packagr issue that causes + * components with multiple decorators and + * a provider to be re-assigned. This re-assignment + * is not supported by Webpack and causes treeshaking + * to not work on these kinds of components. + */ +const accessorProvider = { + provide: NG_VALUE_ACCESSOR, + useExisting: /*@__PURE__*/ forwardRef(() => IonInputOtp), + multi: true, +}; +let IonInputOtp = class IonInputOtp extends ValueAccessor { + constructor(c, r, z, injector) { + super(injector, r); + this.z = z; + c.detach(); + this.el = r.nativeElement; + proxyOutputs(this, this.el, ['ionInput', 'ionChange', 'ionComplete', 'ionBlur', 'ionFocus']); + } + handleIonInput(el) { + this.handleValueChange(el, el.value); + } + registerOnChange(fn) { + super.registerOnChange((value) => { + if (this.type === 'number') { + /** + * If the input type is `number`, we need to convert the value to a number + * when the value is not empty. If the value is empty, we want to treat + * the value as null. + */ + fn(value === '' ? null : parseFloat(value)); + } + else { + fn(value); + } + }); + } +}; +__decorate([ + HostListener('ionInput', ['$event.target']) +], IonInputOtp.prototype, "handleIonInput", null); +IonInputOtp = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineCustomElement, + inputs: INPUT_OTP_INPUTS, + methods: ['setFocus'], + }), + Component({ + selector: 'ion-input-otp', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: INPUT_OTP_INPUTS, + providers: [accessorProvider], + standalone: true, + }) +], IonInputOtp); +export { IonInputOtp }; diff --git a/packages/angular/build/es2015/standalone/src/directives/input.js b/packages/angular/build/es2015/standalone/src/directives/input.js new file mode 100644 index 00000000000..851529186cc --- /dev/null +++ b/packages/angular/build/es2015/standalone/src/directives/input.js @@ -0,0 +1,104 @@ +import { __decorate } from "tslib"; +import { ChangeDetectionStrategy, Component, HostListener, forwardRef, } from '@angular/core'; +import { NG_VALUE_ACCESSOR } from '@angular/forms'; +import { ValueAccessor } from '@ionic/angular/common'; +import { defineCustomElement } from '@ionic/core/components/ion-input.js'; +import { ProxyCmp, proxyOutputs } from './angular-component-lib/utils'; +const INPUT_INPUTS = [ + 'accept', + 'autocapitalize', + 'autocomplete', + 'autocorrect', + 'autofocus', + 'clearInput', + 'clearOnEdit', + 'color', + 'counter', + 'counterFormatter', + 'debounce', + 'disabled', + 'enterkeyhint', + 'errorText', + 'fill', + 'helperText', + 'inputmode', + 'label', + 'labelPlacement', + 'max', + 'maxlength', + 'min', + 'minlength', + 'mode', + 'multiple', + 'name', + 'pattern', + 'placeholder', + 'readonly', + 'required', + 'shape', + 'size', + 'spellcheck', + 'step', + 'type', + 'value', +]; +/** + * Pulling the provider into an object and using PURE works + * around an ng-packagr issue that causes + * components with multiple decorators and + * a provider to be re-assigned. This re-assignment + * is not supported by Webpack and causes treeshaking + * to not work on these kinds of components. + */ +const accessorProvider = { + provide: NG_VALUE_ACCESSOR, + useExisting: /*@__PURE__*/ forwardRef(() => IonInput), + multi: true, +}; +let IonInput = class IonInput extends ValueAccessor { + constructor(c, r, z, injector) { + super(injector, r); + this.z = z; + c.detach(); + this.el = r.nativeElement; + proxyOutputs(this, this.el, ['ionInput', 'ionChange', 'ionBlur', 'ionFocus']); + } + handleIonInput(el) { + this.handleValueChange(el, el.value); + } + registerOnChange(fn) { + super.registerOnChange((value) => { + if (this.type === 'number') { + /** + * If the input type is `number`, we need to convert the value to a number + * when the value is not empty. If the value is empty, we want to treat + * the value as null. + */ + fn(value === '' ? null : parseFloat(value)); + } + else { + fn(value); + } + }); + } +}; +__decorate([ + HostListener('ionInput', ['$event.target']) +], IonInput.prototype, "handleIonInput", null); +IonInput = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineCustomElement, + inputs: INPUT_INPUTS, + methods: ['setFocus', 'getInputElement'], + }), + Component({ + selector: 'ion-input', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: INPUT_INPUTS, + providers: [accessorProvider], + standalone: true, + }) +], IonInput); +export { IonInput }; diff --git a/packages/angular/build/es2015/standalone/src/directives/proxies.js b/packages/angular/build/es2015/standalone/src/directives/proxies.js new file mode 100644 index 00000000000..719304e9049 --- /dev/null +++ b/packages/angular/build/es2015/standalone/src/directives/proxies.js @@ -0,0 +1,1914 @@ +import { __decorate } from "tslib"; +/* tslint:disable */ +/* auto-generated angular directive proxies */ +import { ChangeDetectionStrategy, Component, EventEmitter, Output } from '@angular/core'; +import { ProxyCmp } from './angular-component-lib/utils'; +import { defineCustomElement as defineIonAccordion } from '@ionic/core/components/ion-accordion.js'; +import { defineCustomElement as defineIonAccordionGroup } from '@ionic/core/components/ion-accordion-group.js'; +import { defineCustomElement as defineIonActionSheet } from '@ionic/core/components/ion-action-sheet.js'; +import { defineCustomElement as defineIonAlert } from '@ionic/core/components/ion-alert.js'; +import { defineCustomElement as defineIonApp } from '@ionic/core/components/ion-app.js'; +import { defineCustomElement as defineIonAvatar } from '@ionic/core/components/ion-avatar.js'; +import { defineCustomElement as defineIonBackdrop } from '@ionic/core/components/ion-backdrop.js'; +import { defineCustomElement as defineIonBadge } from '@ionic/core/components/ion-badge.js'; +import { defineCustomElement as defineIonBreadcrumb } from '@ionic/core/components/ion-breadcrumb.js'; +import { defineCustomElement as defineIonBreadcrumbs } from '@ionic/core/components/ion-breadcrumbs.js'; +import { defineCustomElement as defineIonButton } from '@ionic/core/components/ion-button.js'; +import { defineCustomElement as defineIonButtons } from '@ionic/core/components/ion-buttons.js'; +import { defineCustomElement as defineIonCard } from '@ionic/core/components/ion-card.js'; +import { defineCustomElement as defineIonCardContent } from '@ionic/core/components/ion-card-content.js'; +import { defineCustomElement as defineIonCardHeader } from '@ionic/core/components/ion-card-header.js'; +import { defineCustomElement as defineIonCardSubtitle } from '@ionic/core/components/ion-card-subtitle.js'; +import { defineCustomElement as defineIonCardTitle } from '@ionic/core/components/ion-card-title.js'; +import { defineCustomElement as defineIonChip } from '@ionic/core/components/ion-chip.js'; +import { defineCustomElement as defineIonCol } from '@ionic/core/components/ion-col.js'; +import { defineCustomElement as defineIonContent } from '@ionic/core/components/ion-content.js'; +import { defineCustomElement as defineIonDatetimeButton } from '@ionic/core/components/ion-datetime-button.js'; +import { defineCustomElement as defineIonFab } from '@ionic/core/components/ion-fab.js'; +import { defineCustomElement as defineIonFabButton } from '@ionic/core/components/ion-fab-button.js'; +import { defineCustomElement as defineIonFabList } from '@ionic/core/components/ion-fab-list.js'; +import { defineCustomElement as defineIonFooter } from '@ionic/core/components/ion-footer.js'; +import { defineCustomElement as defineIonGrid } from '@ionic/core/components/ion-grid.js'; +import { defineCustomElement as defineIonHeader } from '@ionic/core/components/ion-header.js'; +import { defineCustomElement as defineIonImg } from '@ionic/core/components/ion-img.js'; +import { defineCustomElement as defineIonInfiniteScroll } from '@ionic/core/components/ion-infinite-scroll.js'; +import { defineCustomElement as defineIonInfiniteScrollContent } from '@ionic/core/components/ion-infinite-scroll-content.js'; +import { defineCustomElement as defineIonInputPasswordToggle } from '@ionic/core/components/ion-input-password-toggle.js'; +import { defineCustomElement as defineIonItem } from '@ionic/core/components/ion-item.js'; +import { defineCustomElement as defineIonItemDivider } from '@ionic/core/components/ion-item-divider.js'; +import { defineCustomElement as defineIonItemGroup } from '@ionic/core/components/ion-item-group.js'; +import { defineCustomElement as defineIonItemOption } from '@ionic/core/components/ion-item-option.js'; +import { defineCustomElement as defineIonItemOptions } from '@ionic/core/components/ion-item-options.js'; +import { defineCustomElement as defineIonItemSliding } from '@ionic/core/components/ion-item-sliding.js'; +import { defineCustomElement as defineIonLabel } from '@ionic/core/components/ion-label.js'; +import { defineCustomElement as defineIonList } from '@ionic/core/components/ion-list.js'; +import { defineCustomElement as defineIonListHeader } from '@ionic/core/components/ion-list-header.js'; +import { defineCustomElement as defineIonLoading } from '@ionic/core/components/ion-loading.js'; +import { defineCustomElement as defineIonMenu } from '@ionic/core/components/ion-menu.js'; +import { defineCustomElement as defineIonMenuButton } from '@ionic/core/components/ion-menu-button.js'; +import { defineCustomElement as defineIonMenuToggle } from '@ionic/core/components/ion-menu-toggle.js'; +import { defineCustomElement as defineIonNavLink } from '@ionic/core/components/ion-nav-link.js'; +import { defineCustomElement as defineIonNote } from '@ionic/core/components/ion-note.js'; +import { defineCustomElement as defineIonPicker } from '@ionic/core/components/ion-picker.js'; +import { defineCustomElement as defineIonPickerColumn } from '@ionic/core/components/ion-picker-column.js'; +import { defineCustomElement as defineIonPickerColumnOption } from '@ionic/core/components/ion-picker-column-option.js'; +import { defineCustomElement as defineIonProgressBar } from '@ionic/core/components/ion-progress-bar.js'; +import { defineCustomElement as defineIonRadio } from '@ionic/core/components/ion-radio.js'; +import { defineCustomElement as defineIonRefresher } from '@ionic/core/components/ion-refresher.js'; +import { defineCustomElement as defineIonRefresherContent } from '@ionic/core/components/ion-refresher-content.js'; +import { defineCustomElement as defineIonReorder } from '@ionic/core/components/ion-reorder.js'; +import { defineCustomElement as defineIonReorderGroup } from '@ionic/core/components/ion-reorder-group.js'; +import { defineCustomElement as defineIonRippleEffect } from '@ionic/core/components/ion-ripple-effect.js'; +import { defineCustomElement as defineIonRow } from '@ionic/core/components/ion-row.js'; +import { defineCustomElement as defineIonSegmentButton } from '@ionic/core/components/ion-segment-button.js'; +import { defineCustomElement as defineIonSegmentContent } from '@ionic/core/components/ion-segment-content.js'; +import { defineCustomElement as defineIonSegmentView } from '@ionic/core/components/ion-segment-view.js'; +import { defineCustomElement as defineIonSelectModal } from '@ionic/core/components/ion-select-modal.js'; +import { defineCustomElement as defineIonSelectOption } from '@ionic/core/components/ion-select-option.js'; +import { defineCustomElement as defineIonSkeletonText } from '@ionic/core/components/ion-skeleton-text.js'; +import { defineCustomElement as defineIonSpinner } from '@ionic/core/components/ion-spinner.js'; +import { defineCustomElement as defineIonSplitPane } from '@ionic/core/components/ion-split-pane.js'; +import { defineCustomElement as defineIonTab } from '@ionic/core/components/ion-tab.js'; +import { defineCustomElement as defineIonTabBar } from '@ionic/core/components/ion-tab-bar.js'; +import { defineCustomElement as defineIonTabButton } from '@ionic/core/components/ion-tab-button.js'; +import { defineCustomElement as defineIonText } from '@ionic/core/components/ion-text.js'; +import { defineCustomElement as defineIonThumbnail } from '@ionic/core/components/ion-thumbnail.js'; +import { defineCustomElement as defineIonTitle } from '@ionic/core/components/ion-title.js'; +import { defineCustomElement as defineIonToast } from '@ionic/core/components/ion-toast.js'; +import { defineCustomElement as defineIonToolbar } from '@ionic/core/components/ion-toolbar.js'; +let IonAccordion = class IonAccordion { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonAccordion = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonAccordion, + inputs: ['disabled', 'mode', 'readonly', 'toggleIcon', 'toggleIconSlot', 'value'] + }), + Component({ + selector: 'ion-accordion', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['disabled', 'mode', 'readonly', 'toggleIcon', 'toggleIconSlot', 'value'], + }) +], IonAccordion); +export { IonAccordion }; +let IonAccordionGroup = class IonAccordionGroup { + constructor(c, r, z) { + this.z = z; + this.ionChange = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonAccordionGroup.prototype, "ionChange", void 0); +IonAccordionGroup = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonAccordionGroup, + inputs: ['animated', 'disabled', 'expand', 'mode', 'multiple', 'readonly', 'value'] + }), + Component({ + selector: 'ion-accordion-group', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['animated', 'disabled', 'expand', 'mode', 'multiple', 'readonly', 'value'], + outputs: ['ionChange'], + }) +], IonAccordionGroup); +export { IonAccordionGroup }; +let IonActionSheet = class IonActionSheet { + constructor(c, r, z) { + this.z = z; + this.ionActionSheetDidPresent = new EventEmitter(); + this.ionActionSheetWillPresent = new EventEmitter(); + this.ionActionSheetWillDismiss = new EventEmitter(); + this.ionActionSheetDidDismiss = new EventEmitter(); + this.didPresent = new EventEmitter(); + this.willPresent = new EventEmitter(); + this.willDismiss = new EventEmitter(); + this.didDismiss = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonActionSheet.prototype, "ionActionSheetDidPresent", void 0); +__decorate([ + Output() +], IonActionSheet.prototype, "ionActionSheetWillPresent", void 0); +__decorate([ + Output() +], IonActionSheet.prototype, "ionActionSheetWillDismiss", void 0); +__decorate([ + Output() +], IonActionSheet.prototype, "ionActionSheetDidDismiss", void 0); +__decorate([ + Output() +], IonActionSheet.prototype, "didPresent", void 0); +__decorate([ + Output() +], IonActionSheet.prototype, "willPresent", void 0); +__decorate([ + Output() +], IonActionSheet.prototype, "willDismiss", void 0); +__decorate([ + Output() +], IonActionSheet.prototype, "didDismiss", void 0); +IonActionSheet = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonActionSheet, + inputs: ['animated', 'backdropDismiss', 'buttons', 'cssClass', 'enterAnimation', 'header', 'htmlAttributes', 'isOpen', 'keyboardClose', 'leaveAnimation', 'mode', 'subHeader', 'translucent', 'trigger'], + methods: ['present', 'dismiss', 'onDidDismiss', 'onWillDismiss'] + }), + Component({ + selector: 'ion-action-sheet', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['animated', 'backdropDismiss', 'buttons', 'cssClass', 'enterAnimation', 'header', 'htmlAttributes', 'isOpen', 'keyboardClose', 'leaveAnimation', 'mode', 'subHeader', 'translucent', 'trigger'], + outputs: ['ionActionSheetDidPresent', 'ionActionSheetWillPresent', 'ionActionSheetWillDismiss', 'ionActionSheetDidDismiss', 'didPresent', 'willPresent', 'willDismiss', 'didDismiss'], + }) +], IonActionSheet); +export { IonActionSheet }; +let IonAlert = class IonAlert { + constructor(c, r, z) { + this.z = z; + this.ionAlertDidPresent = new EventEmitter(); + this.ionAlertWillPresent = new EventEmitter(); + this.ionAlertWillDismiss = new EventEmitter(); + this.ionAlertDidDismiss = new EventEmitter(); + this.didPresent = new EventEmitter(); + this.willPresent = new EventEmitter(); + this.willDismiss = new EventEmitter(); + this.didDismiss = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonAlert.prototype, "ionAlertDidPresent", void 0); +__decorate([ + Output() +], IonAlert.prototype, "ionAlertWillPresent", void 0); +__decorate([ + Output() +], IonAlert.prototype, "ionAlertWillDismiss", void 0); +__decorate([ + Output() +], IonAlert.prototype, "ionAlertDidDismiss", void 0); +__decorate([ + Output() +], IonAlert.prototype, "didPresent", void 0); +__decorate([ + Output() +], IonAlert.prototype, "willPresent", void 0); +__decorate([ + Output() +], IonAlert.prototype, "willDismiss", void 0); +__decorate([ + Output() +], IonAlert.prototype, "didDismiss", void 0); +IonAlert = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonAlert, + inputs: ['animated', 'backdropDismiss', 'buttons', 'cssClass', 'enterAnimation', 'header', 'htmlAttributes', 'inputs', 'isOpen', 'keyboardClose', 'leaveAnimation', 'message', 'mode', 'subHeader', 'translucent', 'trigger'], + methods: ['present', 'dismiss', 'onDidDismiss', 'onWillDismiss'] + }), + Component({ + selector: 'ion-alert', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['animated', 'backdropDismiss', 'buttons', 'cssClass', 'enterAnimation', 'header', 'htmlAttributes', 'inputs', 'isOpen', 'keyboardClose', 'leaveAnimation', 'message', 'mode', 'subHeader', 'translucent', 'trigger'], + outputs: ['ionAlertDidPresent', 'ionAlertWillPresent', 'ionAlertWillDismiss', 'ionAlertDidDismiss', 'didPresent', 'willPresent', 'willDismiss', 'didDismiss'], + }) +], IonAlert); +export { IonAlert }; +let IonApp = class IonApp { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonApp = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonApp, + methods: ['setFocus'] + }), + Component({ + selector: 'ion-app', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: [], + }) +], IonApp); +export { IonApp }; +let IonAvatar = class IonAvatar { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonAvatar = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonAvatar + }), + Component({ + selector: 'ion-avatar', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: [], + }) +], IonAvatar); +export { IonAvatar }; +let IonBackdrop = class IonBackdrop { + constructor(c, r, z) { + this.z = z; + this.ionBackdropTap = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonBackdrop.prototype, "ionBackdropTap", void 0); +IonBackdrop = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonBackdrop, + inputs: ['stopPropagation', 'tappable', 'visible'] + }), + Component({ + selector: 'ion-backdrop', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['stopPropagation', 'tappable', 'visible'], + outputs: ['ionBackdropTap'], + }) +], IonBackdrop); +export { IonBackdrop }; +let IonBadge = class IonBadge { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonBadge = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonBadge, + inputs: ['color', 'mode'] + }), + Component({ + selector: 'ion-badge', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'mode'], + }) +], IonBadge); +export { IonBadge }; +let IonBreadcrumb = class IonBreadcrumb { + constructor(c, r, z) { + this.z = z; + this.ionFocus = new EventEmitter(); + this.ionBlur = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonBreadcrumb.prototype, "ionFocus", void 0); +__decorate([ + Output() +], IonBreadcrumb.prototype, "ionBlur", void 0); +IonBreadcrumb = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonBreadcrumb, + inputs: ['active', 'color', 'disabled', 'download', 'href', 'mode', 'rel', 'routerAnimation', 'routerDirection', 'separator', 'target'] + }), + Component({ + selector: 'ion-breadcrumb', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['active', 'color', 'disabled', 'download', 'href', 'mode', 'rel', 'routerAnimation', 'routerDirection', 'separator', 'target'], + outputs: ['ionFocus', 'ionBlur'], + }) +], IonBreadcrumb); +export { IonBreadcrumb }; +let IonBreadcrumbs = class IonBreadcrumbs { + constructor(c, r, z) { + this.z = z; + this.ionCollapsedClick = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonBreadcrumbs.prototype, "ionCollapsedClick", void 0); +IonBreadcrumbs = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonBreadcrumbs, + inputs: ['color', 'itemsAfterCollapse', 'itemsBeforeCollapse', 'maxItems', 'mode'] + }), + Component({ + selector: 'ion-breadcrumbs', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'itemsAfterCollapse', 'itemsBeforeCollapse', 'maxItems', 'mode'], + outputs: ['ionCollapsedClick'], + }) +], IonBreadcrumbs); +export { IonBreadcrumbs }; +let IonButton = class IonButton { + constructor(c, r, z) { + this.z = z; + this.ionFocus = new EventEmitter(); + this.ionBlur = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonButton.prototype, "ionFocus", void 0); +__decorate([ + Output() +], IonButton.prototype, "ionBlur", void 0); +IonButton = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonButton, + inputs: ['buttonType', 'color', 'disabled', 'download', 'expand', 'fill', 'form', 'href', 'mode', 'rel', 'routerAnimation', 'routerDirection', 'shape', 'size', 'strong', 'target', 'type'] + }), + Component({ + selector: 'ion-button', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['buttonType', 'color', 'disabled', 'download', 'expand', 'fill', 'form', 'href', 'mode', 'rel', 'routerAnimation', 'routerDirection', 'shape', 'size', 'strong', 'target', 'type'], + outputs: ['ionFocus', 'ionBlur'], + }) +], IonButton); +export { IonButton }; +let IonButtons = class IonButtons { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonButtons = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonButtons, + inputs: ['collapse'] + }), + Component({ + selector: 'ion-buttons', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['collapse'], + }) +], IonButtons); +export { IonButtons }; +let IonCard = class IonCard { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonCard = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonCard, + inputs: ['button', 'color', 'disabled', 'download', 'href', 'mode', 'rel', 'routerAnimation', 'routerDirection', 'target', 'type'] + }), + Component({ + selector: 'ion-card', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['button', 'color', 'disabled', 'download', 'href', 'mode', 'rel', 'routerAnimation', 'routerDirection', 'target', 'type'], + }) +], IonCard); +export { IonCard }; +let IonCardContent = class IonCardContent { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonCardContent = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonCardContent, + inputs: ['mode'] + }), + Component({ + selector: 'ion-card-content', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['mode'], + }) +], IonCardContent); +export { IonCardContent }; +let IonCardHeader = class IonCardHeader { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonCardHeader = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonCardHeader, + inputs: ['color', 'mode', 'translucent'] + }), + Component({ + selector: 'ion-card-header', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'mode', 'translucent'], + }) +], IonCardHeader); +export { IonCardHeader }; +let IonCardSubtitle = class IonCardSubtitle { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonCardSubtitle = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonCardSubtitle, + inputs: ['color', 'mode'] + }), + Component({ + selector: 'ion-card-subtitle', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'mode'], + }) +], IonCardSubtitle); +export { IonCardSubtitle }; +let IonCardTitle = class IonCardTitle { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonCardTitle = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonCardTitle, + inputs: ['color', 'mode'] + }), + Component({ + selector: 'ion-card-title', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'mode'], + }) +], IonCardTitle); +export { IonCardTitle }; +let IonChip = class IonChip { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonChip = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonChip, + inputs: ['color', 'disabled', 'mode', 'outline'] + }), + Component({ + selector: 'ion-chip', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'disabled', 'mode', 'outline'], + }) +], IonChip); +export { IonChip }; +let IonCol = class IonCol { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonCol = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonCol, + 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'] + }), + Component({ + selector: 'ion-col', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + 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'], + }) +], IonCol); +export { IonCol }; +let IonContent = class IonContent { + constructor(c, r, z) { + this.z = z; + this.ionScrollStart = new EventEmitter(); + this.ionScroll = new EventEmitter(); + this.ionScrollEnd = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonContent.prototype, "ionScrollStart", void 0); +__decorate([ + Output() +], IonContent.prototype, "ionScroll", void 0); +__decorate([ + Output() +], IonContent.prototype, "ionScrollEnd", void 0); +IonContent = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonContent, + inputs: ['color', 'fixedSlotPlacement', 'forceOverscroll', 'fullscreen', 'scrollEvents', 'scrollX', 'scrollY'], + methods: ['getScrollElement', 'scrollToTop', 'scrollToBottom', 'scrollByPoint', 'scrollToPoint'] + }), + Component({ + selector: 'ion-content', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'fixedSlotPlacement', 'forceOverscroll', 'fullscreen', 'scrollEvents', 'scrollX', 'scrollY'], + outputs: ['ionScrollStart', 'ionScroll', 'ionScrollEnd'], + }) +], IonContent); +export { IonContent }; +let IonDatetimeButton = class IonDatetimeButton { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonDatetimeButton = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonDatetimeButton, + inputs: ['color', 'datetime', 'disabled', 'mode'] + }), + Component({ + selector: 'ion-datetime-button', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'datetime', 'disabled', 'mode'], + }) +], IonDatetimeButton); +export { IonDatetimeButton }; +let IonFab = class IonFab { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonFab = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonFab, + inputs: ['activated', 'edge', 'horizontal', 'vertical'], + methods: ['close'] + }), + Component({ + selector: 'ion-fab', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['activated', 'edge', 'horizontal', 'vertical'], + }) +], IonFab); +export { IonFab }; +let IonFabButton = class IonFabButton { + constructor(c, r, z) { + this.z = z; + this.ionFocus = new EventEmitter(); + this.ionBlur = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonFabButton.prototype, "ionFocus", void 0); +__decorate([ + Output() +], IonFabButton.prototype, "ionBlur", void 0); +IonFabButton = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonFabButton, + inputs: ['activated', 'closeIcon', 'color', 'disabled', 'download', 'href', 'mode', 'rel', 'routerAnimation', 'routerDirection', 'show', 'size', 'target', 'translucent', 'type'] + }), + Component({ + selector: 'ion-fab-button', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['activated', 'closeIcon', 'color', 'disabled', 'download', 'href', 'mode', 'rel', 'routerAnimation', 'routerDirection', 'show', 'size', 'target', 'translucent', 'type'], + outputs: ['ionFocus', 'ionBlur'], + }) +], IonFabButton); +export { IonFabButton }; +let IonFabList = class IonFabList { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonFabList = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonFabList, + inputs: ['activated', 'side'] + }), + Component({ + selector: 'ion-fab-list', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['activated', 'side'], + }) +], IonFabList); +export { IonFabList }; +let IonFooter = class IonFooter { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonFooter = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonFooter, + inputs: ['collapse', 'mode', 'translucent'] + }), + Component({ + selector: 'ion-footer', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['collapse', 'mode', 'translucent'], + }) +], IonFooter); +export { IonFooter }; +let IonGrid = class IonGrid { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonGrid = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonGrid, + inputs: ['fixed'] + }), + Component({ + selector: 'ion-grid', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['fixed'], + }) +], IonGrid); +export { IonGrid }; +let IonHeader = class IonHeader { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonHeader = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonHeader, + inputs: ['collapse', 'mode', 'translucent'] + }), + Component({ + selector: 'ion-header', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['collapse', 'mode', 'translucent'], + }) +], IonHeader); +export { IonHeader }; +let IonImg = class IonImg { + constructor(c, r, z) { + this.z = z; + this.ionImgWillLoad = new EventEmitter(); + this.ionImgDidLoad = new EventEmitter(); + this.ionError = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonImg.prototype, "ionImgWillLoad", void 0); +__decorate([ + Output() +], IonImg.prototype, "ionImgDidLoad", void 0); +__decorate([ + Output() +], IonImg.prototype, "ionError", void 0); +IonImg = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonImg, + inputs: ['alt', 'src'] + }), + Component({ + selector: 'ion-img', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['alt', 'src'], + outputs: ['ionImgWillLoad', 'ionImgDidLoad', 'ionError'], + }) +], IonImg); +export { IonImg }; +let IonInfiniteScroll = class IonInfiniteScroll { + constructor(c, r, z) { + this.z = z; + this.ionInfinite = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonInfiniteScroll.prototype, "ionInfinite", void 0); +IonInfiniteScroll = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonInfiniteScroll, + inputs: ['disabled', 'position', 'threshold'], + methods: ['complete'] + }), + Component({ + selector: 'ion-infinite-scroll', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['disabled', 'position', 'threshold'], + outputs: ['ionInfinite'], + }) +], IonInfiniteScroll); +export { IonInfiniteScroll }; +let IonInfiniteScrollContent = class IonInfiniteScrollContent { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonInfiniteScrollContent = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonInfiniteScrollContent, + inputs: ['loadingSpinner', 'loadingText'] + }), + Component({ + selector: 'ion-infinite-scroll-content', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['loadingSpinner', 'loadingText'], + }) +], IonInfiniteScrollContent); +export { IonInfiniteScrollContent }; +let IonInputPasswordToggle = class IonInputPasswordToggle { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonInputPasswordToggle = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonInputPasswordToggle, + inputs: ['color', 'hideIcon', 'mode', 'showIcon'] + }), + Component({ + selector: 'ion-input-password-toggle', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'hideIcon', 'mode', 'showIcon'], + }) +], IonInputPasswordToggle); +export { IonInputPasswordToggle }; +let IonItem = class IonItem { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonItem = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonItem, + inputs: ['button', 'color', 'detail', 'detailIcon', 'disabled', 'download', 'href', 'lines', 'mode', 'rel', 'routerAnimation', 'routerDirection', 'target', 'type'] + }), + Component({ + selector: 'ion-item', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['button', 'color', 'detail', 'detailIcon', 'disabled', 'download', 'href', 'lines', 'mode', 'rel', 'routerAnimation', 'routerDirection', 'target', 'type'], + }) +], IonItem); +export { IonItem }; +let IonItemDivider = class IonItemDivider { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonItemDivider = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonItemDivider, + inputs: ['color', 'mode', 'sticky'] + }), + Component({ + selector: 'ion-item-divider', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'mode', 'sticky'], + }) +], IonItemDivider); +export { IonItemDivider }; +let IonItemGroup = class IonItemGroup { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonItemGroup = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonItemGroup + }), + Component({ + selector: 'ion-item-group', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: [], + }) +], IonItemGroup); +export { IonItemGroup }; +let IonItemOption = class IonItemOption { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonItemOption = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonItemOption, + inputs: ['color', 'disabled', 'download', 'expandable', 'href', 'mode', 'rel', 'target', 'type'] + }), + Component({ + selector: 'ion-item-option', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'disabled', 'download', 'expandable', 'href', 'mode', 'rel', 'target', 'type'], + }) +], IonItemOption); +export { IonItemOption }; +let IonItemOptions = class IonItemOptions { + constructor(c, r, z) { + this.z = z; + this.ionSwipe = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonItemOptions.prototype, "ionSwipe", void 0); +IonItemOptions = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonItemOptions, + inputs: ['side'] + }), + Component({ + selector: 'ion-item-options', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['side'], + outputs: ['ionSwipe'], + }) +], IonItemOptions); +export { IonItemOptions }; +let IonItemSliding = class IonItemSliding { + constructor(c, r, z) { + this.z = z; + this.ionDrag = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonItemSliding.prototype, "ionDrag", void 0); +IonItemSliding = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonItemSliding, + inputs: ['disabled'], + methods: ['getOpenAmount', 'getSlidingRatio', 'open', 'close', 'closeOpened'] + }), + Component({ + selector: 'ion-item-sliding', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['disabled'], + outputs: ['ionDrag'], + }) +], IonItemSliding); +export { IonItemSliding }; +let IonLabel = class IonLabel { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonLabel = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonLabel, + inputs: ['color', 'mode', 'position'] + }), + Component({ + selector: 'ion-label', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'mode', 'position'], + }) +], IonLabel); +export { IonLabel }; +let IonList = class IonList { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonList = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonList, + inputs: ['inset', 'lines', 'mode'], + methods: ['closeSlidingItems'] + }), + Component({ + selector: 'ion-list', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['inset', 'lines', 'mode'], + }) +], IonList); +export { IonList }; +let IonListHeader = class IonListHeader { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonListHeader = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonListHeader, + inputs: ['color', 'lines', 'mode'] + }), + Component({ + selector: 'ion-list-header', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'lines', 'mode'], + }) +], IonListHeader); +export { IonListHeader }; +let IonLoading = class IonLoading { + constructor(c, r, z) { + this.z = z; + this.ionLoadingDidPresent = new EventEmitter(); + this.ionLoadingWillPresent = new EventEmitter(); + this.ionLoadingWillDismiss = new EventEmitter(); + this.ionLoadingDidDismiss = new EventEmitter(); + this.didPresent = new EventEmitter(); + this.willPresent = new EventEmitter(); + this.willDismiss = new EventEmitter(); + this.didDismiss = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonLoading.prototype, "ionLoadingDidPresent", void 0); +__decorate([ + Output() +], IonLoading.prototype, "ionLoadingWillPresent", void 0); +__decorate([ + Output() +], IonLoading.prototype, "ionLoadingWillDismiss", void 0); +__decorate([ + Output() +], IonLoading.prototype, "ionLoadingDidDismiss", void 0); +__decorate([ + Output() +], IonLoading.prototype, "didPresent", void 0); +__decorate([ + Output() +], IonLoading.prototype, "willPresent", void 0); +__decorate([ + Output() +], IonLoading.prototype, "willDismiss", void 0); +__decorate([ + Output() +], IonLoading.prototype, "didDismiss", void 0); +IonLoading = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonLoading, + inputs: ['animated', 'backdropDismiss', 'cssClass', 'duration', 'enterAnimation', 'htmlAttributes', 'isOpen', 'keyboardClose', 'leaveAnimation', 'message', 'mode', 'showBackdrop', 'spinner', 'translucent', 'trigger'], + methods: ['present', 'dismiss', 'onDidDismiss', 'onWillDismiss'] + }), + Component({ + selector: 'ion-loading', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['animated', 'backdropDismiss', 'cssClass', 'duration', 'enterAnimation', 'htmlAttributes', 'isOpen', 'keyboardClose', 'leaveAnimation', 'message', 'mode', 'showBackdrop', 'spinner', 'translucent', 'trigger'], + outputs: ['ionLoadingDidPresent', 'ionLoadingWillPresent', 'ionLoadingWillDismiss', 'ionLoadingDidDismiss', 'didPresent', 'willPresent', 'willDismiss', 'didDismiss'], + }) +], IonLoading); +export { IonLoading }; +let IonMenu = class IonMenu { + constructor(c, r, z) { + this.z = z; + this.ionWillOpen = new EventEmitter(); + this.ionWillClose = new EventEmitter(); + this.ionDidOpen = new EventEmitter(); + this.ionDidClose = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonMenu.prototype, "ionWillOpen", void 0); +__decorate([ + Output() +], IonMenu.prototype, "ionWillClose", void 0); +__decorate([ + Output() +], IonMenu.prototype, "ionDidOpen", void 0); +__decorate([ + Output() +], IonMenu.prototype, "ionDidClose", void 0); +IonMenu = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonMenu, + inputs: ['contentId', 'disabled', 'maxEdgeStart', 'menuId', 'side', 'swipeGesture', 'type'], + methods: ['isOpen', 'isActive', 'open', 'close', 'toggle', 'setOpen'] + }), + Component({ + selector: 'ion-menu', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['contentId', 'disabled', 'maxEdgeStart', 'menuId', 'side', 'swipeGesture', 'type'], + outputs: ['ionWillOpen', 'ionWillClose', 'ionDidOpen', 'ionDidClose'], + }) +], IonMenu); +export { IonMenu }; +let IonMenuButton = class IonMenuButton { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonMenuButton = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonMenuButton, + inputs: ['autoHide', 'color', 'disabled', 'menu', 'mode', 'type'] + }), + Component({ + selector: 'ion-menu-button', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['autoHide', 'color', 'disabled', 'menu', 'mode', 'type'], + }) +], IonMenuButton); +export { IonMenuButton }; +let IonMenuToggle = class IonMenuToggle { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonMenuToggle = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonMenuToggle, + inputs: ['autoHide', 'menu'] + }), + Component({ + selector: 'ion-menu-toggle', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['autoHide', 'menu'], + }) +], IonMenuToggle); +export { IonMenuToggle }; +let IonNavLink = class IonNavLink { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonNavLink = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonNavLink, + inputs: ['component', 'componentProps', 'routerAnimation', 'routerDirection'] + }), + Component({ + selector: 'ion-nav-link', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['component', 'componentProps', 'routerAnimation', 'routerDirection'], + }) +], IonNavLink); +export { IonNavLink }; +let IonNote = class IonNote { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonNote = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonNote, + inputs: ['color', 'mode'] + }), + Component({ + selector: 'ion-note', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'mode'], + }) +], IonNote); +export { IonNote }; +let IonPicker = class IonPicker { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonPicker = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonPicker, + inputs: ['mode'] + }), + Component({ + selector: 'ion-picker', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['mode'], + }) +], IonPicker); +export { IonPicker }; +let IonPickerColumn = class IonPickerColumn { + constructor(c, r, z) { + this.z = z; + this.ionChange = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonPickerColumn.prototype, "ionChange", void 0); +IonPickerColumn = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonPickerColumn, + inputs: ['color', 'disabled', 'mode', 'value'], + methods: ['setFocus'] + }), + Component({ + selector: 'ion-picker-column', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'disabled', 'mode', 'value'], + outputs: ['ionChange'], + }) +], IonPickerColumn); +export { IonPickerColumn }; +let IonPickerColumnOption = class IonPickerColumnOption { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonPickerColumnOption = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonPickerColumnOption, + inputs: ['color', 'disabled', 'value'] + }), + Component({ + selector: 'ion-picker-column-option', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'disabled', 'value'], + }) +], IonPickerColumnOption); +export { IonPickerColumnOption }; +let IonProgressBar = class IonProgressBar { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonProgressBar = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonProgressBar, + inputs: ['buffer', 'color', 'mode', 'reversed', 'type', 'value'] + }), + Component({ + selector: 'ion-progress-bar', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['buffer', 'color', 'mode', 'reversed', 'type', 'value'], + }) +], IonProgressBar); +export { IonProgressBar }; +let IonRadio = class IonRadio { + constructor(c, r, z) { + this.z = z; + this.ionFocus = new EventEmitter(); + this.ionBlur = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonRadio.prototype, "ionFocus", void 0); +__decorate([ + Output() +], IonRadio.prototype, "ionBlur", void 0); +IonRadio = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonRadio, + inputs: ['alignment', 'color', 'disabled', 'justify', 'labelPlacement', 'mode', 'name', 'value'] + }), + Component({ + selector: 'ion-radio', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['alignment', 'color', 'disabled', 'justify', 'labelPlacement', 'mode', 'name', 'value'], + outputs: ['ionFocus', 'ionBlur'], + }) +], IonRadio); +export { IonRadio }; +let IonRefresher = class IonRefresher { + constructor(c, r, z) { + this.z = z; + this.ionRefresh = new EventEmitter(); + this.ionPull = new EventEmitter(); + this.ionStart = new EventEmitter(); + this.ionPullStart = new EventEmitter(); + this.ionPullEnd = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonRefresher.prototype, "ionRefresh", void 0); +__decorate([ + Output() +], IonRefresher.prototype, "ionPull", void 0); +__decorate([ + Output() +], IonRefresher.prototype, "ionStart", void 0); +__decorate([ + Output() +], IonRefresher.prototype, "ionPullStart", void 0); +__decorate([ + Output() +], IonRefresher.prototype, "ionPullEnd", void 0); +IonRefresher = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonRefresher, + inputs: ['closeDuration', 'disabled', 'mode', 'pullFactor', 'pullMax', 'pullMin', 'snapbackDuration'], + methods: ['complete', 'cancel', 'getProgress'] + }), + Component({ + selector: 'ion-refresher', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['closeDuration', 'disabled', 'mode', 'pullFactor', 'pullMax', 'pullMin', 'snapbackDuration'], + outputs: ['ionRefresh', 'ionPull', 'ionStart', 'ionPullStart', 'ionPullEnd'], + }) +], IonRefresher); +export { IonRefresher }; +let IonRefresherContent = class IonRefresherContent { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonRefresherContent = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonRefresherContent, + inputs: ['pullingIcon', 'pullingText', 'refreshingSpinner', 'refreshingText'] + }), + Component({ + selector: 'ion-refresher-content', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['pullingIcon', 'pullingText', 'refreshingSpinner', 'refreshingText'], + }) +], IonRefresherContent); +export { IonRefresherContent }; +let IonReorder = class IonReorder { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonReorder = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonReorder + }), + Component({ + selector: 'ion-reorder', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: [], + }) +], IonReorder); +export { IonReorder }; +let IonReorderGroup = class IonReorderGroup { + constructor(c, r, z) { + this.z = z; + this.ionItemReorder = new EventEmitter(); + this.ionReorderStart = new EventEmitter(); + this.ionReorderMove = new EventEmitter(); + this.ionReorderEnd = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonReorderGroup.prototype, "ionItemReorder", void 0); +__decorate([ + Output() +], IonReorderGroup.prototype, "ionReorderStart", void 0); +__decorate([ + Output() +], IonReorderGroup.prototype, "ionReorderMove", void 0); +__decorate([ + Output() +], IonReorderGroup.prototype, "ionReorderEnd", void 0); +IonReorderGroup = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonReorderGroup, + inputs: ['disabled'], + methods: ['complete'] + }), + Component({ + selector: 'ion-reorder-group', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['disabled'], + outputs: ['ionItemReorder', 'ionReorderStart', 'ionReorderMove', 'ionReorderEnd'], + }) +], IonReorderGroup); +export { IonReorderGroup }; +let IonRippleEffect = class IonRippleEffect { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonRippleEffect = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonRippleEffect, + inputs: ['type'], + methods: ['addRipple'] + }), + Component({ + selector: 'ion-ripple-effect', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['type'], + }) +], IonRippleEffect); +export { IonRippleEffect }; +let IonRow = class IonRow { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonRow = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonRow + }), + Component({ + selector: 'ion-row', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: [], + }) +], IonRow); +export { IonRow }; +let IonSegmentButton = class IonSegmentButton { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonSegmentButton = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonSegmentButton, + inputs: ['contentId', 'disabled', 'layout', 'mode', 'type', 'value'] + }), + Component({ + selector: 'ion-segment-button', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['contentId', 'disabled', 'layout', 'mode', 'type', 'value'], + }) +], IonSegmentButton); +export { IonSegmentButton }; +let IonSegmentContent = class IonSegmentContent { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonSegmentContent = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonSegmentContent + }), + Component({ + selector: 'ion-segment-content', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: [], + }) +], IonSegmentContent); +export { IonSegmentContent }; +let IonSegmentView = class IonSegmentView { + constructor(c, r, z) { + this.z = z; + this.ionSegmentViewScroll = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonSegmentView.prototype, "ionSegmentViewScroll", void 0); +IonSegmentView = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonSegmentView, + inputs: ['disabled', 'swipeGesture'] + }), + Component({ + selector: 'ion-segment-view', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['disabled', 'swipeGesture'], + outputs: ['ionSegmentViewScroll'], + }) +], IonSegmentView); +export { IonSegmentView }; +let IonSelectModal = class IonSelectModal { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonSelectModal = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonSelectModal, + inputs: ['cancelText', 'header', 'multiple', 'options'] + }), + Component({ + selector: 'ion-select-modal', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['cancelText', 'header', 'multiple', 'options'], + }) +], IonSelectModal); +export { IonSelectModal }; +let IonSelectOption = class IonSelectOption { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonSelectOption = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonSelectOption, + inputs: ['description', 'disabled', 'justify', 'labelPlacement', 'mode', 'value'] + }), + Component({ + selector: 'ion-select-option', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['description', 'disabled', 'justify', 'labelPlacement', 'mode', 'value'], + }) +], IonSelectOption); +export { IonSelectOption }; +let IonSkeletonText = class IonSkeletonText { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonSkeletonText = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonSkeletonText, + inputs: ['animated'] + }), + Component({ + selector: 'ion-skeleton-text', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['animated'], + }) +], IonSkeletonText); +export { IonSkeletonText }; +let IonSpinner = class IonSpinner { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonSpinner = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonSpinner, + inputs: ['color', 'duration', 'name', 'paused'] + }), + Component({ + selector: 'ion-spinner', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'duration', 'name', 'paused'], + }) +], IonSpinner); +export { IonSpinner }; +let IonSplitPane = class IonSplitPane { + constructor(c, r, z) { + this.z = z; + this.ionSplitPaneVisible = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonSplitPane.prototype, "ionSplitPaneVisible", void 0); +IonSplitPane = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonSplitPane, + inputs: ['contentId', 'disabled', 'when'] + }), + Component({ + selector: 'ion-split-pane', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['contentId', 'disabled', 'when'], + outputs: ['ionSplitPaneVisible'], + }) +], IonSplitPane); +export { IonSplitPane }; +let IonTab = class IonTab { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonTab = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonTab, + inputs: ['component', 'tab'], + methods: ['setActive'] + }), + Component({ + selector: 'ion-tab', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['component', { name: 'tab', required: true }], + }) +], IonTab); +export { IonTab }; +let IonTabBar = class IonTabBar { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonTabBar = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonTabBar, + inputs: ['color', 'mode', 'selectedTab', 'translucent'] + }), + Component({ + selector: 'ion-tab-bar', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'mode', 'selectedTab', 'translucent'], + }) +], IonTabBar); +export { IonTabBar }; +let IonTabButton = class IonTabButton { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonTabButton = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonTabButton, + inputs: ['disabled', 'download', 'href', 'layout', 'mode', 'rel', 'selected', 'tab', 'target'] + }), + Component({ + selector: 'ion-tab-button', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['disabled', 'download', 'href', 'layout', 'mode', 'rel', 'selected', 'tab', 'target'], + }) +], IonTabButton); +export { IonTabButton }; +let IonText = class IonText { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonText = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonText, + inputs: ['color', 'mode'] + }), + Component({ + selector: 'ion-text', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'mode'], + }) +], IonText); +export { IonText }; +let IonThumbnail = class IonThumbnail { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonThumbnail = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonThumbnail + }), + Component({ + selector: 'ion-thumbnail', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: [], + }) +], IonThumbnail); +export { IonThumbnail }; +let IonTitle = class IonTitle { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonTitle = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonTitle, + inputs: ['color', 'size'] + }), + Component({ + selector: 'ion-title', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'size'], + }) +], IonTitle); +export { IonTitle }; +let IonToast = class IonToast { + constructor(c, r, z) { + this.z = z; + this.ionToastDidPresent = new EventEmitter(); + this.ionToastWillPresent = new EventEmitter(); + this.ionToastWillDismiss = new EventEmitter(); + this.ionToastDidDismiss = new EventEmitter(); + this.didPresent = new EventEmitter(); + this.willPresent = new EventEmitter(); + this.willDismiss = new EventEmitter(); + this.didDismiss = new EventEmitter(); + c.detach(); + this.el = r.nativeElement; + } +}; +__decorate([ + Output() +], IonToast.prototype, "ionToastDidPresent", void 0); +__decorate([ + Output() +], IonToast.prototype, "ionToastWillPresent", void 0); +__decorate([ + Output() +], IonToast.prototype, "ionToastWillDismiss", void 0); +__decorate([ + Output() +], IonToast.prototype, "ionToastDidDismiss", void 0); +__decorate([ + Output() +], IonToast.prototype, "didPresent", void 0); +__decorate([ + Output() +], IonToast.prototype, "willPresent", void 0); +__decorate([ + Output() +], IonToast.prototype, "willDismiss", void 0); +__decorate([ + Output() +], IonToast.prototype, "didDismiss", void 0); +IonToast = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonToast, + inputs: ['animated', 'buttons', 'color', 'cssClass', 'duration', 'enterAnimation', 'header', 'htmlAttributes', 'icon', 'isOpen', 'keyboardClose', 'layout', 'leaveAnimation', 'message', 'mode', 'position', 'positionAnchor', 'swipeGesture', 'translucent', 'trigger'], + methods: ['present', 'dismiss', 'onDidDismiss', 'onWillDismiss'] + }), + Component({ + selector: 'ion-toast', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['animated', 'buttons', 'color', 'cssClass', 'duration', 'enterAnimation', 'header', 'htmlAttributes', 'icon', 'isOpen', 'keyboardClose', 'layout', 'leaveAnimation', 'message', 'mode', 'position', 'positionAnchor', 'swipeGesture', 'translucent', 'trigger'], + outputs: ['ionToastDidPresent', 'ionToastWillPresent', 'ionToastWillDismiss', 'ionToastDidDismiss', 'didPresent', 'willPresent', 'willDismiss', 'didDismiss'], + }) +], IonToast); +export { IonToast }; +let IonToolbar = class IonToolbar { + constructor(c, r, z) { + this.z = z; + c.detach(); + this.el = r.nativeElement; + } +}; +IonToolbar = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineIonToolbar, + inputs: ['color', 'mode'] + }), + Component({ + selector: 'ion-toolbar', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: ['color', 'mode'], + }) +], IonToolbar); +export { IonToolbar }; diff --git a/packages/angular/build/es2015/standalone/src/directives/radio-group.js b/packages/angular/build/es2015/standalone/src/directives/radio-group.js new file mode 100644 index 00000000000..247e5203301 --- /dev/null +++ b/packages/angular/build/es2015/standalone/src/directives/radio-group.js @@ -0,0 +1,51 @@ +import { __decorate } from "tslib"; +import { ChangeDetectionStrategy, Component, HostListener, forwardRef, } from '@angular/core'; +import { NG_VALUE_ACCESSOR } from '@angular/forms'; +import { ValueAccessor } from '@ionic/angular/common'; +import { defineCustomElement } from '@ionic/core/components/ion-radio-group.js'; +import { ProxyCmp, proxyOutputs } from './angular-component-lib/utils'; +const RADIO_GROUP_INPUTS = ['allowEmptySelection', 'compareWith', 'errorText', 'helperText', 'name', 'value']; +/** + * Pulling the provider into an object and using PURE works + * around an ng-packagr issue that causes + * components with multiple decorators and + * a provider to be re-assigned. This re-assignment + * is not supported by Webpack and causes treeshaking + * to not work on these kinds of components. + */ +const accessorProvider = { + provide: NG_VALUE_ACCESSOR, + useExisting: /*@__PURE__*/ forwardRef(() => IonRadioGroup), + multi: true, +}; +let IonRadioGroup = class IonRadioGroup extends ValueAccessor { + constructor(c, r, z, injector) { + super(injector, r); + this.z = z; + c.detach(); + this.el = r.nativeElement; + proxyOutputs(this, this.el, ['ionChange']); + } + handleIonChange(el) { + this.handleValueChange(el, el.value); + } +}; +__decorate([ + HostListener('ionChange', ['$event.target']) +], IonRadioGroup.prototype, "handleIonChange", null); +IonRadioGroup = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineCustomElement, + inputs: RADIO_GROUP_INPUTS, + }), + Component({ + selector: 'ion-radio-group', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: RADIO_GROUP_INPUTS, + providers: [accessorProvider], + standalone: true, + }) +], IonRadioGroup); +export { IonRadioGroup }; diff --git a/packages/angular/build/es2015/standalone/src/directives/range.js b/packages/angular/build/es2015/standalone/src/directives/range.js new file mode 100644 index 00000000000..0fc436b59ae --- /dev/null +++ b/packages/angular/build/es2015/standalone/src/directives/range.js @@ -0,0 +1,69 @@ +import { __decorate } from "tslib"; +import { ChangeDetectionStrategy, Component, HostListener, forwardRef, } from '@angular/core'; +import { NG_VALUE_ACCESSOR } from '@angular/forms'; +import { ValueAccessor } from '@ionic/angular/common'; +import { defineCustomElement } from '@ionic/core/components/ion-range.js'; +import { ProxyCmp, proxyOutputs } from './angular-component-lib/utils'; +const RANGE_INPUTS = [ + 'activeBarStart', + 'color', + 'debounce', + 'disabled', + 'dualKnobs', + 'label', + 'labelPlacement', + 'max', + 'min', + 'mode', + 'name', + 'pin', + 'pinFormatter', + 'snaps', + 'step', + 'ticks', + 'value', +]; +/** + * Pulling the provider into an object and using PURE works + * around an ng-packagr issue that causes + * components with multiple decorators and + * a provider to be re-assigned. This re-assignment + * is not supported by Webpack and causes treeshaking + * to not work on these kinds of components. + */ +const accessorProvider = { + provide: NG_VALUE_ACCESSOR, + useExisting: /*@__PURE__*/ forwardRef(() => IonRange), + multi: true, +}; +let IonRange = class IonRange extends ValueAccessor { + constructor(c, r, z, injector) { + super(injector, r); + this.z = z; + c.detach(); + this.el = r.nativeElement; + proxyOutputs(this, this.el, ['ionChange', 'ionInput', 'ionFocus', 'ionBlur', 'ionKnobMoveStart', 'ionKnobMoveEnd']); + } + handleIonInput(el) { + this.handleValueChange(el, el.value); + } +}; +__decorate([ + HostListener('ionInput', ['$event.target']) +], IonRange.prototype, "handleIonInput", null); +IonRange = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineCustomElement, + inputs: RANGE_INPUTS, + }), + Component({ + selector: 'ion-range', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: RANGE_INPUTS, + providers: [accessorProvider], + standalone: true, + }) +], IonRange); +export { IonRange }; diff --git a/packages/angular/build/es2015/standalone/src/directives/searchbar.js b/packages/angular/build/es2015/standalone/src/directives/searchbar.js new file mode 100644 index 00000000000..fbab630c96b --- /dev/null +++ b/packages/angular/build/es2015/standalone/src/directives/searchbar.js @@ -0,0 +1,73 @@ +import { __decorate } from "tslib"; +import { ChangeDetectionStrategy, Component, HostListener, forwardRef, } from '@angular/core'; +import { NG_VALUE_ACCESSOR } from '@angular/forms'; +import { ValueAccessor } from '@ionic/angular/common'; +import { defineCustomElement } from '@ionic/core/components/ion-searchbar.js'; +import { ProxyCmp, proxyOutputs } from './angular-component-lib/utils'; +const SEARCHBAR_INPUTS = [ + 'animated', + 'autocomplete', + 'autocorrect', + 'cancelButtonIcon', + 'cancelButtonText', + 'clearIcon', + 'color', + 'debounce', + 'disabled', + 'enterkeyhint', + 'inputmode', + 'mode', + 'name', + 'placeholder', + 'searchIcon', + 'showCancelButton', + 'showClearButton', + 'spellcheck', + 'type', + 'value', +]; +/** + * Pulling the provider into an object and using PURE works + * around an ng-packagr issue that causes + * components with multiple decorators and + * a provider to be re-assigned. This re-assignment + * is not supported by Webpack and causes treeshaking + * to not work on these kinds of components. + */ +const accessorProvider = { + provide: NG_VALUE_ACCESSOR, + useExisting: /*@__PURE__*/ forwardRef(() => IonSearchbar), + multi: true, +}; +let IonSearchbar = class IonSearchbar extends ValueAccessor { + constructor(c, r, z, injector) { + super(injector, r); + this.z = z; + c.detach(); + this.el = r.nativeElement; + proxyOutputs(this, this.el, ['ionInput', 'ionChange', 'ionCancel', 'ionClear', 'ionBlur', 'ionFocus']); + } + handleIonInput(el) { + this.handleValueChange(el, el.value); + } +}; +__decorate([ + HostListener('ionInput', ['$event.target']) +], IonSearchbar.prototype, "handleIonInput", null); +IonSearchbar = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineCustomElement, + inputs: SEARCHBAR_INPUTS, + methods: ['setFocus', 'getInputElement'], + }), + Component({ + selector: 'ion-searchbar', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: SEARCHBAR_INPUTS, + providers: [accessorProvider], + standalone: true, + }) +], IonSearchbar); +export { IonSearchbar }; diff --git a/packages/angular/build/es2015/standalone/src/directives/segment.js b/packages/angular/build/es2015/standalone/src/directives/segment.js new file mode 100644 index 00000000000..2730cbba77e --- /dev/null +++ b/packages/angular/build/es2015/standalone/src/directives/segment.js @@ -0,0 +1,51 @@ +import { __decorate } from "tslib"; +import { ChangeDetectionStrategy, Component, HostListener, forwardRef, } from '@angular/core'; +import { NG_VALUE_ACCESSOR } from '@angular/forms'; +import { ValueAccessor } from '@ionic/angular/common'; +import { defineCustomElement } from '@ionic/core/components/ion-segment.js'; +import { ProxyCmp, proxyOutputs } from './angular-component-lib/utils'; +const SEGMENT_INPUTS = ['color', 'disabled', 'mode', 'scrollable', 'selectOnFocus', 'swipeGesture', 'value']; +/** + * Pulling the provider into an object and using PURE works + * around an ng-packagr issue that causes + * components with multiple decorators and + * a provider to be re-assigned. This re-assignment + * is not supported by Webpack and causes treeshaking + * to not work on these kinds of components. + */ +const accessorProvider = { + provide: NG_VALUE_ACCESSOR, + useExisting: /*@__PURE__*/ forwardRef(() => IonSegment), + multi: true, +}; +let IonSegment = class IonSegment extends ValueAccessor { + constructor(c, r, z, injector) { + super(injector, r); + this.z = z; + c.detach(); + this.el = r.nativeElement; + proxyOutputs(this, this.el, ['ionChange']); + } + handleIonChange(el) { + this.handleValueChange(el, el.value); + } +}; +__decorate([ + HostListener('ionChange', ['$event.target']) +], IonSegment.prototype, "handleIonChange", null); +IonSegment = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineCustomElement, + inputs: SEGMENT_INPUTS, + }), + Component({ + selector: 'ion-segment', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: SEGMENT_INPUTS, + providers: [accessorProvider], + standalone: true, + }) +], IonSegment); +export { IonSegment }; diff --git a/packages/angular/build/es2015/standalone/src/directives/select.js b/packages/angular/build/es2015/standalone/src/directives/select.js new file mode 100644 index 00000000000..7c48992ee06 --- /dev/null +++ b/packages/angular/build/es2015/standalone/src/directives/select.js @@ -0,0 +1,75 @@ +import { __decorate } from "tslib"; +import { ChangeDetectionStrategy, Component, HostListener, forwardRef, } from '@angular/core'; +import { NG_VALUE_ACCESSOR } from '@angular/forms'; +import { ValueAccessor } from '@ionic/angular/common'; +import { defineCustomElement } from '@ionic/core/components/ion-select.js'; +import { ProxyCmp, proxyOutputs } from './angular-component-lib/utils'; +const SELECT_INPUTS = [ + 'cancelText', + 'color', + 'compareWith', + 'disabled', + 'errorText', + 'expandedIcon', + 'fill', + 'helperText', + 'interface', + 'interfaceOptions', + 'justify', + 'label', + 'labelPlacement', + 'mode', + 'multiple', + 'name', + 'okText', + 'placeholder', + 'selectedText', + 'shape', + 'toggleIcon', + 'value', +]; +/** + * Pulling the provider into an object and using PURE works + * around an ng-packagr issue that causes + * components with multiple decorators and + * a provider to be re-assigned. This re-assignment + * is not supported by Webpack and causes treeshaking + * to not work on these kinds of components. + */ +const accessorProvider = { + provide: NG_VALUE_ACCESSOR, + useExisting: /*@__PURE__*/ forwardRef(() => IonSelect), + multi: true, +}; +let IonSelect = class IonSelect extends ValueAccessor { + constructor(c, r, z, injector) { + super(injector, r); + this.z = z; + c.detach(); + this.el = r.nativeElement; + proxyOutputs(this, this.el, ['ionChange', 'ionCancel', 'ionDismiss', 'ionFocus', 'ionBlur']); + } + handleIonChange(el) { + this.handleValueChange(el, el.value); + } +}; +__decorate([ + HostListener('ionChange', ['$event.target']) +], IonSelect.prototype, "handleIonChange", null); +IonSelect = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineCustomElement, + inputs: SELECT_INPUTS, + methods: ['open'], + }), + Component({ + selector: 'ion-select', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: SELECT_INPUTS, + providers: [accessorProvider], + standalone: true, + }) +], IonSelect); +export { IonSelect }; diff --git a/packages/angular/build/es2015/standalone/src/directives/textarea.js b/packages/angular/build/es2015/standalone/src/directives/textarea.js new file mode 100644 index 00000000000..ffe4da4fd43 --- /dev/null +++ b/packages/angular/build/es2015/standalone/src/directives/textarea.js @@ -0,0 +1,82 @@ +import { __decorate } from "tslib"; +import { ChangeDetectionStrategy, Component, HostListener, forwardRef, } from '@angular/core'; +import { NG_VALUE_ACCESSOR } from '@angular/forms'; +import { ValueAccessor } from '@ionic/angular/common'; +import { defineCustomElement } from '@ionic/core/components/ion-textarea.js'; +import { ProxyCmp, proxyOutputs } from './angular-component-lib/utils'; +const TEXTAREA_INPUTS = [ + 'autoGrow', + 'autocapitalize', + 'autofocus', + 'clearOnEdit', + 'color', + 'cols', + 'counter', + 'counterFormatter', + 'debounce', + 'disabled', + 'enterkeyhint', + 'errorText', + 'fill', + 'helperText', + 'inputmode', + 'label', + 'labelPlacement', + 'maxlength', + 'minlength', + 'mode', + 'name', + 'placeholder', + 'readonly', + 'required', + 'rows', + 'shape', + 'spellcheck', + 'value', + 'wrap', +]; +/** + * Pulling the provider into an object and using PURE works + * around an ng-packagr issue that causes + * components with multiple decorators and + * a provider to be re-assigned. This re-assignment + * is not supported by Webpack and causes treeshaking + * to not work on these kinds of components. + */ +const accessorProvider = { + provide: NG_VALUE_ACCESSOR, + useExisting: /*@__PURE__*/ forwardRef(() => IonTextarea), + multi: true, +}; +let IonTextarea = class IonTextarea extends ValueAccessor { + constructor(c, r, z, injector) { + super(injector, r); + this.z = z; + c.detach(); + this.el = r.nativeElement; + proxyOutputs(this, this.el, ['ionChange', 'ionInput', 'ionBlur', 'ionFocus']); + } + handleIonInput(el) { + this.handleValueChange(el, el.value); + } +}; +__decorate([ + HostListener('ionInput', ['$event.target']) +], IonTextarea.prototype, "handleIonInput", null); +IonTextarea = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineCustomElement, + inputs: TEXTAREA_INPUTS, + methods: ['setFocus', 'getInputElement'], + }), + Component({ + selector: 'ion-textarea', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: TEXTAREA_INPUTS, + providers: [accessorProvider], + standalone: true, + }) +], IonTextarea); +export { IonTextarea }; diff --git a/packages/angular/build/es2015/standalone/src/directives/toggle.js b/packages/angular/build/es2015/standalone/src/directives/toggle.js new file mode 100644 index 00000000000..696a86e014b --- /dev/null +++ b/packages/angular/build/es2015/standalone/src/directives/toggle.js @@ -0,0 +1,67 @@ +import { __decorate } from "tslib"; +import { ChangeDetectionStrategy, Component, HostListener, forwardRef, } from '@angular/core'; +import { NG_VALUE_ACCESSOR } from '@angular/forms'; +import { ValueAccessor, setIonicClasses } from '@ionic/angular/common'; +import { defineCustomElement } from '@ionic/core/components/ion-toggle.js'; +import { ProxyCmp, proxyOutputs } from './angular-component-lib/utils'; +const TOGGLE_INPUTS = [ + 'checked', + 'color', + 'disabled', + 'enableOnOffLabels', + 'errorText', + 'helperText', + 'justify', + 'labelPlacement', + 'mode', + 'name', + 'value', +]; +/** + * Pulling the provider into an object and using PURE works + * around an ng-packagr issue that causes + * components with multiple decorators and + * a provider to be re-assigned. This re-assignment + * is not supported by Webpack and causes treeshaking + * to not work on these kinds of components. + */ +const accessorProvider = { + provide: NG_VALUE_ACCESSOR, + useExisting: /*@__PURE__*/ forwardRef(() => IonToggle), + multi: true, +}; +let IonToggle = class IonToggle extends ValueAccessor { + constructor(c, r, z, injector) { + super(injector, r); + this.z = z; + c.detach(); + this.el = r.nativeElement; + proxyOutputs(this, this.el, ['ionChange', 'ionFocus', 'ionBlur']); + } + writeValue(value) { + this.elementRef.nativeElement.checked = this.lastValue = value; + setIonicClasses(this.elementRef); + } + handleIonChange(el) { + this.handleValueChange(el, el.checked); + } +}; +__decorate([ + HostListener('ionChange', ['$event.target']) +], IonToggle.prototype, "handleIonChange", null); +IonToggle = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineCustomElement, + inputs: TOGGLE_INPUTS, + }), + Component({ + selector: 'ion-toggle', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property + inputs: TOGGLE_INPUTS, + providers: [accessorProvider], + standalone: true, + }) +], IonToggle); +export { IonToggle }; diff --git a/packages/angular/build/es2015/standalone/src/index.js b/packages/angular/build/es2015/standalone/src/index.js new file mode 100644 index 00000000000..9545b9e29bd --- /dev/null +++ b/packages/angular/build/es2015/standalone/src/index.js @@ -0,0 +1,23 @@ +export { IonBackButton } from './navigation/back-button'; +export { IonModal } from './overlays/modal'; +export { IonPopover } from './overlays/popover'; +export { IonRouterOutlet } from './navigation/router-outlet'; +export { IonRouterLink, IonRouterLinkWithHref } from './navigation/router-link-delegate'; +export { IonTabs } from './navigation/tabs'; +export { provideIonicAngular } from './providers/ionic-angular'; +export { ActionSheetController } from './providers/action-sheet-controller'; +export { AlertController } from './providers/alert-controller'; +export { AnimationController } from './providers/animation-controller'; +export { GestureController } from './providers/gesture-controller'; +export { LoadingController } from './providers/loading-controller'; +export { MenuController } from './providers/menu-controller'; +export { ModalController } from './providers/modal-controller'; +export { PopoverController } from './providers/popover-controller'; +export { ToastController } from './providers/toast-controller'; +export { DomController, NavController, Config, Platform, NavParams, IonModalToken, IonicRouteStrategy, } from '@ionic/angular/common'; +export { IonNav } from './navigation/nav'; +export { IonCheckbox, IonDatetime, IonInput, IonInputOtp, IonIcon, IonRadioGroup, IonRange, IonSearchbar, IonSegment, IonSelect, IonTextarea, IonToggle, } from './directives'; +export * from './directives/proxies'; +export { +// UTILS +createAnimation, createGesture, iosTransitionAnimation, mdTransitionAnimation, IonicSlides, getPlatforms, isPlatform, getTimeGivenProgression, IonicSafeString, } from '@ionic/core/components'; diff --git a/packages/angular/build/es2015/standalone/src/navigation/back-button.js b/packages/angular/build/es2015/standalone/src/navigation/back-button.js new file mode 100644 index 00000000000..b204f687de3 --- /dev/null +++ b/packages/angular/build/es2015/standalone/src/navigation/back-button.js @@ -0,0 +1,22 @@ +import { __decorate, __param } from "tslib"; +import { Component, Optional, ChangeDetectionStrategy } from '@angular/core'; +import { IonBackButton as IonBackButtonBase, ProxyCmp } from '@ionic/angular/common'; +import { defineCustomElement } from '@ionic/core/components/ion-back-button.js'; +let IonBackButton = class IonBackButton extends IonBackButtonBase { + constructor(routerOutlet, navCtrl, config, r, z, c) { + super(routerOutlet, navCtrl, config, r, z, c); + } +}; +IonBackButton = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineCustomElement, + }), + Component({ + selector: 'ion-back-button', + changeDetection: ChangeDetectionStrategy.OnPush, + template: '', + standalone: true, + }), + __param(0, Optional()) +], IonBackButton); +export { IonBackButton }; diff --git a/packages/angular/build/es2015/standalone/src/navigation/nav.js b/packages/angular/build/es2015/standalone/src/navigation/nav.js new file mode 100644 index 00000000000..e69035fb3f0 --- /dev/null +++ b/packages/angular/build/es2015/standalone/src/navigation/nav.js @@ -0,0 +1,20 @@ +import { __decorate } from "tslib"; +import { Component } from '@angular/core'; +import { IonNav as IonNavBase, ProxyCmp } from '@ionic/angular/common'; +import { defineCustomElement } from '@ionic/core/components/ion-nav.js'; +let IonNav = class IonNav extends IonNavBase { + constructor(ref, environmentInjector, injector, angularDelegate, z, c) { + super(ref, environmentInjector, injector, angularDelegate, z, c); + } +}; +IonNav = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineCustomElement, + }), + Component({ + selector: 'ion-nav', + template: '', + standalone: true, + }) +], IonNav); +export { IonNav }; diff --git a/packages/angular/build/es2015/standalone/src/navigation/router-link-delegate.js b/packages/angular/build/es2015/standalone/src/navigation/router-link-delegate.js new file mode 100644 index 00000000000..33f48efc98c --- /dev/null +++ b/packages/angular/build/es2015/standalone/src/navigation/router-link-delegate.js @@ -0,0 +1,21 @@ +import { __decorate } from "tslib"; +import { Directive } from '@angular/core'; +import { RouterLinkDelegateDirective as RouterLinkDelegateBase, RouterLinkWithHrefDelegateDirective as RouterLinkHrefDelegateBase, } from '@ionic/angular/common'; +let IonRouterLink = class IonRouterLink extends RouterLinkDelegateBase { +}; +IonRouterLink = __decorate([ + Directive({ + selector: ':not(a):not(area)[routerLink]', + standalone: true, + }) +], IonRouterLink); +export { IonRouterLink }; +let IonRouterLinkWithHref = class IonRouterLinkWithHref extends RouterLinkHrefDelegateBase { +}; +IonRouterLinkWithHref = __decorate([ + Directive({ + selector: 'a[routerLink],area[routerLink]', + standalone: true, + }) +], IonRouterLinkWithHref); +export { IonRouterLinkWithHref }; diff --git a/packages/angular/build/es2015/standalone/src/navigation/router-outlet.js b/packages/angular/build/es2015/standalone/src/navigation/router-outlet.js new file mode 100644 index 00000000000..09eb8db1a4d --- /dev/null +++ b/packages/angular/build/es2015/standalone/src/navigation/router-outlet.js @@ -0,0 +1,35 @@ +import { __decorate, __param } from "tslib"; +import { ViewChild, ViewContainerRef, Component, Attribute, Optional, SkipSelf, } from '@angular/core'; +import { IonRouterOutlet as IonRouterOutletBase, ProxyCmp } from '@ionic/angular/common'; +import { defineCustomElement } from '@ionic/core/components/ion-router-outlet.js'; +let IonRouterOutlet = class IonRouterOutlet extends IonRouterOutletBase { + /** + * We need to pass in the correct instance of IonRouterOutlet + * otherwise parentOutlet will be null in a nested outlet context. + * This results in APIs such as NavController.pop not working + * in nested outlets because the parent outlet cannot be found. + */ + constructor(name, tabs, commonLocation, elementRef, router, zone, activatedRoute, parentOutlet) { + super(name, tabs, commonLocation, elementRef, router, zone, activatedRoute, parentOutlet); + this.parentOutlet = parentOutlet; + } +}; +__decorate([ + ViewChild('outletContent', { read: ViewContainerRef, static: true }) +], IonRouterOutlet.prototype, "outletContent", void 0); +IonRouterOutlet = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineCustomElement, + }), + Component({ + selector: 'ion-router-outlet', + standalone: true, + template: '', + }), + __param(0, Attribute('name')), + __param(1, Optional()), + __param(1, Attribute('tabs')), + __param(7, SkipSelf()), + __param(7, Optional()) +], IonRouterOutlet); +export { IonRouterOutlet }; diff --git a/packages/angular/build/es2015/standalone/src/navigation/tabs.js b/packages/angular/build/es2015/standalone/src/navigation/tabs.js new file mode 100644 index 00000000000..802ec66ed4f --- /dev/null +++ b/packages/angular/build/es2015/standalone/src/navigation/tabs.js @@ -0,0 +1,68 @@ +import { __decorate } from "tslib"; +import { NgIf } from '@angular/common'; +import { Component, ContentChild, ContentChildren, ViewChild } from '@angular/core'; +import { IonTabs as IonTabsBase } from '@ionic/angular/common'; +import { IonTabBar, IonTab } from '../directives/proxies'; +import { IonRouterOutlet } from './router-outlet'; +let IonTabs = class IonTabs extends IonTabsBase { +}; +__decorate([ + ViewChild('outlet', { read: IonRouterOutlet, static: false }) +], IonTabs.prototype, "outlet", void 0); +__decorate([ + ContentChild(IonTabBar, { static: false }) +], IonTabs.prototype, "tabBar", void 0); +__decorate([ + ContentChildren(IonTabBar) +], IonTabs.prototype, "tabBars", void 0); +__decorate([ + ContentChildren(IonTab) +], IonTabs.prototype, "tabs", void 0); +IonTabs = __decorate([ + Component({ + selector: 'ion-tabs', + template: ` + +
+ + +
+ + `, + standalone: true, + styles: [ + ` + :host { + display: flex; + position: absolute; + top: 0; + left: 0; + right: 0; + bottom: 0; + + flex-direction: column; + + width: 100%; + height: 100%; + + contain: layout size style; + } + .tabs-inner { + position: relative; + + flex: 1; + + contain: layout size style; + } + `, + ], + imports: [IonRouterOutlet, NgIf], + }) +], IonTabs); +export { IonTabs }; diff --git a/packages/angular/build/es2015/standalone/src/overlays/modal.js b/packages/angular/build/es2015/standalone/src/overlays/modal.js new file mode 100644 index 00000000000..d3e6b584717 --- /dev/null +++ b/packages/angular/build/es2015/standalone/src/overlays/modal.js @@ -0,0 +1,22 @@ +import { __decorate } from "tslib"; +import { CommonModule } from '@angular/common'; +import { ChangeDetectionStrategy, Component } from '@angular/core'; +import { IonModal as IonModalBase, ProxyCmp } from '@ionic/angular/common'; +import { defineCustomElement } from '@ionic/core/components/ion-modal.js'; +let IonModal = class IonModal extends IonModalBase { +}; +IonModal = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineCustomElement, + }), + Component({ + selector: 'ion-modal', + changeDetection: ChangeDetectionStrategy.OnPush, + template: `
+ +
`, + standalone: true, + imports: [CommonModule], + }) +], IonModal); +export { IonModal }; diff --git a/packages/angular/build/es2015/standalone/src/overlays/popover.js b/packages/angular/build/es2015/standalone/src/overlays/popover.js new file mode 100644 index 00000000000..a5b8b139979 --- /dev/null +++ b/packages/angular/build/es2015/standalone/src/overlays/popover.js @@ -0,0 +1,20 @@ +import { __decorate } from "tslib"; +import { CommonModule } from '@angular/common'; +import { ChangeDetectionStrategy, Component } from '@angular/core'; +import { IonPopover as IonPopoverBase, ProxyCmp } from '@ionic/angular/common'; +import { defineCustomElement } from '@ionic/core/components/ion-popover.js'; +let IonPopover = class IonPopover extends IonPopoverBase { +}; +IonPopover = __decorate([ + ProxyCmp({ + defineCustomElementFn: defineCustomElement, + }), + Component({ + selector: 'ion-popover', + changeDetection: ChangeDetectionStrategy.OnPush, + template: ``, + standalone: true, + imports: [CommonModule], + }) +], IonPopover); +export { IonPopover }; diff --git a/packages/angular/build/es2015/standalone/src/providers/action-sheet-controller.js b/packages/angular/build/es2015/standalone/src/providers/action-sheet-controller.js new file mode 100644 index 00000000000..0f340dcbe3d --- /dev/null +++ b/packages/angular/build/es2015/standalone/src/providers/action-sheet-controller.js @@ -0,0 +1,17 @@ +import { __decorate } from "tslib"; +import { Injectable } from '@angular/core'; +import { OverlayBaseController } from '@ionic/angular/common'; +import { actionSheetController } from '@ionic/core/components'; +import { defineCustomElement } from '@ionic/core/components/ion-action-sheet.js'; +let ActionSheetController = class ActionSheetController extends OverlayBaseController { + constructor() { + super(actionSheetController); + defineCustomElement(); + } +}; +ActionSheetController = __decorate([ + Injectable({ + providedIn: 'root', + }) +], ActionSheetController); +export { ActionSheetController }; diff --git a/packages/angular/build/es2015/standalone/src/providers/alert-controller.js b/packages/angular/build/es2015/standalone/src/providers/alert-controller.js new file mode 100644 index 00000000000..6ebcc1023a8 --- /dev/null +++ b/packages/angular/build/es2015/standalone/src/providers/alert-controller.js @@ -0,0 +1,17 @@ +import { __decorate } from "tslib"; +import { Injectable } from '@angular/core'; +import { OverlayBaseController } from '@ionic/angular/common'; +import { alertController } from '@ionic/core/components'; +import { defineCustomElement } from '@ionic/core/components/ion-alert.js'; +let AlertController = class AlertController extends OverlayBaseController { + constructor() { + super(alertController); + defineCustomElement(); + } +}; +AlertController = __decorate([ + Injectable({ + providedIn: 'root', + }) +], AlertController); +export { AlertController }; diff --git a/packages/angular/build/es2015/standalone/src/providers/animation-controller.js b/packages/angular/build/es2015/standalone/src/providers/animation-controller.js new file mode 100644 index 00000000000..64b671b0e15 --- /dev/null +++ b/packages/angular/build/es2015/standalone/src/providers/animation-controller.js @@ -0,0 +1,34 @@ +import { __decorate } from "tslib"; +import { Injectable } from '@angular/core'; +import { createAnimation, getTimeGivenProgression } from '@ionic/core/components'; +let AnimationController = class AnimationController { + /** + * Create a new animation + */ + create(animationId) { + return createAnimation(animationId); + } + /** + * EXPERIMENTAL + * + * Given a progression and a cubic bezier function, + * this utility returns the time value(s) at which the + * cubic bezier reaches the given time progression. + * + * If the cubic bezier never reaches the progression + * the result will be an empty array. + * + * This is most useful for switching between easing curves + * when doing a gesture animation (i.e. going from linear easing + * during a drag, to another easing when `progressEnd` is called) + */ + easingTime(p0, p1, p2, p3, progression) { + return getTimeGivenProgression(p0, p1, p2, p3, progression); + } +}; +AnimationController = __decorate([ + Injectable({ + providedIn: 'root', + }) +], AnimationController); +export { AnimationController }; diff --git a/packages/angular/build/es2015/standalone/src/providers/gesture-controller.js b/packages/angular/build/es2015/standalone/src/providers/gesture-controller.js new file mode 100644 index 00000000000..c83f0fbf261 --- /dev/null +++ b/packages/angular/build/es2015/standalone/src/providers/gesture-controller.js @@ -0,0 +1,28 @@ +import { __decorate } from "tslib"; +import { Injectable } from '@angular/core'; +import { createGesture } from '@ionic/core/components'; +let GestureController = class GestureController { + constructor(zone) { + this.zone = zone; + } + /** + * Create a new gesture + */ + create(opts, runInsideAngularZone = false) { + if (runInsideAngularZone) { + Object.getOwnPropertyNames(opts).forEach((key) => { + if (typeof opts[key] === 'function') { + const fn = opts[key]; + opts[key] = (...props) => this.zone.run(() => fn(...props)); + } + }); + } + return createGesture(opts); + } +}; +GestureController = __decorate([ + Injectable({ + providedIn: 'root', + }) +], GestureController); +export { GestureController }; diff --git a/packages/angular/build/es2015/standalone/src/providers/ionic-angular.js b/packages/angular/build/es2015/standalone/src/providers/ionic-angular.js new file mode 100644 index 00000000000..002b6085dd3 --- /dev/null +++ b/packages/angular/build/es2015/standalone/src/providers/ionic-angular.js @@ -0,0 +1,37 @@ +import { DOCUMENT } from '@angular/common'; +import { APP_INITIALIZER, makeEnvironmentProviders } from '@angular/core'; +import { AngularDelegate, ConfigToken, provideComponentInputBinding } from '@ionic/angular/common'; +import { initialize } from '@ionic/core/components'; +import { ModalController } from './modal-controller'; +import { PopoverController } from './popover-controller'; +export const provideIonicAngular = (config = {}) => { + return makeEnvironmentProviders([ + { + provide: ConfigToken, + useValue: config, + }, + { + provide: APP_INITIALIZER, + useFactory: initializeIonicAngular, + multi: true, + deps: [ConfigToken, DOCUMENT], + }, + provideComponentInputBinding(), + AngularDelegate, + ModalController, + PopoverController, + ]); +}; +const initializeIonicAngular = (config, doc) => { + return () => { + /** + * By default Ionic Framework hides elements that + * are not hydrated, but in the CE build there is no + * hydration. + * TODO FW-2797: Remove when all integrations have been + * migrated to CE build. + */ + doc.documentElement.classList.add('ion-ce'); + initialize(config); + }; +}; diff --git a/packages/angular/build/es2015/standalone/src/providers/loading-controller.js b/packages/angular/build/es2015/standalone/src/providers/loading-controller.js new file mode 100644 index 00000000000..3caed2088f6 --- /dev/null +++ b/packages/angular/build/es2015/standalone/src/providers/loading-controller.js @@ -0,0 +1,17 @@ +import { __decorate } from "tslib"; +import { Injectable } from '@angular/core'; +import { OverlayBaseController } from '@ionic/angular/common'; +import { loadingController } from '@ionic/core/components'; +import { defineCustomElement } from '@ionic/core/components/ion-loading.js'; +let LoadingController = class LoadingController extends OverlayBaseController { + constructor() { + super(loadingController); + defineCustomElement(); + } +}; +LoadingController = __decorate([ + Injectable({ + providedIn: 'root', + }) +], LoadingController); +export { LoadingController }; diff --git a/packages/angular/build/es2015/standalone/src/providers/menu-controller.js b/packages/angular/build/es2015/standalone/src/providers/menu-controller.js new file mode 100644 index 00000000000..5865b4b7b0a --- /dev/null +++ b/packages/angular/build/es2015/standalone/src/providers/menu-controller.js @@ -0,0 +1,15 @@ +import { __decorate } from "tslib"; +import { Injectable } from '@angular/core'; +import { MenuController as MenuControllerBase } from '@ionic/angular/common'; +import { menuController } from '@ionic/core/components'; +let MenuController = class MenuController extends MenuControllerBase { + constructor() { + super(menuController); + } +}; +MenuController = __decorate([ + Injectable({ + providedIn: 'root', + }) +], MenuController); +export { MenuController }; diff --git a/packages/angular/build/es2015/standalone/src/providers/modal-controller.js b/packages/angular/build/es2015/standalone/src/providers/modal-controller.js new file mode 100644 index 00000000000..11842feb50d --- /dev/null +++ b/packages/angular/build/es2015/standalone/src/providers/modal-controller.js @@ -0,0 +1,22 @@ +import { __decorate, __rest } from "tslib"; +import { Injector, Injectable, EnvironmentInjector, inject } from '@angular/core'; +import { AngularDelegate, OverlayBaseController } from '@ionic/angular/common'; +import { modalController } from '@ionic/core/components'; +import { defineCustomElement } from '@ionic/core/components/ion-modal.js'; +let ModalController = class ModalController extends OverlayBaseController { + constructor() { + super(modalController); + this.angularDelegate = inject(AngularDelegate); + this.injector = inject(Injector); + this.environmentInjector = inject(EnvironmentInjector); + defineCustomElement(); + } + create(opts) { + const { injector: customInjector } = opts, restOpts = __rest(opts, ["injector"]); + return super.create(Object.assign(Object.assign({}, restOpts), { delegate: this.angularDelegate.create(this.environmentInjector, this.injector, 'modal', customInjector) })); + } +}; +ModalController = __decorate([ + Injectable() +], ModalController); +export { ModalController }; diff --git a/packages/angular/build/es2015/standalone/src/providers/popover-controller.js b/packages/angular/build/es2015/standalone/src/providers/popover-controller.js new file mode 100644 index 00000000000..05af778c792 --- /dev/null +++ b/packages/angular/build/es2015/standalone/src/providers/popover-controller.js @@ -0,0 +1,18 @@ +import { __rest } from "tslib"; +import { Injector, inject, EnvironmentInjector } from '@angular/core'; +import { AngularDelegate, OverlayBaseController } from '@ionic/angular/common'; +import { popoverController } from '@ionic/core/components'; +import { defineCustomElement } from '@ionic/core/components/ion-popover.js'; +export class PopoverController extends OverlayBaseController { + constructor() { + super(popoverController); + this.angularDelegate = inject(AngularDelegate); + this.injector = inject(Injector); + this.environmentInjector = inject(EnvironmentInjector); + defineCustomElement(); + } + create(opts) { + const { injector: customInjector } = opts, restOpts = __rest(opts, ["injector"]); + return super.create(Object.assign(Object.assign({}, restOpts), { delegate: this.angularDelegate.create(this.environmentInjector, this.injector, 'popover', customInjector) })); + } +} diff --git a/packages/angular/build/es2015/standalone/src/providers/toast-controller.js b/packages/angular/build/es2015/standalone/src/providers/toast-controller.js new file mode 100644 index 00000000000..cee49b63403 --- /dev/null +++ b/packages/angular/build/es2015/standalone/src/providers/toast-controller.js @@ -0,0 +1,17 @@ +import { __decorate } from "tslib"; +import { Injectable } from '@angular/core'; +import { OverlayBaseController } from '@ionic/angular/common'; +import { toastController } from '@ionic/core/components'; +import { defineCustomElement } from '@ionic/core/components/ion-toast.js'; +let ToastController = class ToastController extends OverlayBaseController { + constructor() { + super(toastController); + defineCustomElement(); + } +}; +ToastController = __decorate([ + Injectable({ + providedIn: 'root', + }) +], ToastController); +export { ToastController }; diff --git a/packages/angular/lazy/src/index.ts b/packages/angular/lazy/src/index.ts index 4f271c6640d..0b7475f58ef 100644 --- a/packages/angular/lazy/src/index.ts +++ b/packages/angular/lazy/src/index.ts @@ -43,7 +43,12 @@ export { ModalController } from './providers/modal-controller'; export { PopoverController } from './providers/popover-controller'; export { ToastController } from './providers/toast-controller'; -// PACKAGE MODULE +/* + * PACKAGE MODULE + * `IonicModule` is deprecated and will be removed in a future major version. + * Use `provideIonicAngular()` from `@ionic/angular` instead. The deprecation is + * declared on the class itself, so consumers importing it here see the notice. + */ export { IonicModule } from './ionic-module'; export { diff --git a/packages/angular/lazy/src/ionic-module.ts b/packages/angular/lazy/src/ionic-module.ts index acd7745294b..a22b0cd038d 100644 --- a/packages/angular/lazy/src/ionic-module.ts +++ b/packages/angular/lazy/src/ionic-module.ts @@ -56,6 +56,11 @@ type OptInAngularFeatures = { useSetInputAPI?: boolean; }; +/** + * @deprecated `IonicModule` is deprecated and will be removed in a future major version. + * Use `provideIonicAngular()` instead, which works in both standalone and NgModule-based + * applications. Refer to https://ionicframework.com/docs/angular/build-options for migration steps. + */ @NgModule({ declarations: DECLARATIONS, exports: DECLARATIONS, @@ -63,7 +68,15 @@ type OptInAngularFeatures = { imports: [CommonModule], }) export class IonicModule { + /** + * @deprecated `IonicModule.forRoot()` is deprecated and will be removed in a future major version. + * Use `provideIonicAngular()` instead. Any config passed here can be passed as an object to that + * function. Refer to https://ionicframework.com/docs/angular/build-options for migration steps. + */ static forRoot(config: IonicConfig & OptInAngularFeatures = {}): ModuleWithProviders { + console.warn( + `[Ionic Warning]: IonicModule has been deprecated in favor of provideIonicAngular() and will be removed in a future major version. Refer to https://ionicframework.com/docs/angular/build-options for migration steps.` + ); return { ngModule: IonicModule, providers: [ diff --git a/packages/react/src/components/components.ts b/packages/react/src/components/components.ts index 7080edec552..785a7bfab0e 100644 --- a/packages/react/src/components/components.ts +++ b/packages/react/src/components/components.ts @@ -11,1430 +11,1027 @@ import type { EventName, StencilReactComponent } from '@stencil/react-output-tar import { createComponent } from '@stencil/react-output-target/runtime'; import React from 'react'; -import { - type AccordionGroupChangeEventDetail, - type BreadcrumbCollapsedClickEventDetail, - type CheckboxChangeEventDetail, - type DatetimeChangeEventDetail, - type InputChangeEventDetail, - type InputInputEventDetail, - type InputOtpChangeEventDetail, - type InputOtpCompleteEventDetail, - type InputOtpInputEventDetail, - type IonAccordionGroupCustomEvent, - type IonBackdropCustomEvent, - type IonBreadcrumbsCustomEvent, - type IonCheckboxCustomEvent, - type IonContentCustomEvent, - type IonDatetimeCustomEvent, - type IonImgCustomEvent, - type IonInfiniteScrollCustomEvent, - type IonInputCustomEvent, - type IonInputOtpCustomEvent, - type IonItemOptionsCustomEvent, - type IonItemSlidingCustomEvent, - type IonMenuCustomEvent, - type IonNavCustomEvent, - type IonPickerColumnCustomEvent, - type IonRadioCustomEvent, - type IonRadioGroupCustomEvent, - type IonRangeCustomEvent, - type IonRefresherCustomEvent, - type IonReorderGroupCustomEvent, - type IonSearchbarCustomEvent, - type IonSegmentCustomEvent, - type IonSegmentViewCustomEvent, - type IonSelectCustomEvent, - type IonSplitPaneCustomEvent, - type IonTextareaCustomEvent, - type IonToggleCustomEvent, - type ItemReorderEventDetail, - type MenuCloseEventDetail, - type PickerColumnChangeEventDetail, - type RadioGroupChangeEventDetail, - type RangeChangeEventDetail, - type RangeKnobMoveEndEventDetail, - type RangeKnobMoveStartEventDetail, - type RefresherEventDetail, - type RefresherPullEndEventDetail, - type ReorderEndEventDetail, - type ReorderMoveEventDetail, - type ScrollBaseDetail, - type ScrollDetail, - type SearchbarChangeEventDetail, - type SearchbarInputEventDetail, - type SegmentChangeEventDetail, - type SegmentViewScrollEvent, - type SelectChangeEventDetail, - type TextareaChangeEventDetail, - type TextareaInputEventDetail, - type ToggleChangeEventDetail, -} from '@ionic/core'; -import type { Components } from '@ionic/core/components'; -import { - IonAccordionGroup as IonAccordionGroupElement, - defineCustomElement as defineIonAccordionGroup, -} from '@ionic/core/components/ion-accordion-group.js'; -import { - IonAccordion as IonAccordionElement, - defineCustomElement as defineIonAccordion, -} from '@ionic/core/components/ion-accordion.js'; -import { - IonAvatar as IonAvatarElement, - defineCustomElement as defineIonAvatar, -} from '@ionic/core/components/ion-avatar.js'; -import { - IonBackdrop as IonBackdropElement, - defineCustomElement as defineIonBackdrop, -} from '@ionic/core/components/ion-backdrop.js'; -import { - IonBadge as IonBadgeElement, - defineCustomElement as defineIonBadge, -} from '@ionic/core/components/ion-badge.js'; -import { - IonBreadcrumbs as IonBreadcrumbsElement, - defineCustomElement as defineIonBreadcrumbs, -} from '@ionic/core/components/ion-breadcrumbs.js'; -import { - IonButtons as IonButtonsElement, - defineCustomElement as defineIonButtons, -} from '@ionic/core/components/ion-buttons.js'; -import { - IonCardContent as IonCardContentElement, - defineCustomElement as defineIonCardContent, -} from '@ionic/core/components/ion-card-content.js'; -import { - IonCardHeader as IonCardHeaderElement, - defineCustomElement as defineIonCardHeader, -} from '@ionic/core/components/ion-card-header.js'; -import { - IonCardSubtitle as IonCardSubtitleElement, - defineCustomElement as defineIonCardSubtitle, -} from '@ionic/core/components/ion-card-subtitle.js'; -import { - IonCardTitle as IonCardTitleElement, - defineCustomElement as defineIonCardTitle, -} from '@ionic/core/components/ion-card-title.js'; -import { - IonCheckbox as IonCheckboxElement, - defineCustomElement as defineIonCheckbox, -} from '@ionic/core/components/ion-checkbox.js'; -import { IonChip as IonChipElement, defineCustomElement as defineIonChip } from '@ionic/core/components/ion-chip.js'; -import { IonCol as IonColElement, defineCustomElement as defineIonCol } from '@ionic/core/components/ion-col.js'; -import { - IonContent as IonContentElement, - defineCustomElement as defineIonContent, -} from '@ionic/core/components/ion-content.js'; -import { - IonDatetimeButton as IonDatetimeButtonElement, - defineCustomElement as defineIonDatetimeButton, -} from '@ionic/core/components/ion-datetime-button.js'; -import { - IonDatetime as IonDatetimeElement, - defineCustomElement as defineIonDatetime, -} from '@ionic/core/components/ion-datetime.js'; -import { - IonFabList as IonFabListElement, - defineCustomElement as defineIonFabList, -} from '@ionic/core/components/ion-fab-list.js'; -import { IonFab as IonFabElement, defineCustomElement as defineIonFab } from '@ionic/core/components/ion-fab.js'; -import { - IonFooter as IonFooterElement, - defineCustomElement as defineIonFooter, -} from '@ionic/core/components/ion-footer.js'; -import { IonGrid as IonGridElement, defineCustomElement as defineIonGrid } from '@ionic/core/components/ion-grid.js'; -import { - IonHeader as IonHeaderElement, - defineCustomElement as defineIonHeader, -} from '@ionic/core/components/ion-header.js'; -import { IonImg as IonImgElement, defineCustomElement as defineIonImg } from '@ionic/core/components/ion-img.js'; -import { - IonInfiniteScrollContent as IonInfiniteScrollContentElement, - defineCustomElement as defineIonInfiniteScrollContent, -} from '@ionic/core/components/ion-infinite-scroll-content.js'; -import { - IonInfiniteScroll as IonInfiniteScrollElement, - defineCustomElement as defineIonInfiniteScroll, -} from '@ionic/core/components/ion-infinite-scroll.js'; -import { - IonInputOtp as IonInputOtpElement, - defineCustomElement as defineIonInputOtp, -} from '@ionic/core/components/ion-input-otp.js'; -import { - IonInputPasswordToggle as IonInputPasswordToggleElement, - defineCustomElement as defineIonInputPasswordToggle, -} from '@ionic/core/components/ion-input-password-toggle.js'; -import { - IonInput as IonInputElement, - defineCustomElement as defineIonInput, -} from '@ionic/core/components/ion-input.js'; -import { - IonItemDivider as IonItemDividerElement, - defineCustomElement as defineIonItemDivider, -} from '@ionic/core/components/ion-item-divider.js'; -import { - IonItemGroup as IonItemGroupElement, - defineCustomElement as defineIonItemGroup, -} from '@ionic/core/components/ion-item-group.js'; -import { - IonItemOptions as IonItemOptionsElement, - defineCustomElement as defineIonItemOptions, -} from '@ionic/core/components/ion-item-options.js'; -import { - IonItemSliding as IonItemSlidingElement, - defineCustomElement as defineIonItemSliding, -} from '@ionic/core/components/ion-item-sliding.js'; -import { - IonLabel as IonLabelElement, - defineCustomElement as defineIonLabel, -} from '@ionic/core/components/ion-label.js'; -import { - IonListHeader as IonListHeaderElement, - defineCustomElement as defineIonListHeader, -} from '@ionic/core/components/ion-list-header.js'; -import { IonList as IonListElement, defineCustomElement as defineIonList } from '@ionic/core/components/ion-list.js'; -import { - IonMenuButton as IonMenuButtonElement, - defineCustomElement as defineIonMenuButton, -} from '@ionic/core/components/ion-menu-button.js'; -import { - IonMenuToggle as IonMenuToggleElement, - defineCustomElement as defineIonMenuToggle, -} from '@ionic/core/components/ion-menu-toggle.js'; -import { IonMenu as IonMenuElement, defineCustomElement as defineIonMenu } from '@ionic/core/components/ion-menu.js'; -import { - IonNavLink as IonNavLinkElement, - defineCustomElement as defineIonNavLink, -} from '@ionic/core/components/ion-nav-link.js'; -import { IonNav as IonNavElement, defineCustomElement as defineIonNav } from '@ionic/core/components/ion-nav.js'; -import { IonNote as IonNoteElement, defineCustomElement as defineIonNote } from '@ionic/core/components/ion-note.js'; -import { - IonPickerColumnOption as IonPickerColumnOptionElement, - defineCustomElement as defineIonPickerColumnOption, -} from '@ionic/core/components/ion-picker-column-option.js'; -import { - IonPickerColumn as IonPickerColumnElement, - defineCustomElement as defineIonPickerColumn, -} from '@ionic/core/components/ion-picker-column.js'; -import { - IonPicker as IonPickerElement, - defineCustomElement as defineIonPicker, -} from '@ionic/core/components/ion-picker.js'; -import { - IonProgressBar as IonProgressBarElement, - defineCustomElement as defineIonProgressBar, -} from '@ionic/core/components/ion-progress-bar.js'; -import { - IonRadioGroup as IonRadioGroupElement, - defineCustomElement as defineIonRadioGroup, -} from '@ionic/core/components/ion-radio-group.js'; -import { - IonRadio as IonRadioElement, - defineCustomElement as defineIonRadio, -} from '@ionic/core/components/ion-radio.js'; -import { - IonRange as IonRangeElement, - defineCustomElement as defineIonRange, -} from '@ionic/core/components/ion-range.js'; -import { - IonRefresherContent as IonRefresherContentElement, - defineCustomElement as defineIonRefresherContent, -} from '@ionic/core/components/ion-refresher-content.js'; -import { - IonRefresher as IonRefresherElement, - defineCustomElement as defineIonRefresher, -} from '@ionic/core/components/ion-refresher.js'; -import { - IonReorderGroup as IonReorderGroupElement, - defineCustomElement as defineIonReorderGroup, -} from '@ionic/core/components/ion-reorder-group.js'; -import { - IonReorder as IonReorderElement, - defineCustomElement as defineIonReorder, -} from '@ionic/core/components/ion-reorder.js'; -import { - IonRippleEffect as IonRippleEffectElement, - defineCustomElement as defineIonRippleEffect, -} from '@ionic/core/components/ion-ripple-effect.js'; -import { IonRow as IonRowElement, defineCustomElement as defineIonRow } from '@ionic/core/components/ion-row.js'; -import { - IonSearchbar as IonSearchbarElement, - defineCustomElement as defineIonSearchbar, -} from '@ionic/core/components/ion-searchbar.js'; -import { - IonSegmentButton as IonSegmentButtonElement, - defineCustomElement as defineIonSegmentButton, -} from '@ionic/core/components/ion-segment-button.js'; -import { - IonSegmentContent as IonSegmentContentElement, - defineCustomElement as defineIonSegmentContent, -} from '@ionic/core/components/ion-segment-content.js'; -import { - IonSegmentView as IonSegmentViewElement, - defineCustomElement as defineIonSegmentView, -} from '@ionic/core/components/ion-segment-view.js'; -import { - IonSegment as IonSegmentElement, - defineCustomElement as defineIonSegment, -} from '@ionic/core/components/ion-segment.js'; -import { - IonSelectModal as IonSelectModalElement, - defineCustomElement as defineIonSelectModal, -} from '@ionic/core/components/ion-select-modal.js'; -import { - IonSelectOption as IonSelectOptionElement, - defineCustomElement as defineIonSelectOption, -} from '@ionic/core/components/ion-select-option.js'; -import { - IonSelect as IonSelectElement, - defineCustomElement as defineIonSelect, -} from '@ionic/core/components/ion-select.js'; -import { - IonSkeletonText as IonSkeletonTextElement, - defineCustomElement as defineIonSkeletonText, -} from '@ionic/core/components/ion-skeleton-text.js'; -import { - IonSpinner as IonSpinnerElement, - defineCustomElement as defineIonSpinner, -} from '@ionic/core/components/ion-spinner.js'; -import { - IonSplitPane as IonSplitPaneElement, - defineCustomElement as defineIonSplitPane, -} from '@ionic/core/components/ion-split-pane.js'; -import { IonTab as IonTabElement, defineCustomElement as defineIonTab } from '@ionic/core/components/ion-tab.js'; -import { IonText as IonTextElement, defineCustomElement as defineIonText } from '@ionic/core/components/ion-text.js'; -import { - IonTextarea as IonTextareaElement, - defineCustomElement as defineIonTextarea, -} from '@ionic/core/components/ion-textarea.js'; -import { - IonThumbnail as IonThumbnailElement, - defineCustomElement as defineIonThumbnail, -} from '@ionic/core/components/ion-thumbnail.js'; -import { - IonTitle as IonTitleElement, - defineCustomElement as defineIonTitle, -} from '@ionic/core/components/ion-title.js'; -import { - IonToggle as IonToggleElement, - defineCustomElement as defineIonToggle, -} from '@ionic/core/components/ion-toggle.js'; -import { - IonToolbar as IonToolbarElement, - defineCustomElement as defineIonToolbar, -} from '@ionic/core/components/ion-toolbar.js'; +import { type AccordionGroupChangeEventDetail, type BreadcrumbCollapsedClickEventDetail, type CheckboxChangeEventDetail, type DatetimeChangeEventDetail, type InputChangeEventDetail, type InputInputEventDetail, type InputOtpChangeEventDetail, type InputOtpCompleteEventDetail, type InputOtpInputEventDetail, type IonAccordionGroupCustomEvent, type IonBackdropCustomEvent, type IonBreadcrumbsCustomEvent, type IonCheckboxCustomEvent, type IonContentCustomEvent, type IonDatetimeCustomEvent, type IonImgCustomEvent, type IonInfiniteScrollCustomEvent, type IonInputCustomEvent, type IonInputOtpCustomEvent, type IonItemOptionsCustomEvent, type IonItemSlidingCustomEvent, type IonMenuCustomEvent, type IonNavCustomEvent, type IonPickerColumnCustomEvent, type IonRadioCustomEvent, type IonRadioGroupCustomEvent, type IonRangeCustomEvent, type IonRefresherCustomEvent, type IonReorderGroupCustomEvent, type IonSearchbarCustomEvent, type IonSegmentCustomEvent, type IonSegmentViewCustomEvent, type IonSelectCustomEvent, type IonSplitPaneCustomEvent, type IonTextareaCustomEvent, type IonToggleCustomEvent, type ItemReorderEventDetail, type MenuCloseEventDetail, type PickerColumnChangeEventDetail, type RadioGroupChangeEventDetail, type RangeChangeEventDetail, type RangeKnobMoveEndEventDetail, type RangeKnobMoveStartEventDetail, type RefresherEventDetail, type RefresherPullEndEventDetail, type ReorderEndEventDetail, type ReorderMoveEventDetail, type ScrollBaseDetail, type ScrollDetail, type SearchbarChangeEventDetail, type SearchbarInputEventDetail, type SegmentChangeEventDetail, type SegmentViewScrollEvent, type SelectChangeEventDetail, type TextareaChangeEventDetail, type TextareaInputEventDetail, type ToggleChangeEventDetail } from "@ionic/core"; +import type { Components } from "@ionic/core/components"; +import { IonAccordionGroup as IonAccordionGroupElement, defineCustomElement as defineIonAccordionGroup } from "@ionic/core/components/ion-accordion-group.js"; +import { IonAccordion as IonAccordionElement, defineCustomElement as defineIonAccordion } from "@ionic/core/components/ion-accordion.js"; +import { IonAvatar as IonAvatarElement, defineCustomElement as defineIonAvatar } from "@ionic/core/components/ion-avatar.js"; +import { IonBackdrop as IonBackdropElement, defineCustomElement as defineIonBackdrop } from "@ionic/core/components/ion-backdrop.js"; +import { IonBadge as IonBadgeElement, defineCustomElement as defineIonBadge } from "@ionic/core/components/ion-badge.js"; +import { IonBreadcrumbs as IonBreadcrumbsElement, defineCustomElement as defineIonBreadcrumbs } from "@ionic/core/components/ion-breadcrumbs.js"; +import { IonButtons as IonButtonsElement, defineCustomElement as defineIonButtons } from "@ionic/core/components/ion-buttons.js"; +import { IonCardContent as IonCardContentElement, defineCustomElement as defineIonCardContent } from "@ionic/core/components/ion-card-content.js"; +import { IonCardHeader as IonCardHeaderElement, defineCustomElement as defineIonCardHeader } from "@ionic/core/components/ion-card-header.js"; +import { IonCardSubtitle as IonCardSubtitleElement, defineCustomElement as defineIonCardSubtitle } from "@ionic/core/components/ion-card-subtitle.js"; +import { IonCardTitle as IonCardTitleElement, defineCustomElement as defineIonCardTitle } from "@ionic/core/components/ion-card-title.js"; +import { IonCheckbox as IonCheckboxElement, defineCustomElement as defineIonCheckbox } from "@ionic/core/components/ion-checkbox.js"; +import { IonChip as IonChipElement, defineCustomElement as defineIonChip } from "@ionic/core/components/ion-chip.js"; +import { IonCol as IonColElement, defineCustomElement as defineIonCol } from "@ionic/core/components/ion-col.js"; +import { IonContent as IonContentElement, defineCustomElement as defineIonContent } from "@ionic/core/components/ion-content.js"; +import { IonDatetimeButton as IonDatetimeButtonElement, defineCustomElement as defineIonDatetimeButton } from "@ionic/core/components/ion-datetime-button.js"; +import { IonDatetime as IonDatetimeElement, defineCustomElement as defineIonDatetime } from "@ionic/core/components/ion-datetime.js"; +import { IonFabList as IonFabListElement, defineCustomElement as defineIonFabList } from "@ionic/core/components/ion-fab-list.js"; +import { IonFab as IonFabElement, defineCustomElement as defineIonFab } from "@ionic/core/components/ion-fab.js"; +import { IonFooter as IonFooterElement, defineCustomElement as defineIonFooter } from "@ionic/core/components/ion-footer.js"; +import { IonGrid as IonGridElement, defineCustomElement as defineIonGrid } from "@ionic/core/components/ion-grid.js"; +import { IonHeader as IonHeaderElement, defineCustomElement as defineIonHeader } from "@ionic/core/components/ion-header.js"; +import { IonImg as IonImgElement, defineCustomElement as defineIonImg } from "@ionic/core/components/ion-img.js"; +import { IonInfiniteScrollContent as IonInfiniteScrollContentElement, defineCustomElement as defineIonInfiniteScrollContent } from "@ionic/core/components/ion-infinite-scroll-content.js"; +import { IonInfiniteScroll as IonInfiniteScrollElement, defineCustomElement as defineIonInfiniteScroll } from "@ionic/core/components/ion-infinite-scroll.js"; +import { IonInputOtp as IonInputOtpElement, defineCustomElement as defineIonInputOtp } from "@ionic/core/components/ion-input-otp.js"; +import { IonInputPasswordToggle as IonInputPasswordToggleElement, defineCustomElement as defineIonInputPasswordToggle } from "@ionic/core/components/ion-input-password-toggle.js"; +import { IonInput as IonInputElement, defineCustomElement as defineIonInput } from "@ionic/core/components/ion-input.js"; +import { IonItemDivider as IonItemDividerElement, defineCustomElement as defineIonItemDivider } from "@ionic/core/components/ion-item-divider.js"; +import { IonItemGroup as IonItemGroupElement, defineCustomElement as defineIonItemGroup } from "@ionic/core/components/ion-item-group.js"; +import { IonItemOptions as IonItemOptionsElement, defineCustomElement as defineIonItemOptions } from "@ionic/core/components/ion-item-options.js"; +import { IonItemSliding as IonItemSlidingElement, defineCustomElement as defineIonItemSliding } from "@ionic/core/components/ion-item-sliding.js"; +import { IonLabel as IonLabelElement, defineCustomElement as defineIonLabel } from "@ionic/core/components/ion-label.js"; +import { IonListHeader as IonListHeaderElement, defineCustomElement as defineIonListHeader } from "@ionic/core/components/ion-list-header.js"; +import { IonList as IonListElement, defineCustomElement as defineIonList } from "@ionic/core/components/ion-list.js"; +import { IonMenuButton as IonMenuButtonElement, defineCustomElement as defineIonMenuButton } from "@ionic/core/components/ion-menu-button.js"; +import { IonMenuToggle as IonMenuToggleElement, defineCustomElement as defineIonMenuToggle } from "@ionic/core/components/ion-menu-toggle.js"; +import { IonMenu as IonMenuElement, defineCustomElement as defineIonMenu } from "@ionic/core/components/ion-menu.js"; +import { IonNavLink as IonNavLinkElement, defineCustomElement as defineIonNavLink } from "@ionic/core/components/ion-nav-link.js"; +import { IonNav as IonNavElement, defineCustomElement as defineIonNav } from "@ionic/core/components/ion-nav.js"; +import { IonNote as IonNoteElement, defineCustomElement as defineIonNote } from "@ionic/core/components/ion-note.js"; +import { IonPickerColumnOption as IonPickerColumnOptionElement, defineCustomElement as defineIonPickerColumnOption } from "@ionic/core/components/ion-picker-column-option.js"; +import { IonPickerColumn as IonPickerColumnElement, defineCustomElement as defineIonPickerColumn } from "@ionic/core/components/ion-picker-column.js"; +import { IonPicker as IonPickerElement, defineCustomElement as defineIonPicker } from "@ionic/core/components/ion-picker.js"; +import { IonProgressBar as IonProgressBarElement, defineCustomElement as defineIonProgressBar } from "@ionic/core/components/ion-progress-bar.js"; +import { IonRadioGroup as IonRadioGroupElement, defineCustomElement as defineIonRadioGroup } from "@ionic/core/components/ion-radio-group.js"; +import { IonRadio as IonRadioElement, defineCustomElement as defineIonRadio } from "@ionic/core/components/ion-radio.js"; +import { IonRange as IonRangeElement, defineCustomElement as defineIonRange } from "@ionic/core/components/ion-range.js"; +import { IonRefresherContent as IonRefresherContentElement, defineCustomElement as defineIonRefresherContent } from "@ionic/core/components/ion-refresher-content.js"; +import { IonRefresher as IonRefresherElement, defineCustomElement as defineIonRefresher } from "@ionic/core/components/ion-refresher.js"; +import { IonReorderGroup as IonReorderGroupElement, defineCustomElement as defineIonReorderGroup } from "@ionic/core/components/ion-reorder-group.js"; +import { IonReorder as IonReorderElement, defineCustomElement as defineIonReorder } from "@ionic/core/components/ion-reorder.js"; +import { IonRippleEffect as IonRippleEffectElement, defineCustomElement as defineIonRippleEffect } from "@ionic/core/components/ion-ripple-effect.js"; +import { IonRow as IonRowElement, defineCustomElement as defineIonRow } from "@ionic/core/components/ion-row.js"; +import { IonSearchbar as IonSearchbarElement, defineCustomElement as defineIonSearchbar } from "@ionic/core/components/ion-searchbar.js"; +import { IonSegmentButton as IonSegmentButtonElement, defineCustomElement as defineIonSegmentButton } from "@ionic/core/components/ion-segment-button.js"; +import { IonSegmentContent as IonSegmentContentElement, defineCustomElement as defineIonSegmentContent } from "@ionic/core/components/ion-segment-content.js"; +import { IonSegmentView as IonSegmentViewElement, defineCustomElement as defineIonSegmentView } from "@ionic/core/components/ion-segment-view.js"; +import { IonSegment as IonSegmentElement, defineCustomElement as defineIonSegment } from "@ionic/core/components/ion-segment.js"; +import { IonSelectModal as IonSelectModalElement, defineCustomElement as defineIonSelectModal } from "@ionic/core/components/ion-select-modal.js"; +import { IonSelectOption as IonSelectOptionElement, defineCustomElement as defineIonSelectOption } from "@ionic/core/components/ion-select-option.js"; +import { IonSelect as IonSelectElement, defineCustomElement as defineIonSelect } from "@ionic/core/components/ion-select.js"; +import { IonSkeletonText as IonSkeletonTextElement, defineCustomElement as defineIonSkeletonText } from "@ionic/core/components/ion-skeleton-text.js"; +import { IonSpinner as IonSpinnerElement, defineCustomElement as defineIonSpinner } from "@ionic/core/components/ion-spinner.js"; +import { IonSplitPane as IonSplitPaneElement, defineCustomElement as defineIonSplitPane } from "@ionic/core/components/ion-split-pane.js"; +import { IonTab as IonTabElement, defineCustomElement as defineIonTab } from "@ionic/core/components/ion-tab.js"; +import { IonText as IonTextElement, defineCustomElement as defineIonText } from "@ionic/core/components/ion-text.js"; +import { IonTextarea as IonTextareaElement, defineCustomElement as defineIonTextarea } from "@ionic/core/components/ion-textarea.js"; +import { IonThumbnail as IonThumbnailElement, defineCustomElement as defineIonThumbnail } from "@ionic/core/components/ion-thumbnail.js"; +import { IonTitle as IonTitleElement, defineCustomElement as defineIonTitle } from "@ionic/core/components/ion-title.js"; +import { IonToggle as IonToggleElement, defineCustomElement as defineIonToggle } from "@ionic/core/components/ion-toggle.js"; +import { IonToolbar as IonToolbarElement, defineCustomElement as defineIonToolbar } from "@ionic/core/components/ion-toolbar.js"; export type IonAccordionEvents = NonNullable; -export const IonAccordion: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonAccordion: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-accordion', elementClass: IonAccordionElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonAccordionEvents, - defineCustomElement: defineIonAccordion, - }); + defineCustomElement: defineIonAccordion +}); -export type IonAccordionGroupEvents = { - onIonChange: EventName>; -}; +export type IonAccordionGroupEvents = { onIonChange: EventName> }; -export const IonAccordionGroup: StencilReactComponent< - IonAccordionGroupElement, - IonAccordionGroupEvents, - Components.IonAccordionGroup -> = /*@__PURE__*/ createComponent({ - tagName: 'ion-accordion-group', - elementClass: IonAccordionGroupElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: { onIonChange: 'ionChange' } as IonAccordionGroupEvents, - defineCustomElement: defineIonAccordionGroup, +export const IonAccordionGroup: StencilReactComponent = /*@__PURE__*/ createComponent({ + tagName: 'ion-accordion-group', + elementClass: IonAccordionGroupElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: { onIonChange: 'ionChange' } as IonAccordionGroupEvents, + defineCustomElement: defineIonAccordionGroup }); export type IonAvatarEvents = NonNullable; -export const IonAvatar: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonAvatar: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-avatar', elementClass: IonAvatarElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonAvatarEvents, - defineCustomElement: defineIonAvatar, - }); + defineCustomElement: defineIonAvatar +}); export type IonBackdropEvents = { onIonBackdropTap: EventName> }; -export const IonBackdrop: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonBackdrop: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-backdrop', elementClass: IonBackdropElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: { onIonBackdropTap: 'ionBackdropTap' } as IonBackdropEvents, - defineCustomElement: defineIonBackdrop, - }); + defineCustomElement: defineIonBackdrop +}); export type IonBadgeEvents = NonNullable; -export const IonBadge: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonBadge: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-badge', elementClass: IonBadgeElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonBadgeEvents, - defineCustomElement: defineIonBadge, - }); + defineCustomElement: defineIonBadge +}); -export type IonBreadcrumbsEvents = { - onIonCollapsedClick: EventName>; -}; +export type IonBreadcrumbsEvents = { onIonCollapsedClick: EventName> }; -export const IonBreadcrumbs: StencilReactComponent< - IonBreadcrumbsElement, - IonBreadcrumbsEvents, - Components.IonBreadcrumbs -> = /*@__PURE__*/ createComponent({ - tagName: 'ion-breadcrumbs', - elementClass: IonBreadcrumbsElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: { onIonCollapsedClick: 'ionCollapsedClick' } as IonBreadcrumbsEvents, - defineCustomElement: defineIonBreadcrumbs, +export const IonBreadcrumbs: StencilReactComponent = /*@__PURE__*/ createComponent({ + tagName: 'ion-breadcrumbs', + elementClass: IonBreadcrumbsElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: { onIonCollapsedClick: 'ionCollapsedClick' } as IonBreadcrumbsEvents, + defineCustomElement: defineIonBreadcrumbs }); export type IonButtonsEvents = NonNullable; -export const IonButtons: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonButtons: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-buttons', elementClass: IonButtonsElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonButtonsEvents, - defineCustomElement: defineIonButtons, - }); + defineCustomElement: defineIonButtons +}); export type IonCardContentEvents = NonNullable; -export const IonCardContent: StencilReactComponent< - IonCardContentElement, - IonCardContentEvents, - Components.IonCardContent -> = /*@__PURE__*/ createComponent({ - tagName: 'ion-card-content', - elementClass: IonCardContentElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: {} as IonCardContentEvents, - defineCustomElement: defineIonCardContent, +export const IonCardContent: StencilReactComponent = /*@__PURE__*/ createComponent({ + tagName: 'ion-card-content', + elementClass: IonCardContentElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: {} as IonCardContentEvents, + defineCustomElement: defineIonCardContent }); export type IonCardHeaderEvents = NonNullable; -export const IonCardHeader: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonCardHeader: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-card-header', elementClass: IonCardHeaderElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonCardHeaderEvents, - defineCustomElement: defineIonCardHeader, - }); + defineCustomElement: defineIonCardHeader +}); export type IonCardSubtitleEvents = NonNullable; -export const IonCardSubtitle: StencilReactComponent< - IonCardSubtitleElement, - IonCardSubtitleEvents, - Components.IonCardSubtitle -> = /*@__PURE__*/ createComponent({ - tagName: 'ion-card-subtitle', - elementClass: IonCardSubtitleElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: {} as IonCardSubtitleEvents, - defineCustomElement: defineIonCardSubtitle, +export const IonCardSubtitle: StencilReactComponent = /*@__PURE__*/ createComponent({ + tagName: 'ion-card-subtitle', + elementClass: IonCardSubtitleElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: {} as IonCardSubtitleEvents, + defineCustomElement: defineIonCardSubtitle }); export type IonCardTitleEvents = NonNullable; -export const IonCardTitle: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonCardTitle: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-card-title', elementClass: IonCardTitleElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonCardTitleEvents, - defineCustomElement: defineIonCardTitle, - }); + defineCustomElement: defineIonCardTitle +}); export type IonCheckboxEvents = { - onIonChange: EventName>; - onIonFocus: EventName>; - onIonBlur: EventName>; + onIonChange: EventName>, + onIonFocus: EventName>, + onIonBlur: EventName> }; -export const IonCheckbox: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonCheckbox: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-checkbox', elementClass: IonCheckboxElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: { - onIonChange: 'ionChange', - onIonFocus: 'ionFocus', - onIonBlur: 'ionBlur', + onIonChange: 'ionChange', + onIonFocus: 'ionFocus', + onIonBlur: 'ionBlur' } as IonCheckboxEvents, - defineCustomElement: defineIonCheckbox, - }); + defineCustomElement: defineIonCheckbox +}); export type IonChipEvents = NonNullable; -export const IonChip: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonChip: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-chip', elementClass: IonChipElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonChipEvents, - defineCustomElement: defineIonChip, - }); + defineCustomElement: defineIonChip +}); export type IonColEvents = NonNullable; -export const IonCol: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonCol: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-col', elementClass: IonColElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonColEvents, - defineCustomElement: defineIonCol, - }); + defineCustomElement: defineIonCol +}); export type IonContentEvents = { - onIonScrollStart: EventName>; - onIonScroll: EventName>; - onIonScrollEnd: EventName>; + onIonScrollStart: EventName>, + onIonScroll: EventName>, + onIonScrollEnd: EventName> }; -export const IonContent: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonContent: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-content', elementClass: IonContentElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: { - onIonScrollStart: 'ionScrollStart', - onIonScroll: 'ionScroll', - onIonScrollEnd: 'ionScrollEnd', + onIonScrollStart: 'ionScrollStart', + onIonScroll: 'ionScroll', + onIonScrollEnd: 'ionScrollEnd' } as IonContentEvents, - defineCustomElement: defineIonContent, - }); + defineCustomElement: defineIonContent +}); export type IonDatetimeEvents = { - onIonCancel: EventName>; - onIonChange: EventName>; - onIonFocus: EventName>; - onIonBlur: EventName>; + onIonCancel: EventName>, + onIonChange: EventName>, + onIonFocus: EventName>, + onIonBlur: EventName> }; -export const IonDatetime: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonDatetime: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-datetime', elementClass: IonDatetimeElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: { - onIonCancel: 'ionCancel', - onIonChange: 'ionChange', - onIonFocus: 'ionFocus', - onIonBlur: 'ionBlur', + onIonCancel: 'ionCancel', + onIonChange: 'ionChange', + onIonFocus: 'ionFocus', + onIonBlur: 'ionBlur' } as IonDatetimeEvents, - defineCustomElement: defineIonDatetime, - }); + defineCustomElement: defineIonDatetime +}); export type IonDatetimeButtonEvents = NonNullable; -export const IonDatetimeButton: StencilReactComponent< - IonDatetimeButtonElement, - IonDatetimeButtonEvents, - Components.IonDatetimeButton -> = /*@__PURE__*/ createComponent({ - tagName: 'ion-datetime-button', - elementClass: IonDatetimeButtonElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: {} as IonDatetimeButtonEvents, - defineCustomElement: defineIonDatetimeButton, +export const IonDatetimeButton: StencilReactComponent = /*@__PURE__*/ createComponent({ + tagName: 'ion-datetime-button', + elementClass: IonDatetimeButtonElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: {} as IonDatetimeButtonEvents, + defineCustomElement: defineIonDatetimeButton }); export type IonFabEvents = NonNullable; -export const IonFab: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonFab: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-fab', elementClass: IonFabElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonFabEvents, - defineCustomElement: defineIonFab, - }); + defineCustomElement: defineIonFab +}); export type IonFabListEvents = NonNullable; -export const IonFabList: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonFabList: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-fab-list', elementClass: IonFabListElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonFabListEvents, - defineCustomElement: defineIonFabList, - }); + defineCustomElement: defineIonFabList +}); export type IonFooterEvents = NonNullable; -export const IonFooter: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonFooter: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-footer', elementClass: IonFooterElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonFooterEvents, - defineCustomElement: defineIonFooter, - }); + defineCustomElement: defineIonFooter +}); export type IonGridEvents = NonNullable; -export const IonGrid: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonGrid: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-grid', elementClass: IonGridElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonGridEvents, - defineCustomElement: defineIonGrid, - }); + defineCustomElement: defineIonGrid +}); export type IonHeaderEvents = NonNullable; -export const IonHeader: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonHeader: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-header', elementClass: IonHeaderElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonHeaderEvents, - defineCustomElement: defineIonHeader, - }); + defineCustomElement: defineIonHeader +}); export type IonImgEvents = { - onIonImgWillLoad: EventName>; - onIonImgDidLoad: EventName>; - onIonError: EventName>; + onIonImgWillLoad: EventName>, + onIonImgDidLoad: EventName>, + onIonError: EventName> }; -export const IonImg: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonImg: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-img', elementClass: IonImgElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: { - onIonImgWillLoad: 'ionImgWillLoad', - onIonImgDidLoad: 'ionImgDidLoad', - onIonError: 'ionError', + onIonImgWillLoad: 'ionImgWillLoad', + onIonImgDidLoad: 'ionImgDidLoad', + onIonError: 'ionError' } as IonImgEvents, - defineCustomElement: defineIonImg, - }); + defineCustomElement: defineIonImg +}); export type IonInfiniteScrollEvents = { onIonInfinite: EventName> }; -export const IonInfiniteScroll: StencilReactComponent< - IonInfiniteScrollElement, - IonInfiniteScrollEvents, - Components.IonInfiniteScroll -> = /*@__PURE__*/ createComponent({ - tagName: 'ion-infinite-scroll', - elementClass: IonInfiniteScrollElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: { onIonInfinite: 'ionInfinite' } as IonInfiniteScrollEvents, - defineCustomElement: defineIonInfiniteScroll, +export const IonInfiniteScroll: StencilReactComponent = /*@__PURE__*/ createComponent({ + tagName: 'ion-infinite-scroll', + elementClass: IonInfiniteScrollElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: { onIonInfinite: 'ionInfinite' } as IonInfiniteScrollEvents, + defineCustomElement: defineIonInfiniteScroll }); export type IonInfiniteScrollContentEvents = NonNullable; -export const IonInfiniteScrollContent: StencilReactComponent< - IonInfiniteScrollContentElement, - IonInfiniteScrollContentEvents, - Components.IonInfiniteScrollContent -> = /*@__PURE__*/ createComponent< - IonInfiniteScrollContentElement, - IonInfiniteScrollContentEvents, - Components.IonInfiniteScrollContent ->({ - tagName: 'ion-infinite-scroll-content', - elementClass: IonInfiniteScrollContentElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: {} as IonInfiniteScrollContentEvents, - defineCustomElement: defineIonInfiniteScrollContent, +export const IonInfiniteScrollContent: StencilReactComponent = /*@__PURE__*/ createComponent({ + tagName: 'ion-infinite-scroll-content', + elementClass: IonInfiniteScrollContentElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: {} as IonInfiniteScrollContentEvents, + defineCustomElement: defineIonInfiniteScrollContent }); export type IonInputEvents = { - onIonInput: EventName>; - onIonChange: EventName>; - onIonBlur: EventName>; - onIonFocus: EventName>; + onIonInput: EventName>, + onIonChange: EventName>, + onIonBlur: EventName>, + onIonFocus: EventName> }; -export const IonInput: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonInput: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-input', elementClass: IonInputElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: { - onIonInput: 'ionInput', - onIonChange: 'ionChange', - onIonBlur: 'ionBlur', - onIonFocus: 'ionFocus', + onIonInput: 'ionInput', + onIonChange: 'ionChange', + onIonBlur: 'ionBlur', + onIonFocus: 'ionFocus' } as IonInputEvents, - defineCustomElement: defineIonInput, - }); + defineCustomElement: defineIonInput +}); export type IonInputOtpEvents = { - onIonInput: EventName>; - onIonChange: EventName>; - onIonComplete: EventName>; - onIonBlur: EventName>; - onIonFocus: EventName>; + onIonInput: EventName>, + onIonChange: EventName>, + onIonComplete: EventName>, + onIonBlur: EventName>, + onIonFocus: EventName> }; -export const IonInputOtp: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonInputOtp: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-input-otp', elementClass: IonInputOtpElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: { - onIonInput: 'ionInput', - onIonChange: 'ionChange', - onIonComplete: 'ionComplete', - onIonBlur: 'ionBlur', - onIonFocus: 'ionFocus', + onIonInput: 'ionInput', + onIonChange: 'ionChange', + onIonComplete: 'ionComplete', + onIonBlur: 'ionBlur', + onIonFocus: 'ionFocus' } as IonInputOtpEvents, - defineCustomElement: defineIonInputOtp, - }); + defineCustomElement: defineIonInputOtp +}); export type IonInputPasswordToggleEvents = NonNullable; -export const IonInputPasswordToggle: StencilReactComponent< - IonInputPasswordToggleElement, - IonInputPasswordToggleEvents, - Components.IonInputPasswordToggle -> = /*@__PURE__*/ createComponent< - IonInputPasswordToggleElement, - IonInputPasswordToggleEvents, - Components.IonInputPasswordToggle ->({ - tagName: 'ion-input-password-toggle', - elementClass: IonInputPasswordToggleElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: {} as IonInputPasswordToggleEvents, - defineCustomElement: defineIonInputPasswordToggle, +export const IonInputPasswordToggle: StencilReactComponent = /*@__PURE__*/ createComponent({ + tagName: 'ion-input-password-toggle', + elementClass: IonInputPasswordToggleElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: {} as IonInputPasswordToggleEvents, + defineCustomElement: defineIonInputPasswordToggle }); export type IonItemDividerEvents = NonNullable; -export const IonItemDivider: StencilReactComponent< - IonItemDividerElement, - IonItemDividerEvents, - Components.IonItemDivider -> = /*@__PURE__*/ createComponent({ - tagName: 'ion-item-divider', - elementClass: IonItemDividerElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: {} as IonItemDividerEvents, - defineCustomElement: defineIonItemDivider, +export const IonItemDivider: StencilReactComponent = /*@__PURE__*/ createComponent({ + tagName: 'ion-item-divider', + elementClass: IonItemDividerElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: {} as IonItemDividerEvents, + defineCustomElement: defineIonItemDivider }); export type IonItemGroupEvents = NonNullable; -export const IonItemGroup: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonItemGroup: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-item-group', elementClass: IonItemGroupElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonItemGroupEvents, - defineCustomElement: defineIonItemGroup, - }); + defineCustomElement: defineIonItemGroup +}); export type IonItemOptionsEvents = { onIonSwipe: EventName> }; -export const IonItemOptions: StencilReactComponent< - IonItemOptionsElement, - IonItemOptionsEvents, - Components.IonItemOptions -> = /*@__PURE__*/ createComponent({ - tagName: 'ion-item-options', - elementClass: IonItemOptionsElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: { onIonSwipe: 'ionSwipe' } as IonItemOptionsEvents, - defineCustomElement: defineIonItemOptions, +export const IonItemOptions: StencilReactComponent = /*@__PURE__*/ createComponent({ + tagName: 'ion-item-options', + elementClass: IonItemOptionsElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: { onIonSwipe: 'ionSwipe' } as IonItemOptionsEvents, + defineCustomElement: defineIonItemOptions }); export type IonItemSlidingEvents = { onIonDrag: EventName> }; -export const IonItemSliding: StencilReactComponent< - IonItemSlidingElement, - IonItemSlidingEvents, - Components.IonItemSliding -> = /*@__PURE__*/ createComponent({ - tagName: 'ion-item-sliding', - elementClass: IonItemSlidingElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: { onIonDrag: 'ionDrag' } as IonItemSlidingEvents, - defineCustomElement: defineIonItemSliding, +export const IonItemSliding: StencilReactComponent = /*@__PURE__*/ createComponent({ + tagName: 'ion-item-sliding', + elementClass: IonItemSlidingElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: { onIonDrag: 'ionDrag' } as IonItemSlidingEvents, + defineCustomElement: defineIonItemSliding }); export type IonLabelEvents = NonNullable; -export const IonLabel: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonLabel: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-label', elementClass: IonLabelElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonLabelEvents, - defineCustomElement: defineIonLabel, - }); + defineCustomElement: defineIonLabel +}); export type IonListEvents = NonNullable; -export const IonList: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonList: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-list', elementClass: IonListElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonListEvents, - defineCustomElement: defineIonList, - }); + defineCustomElement: defineIonList +}); export type IonListHeaderEvents = NonNullable; -export const IonListHeader: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonListHeader: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-list-header', elementClass: IonListHeaderElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonListHeaderEvents, - defineCustomElement: defineIonListHeader, - }); + defineCustomElement: defineIonListHeader +}); export type IonMenuEvents = { - onIonWillOpen: EventName>; - onIonWillClose: EventName>; - onIonDidOpen: EventName>; - onIonDidClose: EventName>; + onIonWillOpen: EventName>, + onIonWillClose: EventName>, + onIonDidOpen: EventName>, + onIonDidClose: EventName> }; -export const IonMenu: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonMenu: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-menu', elementClass: IonMenuElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: { - onIonWillOpen: 'ionWillOpen', - onIonWillClose: 'ionWillClose', - onIonDidOpen: 'ionDidOpen', - onIonDidClose: 'ionDidClose', + onIonWillOpen: 'ionWillOpen', + onIonWillClose: 'ionWillClose', + onIonDidOpen: 'ionDidOpen', + onIonDidClose: 'ionDidClose' } as IonMenuEvents, - defineCustomElement: defineIonMenu, - }); + defineCustomElement: defineIonMenu +}); export type IonMenuButtonEvents = NonNullable; -export const IonMenuButton: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonMenuButton: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-menu-button', elementClass: IonMenuButtonElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonMenuButtonEvents, - defineCustomElement: defineIonMenuButton, - }); + defineCustomElement: defineIonMenuButton +}); export type IonMenuToggleEvents = NonNullable; -export const IonMenuToggle: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonMenuToggle: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-menu-toggle', elementClass: IonMenuToggleElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonMenuToggleEvents, - defineCustomElement: defineIonMenuToggle, - }); + defineCustomElement: defineIonMenuToggle +}); export type IonNavEvents = { - onIonNavWillChange: EventName>; - onIonNavDidChange: EventName>; + onIonNavWillChange: EventName>, + onIonNavDidChange: EventName> }; -export const IonNav: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonNav: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-nav', elementClass: IonNavElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: { - onIonNavWillChange: 'ionNavWillChange', - onIonNavDidChange: 'ionNavDidChange', + onIonNavWillChange: 'ionNavWillChange', + onIonNavDidChange: 'ionNavDidChange' } as IonNavEvents, - defineCustomElement: defineIonNav, - }); + defineCustomElement: defineIonNav +}); export type IonNavLinkEvents = NonNullable; -export const IonNavLink: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonNavLink: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-nav-link', elementClass: IonNavLinkElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonNavLinkEvents, - defineCustomElement: defineIonNavLink, - }); + defineCustomElement: defineIonNavLink +}); export type IonNoteEvents = NonNullable; -export const IonNote: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonNote: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-note', elementClass: IonNoteElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonNoteEvents, - defineCustomElement: defineIonNote, - }); + defineCustomElement: defineIonNote +}); export type IonPickerEvents = NonNullable; -export const IonPicker: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonPicker: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-picker', elementClass: IonPickerElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonPickerEvents, - defineCustomElement: defineIonPicker, - }); + defineCustomElement: defineIonPicker +}); -export type IonPickerColumnEvents = { - onIonChange: EventName>; -}; +export type IonPickerColumnEvents = { onIonChange: EventName> }; -export const IonPickerColumn: StencilReactComponent< - IonPickerColumnElement, - IonPickerColumnEvents, - Components.IonPickerColumn -> = /*@__PURE__*/ createComponent({ - tagName: 'ion-picker-column', - elementClass: IonPickerColumnElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: { onIonChange: 'ionChange' } as IonPickerColumnEvents, - defineCustomElement: defineIonPickerColumn, +export const IonPickerColumn: StencilReactComponent = /*@__PURE__*/ createComponent({ + tagName: 'ion-picker-column', + elementClass: IonPickerColumnElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: { onIonChange: 'ionChange' } as IonPickerColumnEvents, + defineCustomElement: defineIonPickerColumn }); export type IonPickerColumnOptionEvents = NonNullable; -export const IonPickerColumnOption: StencilReactComponent< - IonPickerColumnOptionElement, - IonPickerColumnOptionEvents, - Components.IonPickerColumnOption -> = /*@__PURE__*/ createComponent< - IonPickerColumnOptionElement, - IonPickerColumnOptionEvents, - Components.IonPickerColumnOption ->({ - tagName: 'ion-picker-column-option', - elementClass: IonPickerColumnOptionElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: {} as IonPickerColumnOptionEvents, - defineCustomElement: defineIonPickerColumnOption, +export const IonPickerColumnOption: StencilReactComponent = /*@__PURE__*/ createComponent({ + tagName: 'ion-picker-column-option', + elementClass: IonPickerColumnOptionElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: {} as IonPickerColumnOptionEvents, + defineCustomElement: defineIonPickerColumnOption }); export type IonProgressBarEvents = NonNullable; -export const IonProgressBar: StencilReactComponent< - IonProgressBarElement, - IonProgressBarEvents, - Components.IonProgressBar -> = /*@__PURE__*/ createComponent({ - tagName: 'ion-progress-bar', - elementClass: IonProgressBarElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: {} as IonProgressBarEvents, - defineCustomElement: defineIonProgressBar, +export const IonProgressBar: StencilReactComponent = /*@__PURE__*/ createComponent({ + tagName: 'ion-progress-bar', + elementClass: IonProgressBarElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: {} as IonProgressBarEvents, + defineCustomElement: defineIonProgressBar }); export type IonRadioEvents = { - onIonFocus: EventName>; - onIonBlur: EventName>; + onIonFocus: EventName>, + onIonBlur: EventName> }; -export const IonRadio: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonRadio: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-radio', elementClass: IonRadioElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: { - onIonFocus: 'ionFocus', - onIonBlur: 'ionBlur', + onIonFocus: 'ionFocus', + onIonBlur: 'ionBlur' } as IonRadioEvents, - defineCustomElement: defineIonRadio, - }); + defineCustomElement: defineIonRadio +}); export type IonRadioGroupEvents = { onIonChange: EventName> }; -export const IonRadioGroup: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonRadioGroup: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-radio-group', elementClass: IonRadioGroupElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: { onIonChange: 'ionChange' } as IonRadioGroupEvents, - defineCustomElement: defineIonRadioGroup, - }); + defineCustomElement: defineIonRadioGroup +}); export type IonRangeEvents = { - onIonChange: EventName>; - onIonInput: EventName>; - onIonFocus: EventName>; - onIonBlur: EventName>; - onIonKnobMoveStart: EventName>; - onIonKnobMoveEnd: EventName>; + onIonChange: EventName>, + onIonInput: EventName>, + onIonFocus: EventName>, + onIonBlur: EventName>, + onIonKnobMoveStart: EventName>, + onIonKnobMoveEnd: EventName> }; -export const IonRange: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonRange: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-range', elementClass: IonRangeElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: { - onIonChange: 'ionChange', - onIonInput: 'ionInput', - onIonFocus: 'ionFocus', - onIonBlur: 'ionBlur', - onIonKnobMoveStart: 'ionKnobMoveStart', - onIonKnobMoveEnd: 'ionKnobMoveEnd', + onIonChange: 'ionChange', + onIonInput: 'ionInput', + onIonFocus: 'ionFocus', + onIonBlur: 'ionBlur', + onIonKnobMoveStart: 'ionKnobMoveStart', + onIonKnobMoveEnd: 'ionKnobMoveEnd' } as IonRangeEvents, - defineCustomElement: defineIonRange, - }); + defineCustomElement: defineIonRange +}); export type IonRefresherEvents = { - onIonRefresh: EventName>; - onIonPull: EventName>; - onIonStart: EventName>; - onIonPullStart: EventName>; - onIonPullEnd: EventName>; + onIonRefresh: EventName>, + onIonPull: EventName>, + onIonStart: EventName>, + onIonPullStart: EventName>, + onIonPullEnd: EventName> }; -export const IonRefresher: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonRefresher: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-refresher', elementClass: IonRefresherElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: { - onIonRefresh: 'ionRefresh', - onIonPull: 'ionPull', - onIonStart: 'ionStart', - onIonPullStart: 'ionPullStart', - onIonPullEnd: 'ionPullEnd', + onIonRefresh: 'ionRefresh', + onIonPull: 'ionPull', + onIonStart: 'ionStart', + onIonPullStart: 'ionPullStart', + onIonPullEnd: 'ionPullEnd' } as IonRefresherEvents, - defineCustomElement: defineIonRefresher, - }); + defineCustomElement: defineIonRefresher +}); export type IonRefresherContentEvents = NonNullable; -export const IonRefresherContent: StencilReactComponent< - IonRefresherContentElement, - IonRefresherContentEvents, - Components.IonRefresherContent -> = /*@__PURE__*/ createComponent< - IonRefresherContentElement, - IonRefresherContentEvents, - Components.IonRefresherContent ->({ - tagName: 'ion-refresher-content', - elementClass: IonRefresherContentElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: {} as IonRefresherContentEvents, - defineCustomElement: defineIonRefresherContent, +export const IonRefresherContent: StencilReactComponent = /*@__PURE__*/ createComponent({ + tagName: 'ion-refresher-content', + elementClass: IonRefresherContentElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: {} as IonRefresherContentEvents, + defineCustomElement: defineIonRefresherContent }); export type IonReorderEvents = NonNullable; -export const IonReorder: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonReorder: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-reorder', elementClass: IonReorderElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonReorderEvents, - defineCustomElement: defineIonReorder, - }); + defineCustomElement: defineIonReorder +}); export type IonReorderGroupEvents = { - onIonItemReorder: EventName>; - onIonReorderStart: EventName>; - onIonReorderMove: EventName>; - onIonReorderEnd: EventName>; + onIonItemReorder: EventName>, + onIonReorderStart: EventName>, + onIonReorderMove: EventName>, + onIonReorderEnd: EventName> }; -export const IonReorderGroup: StencilReactComponent< - IonReorderGroupElement, - IonReorderGroupEvents, - Components.IonReorderGroup -> = /*@__PURE__*/ createComponent({ - tagName: 'ion-reorder-group', - elementClass: IonReorderGroupElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: { - onIonItemReorder: 'ionItemReorder', - onIonReorderStart: 'ionReorderStart', - onIonReorderMove: 'ionReorderMove', - onIonReorderEnd: 'ionReorderEnd', - } as IonReorderGroupEvents, - defineCustomElement: defineIonReorderGroup, +export const IonReorderGroup: StencilReactComponent = /*@__PURE__*/ createComponent({ + tagName: 'ion-reorder-group', + elementClass: IonReorderGroupElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: { + onIonItemReorder: 'ionItemReorder', + onIonReorderStart: 'ionReorderStart', + onIonReorderMove: 'ionReorderMove', + onIonReorderEnd: 'ionReorderEnd' + } as IonReorderGroupEvents, + defineCustomElement: defineIonReorderGroup }); export type IonRippleEffectEvents = NonNullable; -export const IonRippleEffect: StencilReactComponent< - IonRippleEffectElement, - IonRippleEffectEvents, - Components.IonRippleEffect -> = /*@__PURE__*/ createComponent({ - tagName: 'ion-ripple-effect', - elementClass: IonRippleEffectElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: {} as IonRippleEffectEvents, - defineCustomElement: defineIonRippleEffect, +export const IonRippleEffect: StencilReactComponent = /*@__PURE__*/ createComponent({ + tagName: 'ion-ripple-effect', + elementClass: IonRippleEffectElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: {} as IonRippleEffectEvents, + defineCustomElement: defineIonRippleEffect }); export type IonRowEvents = NonNullable; -export const IonRow: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonRow: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-row', elementClass: IonRowElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonRowEvents, - defineCustomElement: defineIonRow, - }); + defineCustomElement: defineIonRow +}); export type IonSearchbarEvents = { - onIonInput: EventName>; - onIonChange: EventName>; - onIonCancel: EventName>; - onIonClear: EventName>; - onIonBlur: EventName>; - onIonFocus: EventName>; + onIonInput: EventName>, + onIonChange: EventName>, + onIonCancel: EventName>, + onIonClear: EventName>, + onIonBlur: EventName>, + onIonFocus: EventName> }; -export const IonSearchbar: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonSearchbar: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-searchbar', elementClass: IonSearchbarElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: { - onIonInput: 'ionInput', - onIonChange: 'ionChange', - onIonCancel: 'ionCancel', - onIonClear: 'ionClear', - onIonBlur: 'ionBlur', - onIonFocus: 'ionFocus', + onIonInput: 'ionInput', + onIonChange: 'ionChange', + onIonCancel: 'ionCancel', + onIonClear: 'ionClear', + onIonBlur: 'ionBlur', + onIonFocus: 'ionFocus' } as IonSearchbarEvents, - defineCustomElement: defineIonSearchbar, - }); + defineCustomElement: defineIonSearchbar +}); export type IonSegmentEvents = { onIonChange: EventName> }; -export const IonSegment: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonSegment: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-segment', elementClass: IonSegmentElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: { onIonChange: 'ionChange' } as IonSegmentEvents, - defineCustomElement: defineIonSegment, - }); + defineCustomElement: defineIonSegment +}); export type IonSegmentButtonEvents = NonNullable; -export const IonSegmentButton: StencilReactComponent< - IonSegmentButtonElement, - IonSegmentButtonEvents, - Components.IonSegmentButton -> = /*@__PURE__*/ createComponent({ - tagName: 'ion-segment-button', - elementClass: IonSegmentButtonElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: {} as IonSegmentButtonEvents, - defineCustomElement: defineIonSegmentButton, +export const IonSegmentButton: StencilReactComponent = /*@__PURE__*/ createComponent({ + tagName: 'ion-segment-button', + elementClass: IonSegmentButtonElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: {} as IonSegmentButtonEvents, + defineCustomElement: defineIonSegmentButton }); export type IonSegmentContentEvents = NonNullable; -export const IonSegmentContent: StencilReactComponent< - IonSegmentContentElement, - IonSegmentContentEvents, - Components.IonSegmentContent -> = /*@__PURE__*/ createComponent({ - tagName: 'ion-segment-content', - elementClass: IonSegmentContentElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: {} as IonSegmentContentEvents, - defineCustomElement: defineIonSegmentContent, -}); - -export type IonSegmentViewEvents = { - onIonSegmentViewScroll: EventName>; -}; +export const IonSegmentContent: StencilReactComponent = /*@__PURE__*/ createComponent({ + tagName: 'ion-segment-content', + elementClass: IonSegmentContentElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: {} as IonSegmentContentEvents, + defineCustomElement: defineIonSegmentContent +}); + +export type IonSegmentViewEvents = { onIonSegmentViewScroll: EventName> }; -export const IonSegmentView: StencilReactComponent< - IonSegmentViewElement, - IonSegmentViewEvents, - Components.IonSegmentView -> = /*@__PURE__*/ createComponent({ - tagName: 'ion-segment-view', - elementClass: IonSegmentViewElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: { onIonSegmentViewScroll: 'ionSegmentViewScroll' } as IonSegmentViewEvents, - defineCustomElement: defineIonSegmentView, +export const IonSegmentView: StencilReactComponent = /*@__PURE__*/ createComponent({ + tagName: 'ion-segment-view', + elementClass: IonSegmentViewElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: { onIonSegmentViewScroll: 'ionSegmentViewScroll' } as IonSegmentViewEvents, + defineCustomElement: defineIonSegmentView }); export type IonSelectEvents = { - onIonChange: EventName>; - onIonCancel: EventName>; - onIonDismiss: EventName>; - onIonFocus: EventName>; - onIonBlur: EventName>; + onIonChange: EventName>, + onIonCancel: EventName>, + onIonDismiss: EventName>, + onIonFocus: EventName>, + onIonBlur: EventName> }; -export const IonSelect: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonSelect: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-select', elementClass: IonSelectElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: { - onIonChange: 'ionChange', - onIonCancel: 'ionCancel', - onIonDismiss: 'ionDismiss', - onIonFocus: 'ionFocus', - onIonBlur: 'ionBlur', + onIonChange: 'ionChange', + onIonCancel: 'ionCancel', + onIonDismiss: 'ionDismiss', + onIonFocus: 'ionFocus', + onIonBlur: 'ionBlur' } as IonSelectEvents, - defineCustomElement: defineIonSelect, - }); + defineCustomElement: defineIonSelect +}); export type IonSelectModalEvents = NonNullable; -export const IonSelectModal: StencilReactComponent< - IonSelectModalElement, - IonSelectModalEvents, - Components.IonSelectModal -> = /*@__PURE__*/ createComponent({ - tagName: 'ion-select-modal', - elementClass: IonSelectModalElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: {} as IonSelectModalEvents, - defineCustomElement: defineIonSelectModal, +export const IonSelectModal: StencilReactComponent = /*@__PURE__*/ createComponent({ + tagName: 'ion-select-modal', + elementClass: IonSelectModalElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: {} as IonSelectModalEvents, + defineCustomElement: defineIonSelectModal }); export type IonSelectOptionEvents = NonNullable; -export const IonSelectOption: StencilReactComponent< - IonSelectOptionElement, - IonSelectOptionEvents, - Components.IonSelectOption -> = /*@__PURE__*/ createComponent({ - tagName: 'ion-select-option', - elementClass: IonSelectOptionElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: {} as IonSelectOptionEvents, - defineCustomElement: defineIonSelectOption, +export const IonSelectOption: StencilReactComponent = /*@__PURE__*/ createComponent({ + tagName: 'ion-select-option', + elementClass: IonSelectOptionElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: {} as IonSelectOptionEvents, + defineCustomElement: defineIonSelectOption }); export type IonSkeletonTextEvents = NonNullable; -export const IonSkeletonText: StencilReactComponent< - IonSkeletonTextElement, - IonSkeletonTextEvents, - Components.IonSkeletonText -> = /*@__PURE__*/ createComponent({ - tagName: 'ion-skeleton-text', - elementClass: IonSkeletonTextElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: {} as IonSkeletonTextEvents, - defineCustomElement: defineIonSkeletonText, +export const IonSkeletonText: StencilReactComponent = /*@__PURE__*/ createComponent({ + tagName: 'ion-skeleton-text', + elementClass: IonSkeletonTextElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: {} as IonSkeletonTextEvents, + defineCustomElement: defineIonSkeletonText }); export type IonSpinnerEvents = NonNullable; -export const IonSpinner: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonSpinner: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-spinner', elementClass: IonSpinnerElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonSpinnerEvents, - defineCustomElement: defineIonSpinner, - }); + defineCustomElement: defineIonSpinner +}); export type IonSplitPaneEvents = { onIonSplitPaneVisible: EventName> }; -export const IonSplitPane: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonSplitPane: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-split-pane', elementClass: IonSplitPaneElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: { onIonSplitPaneVisible: 'ionSplitPaneVisible' } as IonSplitPaneEvents, - defineCustomElement: defineIonSplitPane, - }); + defineCustomElement: defineIonSplitPane +}); export type IonTabEvents = NonNullable; -export const IonTab: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonTab: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-tab', elementClass: IonTabElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonTabEvents, - defineCustomElement: defineIonTab, - }); + defineCustomElement: defineIonTab +}); export type IonTextEvents = NonNullable; -export const IonText: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonText: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-text', elementClass: IonTextElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonTextEvents, - defineCustomElement: defineIonText, - }); + defineCustomElement: defineIonText +}); export type IonTextareaEvents = { - onIonChange: EventName>; - onIonInput: EventName>; - onIonBlur: EventName>; - onIonFocus: EventName>; + onIonChange: EventName>, + onIonInput: EventName>, + onIonBlur: EventName>, + onIonFocus: EventName> }; -export const IonTextarea: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonTextarea: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-textarea', elementClass: IonTextareaElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: { - onIonChange: 'ionChange', - onIonInput: 'ionInput', - onIonBlur: 'ionBlur', - onIonFocus: 'ionFocus', + onIonChange: 'ionChange', + onIonInput: 'ionInput', + onIonBlur: 'ionBlur', + onIonFocus: 'ionFocus' } as IonTextareaEvents, - defineCustomElement: defineIonTextarea, - }); + defineCustomElement: defineIonTextarea +}); export type IonThumbnailEvents = NonNullable; -export const IonThumbnail: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonThumbnail: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-thumbnail', elementClass: IonThumbnailElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonThumbnailEvents, - defineCustomElement: defineIonThumbnail, - }); + defineCustomElement: defineIonThumbnail +}); export type IonTitleEvents = NonNullable; -export const IonTitle: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonTitle: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-title', elementClass: IonTitleElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonTitleEvents, - defineCustomElement: defineIonTitle, - }); + defineCustomElement: defineIonTitle +}); export type IonToggleEvents = { - onIonChange: EventName>; - onIonFocus: EventName>; - onIonBlur: EventName>; + onIonChange: EventName>, + onIonFocus: EventName>, + onIonBlur: EventName> }; -export const IonToggle: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonToggle: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-toggle', elementClass: IonToggleElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: { - onIonChange: 'ionChange', - onIonFocus: 'ionFocus', - onIonBlur: 'ionBlur', + onIonChange: 'ionChange', + onIonFocus: 'ionFocus', + onIonBlur: 'ionBlur' } as IonToggleEvents, - defineCustomElement: defineIonToggle, - }); + defineCustomElement: defineIonToggle +}); export type IonToolbarEvents = NonNullable; -export const IonToolbar: StencilReactComponent = - /*@__PURE__*/ createComponent({ +export const IonToolbar: StencilReactComponent = /*@__PURE__*/ createComponent({ tagName: 'ion-toolbar', elementClass: IonToolbarElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonToolbarEvents, - defineCustomElement: defineIonToolbar, - }); + defineCustomElement: defineIonToolbar +}); From e3a802d0fb7547c8ccbaf10e15f639cace18114d Mon Sep 17 00:00:00 2001 From: Maria Hutt Date: Thu, 16 Jul 2026 10:48:46 -0700 Subject: [PATCH 2/6] chore(react): revert changes --- packages/react/src/components/components.ts | 1433 ++++++++++++------- 1 file changed, 918 insertions(+), 515 deletions(-) diff --git a/packages/react/src/components/components.ts b/packages/react/src/components/components.ts index 785a7bfab0e..7080edec552 100644 --- a/packages/react/src/components/components.ts +++ b/packages/react/src/components/components.ts @@ -11,1027 +11,1430 @@ import type { EventName, StencilReactComponent } from '@stencil/react-output-tar import { createComponent } from '@stencil/react-output-target/runtime'; import React from 'react'; -import { type AccordionGroupChangeEventDetail, type BreadcrumbCollapsedClickEventDetail, type CheckboxChangeEventDetail, type DatetimeChangeEventDetail, type InputChangeEventDetail, type InputInputEventDetail, type InputOtpChangeEventDetail, type InputOtpCompleteEventDetail, type InputOtpInputEventDetail, type IonAccordionGroupCustomEvent, type IonBackdropCustomEvent, type IonBreadcrumbsCustomEvent, type IonCheckboxCustomEvent, type IonContentCustomEvent, type IonDatetimeCustomEvent, type IonImgCustomEvent, type IonInfiniteScrollCustomEvent, type IonInputCustomEvent, type IonInputOtpCustomEvent, type IonItemOptionsCustomEvent, type IonItemSlidingCustomEvent, type IonMenuCustomEvent, type IonNavCustomEvent, type IonPickerColumnCustomEvent, type IonRadioCustomEvent, type IonRadioGroupCustomEvent, type IonRangeCustomEvent, type IonRefresherCustomEvent, type IonReorderGroupCustomEvent, type IonSearchbarCustomEvent, type IonSegmentCustomEvent, type IonSegmentViewCustomEvent, type IonSelectCustomEvent, type IonSplitPaneCustomEvent, type IonTextareaCustomEvent, type IonToggleCustomEvent, type ItemReorderEventDetail, type MenuCloseEventDetail, type PickerColumnChangeEventDetail, type RadioGroupChangeEventDetail, type RangeChangeEventDetail, type RangeKnobMoveEndEventDetail, type RangeKnobMoveStartEventDetail, type RefresherEventDetail, type RefresherPullEndEventDetail, type ReorderEndEventDetail, type ReorderMoveEventDetail, type ScrollBaseDetail, type ScrollDetail, type SearchbarChangeEventDetail, type SearchbarInputEventDetail, type SegmentChangeEventDetail, type SegmentViewScrollEvent, type SelectChangeEventDetail, type TextareaChangeEventDetail, type TextareaInputEventDetail, type ToggleChangeEventDetail } from "@ionic/core"; -import type { Components } from "@ionic/core/components"; -import { IonAccordionGroup as IonAccordionGroupElement, defineCustomElement as defineIonAccordionGroup } from "@ionic/core/components/ion-accordion-group.js"; -import { IonAccordion as IonAccordionElement, defineCustomElement as defineIonAccordion } from "@ionic/core/components/ion-accordion.js"; -import { IonAvatar as IonAvatarElement, defineCustomElement as defineIonAvatar } from "@ionic/core/components/ion-avatar.js"; -import { IonBackdrop as IonBackdropElement, defineCustomElement as defineIonBackdrop } from "@ionic/core/components/ion-backdrop.js"; -import { IonBadge as IonBadgeElement, defineCustomElement as defineIonBadge } from "@ionic/core/components/ion-badge.js"; -import { IonBreadcrumbs as IonBreadcrumbsElement, defineCustomElement as defineIonBreadcrumbs } from "@ionic/core/components/ion-breadcrumbs.js"; -import { IonButtons as IonButtonsElement, defineCustomElement as defineIonButtons } from "@ionic/core/components/ion-buttons.js"; -import { IonCardContent as IonCardContentElement, defineCustomElement as defineIonCardContent } from "@ionic/core/components/ion-card-content.js"; -import { IonCardHeader as IonCardHeaderElement, defineCustomElement as defineIonCardHeader } from "@ionic/core/components/ion-card-header.js"; -import { IonCardSubtitle as IonCardSubtitleElement, defineCustomElement as defineIonCardSubtitle } from "@ionic/core/components/ion-card-subtitle.js"; -import { IonCardTitle as IonCardTitleElement, defineCustomElement as defineIonCardTitle } from "@ionic/core/components/ion-card-title.js"; -import { IonCheckbox as IonCheckboxElement, defineCustomElement as defineIonCheckbox } from "@ionic/core/components/ion-checkbox.js"; -import { IonChip as IonChipElement, defineCustomElement as defineIonChip } from "@ionic/core/components/ion-chip.js"; -import { IonCol as IonColElement, defineCustomElement as defineIonCol } from "@ionic/core/components/ion-col.js"; -import { IonContent as IonContentElement, defineCustomElement as defineIonContent } from "@ionic/core/components/ion-content.js"; -import { IonDatetimeButton as IonDatetimeButtonElement, defineCustomElement as defineIonDatetimeButton } from "@ionic/core/components/ion-datetime-button.js"; -import { IonDatetime as IonDatetimeElement, defineCustomElement as defineIonDatetime } from "@ionic/core/components/ion-datetime.js"; -import { IonFabList as IonFabListElement, defineCustomElement as defineIonFabList } from "@ionic/core/components/ion-fab-list.js"; -import { IonFab as IonFabElement, defineCustomElement as defineIonFab } from "@ionic/core/components/ion-fab.js"; -import { IonFooter as IonFooterElement, defineCustomElement as defineIonFooter } from "@ionic/core/components/ion-footer.js"; -import { IonGrid as IonGridElement, defineCustomElement as defineIonGrid } from "@ionic/core/components/ion-grid.js"; -import { IonHeader as IonHeaderElement, defineCustomElement as defineIonHeader } from "@ionic/core/components/ion-header.js"; -import { IonImg as IonImgElement, defineCustomElement as defineIonImg } from "@ionic/core/components/ion-img.js"; -import { IonInfiniteScrollContent as IonInfiniteScrollContentElement, defineCustomElement as defineIonInfiniteScrollContent } from "@ionic/core/components/ion-infinite-scroll-content.js"; -import { IonInfiniteScroll as IonInfiniteScrollElement, defineCustomElement as defineIonInfiniteScroll } from "@ionic/core/components/ion-infinite-scroll.js"; -import { IonInputOtp as IonInputOtpElement, defineCustomElement as defineIonInputOtp } from "@ionic/core/components/ion-input-otp.js"; -import { IonInputPasswordToggle as IonInputPasswordToggleElement, defineCustomElement as defineIonInputPasswordToggle } from "@ionic/core/components/ion-input-password-toggle.js"; -import { IonInput as IonInputElement, defineCustomElement as defineIonInput } from "@ionic/core/components/ion-input.js"; -import { IonItemDivider as IonItemDividerElement, defineCustomElement as defineIonItemDivider } from "@ionic/core/components/ion-item-divider.js"; -import { IonItemGroup as IonItemGroupElement, defineCustomElement as defineIonItemGroup } from "@ionic/core/components/ion-item-group.js"; -import { IonItemOptions as IonItemOptionsElement, defineCustomElement as defineIonItemOptions } from "@ionic/core/components/ion-item-options.js"; -import { IonItemSliding as IonItemSlidingElement, defineCustomElement as defineIonItemSliding } from "@ionic/core/components/ion-item-sliding.js"; -import { IonLabel as IonLabelElement, defineCustomElement as defineIonLabel } from "@ionic/core/components/ion-label.js"; -import { IonListHeader as IonListHeaderElement, defineCustomElement as defineIonListHeader } from "@ionic/core/components/ion-list-header.js"; -import { IonList as IonListElement, defineCustomElement as defineIonList } from "@ionic/core/components/ion-list.js"; -import { IonMenuButton as IonMenuButtonElement, defineCustomElement as defineIonMenuButton } from "@ionic/core/components/ion-menu-button.js"; -import { IonMenuToggle as IonMenuToggleElement, defineCustomElement as defineIonMenuToggle } from "@ionic/core/components/ion-menu-toggle.js"; -import { IonMenu as IonMenuElement, defineCustomElement as defineIonMenu } from "@ionic/core/components/ion-menu.js"; -import { IonNavLink as IonNavLinkElement, defineCustomElement as defineIonNavLink } from "@ionic/core/components/ion-nav-link.js"; -import { IonNav as IonNavElement, defineCustomElement as defineIonNav } from "@ionic/core/components/ion-nav.js"; -import { IonNote as IonNoteElement, defineCustomElement as defineIonNote } from "@ionic/core/components/ion-note.js"; -import { IonPickerColumnOption as IonPickerColumnOptionElement, defineCustomElement as defineIonPickerColumnOption } from "@ionic/core/components/ion-picker-column-option.js"; -import { IonPickerColumn as IonPickerColumnElement, defineCustomElement as defineIonPickerColumn } from "@ionic/core/components/ion-picker-column.js"; -import { IonPicker as IonPickerElement, defineCustomElement as defineIonPicker } from "@ionic/core/components/ion-picker.js"; -import { IonProgressBar as IonProgressBarElement, defineCustomElement as defineIonProgressBar } from "@ionic/core/components/ion-progress-bar.js"; -import { IonRadioGroup as IonRadioGroupElement, defineCustomElement as defineIonRadioGroup } from "@ionic/core/components/ion-radio-group.js"; -import { IonRadio as IonRadioElement, defineCustomElement as defineIonRadio } from "@ionic/core/components/ion-radio.js"; -import { IonRange as IonRangeElement, defineCustomElement as defineIonRange } from "@ionic/core/components/ion-range.js"; -import { IonRefresherContent as IonRefresherContentElement, defineCustomElement as defineIonRefresherContent } from "@ionic/core/components/ion-refresher-content.js"; -import { IonRefresher as IonRefresherElement, defineCustomElement as defineIonRefresher } from "@ionic/core/components/ion-refresher.js"; -import { IonReorderGroup as IonReorderGroupElement, defineCustomElement as defineIonReorderGroup } from "@ionic/core/components/ion-reorder-group.js"; -import { IonReorder as IonReorderElement, defineCustomElement as defineIonReorder } from "@ionic/core/components/ion-reorder.js"; -import { IonRippleEffect as IonRippleEffectElement, defineCustomElement as defineIonRippleEffect } from "@ionic/core/components/ion-ripple-effect.js"; -import { IonRow as IonRowElement, defineCustomElement as defineIonRow } from "@ionic/core/components/ion-row.js"; -import { IonSearchbar as IonSearchbarElement, defineCustomElement as defineIonSearchbar } from "@ionic/core/components/ion-searchbar.js"; -import { IonSegmentButton as IonSegmentButtonElement, defineCustomElement as defineIonSegmentButton } from "@ionic/core/components/ion-segment-button.js"; -import { IonSegmentContent as IonSegmentContentElement, defineCustomElement as defineIonSegmentContent } from "@ionic/core/components/ion-segment-content.js"; -import { IonSegmentView as IonSegmentViewElement, defineCustomElement as defineIonSegmentView } from "@ionic/core/components/ion-segment-view.js"; -import { IonSegment as IonSegmentElement, defineCustomElement as defineIonSegment } from "@ionic/core/components/ion-segment.js"; -import { IonSelectModal as IonSelectModalElement, defineCustomElement as defineIonSelectModal } from "@ionic/core/components/ion-select-modal.js"; -import { IonSelectOption as IonSelectOptionElement, defineCustomElement as defineIonSelectOption } from "@ionic/core/components/ion-select-option.js"; -import { IonSelect as IonSelectElement, defineCustomElement as defineIonSelect } from "@ionic/core/components/ion-select.js"; -import { IonSkeletonText as IonSkeletonTextElement, defineCustomElement as defineIonSkeletonText } from "@ionic/core/components/ion-skeleton-text.js"; -import { IonSpinner as IonSpinnerElement, defineCustomElement as defineIonSpinner } from "@ionic/core/components/ion-spinner.js"; -import { IonSplitPane as IonSplitPaneElement, defineCustomElement as defineIonSplitPane } from "@ionic/core/components/ion-split-pane.js"; -import { IonTab as IonTabElement, defineCustomElement as defineIonTab } from "@ionic/core/components/ion-tab.js"; -import { IonText as IonTextElement, defineCustomElement as defineIonText } from "@ionic/core/components/ion-text.js"; -import { IonTextarea as IonTextareaElement, defineCustomElement as defineIonTextarea } from "@ionic/core/components/ion-textarea.js"; -import { IonThumbnail as IonThumbnailElement, defineCustomElement as defineIonThumbnail } from "@ionic/core/components/ion-thumbnail.js"; -import { IonTitle as IonTitleElement, defineCustomElement as defineIonTitle } from "@ionic/core/components/ion-title.js"; -import { IonToggle as IonToggleElement, defineCustomElement as defineIonToggle } from "@ionic/core/components/ion-toggle.js"; -import { IonToolbar as IonToolbarElement, defineCustomElement as defineIonToolbar } from "@ionic/core/components/ion-toolbar.js"; +import { + type AccordionGroupChangeEventDetail, + type BreadcrumbCollapsedClickEventDetail, + type CheckboxChangeEventDetail, + type DatetimeChangeEventDetail, + type InputChangeEventDetail, + type InputInputEventDetail, + type InputOtpChangeEventDetail, + type InputOtpCompleteEventDetail, + type InputOtpInputEventDetail, + type IonAccordionGroupCustomEvent, + type IonBackdropCustomEvent, + type IonBreadcrumbsCustomEvent, + type IonCheckboxCustomEvent, + type IonContentCustomEvent, + type IonDatetimeCustomEvent, + type IonImgCustomEvent, + type IonInfiniteScrollCustomEvent, + type IonInputCustomEvent, + type IonInputOtpCustomEvent, + type IonItemOptionsCustomEvent, + type IonItemSlidingCustomEvent, + type IonMenuCustomEvent, + type IonNavCustomEvent, + type IonPickerColumnCustomEvent, + type IonRadioCustomEvent, + type IonRadioGroupCustomEvent, + type IonRangeCustomEvent, + type IonRefresherCustomEvent, + type IonReorderGroupCustomEvent, + type IonSearchbarCustomEvent, + type IonSegmentCustomEvent, + type IonSegmentViewCustomEvent, + type IonSelectCustomEvent, + type IonSplitPaneCustomEvent, + type IonTextareaCustomEvent, + type IonToggleCustomEvent, + type ItemReorderEventDetail, + type MenuCloseEventDetail, + type PickerColumnChangeEventDetail, + type RadioGroupChangeEventDetail, + type RangeChangeEventDetail, + type RangeKnobMoveEndEventDetail, + type RangeKnobMoveStartEventDetail, + type RefresherEventDetail, + type RefresherPullEndEventDetail, + type ReorderEndEventDetail, + type ReorderMoveEventDetail, + type ScrollBaseDetail, + type ScrollDetail, + type SearchbarChangeEventDetail, + type SearchbarInputEventDetail, + type SegmentChangeEventDetail, + type SegmentViewScrollEvent, + type SelectChangeEventDetail, + type TextareaChangeEventDetail, + type TextareaInputEventDetail, + type ToggleChangeEventDetail, +} from '@ionic/core'; +import type { Components } from '@ionic/core/components'; +import { + IonAccordionGroup as IonAccordionGroupElement, + defineCustomElement as defineIonAccordionGroup, +} from '@ionic/core/components/ion-accordion-group.js'; +import { + IonAccordion as IonAccordionElement, + defineCustomElement as defineIonAccordion, +} from '@ionic/core/components/ion-accordion.js'; +import { + IonAvatar as IonAvatarElement, + defineCustomElement as defineIonAvatar, +} from '@ionic/core/components/ion-avatar.js'; +import { + IonBackdrop as IonBackdropElement, + defineCustomElement as defineIonBackdrop, +} from '@ionic/core/components/ion-backdrop.js'; +import { + IonBadge as IonBadgeElement, + defineCustomElement as defineIonBadge, +} from '@ionic/core/components/ion-badge.js'; +import { + IonBreadcrumbs as IonBreadcrumbsElement, + defineCustomElement as defineIonBreadcrumbs, +} from '@ionic/core/components/ion-breadcrumbs.js'; +import { + IonButtons as IonButtonsElement, + defineCustomElement as defineIonButtons, +} from '@ionic/core/components/ion-buttons.js'; +import { + IonCardContent as IonCardContentElement, + defineCustomElement as defineIonCardContent, +} from '@ionic/core/components/ion-card-content.js'; +import { + IonCardHeader as IonCardHeaderElement, + defineCustomElement as defineIonCardHeader, +} from '@ionic/core/components/ion-card-header.js'; +import { + IonCardSubtitle as IonCardSubtitleElement, + defineCustomElement as defineIonCardSubtitle, +} from '@ionic/core/components/ion-card-subtitle.js'; +import { + IonCardTitle as IonCardTitleElement, + defineCustomElement as defineIonCardTitle, +} from '@ionic/core/components/ion-card-title.js'; +import { + IonCheckbox as IonCheckboxElement, + defineCustomElement as defineIonCheckbox, +} from '@ionic/core/components/ion-checkbox.js'; +import { IonChip as IonChipElement, defineCustomElement as defineIonChip } from '@ionic/core/components/ion-chip.js'; +import { IonCol as IonColElement, defineCustomElement as defineIonCol } from '@ionic/core/components/ion-col.js'; +import { + IonContent as IonContentElement, + defineCustomElement as defineIonContent, +} from '@ionic/core/components/ion-content.js'; +import { + IonDatetimeButton as IonDatetimeButtonElement, + defineCustomElement as defineIonDatetimeButton, +} from '@ionic/core/components/ion-datetime-button.js'; +import { + IonDatetime as IonDatetimeElement, + defineCustomElement as defineIonDatetime, +} from '@ionic/core/components/ion-datetime.js'; +import { + IonFabList as IonFabListElement, + defineCustomElement as defineIonFabList, +} from '@ionic/core/components/ion-fab-list.js'; +import { IonFab as IonFabElement, defineCustomElement as defineIonFab } from '@ionic/core/components/ion-fab.js'; +import { + IonFooter as IonFooterElement, + defineCustomElement as defineIonFooter, +} from '@ionic/core/components/ion-footer.js'; +import { IonGrid as IonGridElement, defineCustomElement as defineIonGrid } from '@ionic/core/components/ion-grid.js'; +import { + IonHeader as IonHeaderElement, + defineCustomElement as defineIonHeader, +} from '@ionic/core/components/ion-header.js'; +import { IonImg as IonImgElement, defineCustomElement as defineIonImg } from '@ionic/core/components/ion-img.js'; +import { + IonInfiniteScrollContent as IonInfiniteScrollContentElement, + defineCustomElement as defineIonInfiniteScrollContent, +} from '@ionic/core/components/ion-infinite-scroll-content.js'; +import { + IonInfiniteScroll as IonInfiniteScrollElement, + defineCustomElement as defineIonInfiniteScroll, +} from '@ionic/core/components/ion-infinite-scroll.js'; +import { + IonInputOtp as IonInputOtpElement, + defineCustomElement as defineIonInputOtp, +} from '@ionic/core/components/ion-input-otp.js'; +import { + IonInputPasswordToggle as IonInputPasswordToggleElement, + defineCustomElement as defineIonInputPasswordToggle, +} from '@ionic/core/components/ion-input-password-toggle.js'; +import { + IonInput as IonInputElement, + defineCustomElement as defineIonInput, +} from '@ionic/core/components/ion-input.js'; +import { + IonItemDivider as IonItemDividerElement, + defineCustomElement as defineIonItemDivider, +} from '@ionic/core/components/ion-item-divider.js'; +import { + IonItemGroup as IonItemGroupElement, + defineCustomElement as defineIonItemGroup, +} from '@ionic/core/components/ion-item-group.js'; +import { + IonItemOptions as IonItemOptionsElement, + defineCustomElement as defineIonItemOptions, +} from '@ionic/core/components/ion-item-options.js'; +import { + IonItemSliding as IonItemSlidingElement, + defineCustomElement as defineIonItemSliding, +} from '@ionic/core/components/ion-item-sliding.js'; +import { + IonLabel as IonLabelElement, + defineCustomElement as defineIonLabel, +} from '@ionic/core/components/ion-label.js'; +import { + IonListHeader as IonListHeaderElement, + defineCustomElement as defineIonListHeader, +} from '@ionic/core/components/ion-list-header.js'; +import { IonList as IonListElement, defineCustomElement as defineIonList } from '@ionic/core/components/ion-list.js'; +import { + IonMenuButton as IonMenuButtonElement, + defineCustomElement as defineIonMenuButton, +} from '@ionic/core/components/ion-menu-button.js'; +import { + IonMenuToggle as IonMenuToggleElement, + defineCustomElement as defineIonMenuToggle, +} from '@ionic/core/components/ion-menu-toggle.js'; +import { IonMenu as IonMenuElement, defineCustomElement as defineIonMenu } from '@ionic/core/components/ion-menu.js'; +import { + IonNavLink as IonNavLinkElement, + defineCustomElement as defineIonNavLink, +} from '@ionic/core/components/ion-nav-link.js'; +import { IonNav as IonNavElement, defineCustomElement as defineIonNav } from '@ionic/core/components/ion-nav.js'; +import { IonNote as IonNoteElement, defineCustomElement as defineIonNote } from '@ionic/core/components/ion-note.js'; +import { + IonPickerColumnOption as IonPickerColumnOptionElement, + defineCustomElement as defineIonPickerColumnOption, +} from '@ionic/core/components/ion-picker-column-option.js'; +import { + IonPickerColumn as IonPickerColumnElement, + defineCustomElement as defineIonPickerColumn, +} from '@ionic/core/components/ion-picker-column.js'; +import { + IonPicker as IonPickerElement, + defineCustomElement as defineIonPicker, +} from '@ionic/core/components/ion-picker.js'; +import { + IonProgressBar as IonProgressBarElement, + defineCustomElement as defineIonProgressBar, +} from '@ionic/core/components/ion-progress-bar.js'; +import { + IonRadioGroup as IonRadioGroupElement, + defineCustomElement as defineIonRadioGroup, +} from '@ionic/core/components/ion-radio-group.js'; +import { + IonRadio as IonRadioElement, + defineCustomElement as defineIonRadio, +} from '@ionic/core/components/ion-radio.js'; +import { + IonRange as IonRangeElement, + defineCustomElement as defineIonRange, +} from '@ionic/core/components/ion-range.js'; +import { + IonRefresherContent as IonRefresherContentElement, + defineCustomElement as defineIonRefresherContent, +} from '@ionic/core/components/ion-refresher-content.js'; +import { + IonRefresher as IonRefresherElement, + defineCustomElement as defineIonRefresher, +} from '@ionic/core/components/ion-refresher.js'; +import { + IonReorderGroup as IonReorderGroupElement, + defineCustomElement as defineIonReorderGroup, +} from '@ionic/core/components/ion-reorder-group.js'; +import { + IonReorder as IonReorderElement, + defineCustomElement as defineIonReorder, +} from '@ionic/core/components/ion-reorder.js'; +import { + IonRippleEffect as IonRippleEffectElement, + defineCustomElement as defineIonRippleEffect, +} from '@ionic/core/components/ion-ripple-effect.js'; +import { IonRow as IonRowElement, defineCustomElement as defineIonRow } from '@ionic/core/components/ion-row.js'; +import { + IonSearchbar as IonSearchbarElement, + defineCustomElement as defineIonSearchbar, +} from '@ionic/core/components/ion-searchbar.js'; +import { + IonSegmentButton as IonSegmentButtonElement, + defineCustomElement as defineIonSegmentButton, +} from '@ionic/core/components/ion-segment-button.js'; +import { + IonSegmentContent as IonSegmentContentElement, + defineCustomElement as defineIonSegmentContent, +} from '@ionic/core/components/ion-segment-content.js'; +import { + IonSegmentView as IonSegmentViewElement, + defineCustomElement as defineIonSegmentView, +} from '@ionic/core/components/ion-segment-view.js'; +import { + IonSegment as IonSegmentElement, + defineCustomElement as defineIonSegment, +} from '@ionic/core/components/ion-segment.js'; +import { + IonSelectModal as IonSelectModalElement, + defineCustomElement as defineIonSelectModal, +} from '@ionic/core/components/ion-select-modal.js'; +import { + IonSelectOption as IonSelectOptionElement, + defineCustomElement as defineIonSelectOption, +} from '@ionic/core/components/ion-select-option.js'; +import { + IonSelect as IonSelectElement, + defineCustomElement as defineIonSelect, +} from '@ionic/core/components/ion-select.js'; +import { + IonSkeletonText as IonSkeletonTextElement, + defineCustomElement as defineIonSkeletonText, +} from '@ionic/core/components/ion-skeleton-text.js'; +import { + IonSpinner as IonSpinnerElement, + defineCustomElement as defineIonSpinner, +} from '@ionic/core/components/ion-spinner.js'; +import { + IonSplitPane as IonSplitPaneElement, + defineCustomElement as defineIonSplitPane, +} from '@ionic/core/components/ion-split-pane.js'; +import { IonTab as IonTabElement, defineCustomElement as defineIonTab } from '@ionic/core/components/ion-tab.js'; +import { IonText as IonTextElement, defineCustomElement as defineIonText } from '@ionic/core/components/ion-text.js'; +import { + IonTextarea as IonTextareaElement, + defineCustomElement as defineIonTextarea, +} from '@ionic/core/components/ion-textarea.js'; +import { + IonThumbnail as IonThumbnailElement, + defineCustomElement as defineIonThumbnail, +} from '@ionic/core/components/ion-thumbnail.js'; +import { + IonTitle as IonTitleElement, + defineCustomElement as defineIonTitle, +} from '@ionic/core/components/ion-title.js'; +import { + IonToggle as IonToggleElement, + defineCustomElement as defineIonToggle, +} from '@ionic/core/components/ion-toggle.js'; +import { + IonToolbar as IonToolbarElement, + defineCustomElement as defineIonToolbar, +} from '@ionic/core/components/ion-toolbar.js'; export type IonAccordionEvents = NonNullable; -export const IonAccordion: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonAccordion: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-accordion', elementClass: IonAccordionElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonAccordionEvents, - defineCustomElement: defineIonAccordion -}); + defineCustomElement: defineIonAccordion, + }); -export type IonAccordionGroupEvents = { onIonChange: EventName> }; +export type IonAccordionGroupEvents = { + onIonChange: EventName>; +}; -export const IonAccordionGroup: StencilReactComponent = /*@__PURE__*/ createComponent({ - tagName: 'ion-accordion-group', - elementClass: IonAccordionGroupElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: { onIonChange: 'ionChange' } as IonAccordionGroupEvents, - defineCustomElement: defineIonAccordionGroup +export const IonAccordionGroup: StencilReactComponent< + IonAccordionGroupElement, + IonAccordionGroupEvents, + Components.IonAccordionGroup +> = /*@__PURE__*/ createComponent({ + tagName: 'ion-accordion-group', + elementClass: IonAccordionGroupElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: { onIonChange: 'ionChange' } as IonAccordionGroupEvents, + defineCustomElement: defineIonAccordionGroup, }); export type IonAvatarEvents = NonNullable; -export const IonAvatar: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonAvatar: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-avatar', elementClass: IonAvatarElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonAvatarEvents, - defineCustomElement: defineIonAvatar -}); + defineCustomElement: defineIonAvatar, + }); export type IonBackdropEvents = { onIonBackdropTap: EventName> }; -export const IonBackdrop: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonBackdrop: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-backdrop', elementClass: IonBackdropElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: { onIonBackdropTap: 'ionBackdropTap' } as IonBackdropEvents, - defineCustomElement: defineIonBackdrop -}); + defineCustomElement: defineIonBackdrop, + }); export type IonBadgeEvents = NonNullable; -export const IonBadge: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonBadge: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-badge', elementClass: IonBadgeElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonBadgeEvents, - defineCustomElement: defineIonBadge -}); + defineCustomElement: defineIonBadge, + }); -export type IonBreadcrumbsEvents = { onIonCollapsedClick: EventName> }; +export type IonBreadcrumbsEvents = { + onIonCollapsedClick: EventName>; +}; -export const IonBreadcrumbs: StencilReactComponent = /*@__PURE__*/ createComponent({ - tagName: 'ion-breadcrumbs', - elementClass: IonBreadcrumbsElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: { onIonCollapsedClick: 'ionCollapsedClick' } as IonBreadcrumbsEvents, - defineCustomElement: defineIonBreadcrumbs +export const IonBreadcrumbs: StencilReactComponent< + IonBreadcrumbsElement, + IonBreadcrumbsEvents, + Components.IonBreadcrumbs +> = /*@__PURE__*/ createComponent({ + tagName: 'ion-breadcrumbs', + elementClass: IonBreadcrumbsElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: { onIonCollapsedClick: 'ionCollapsedClick' } as IonBreadcrumbsEvents, + defineCustomElement: defineIonBreadcrumbs, }); export type IonButtonsEvents = NonNullable; -export const IonButtons: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonButtons: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-buttons', elementClass: IonButtonsElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonButtonsEvents, - defineCustomElement: defineIonButtons -}); + defineCustomElement: defineIonButtons, + }); export type IonCardContentEvents = NonNullable; -export const IonCardContent: StencilReactComponent = /*@__PURE__*/ createComponent({ - tagName: 'ion-card-content', - elementClass: IonCardContentElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: {} as IonCardContentEvents, - defineCustomElement: defineIonCardContent +export const IonCardContent: StencilReactComponent< + IonCardContentElement, + IonCardContentEvents, + Components.IonCardContent +> = /*@__PURE__*/ createComponent({ + tagName: 'ion-card-content', + elementClass: IonCardContentElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: {} as IonCardContentEvents, + defineCustomElement: defineIonCardContent, }); export type IonCardHeaderEvents = NonNullable; -export const IonCardHeader: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonCardHeader: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-card-header', elementClass: IonCardHeaderElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonCardHeaderEvents, - defineCustomElement: defineIonCardHeader -}); + defineCustomElement: defineIonCardHeader, + }); export type IonCardSubtitleEvents = NonNullable; -export const IonCardSubtitle: StencilReactComponent = /*@__PURE__*/ createComponent({ - tagName: 'ion-card-subtitle', - elementClass: IonCardSubtitleElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: {} as IonCardSubtitleEvents, - defineCustomElement: defineIonCardSubtitle +export const IonCardSubtitle: StencilReactComponent< + IonCardSubtitleElement, + IonCardSubtitleEvents, + Components.IonCardSubtitle +> = /*@__PURE__*/ createComponent({ + tagName: 'ion-card-subtitle', + elementClass: IonCardSubtitleElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: {} as IonCardSubtitleEvents, + defineCustomElement: defineIonCardSubtitle, }); export type IonCardTitleEvents = NonNullable; -export const IonCardTitle: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonCardTitle: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-card-title', elementClass: IonCardTitleElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonCardTitleEvents, - defineCustomElement: defineIonCardTitle -}); + defineCustomElement: defineIonCardTitle, + }); export type IonCheckboxEvents = { - onIonChange: EventName>, - onIonFocus: EventName>, - onIonBlur: EventName> + onIonChange: EventName>; + onIonFocus: EventName>; + onIonBlur: EventName>; }; -export const IonCheckbox: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonCheckbox: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-checkbox', elementClass: IonCheckboxElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: { - onIonChange: 'ionChange', - onIonFocus: 'ionFocus', - onIonBlur: 'ionBlur' + onIonChange: 'ionChange', + onIonFocus: 'ionFocus', + onIonBlur: 'ionBlur', } as IonCheckboxEvents, - defineCustomElement: defineIonCheckbox -}); + defineCustomElement: defineIonCheckbox, + }); export type IonChipEvents = NonNullable; -export const IonChip: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonChip: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-chip', elementClass: IonChipElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonChipEvents, - defineCustomElement: defineIonChip -}); + defineCustomElement: defineIonChip, + }); export type IonColEvents = NonNullable; -export const IonCol: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonCol: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-col', elementClass: IonColElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonColEvents, - defineCustomElement: defineIonCol -}); + defineCustomElement: defineIonCol, + }); export type IonContentEvents = { - onIonScrollStart: EventName>, - onIonScroll: EventName>, - onIonScrollEnd: EventName> + onIonScrollStart: EventName>; + onIonScroll: EventName>; + onIonScrollEnd: EventName>; }; -export const IonContent: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonContent: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-content', elementClass: IonContentElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: { - onIonScrollStart: 'ionScrollStart', - onIonScroll: 'ionScroll', - onIonScrollEnd: 'ionScrollEnd' + onIonScrollStart: 'ionScrollStart', + onIonScroll: 'ionScroll', + onIonScrollEnd: 'ionScrollEnd', } as IonContentEvents, - defineCustomElement: defineIonContent -}); + defineCustomElement: defineIonContent, + }); export type IonDatetimeEvents = { - onIonCancel: EventName>, - onIonChange: EventName>, - onIonFocus: EventName>, - onIonBlur: EventName> + onIonCancel: EventName>; + onIonChange: EventName>; + onIonFocus: EventName>; + onIonBlur: EventName>; }; -export const IonDatetime: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonDatetime: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-datetime', elementClass: IonDatetimeElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: { - onIonCancel: 'ionCancel', - onIonChange: 'ionChange', - onIonFocus: 'ionFocus', - onIonBlur: 'ionBlur' + onIonCancel: 'ionCancel', + onIonChange: 'ionChange', + onIonFocus: 'ionFocus', + onIonBlur: 'ionBlur', } as IonDatetimeEvents, - defineCustomElement: defineIonDatetime -}); + defineCustomElement: defineIonDatetime, + }); export type IonDatetimeButtonEvents = NonNullable; -export const IonDatetimeButton: StencilReactComponent = /*@__PURE__*/ createComponent({ - tagName: 'ion-datetime-button', - elementClass: IonDatetimeButtonElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: {} as IonDatetimeButtonEvents, - defineCustomElement: defineIonDatetimeButton +export const IonDatetimeButton: StencilReactComponent< + IonDatetimeButtonElement, + IonDatetimeButtonEvents, + Components.IonDatetimeButton +> = /*@__PURE__*/ createComponent({ + tagName: 'ion-datetime-button', + elementClass: IonDatetimeButtonElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: {} as IonDatetimeButtonEvents, + defineCustomElement: defineIonDatetimeButton, }); export type IonFabEvents = NonNullable; -export const IonFab: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonFab: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-fab', elementClass: IonFabElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonFabEvents, - defineCustomElement: defineIonFab -}); + defineCustomElement: defineIonFab, + }); export type IonFabListEvents = NonNullable; -export const IonFabList: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonFabList: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-fab-list', elementClass: IonFabListElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonFabListEvents, - defineCustomElement: defineIonFabList -}); + defineCustomElement: defineIonFabList, + }); export type IonFooterEvents = NonNullable; -export const IonFooter: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonFooter: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-footer', elementClass: IonFooterElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonFooterEvents, - defineCustomElement: defineIonFooter -}); + defineCustomElement: defineIonFooter, + }); export type IonGridEvents = NonNullable; -export const IonGrid: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonGrid: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-grid', elementClass: IonGridElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonGridEvents, - defineCustomElement: defineIonGrid -}); + defineCustomElement: defineIonGrid, + }); export type IonHeaderEvents = NonNullable; -export const IonHeader: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonHeader: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-header', elementClass: IonHeaderElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonHeaderEvents, - defineCustomElement: defineIonHeader -}); + defineCustomElement: defineIonHeader, + }); export type IonImgEvents = { - onIonImgWillLoad: EventName>, - onIonImgDidLoad: EventName>, - onIonError: EventName> + onIonImgWillLoad: EventName>; + onIonImgDidLoad: EventName>; + onIonError: EventName>; }; -export const IonImg: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonImg: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-img', elementClass: IonImgElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: { - onIonImgWillLoad: 'ionImgWillLoad', - onIonImgDidLoad: 'ionImgDidLoad', - onIonError: 'ionError' + onIonImgWillLoad: 'ionImgWillLoad', + onIonImgDidLoad: 'ionImgDidLoad', + onIonError: 'ionError', } as IonImgEvents, - defineCustomElement: defineIonImg -}); + defineCustomElement: defineIonImg, + }); export type IonInfiniteScrollEvents = { onIonInfinite: EventName> }; -export const IonInfiniteScroll: StencilReactComponent = /*@__PURE__*/ createComponent({ - tagName: 'ion-infinite-scroll', - elementClass: IonInfiniteScrollElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: { onIonInfinite: 'ionInfinite' } as IonInfiniteScrollEvents, - defineCustomElement: defineIonInfiniteScroll +export const IonInfiniteScroll: StencilReactComponent< + IonInfiniteScrollElement, + IonInfiniteScrollEvents, + Components.IonInfiniteScroll +> = /*@__PURE__*/ createComponent({ + tagName: 'ion-infinite-scroll', + elementClass: IonInfiniteScrollElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: { onIonInfinite: 'ionInfinite' } as IonInfiniteScrollEvents, + defineCustomElement: defineIonInfiniteScroll, }); export type IonInfiniteScrollContentEvents = NonNullable; -export const IonInfiniteScrollContent: StencilReactComponent = /*@__PURE__*/ createComponent({ - tagName: 'ion-infinite-scroll-content', - elementClass: IonInfiniteScrollContentElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: {} as IonInfiniteScrollContentEvents, - defineCustomElement: defineIonInfiniteScrollContent +export const IonInfiniteScrollContent: StencilReactComponent< + IonInfiniteScrollContentElement, + IonInfiniteScrollContentEvents, + Components.IonInfiniteScrollContent +> = /*@__PURE__*/ createComponent< + IonInfiniteScrollContentElement, + IonInfiniteScrollContentEvents, + Components.IonInfiniteScrollContent +>({ + tagName: 'ion-infinite-scroll-content', + elementClass: IonInfiniteScrollContentElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: {} as IonInfiniteScrollContentEvents, + defineCustomElement: defineIonInfiniteScrollContent, }); export type IonInputEvents = { - onIonInput: EventName>, - onIonChange: EventName>, - onIonBlur: EventName>, - onIonFocus: EventName> + onIonInput: EventName>; + onIonChange: EventName>; + onIonBlur: EventName>; + onIonFocus: EventName>; }; -export const IonInput: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonInput: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-input', elementClass: IonInputElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: { - onIonInput: 'ionInput', - onIonChange: 'ionChange', - onIonBlur: 'ionBlur', - onIonFocus: 'ionFocus' + onIonInput: 'ionInput', + onIonChange: 'ionChange', + onIonBlur: 'ionBlur', + onIonFocus: 'ionFocus', } as IonInputEvents, - defineCustomElement: defineIonInput -}); + defineCustomElement: defineIonInput, + }); export type IonInputOtpEvents = { - onIonInput: EventName>, - onIonChange: EventName>, - onIonComplete: EventName>, - onIonBlur: EventName>, - onIonFocus: EventName> + onIonInput: EventName>; + onIonChange: EventName>; + onIonComplete: EventName>; + onIonBlur: EventName>; + onIonFocus: EventName>; }; -export const IonInputOtp: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonInputOtp: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-input-otp', elementClass: IonInputOtpElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: { - onIonInput: 'ionInput', - onIonChange: 'ionChange', - onIonComplete: 'ionComplete', - onIonBlur: 'ionBlur', - onIonFocus: 'ionFocus' + onIonInput: 'ionInput', + onIonChange: 'ionChange', + onIonComplete: 'ionComplete', + onIonBlur: 'ionBlur', + onIonFocus: 'ionFocus', } as IonInputOtpEvents, - defineCustomElement: defineIonInputOtp -}); + defineCustomElement: defineIonInputOtp, + }); export type IonInputPasswordToggleEvents = NonNullable; -export const IonInputPasswordToggle: StencilReactComponent = /*@__PURE__*/ createComponent({ - tagName: 'ion-input-password-toggle', - elementClass: IonInputPasswordToggleElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: {} as IonInputPasswordToggleEvents, - defineCustomElement: defineIonInputPasswordToggle +export const IonInputPasswordToggle: StencilReactComponent< + IonInputPasswordToggleElement, + IonInputPasswordToggleEvents, + Components.IonInputPasswordToggle +> = /*@__PURE__*/ createComponent< + IonInputPasswordToggleElement, + IonInputPasswordToggleEvents, + Components.IonInputPasswordToggle +>({ + tagName: 'ion-input-password-toggle', + elementClass: IonInputPasswordToggleElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: {} as IonInputPasswordToggleEvents, + defineCustomElement: defineIonInputPasswordToggle, }); export type IonItemDividerEvents = NonNullable; -export const IonItemDivider: StencilReactComponent = /*@__PURE__*/ createComponent({ - tagName: 'ion-item-divider', - elementClass: IonItemDividerElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: {} as IonItemDividerEvents, - defineCustomElement: defineIonItemDivider +export const IonItemDivider: StencilReactComponent< + IonItemDividerElement, + IonItemDividerEvents, + Components.IonItemDivider +> = /*@__PURE__*/ createComponent({ + tagName: 'ion-item-divider', + elementClass: IonItemDividerElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: {} as IonItemDividerEvents, + defineCustomElement: defineIonItemDivider, }); export type IonItemGroupEvents = NonNullable; -export const IonItemGroup: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonItemGroup: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-item-group', elementClass: IonItemGroupElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonItemGroupEvents, - defineCustomElement: defineIonItemGroup -}); + defineCustomElement: defineIonItemGroup, + }); export type IonItemOptionsEvents = { onIonSwipe: EventName> }; -export const IonItemOptions: StencilReactComponent = /*@__PURE__*/ createComponent({ - tagName: 'ion-item-options', - elementClass: IonItemOptionsElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: { onIonSwipe: 'ionSwipe' } as IonItemOptionsEvents, - defineCustomElement: defineIonItemOptions +export const IonItemOptions: StencilReactComponent< + IonItemOptionsElement, + IonItemOptionsEvents, + Components.IonItemOptions +> = /*@__PURE__*/ createComponent({ + tagName: 'ion-item-options', + elementClass: IonItemOptionsElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: { onIonSwipe: 'ionSwipe' } as IonItemOptionsEvents, + defineCustomElement: defineIonItemOptions, }); export type IonItemSlidingEvents = { onIonDrag: EventName> }; -export const IonItemSliding: StencilReactComponent = /*@__PURE__*/ createComponent({ - tagName: 'ion-item-sliding', - elementClass: IonItemSlidingElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: { onIonDrag: 'ionDrag' } as IonItemSlidingEvents, - defineCustomElement: defineIonItemSliding +export const IonItemSliding: StencilReactComponent< + IonItemSlidingElement, + IonItemSlidingEvents, + Components.IonItemSliding +> = /*@__PURE__*/ createComponent({ + tagName: 'ion-item-sliding', + elementClass: IonItemSlidingElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: { onIonDrag: 'ionDrag' } as IonItemSlidingEvents, + defineCustomElement: defineIonItemSliding, }); export type IonLabelEvents = NonNullable; -export const IonLabel: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonLabel: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-label', elementClass: IonLabelElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonLabelEvents, - defineCustomElement: defineIonLabel -}); + defineCustomElement: defineIonLabel, + }); export type IonListEvents = NonNullable; -export const IonList: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonList: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-list', elementClass: IonListElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonListEvents, - defineCustomElement: defineIonList -}); + defineCustomElement: defineIonList, + }); export type IonListHeaderEvents = NonNullable; -export const IonListHeader: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonListHeader: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-list-header', elementClass: IonListHeaderElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonListHeaderEvents, - defineCustomElement: defineIonListHeader -}); + defineCustomElement: defineIonListHeader, + }); export type IonMenuEvents = { - onIonWillOpen: EventName>, - onIonWillClose: EventName>, - onIonDidOpen: EventName>, - onIonDidClose: EventName> + onIonWillOpen: EventName>; + onIonWillClose: EventName>; + onIonDidOpen: EventName>; + onIonDidClose: EventName>; }; -export const IonMenu: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonMenu: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-menu', elementClass: IonMenuElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: { - onIonWillOpen: 'ionWillOpen', - onIonWillClose: 'ionWillClose', - onIonDidOpen: 'ionDidOpen', - onIonDidClose: 'ionDidClose' + onIonWillOpen: 'ionWillOpen', + onIonWillClose: 'ionWillClose', + onIonDidOpen: 'ionDidOpen', + onIonDidClose: 'ionDidClose', } as IonMenuEvents, - defineCustomElement: defineIonMenu -}); + defineCustomElement: defineIonMenu, + }); export type IonMenuButtonEvents = NonNullable; -export const IonMenuButton: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonMenuButton: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-menu-button', elementClass: IonMenuButtonElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonMenuButtonEvents, - defineCustomElement: defineIonMenuButton -}); + defineCustomElement: defineIonMenuButton, + }); export type IonMenuToggleEvents = NonNullable; -export const IonMenuToggle: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonMenuToggle: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-menu-toggle', elementClass: IonMenuToggleElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonMenuToggleEvents, - defineCustomElement: defineIonMenuToggle -}); + defineCustomElement: defineIonMenuToggle, + }); export type IonNavEvents = { - onIonNavWillChange: EventName>, - onIonNavDidChange: EventName> + onIonNavWillChange: EventName>; + onIonNavDidChange: EventName>; }; -export const IonNav: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonNav: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-nav', elementClass: IonNavElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: { - onIonNavWillChange: 'ionNavWillChange', - onIonNavDidChange: 'ionNavDidChange' + onIonNavWillChange: 'ionNavWillChange', + onIonNavDidChange: 'ionNavDidChange', } as IonNavEvents, - defineCustomElement: defineIonNav -}); + defineCustomElement: defineIonNav, + }); export type IonNavLinkEvents = NonNullable; -export const IonNavLink: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonNavLink: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-nav-link', elementClass: IonNavLinkElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonNavLinkEvents, - defineCustomElement: defineIonNavLink -}); + defineCustomElement: defineIonNavLink, + }); export type IonNoteEvents = NonNullable; -export const IonNote: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonNote: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-note', elementClass: IonNoteElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonNoteEvents, - defineCustomElement: defineIonNote -}); + defineCustomElement: defineIonNote, + }); export type IonPickerEvents = NonNullable; -export const IonPicker: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonPicker: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-picker', elementClass: IonPickerElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonPickerEvents, - defineCustomElement: defineIonPicker -}); + defineCustomElement: defineIonPicker, + }); -export type IonPickerColumnEvents = { onIonChange: EventName> }; +export type IonPickerColumnEvents = { + onIonChange: EventName>; +}; -export const IonPickerColumn: StencilReactComponent = /*@__PURE__*/ createComponent({ - tagName: 'ion-picker-column', - elementClass: IonPickerColumnElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: { onIonChange: 'ionChange' } as IonPickerColumnEvents, - defineCustomElement: defineIonPickerColumn +export const IonPickerColumn: StencilReactComponent< + IonPickerColumnElement, + IonPickerColumnEvents, + Components.IonPickerColumn +> = /*@__PURE__*/ createComponent({ + tagName: 'ion-picker-column', + elementClass: IonPickerColumnElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: { onIonChange: 'ionChange' } as IonPickerColumnEvents, + defineCustomElement: defineIonPickerColumn, }); export type IonPickerColumnOptionEvents = NonNullable; -export const IonPickerColumnOption: StencilReactComponent = /*@__PURE__*/ createComponent({ - tagName: 'ion-picker-column-option', - elementClass: IonPickerColumnOptionElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: {} as IonPickerColumnOptionEvents, - defineCustomElement: defineIonPickerColumnOption +export const IonPickerColumnOption: StencilReactComponent< + IonPickerColumnOptionElement, + IonPickerColumnOptionEvents, + Components.IonPickerColumnOption +> = /*@__PURE__*/ createComponent< + IonPickerColumnOptionElement, + IonPickerColumnOptionEvents, + Components.IonPickerColumnOption +>({ + tagName: 'ion-picker-column-option', + elementClass: IonPickerColumnOptionElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: {} as IonPickerColumnOptionEvents, + defineCustomElement: defineIonPickerColumnOption, }); export type IonProgressBarEvents = NonNullable; -export const IonProgressBar: StencilReactComponent = /*@__PURE__*/ createComponent({ - tagName: 'ion-progress-bar', - elementClass: IonProgressBarElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: {} as IonProgressBarEvents, - defineCustomElement: defineIonProgressBar +export const IonProgressBar: StencilReactComponent< + IonProgressBarElement, + IonProgressBarEvents, + Components.IonProgressBar +> = /*@__PURE__*/ createComponent({ + tagName: 'ion-progress-bar', + elementClass: IonProgressBarElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: {} as IonProgressBarEvents, + defineCustomElement: defineIonProgressBar, }); export type IonRadioEvents = { - onIonFocus: EventName>, - onIonBlur: EventName> + onIonFocus: EventName>; + onIonBlur: EventName>; }; -export const IonRadio: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonRadio: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-radio', elementClass: IonRadioElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: { - onIonFocus: 'ionFocus', - onIonBlur: 'ionBlur' + onIonFocus: 'ionFocus', + onIonBlur: 'ionBlur', } as IonRadioEvents, - defineCustomElement: defineIonRadio -}); + defineCustomElement: defineIonRadio, + }); export type IonRadioGroupEvents = { onIonChange: EventName> }; -export const IonRadioGroup: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonRadioGroup: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-radio-group', elementClass: IonRadioGroupElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: { onIonChange: 'ionChange' } as IonRadioGroupEvents, - defineCustomElement: defineIonRadioGroup -}); + defineCustomElement: defineIonRadioGroup, + }); export type IonRangeEvents = { - onIonChange: EventName>, - onIonInput: EventName>, - onIonFocus: EventName>, - onIonBlur: EventName>, - onIonKnobMoveStart: EventName>, - onIonKnobMoveEnd: EventName> + onIonChange: EventName>; + onIonInput: EventName>; + onIonFocus: EventName>; + onIonBlur: EventName>; + onIonKnobMoveStart: EventName>; + onIonKnobMoveEnd: EventName>; }; -export const IonRange: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonRange: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-range', elementClass: IonRangeElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: { - onIonChange: 'ionChange', - onIonInput: 'ionInput', - onIonFocus: 'ionFocus', - onIonBlur: 'ionBlur', - onIonKnobMoveStart: 'ionKnobMoveStart', - onIonKnobMoveEnd: 'ionKnobMoveEnd' + onIonChange: 'ionChange', + onIonInput: 'ionInput', + onIonFocus: 'ionFocus', + onIonBlur: 'ionBlur', + onIonKnobMoveStart: 'ionKnobMoveStart', + onIonKnobMoveEnd: 'ionKnobMoveEnd', } as IonRangeEvents, - defineCustomElement: defineIonRange -}); + defineCustomElement: defineIonRange, + }); export type IonRefresherEvents = { - onIonRefresh: EventName>, - onIonPull: EventName>, - onIonStart: EventName>, - onIonPullStart: EventName>, - onIonPullEnd: EventName> + onIonRefresh: EventName>; + onIonPull: EventName>; + onIonStart: EventName>; + onIonPullStart: EventName>; + onIonPullEnd: EventName>; }; -export const IonRefresher: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonRefresher: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-refresher', elementClass: IonRefresherElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: { - onIonRefresh: 'ionRefresh', - onIonPull: 'ionPull', - onIonStart: 'ionStart', - onIonPullStart: 'ionPullStart', - onIonPullEnd: 'ionPullEnd' + onIonRefresh: 'ionRefresh', + onIonPull: 'ionPull', + onIonStart: 'ionStart', + onIonPullStart: 'ionPullStart', + onIonPullEnd: 'ionPullEnd', } as IonRefresherEvents, - defineCustomElement: defineIonRefresher -}); + defineCustomElement: defineIonRefresher, + }); export type IonRefresherContentEvents = NonNullable; -export const IonRefresherContent: StencilReactComponent = /*@__PURE__*/ createComponent({ - tagName: 'ion-refresher-content', - elementClass: IonRefresherContentElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: {} as IonRefresherContentEvents, - defineCustomElement: defineIonRefresherContent +export const IonRefresherContent: StencilReactComponent< + IonRefresherContentElement, + IonRefresherContentEvents, + Components.IonRefresherContent +> = /*@__PURE__*/ createComponent< + IonRefresherContentElement, + IonRefresherContentEvents, + Components.IonRefresherContent +>({ + tagName: 'ion-refresher-content', + elementClass: IonRefresherContentElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: {} as IonRefresherContentEvents, + defineCustomElement: defineIonRefresherContent, }); export type IonReorderEvents = NonNullable; -export const IonReorder: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonReorder: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-reorder', elementClass: IonReorderElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonReorderEvents, - defineCustomElement: defineIonReorder -}); + defineCustomElement: defineIonReorder, + }); export type IonReorderGroupEvents = { - onIonItemReorder: EventName>, - onIonReorderStart: EventName>, - onIonReorderMove: EventName>, - onIonReorderEnd: EventName> + onIonItemReorder: EventName>; + onIonReorderStart: EventName>; + onIonReorderMove: EventName>; + onIonReorderEnd: EventName>; }; -export const IonReorderGroup: StencilReactComponent = /*@__PURE__*/ createComponent({ - tagName: 'ion-reorder-group', - elementClass: IonReorderGroupElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: { - onIonItemReorder: 'ionItemReorder', - onIonReorderStart: 'ionReorderStart', - onIonReorderMove: 'ionReorderMove', - onIonReorderEnd: 'ionReorderEnd' - } as IonReorderGroupEvents, - defineCustomElement: defineIonReorderGroup +export const IonReorderGroup: StencilReactComponent< + IonReorderGroupElement, + IonReorderGroupEvents, + Components.IonReorderGroup +> = /*@__PURE__*/ createComponent({ + tagName: 'ion-reorder-group', + elementClass: IonReorderGroupElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: { + onIonItemReorder: 'ionItemReorder', + onIonReorderStart: 'ionReorderStart', + onIonReorderMove: 'ionReorderMove', + onIonReorderEnd: 'ionReorderEnd', + } as IonReorderGroupEvents, + defineCustomElement: defineIonReorderGroup, }); export type IonRippleEffectEvents = NonNullable; -export const IonRippleEffect: StencilReactComponent = /*@__PURE__*/ createComponent({ - tagName: 'ion-ripple-effect', - elementClass: IonRippleEffectElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: {} as IonRippleEffectEvents, - defineCustomElement: defineIonRippleEffect +export const IonRippleEffect: StencilReactComponent< + IonRippleEffectElement, + IonRippleEffectEvents, + Components.IonRippleEffect +> = /*@__PURE__*/ createComponent({ + tagName: 'ion-ripple-effect', + elementClass: IonRippleEffectElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: {} as IonRippleEffectEvents, + defineCustomElement: defineIonRippleEffect, }); export type IonRowEvents = NonNullable; -export const IonRow: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonRow: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-row', elementClass: IonRowElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonRowEvents, - defineCustomElement: defineIonRow -}); + defineCustomElement: defineIonRow, + }); export type IonSearchbarEvents = { - onIonInput: EventName>, - onIonChange: EventName>, - onIonCancel: EventName>, - onIonClear: EventName>, - onIonBlur: EventName>, - onIonFocus: EventName> + onIonInput: EventName>; + onIonChange: EventName>; + onIonCancel: EventName>; + onIonClear: EventName>; + onIonBlur: EventName>; + onIonFocus: EventName>; }; -export const IonSearchbar: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonSearchbar: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-searchbar', elementClass: IonSearchbarElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: { - onIonInput: 'ionInput', - onIonChange: 'ionChange', - onIonCancel: 'ionCancel', - onIonClear: 'ionClear', - onIonBlur: 'ionBlur', - onIonFocus: 'ionFocus' + onIonInput: 'ionInput', + onIonChange: 'ionChange', + onIonCancel: 'ionCancel', + onIonClear: 'ionClear', + onIonBlur: 'ionBlur', + onIonFocus: 'ionFocus', } as IonSearchbarEvents, - defineCustomElement: defineIonSearchbar -}); + defineCustomElement: defineIonSearchbar, + }); export type IonSegmentEvents = { onIonChange: EventName> }; -export const IonSegment: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonSegment: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-segment', elementClass: IonSegmentElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: { onIonChange: 'ionChange' } as IonSegmentEvents, - defineCustomElement: defineIonSegment -}); + defineCustomElement: defineIonSegment, + }); export type IonSegmentButtonEvents = NonNullable; -export const IonSegmentButton: StencilReactComponent = /*@__PURE__*/ createComponent({ - tagName: 'ion-segment-button', - elementClass: IonSegmentButtonElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: {} as IonSegmentButtonEvents, - defineCustomElement: defineIonSegmentButton +export const IonSegmentButton: StencilReactComponent< + IonSegmentButtonElement, + IonSegmentButtonEvents, + Components.IonSegmentButton +> = /*@__PURE__*/ createComponent({ + tagName: 'ion-segment-button', + elementClass: IonSegmentButtonElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: {} as IonSegmentButtonEvents, + defineCustomElement: defineIonSegmentButton, }); export type IonSegmentContentEvents = NonNullable; -export const IonSegmentContent: StencilReactComponent = /*@__PURE__*/ createComponent({ - tagName: 'ion-segment-content', - elementClass: IonSegmentContentElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: {} as IonSegmentContentEvents, - defineCustomElement: defineIonSegmentContent -}); - -export type IonSegmentViewEvents = { onIonSegmentViewScroll: EventName> }; +export const IonSegmentContent: StencilReactComponent< + IonSegmentContentElement, + IonSegmentContentEvents, + Components.IonSegmentContent +> = /*@__PURE__*/ createComponent({ + tagName: 'ion-segment-content', + elementClass: IonSegmentContentElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: {} as IonSegmentContentEvents, + defineCustomElement: defineIonSegmentContent, +}); + +export type IonSegmentViewEvents = { + onIonSegmentViewScroll: EventName>; +}; -export const IonSegmentView: StencilReactComponent = /*@__PURE__*/ createComponent({ - tagName: 'ion-segment-view', - elementClass: IonSegmentViewElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: { onIonSegmentViewScroll: 'ionSegmentViewScroll' } as IonSegmentViewEvents, - defineCustomElement: defineIonSegmentView +export const IonSegmentView: StencilReactComponent< + IonSegmentViewElement, + IonSegmentViewEvents, + Components.IonSegmentView +> = /*@__PURE__*/ createComponent({ + tagName: 'ion-segment-view', + elementClass: IonSegmentViewElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: { onIonSegmentViewScroll: 'ionSegmentViewScroll' } as IonSegmentViewEvents, + defineCustomElement: defineIonSegmentView, }); export type IonSelectEvents = { - onIonChange: EventName>, - onIonCancel: EventName>, - onIonDismiss: EventName>, - onIonFocus: EventName>, - onIonBlur: EventName> + onIonChange: EventName>; + onIonCancel: EventName>; + onIonDismiss: EventName>; + onIonFocus: EventName>; + onIonBlur: EventName>; }; -export const IonSelect: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonSelect: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-select', elementClass: IonSelectElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: { - onIonChange: 'ionChange', - onIonCancel: 'ionCancel', - onIonDismiss: 'ionDismiss', - onIonFocus: 'ionFocus', - onIonBlur: 'ionBlur' + onIonChange: 'ionChange', + onIonCancel: 'ionCancel', + onIonDismiss: 'ionDismiss', + onIonFocus: 'ionFocus', + onIonBlur: 'ionBlur', } as IonSelectEvents, - defineCustomElement: defineIonSelect -}); + defineCustomElement: defineIonSelect, + }); export type IonSelectModalEvents = NonNullable; -export const IonSelectModal: StencilReactComponent = /*@__PURE__*/ createComponent({ - tagName: 'ion-select-modal', - elementClass: IonSelectModalElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: {} as IonSelectModalEvents, - defineCustomElement: defineIonSelectModal +export const IonSelectModal: StencilReactComponent< + IonSelectModalElement, + IonSelectModalEvents, + Components.IonSelectModal +> = /*@__PURE__*/ createComponent({ + tagName: 'ion-select-modal', + elementClass: IonSelectModalElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: {} as IonSelectModalEvents, + defineCustomElement: defineIonSelectModal, }); export type IonSelectOptionEvents = NonNullable; -export const IonSelectOption: StencilReactComponent = /*@__PURE__*/ createComponent({ - tagName: 'ion-select-option', - elementClass: IonSelectOptionElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: {} as IonSelectOptionEvents, - defineCustomElement: defineIonSelectOption +export const IonSelectOption: StencilReactComponent< + IonSelectOptionElement, + IonSelectOptionEvents, + Components.IonSelectOption +> = /*@__PURE__*/ createComponent({ + tagName: 'ion-select-option', + elementClass: IonSelectOptionElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: {} as IonSelectOptionEvents, + defineCustomElement: defineIonSelectOption, }); export type IonSkeletonTextEvents = NonNullable; -export const IonSkeletonText: StencilReactComponent = /*@__PURE__*/ createComponent({ - tagName: 'ion-skeleton-text', - elementClass: IonSkeletonTextElement, - // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. - react: React, - events: {} as IonSkeletonTextEvents, - defineCustomElement: defineIonSkeletonText +export const IonSkeletonText: StencilReactComponent< + IonSkeletonTextElement, + IonSkeletonTextEvents, + Components.IonSkeletonText +> = /*@__PURE__*/ createComponent({ + tagName: 'ion-skeleton-text', + elementClass: IonSkeletonTextElement, + // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. + react: React, + events: {} as IonSkeletonTextEvents, + defineCustomElement: defineIonSkeletonText, }); export type IonSpinnerEvents = NonNullable; -export const IonSpinner: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonSpinner: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-spinner', elementClass: IonSpinnerElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonSpinnerEvents, - defineCustomElement: defineIonSpinner -}); + defineCustomElement: defineIonSpinner, + }); export type IonSplitPaneEvents = { onIonSplitPaneVisible: EventName> }; -export const IonSplitPane: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonSplitPane: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-split-pane', elementClass: IonSplitPaneElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: { onIonSplitPaneVisible: 'ionSplitPaneVisible' } as IonSplitPaneEvents, - defineCustomElement: defineIonSplitPane -}); + defineCustomElement: defineIonSplitPane, + }); export type IonTabEvents = NonNullable; -export const IonTab: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonTab: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-tab', elementClass: IonTabElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonTabEvents, - defineCustomElement: defineIonTab -}); + defineCustomElement: defineIonTab, + }); export type IonTextEvents = NonNullable; -export const IonText: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonText: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-text', elementClass: IonTextElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonTextEvents, - defineCustomElement: defineIonText -}); + defineCustomElement: defineIonText, + }); export type IonTextareaEvents = { - onIonChange: EventName>, - onIonInput: EventName>, - onIonBlur: EventName>, - onIonFocus: EventName> + onIonChange: EventName>; + onIonInput: EventName>; + onIonBlur: EventName>; + onIonFocus: EventName>; }; -export const IonTextarea: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonTextarea: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-textarea', elementClass: IonTextareaElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: { - onIonChange: 'ionChange', - onIonInput: 'ionInput', - onIonBlur: 'ionBlur', - onIonFocus: 'ionFocus' + onIonChange: 'ionChange', + onIonInput: 'ionInput', + onIonBlur: 'ionBlur', + onIonFocus: 'ionFocus', } as IonTextareaEvents, - defineCustomElement: defineIonTextarea -}); + defineCustomElement: defineIonTextarea, + }); export type IonThumbnailEvents = NonNullable; -export const IonThumbnail: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonThumbnail: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-thumbnail', elementClass: IonThumbnailElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonThumbnailEvents, - defineCustomElement: defineIonThumbnail -}); + defineCustomElement: defineIonThumbnail, + }); export type IonTitleEvents = NonNullable; -export const IonTitle: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonTitle: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-title', elementClass: IonTitleElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonTitleEvents, - defineCustomElement: defineIonTitle -}); + defineCustomElement: defineIonTitle, + }); export type IonToggleEvents = { - onIonChange: EventName>, - onIonFocus: EventName>, - onIonBlur: EventName> + onIonChange: EventName>; + onIonFocus: EventName>; + onIonBlur: EventName>; }; -export const IonToggle: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonToggle: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-toggle', elementClass: IonToggleElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: { - onIonChange: 'ionChange', - onIonFocus: 'ionFocus', - onIonBlur: 'ionBlur' + onIonChange: 'ionChange', + onIonFocus: 'ionFocus', + onIonBlur: 'ionBlur', } as IonToggleEvents, - defineCustomElement: defineIonToggle -}); + defineCustomElement: defineIonToggle, + }); export type IonToolbarEvents = NonNullable; -export const IonToolbar: StencilReactComponent = /*@__PURE__*/ createComponent({ +export const IonToolbar: StencilReactComponent = + /*@__PURE__*/ createComponent({ tagName: 'ion-toolbar', elementClass: IonToolbarElement, // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project. react: React, events: {} as IonToolbarEvents, - defineCustomElement: defineIonToolbar -}); + defineCustomElement: defineIonToolbar, + }); From 1f0110c18bf451a9943226d50d0500cd0928909e Mon Sep 17 00:00:00 2001 From: Maria Hutt Date: Thu, 16 Jul 2026 11:02:28 -0700 Subject: [PATCH 3/6] chore(angular): remove ts build --- .../control-value-accessors/index.js | 1 - .../control-value-accessors/value-accessor.js | 146 -- .../src/directives/navigation/back-button.js | 45 - .../src/directives/navigation/nav-params.js | 45 - .../common/src/directives/navigation/nav.js | 39 - .../navigation/router-link-delegate.js | 172 -- .../directives/navigation/router-outlet.js | 462 ---- .../directives/navigation/stack-controller.js | 276 -- .../src/directives/navigation/stack-utils.js | 72 - .../common/src/directives/navigation/tabs.js | 277 -- .../angular/build/es2015/common/src/index.js | 19 - .../build/es2015/common/src/overlays/modal.js | 86 - .../es2015/common/src/overlays/popover.js | 74 - .../common/src/providers/angular-delegate.js | 221 -- .../es2015/common/src/providers/config.js | 41 - .../common/src/providers/dom-controller.js | 41 - .../common/src/providers/menu-controller.js | 112 - .../common/src/providers/nav-controller.js | 221 -- .../es2015/common/src/providers/platform.js | 250 -- .../es2015/common/src/types/interfaces.js | 1 - .../common/src/types/ionic-lifecycle-hooks.js | 4 - .../common/src/types/overlay-options.js | 1 - .../build/es2015/common/src/utils/overlay.js | 24 - .../build/es2015/common/src/utils/proxy.js | 46 - .../build/es2015/common/src/utils/routing.js | 54 - .../build/es2015/common/src/utils/util.js | 9 - .../build/es2015/lazy/src/app-initialize.js | 25 - .../directives/angular-component-lib/utils.js | 58 - .../boolean-value-accessor.js | 38 - .../control-value-accessors/index.js | 4 - .../numeric-value-accessor.js | 45 - .../select-value-accessor.js | 35 - .../text-value-accessor.js | 34 - .../directives/navigation/ion-back-button.js | 18 - .../lazy/src/directives/navigation/ion-nav.js | 17 - .../navigation/ion-router-outlet.js | 31 - .../src/directives/navigation/ion-tabs.js | 66 - .../navigation/router-link-delegate.js | 27 - .../lazy/src/directives/overlays/modal.js | 16 - .../lazy/src/directives/overlays/popover.js | 14 - .../lazy/src/directives/proxies-list.js | 88 - .../es2015/lazy/src/directives/proxies.js | 2272 ----------------- .../lazy/src/directives/validators/index.js | 2 - .../directives/validators/max-validator.js | 23 - .../directives/validators/min-validator.js | 23 - .../angular/build/es2015/lazy/src/index.js | 35 - .../build/es2015/lazy/src/ionic-module.js | 81 - .../src/providers/action-sheet-controller.js | 15 - .../lazy/src/providers/alert-controller.js | 15 - .../src/providers/animation-controller.js | 34 - .../lazy/src/providers/gesture-controller.js | 28 - .../lazy/src/providers/loading-controller.js | 15 - .../lazy/src/providers/menu-controller.js | 15 - .../lazy/src/providers/modal-controller.js | 20 - .../lazy/src/providers/popover-controller.js | 16 - .../lazy/src/providers/toast-controller.js | 15 - .../directives/angular-component-lib/utils.js | 58 - .../standalone/src/directives/checkbox.js | 67 - .../standalone/src/directives/datetime.js | 86 - .../es2015/standalone/src/directives/icon.js | 26 - .../es2015/standalone/src/directives/index.js | 12 - .../standalone/src/directives/input-otp.js | 81 - .../es2015/standalone/src/directives/input.js | 104 - .../standalone/src/directives/proxies.js | 1914 -------------- .../standalone/src/directives/radio-group.js | 51 - .../es2015/standalone/src/directives/range.js | 69 - .../standalone/src/directives/searchbar.js | 73 - .../standalone/src/directives/segment.js | 51 - .../standalone/src/directives/select.js | 75 - .../standalone/src/directives/textarea.js | 82 - .../standalone/src/directives/toggle.js | 67 - .../build/es2015/standalone/src/index.js | 23 - .../standalone/src/navigation/back-button.js | 22 - .../es2015/standalone/src/navigation/nav.js | 20 - .../src/navigation/router-link-delegate.js | 21 - .../src/navigation/router-outlet.js | 35 - .../es2015/standalone/src/navigation/tabs.js | 68 - .../es2015/standalone/src/overlays/modal.js | 22 - .../es2015/standalone/src/overlays/popover.js | 20 - .../src/providers/action-sheet-controller.js | 17 - .../src/providers/alert-controller.js | 17 - .../src/providers/animation-controller.js | 34 - .../src/providers/gesture-controller.js | 28 - .../standalone/src/providers/ionic-angular.js | 37 - .../src/providers/loading-controller.js | 17 - .../src/providers/menu-controller.js | 15 - .../src/providers/modal-controller.js | 22 - .../src/providers/popover-controller.js | 18 - .../src/providers/toast-controller.js | 17 - 89 files changed, 9133 deletions(-) delete mode 100644 packages/angular/build/es2015/common/src/directives/control-value-accessors/index.js delete mode 100644 packages/angular/build/es2015/common/src/directives/control-value-accessors/value-accessor.js delete mode 100644 packages/angular/build/es2015/common/src/directives/navigation/back-button.js delete mode 100644 packages/angular/build/es2015/common/src/directives/navigation/nav-params.js delete mode 100644 packages/angular/build/es2015/common/src/directives/navigation/nav.js delete mode 100644 packages/angular/build/es2015/common/src/directives/navigation/router-link-delegate.js delete mode 100644 packages/angular/build/es2015/common/src/directives/navigation/router-outlet.js delete mode 100644 packages/angular/build/es2015/common/src/directives/navigation/stack-controller.js delete mode 100644 packages/angular/build/es2015/common/src/directives/navigation/stack-utils.js delete mode 100644 packages/angular/build/es2015/common/src/directives/navigation/tabs.js delete mode 100644 packages/angular/build/es2015/common/src/index.js delete mode 100644 packages/angular/build/es2015/common/src/overlays/modal.js delete mode 100644 packages/angular/build/es2015/common/src/overlays/popover.js delete mode 100644 packages/angular/build/es2015/common/src/providers/angular-delegate.js delete mode 100644 packages/angular/build/es2015/common/src/providers/config.js delete mode 100644 packages/angular/build/es2015/common/src/providers/dom-controller.js delete mode 100644 packages/angular/build/es2015/common/src/providers/menu-controller.js delete mode 100644 packages/angular/build/es2015/common/src/providers/nav-controller.js delete mode 100644 packages/angular/build/es2015/common/src/providers/platform.js delete mode 100644 packages/angular/build/es2015/common/src/types/interfaces.js delete mode 100644 packages/angular/build/es2015/common/src/types/ionic-lifecycle-hooks.js delete mode 100644 packages/angular/build/es2015/common/src/types/overlay-options.js delete mode 100644 packages/angular/build/es2015/common/src/utils/overlay.js delete mode 100644 packages/angular/build/es2015/common/src/utils/proxy.js delete mode 100644 packages/angular/build/es2015/common/src/utils/routing.js delete mode 100644 packages/angular/build/es2015/common/src/utils/util.js delete mode 100644 packages/angular/build/es2015/lazy/src/app-initialize.js delete mode 100644 packages/angular/build/es2015/lazy/src/directives/angular-component-lib/utils.js delete mode 100644 packages/angular/build/es2015/lazy/src/directives/control-value-accessors/boolean-value-accessor.js delete mode 100644 packages/angular/build/es2015/lazy/src/directives/control-value-accessors/index.js delete mode 100644 packages/angular/build/es2015/lazy/src/directives/control-value-accessors/numeric-value-accessor.js delete mode 100644 packages/angular/build/es2015/lazy/src/directives/control-value-accessors/select-value-accessor.js delete mode 100644 packages/angular/build/es2015/lazy/src/directives/control-value-accessors/text-value-accessor.js delete mode 100644 packages/angular/build/es2015/lazy/src/directives/navigation/ion-back-button.js delete mode 100644 packages/angular/build/es2015/lazy/src/directives/navigation/ion-nav.js delete mode 100644 packages/angular/build/es2015/lazy/src/directives/navigation/ion-router-outlet.js delete mode 100644 packages/angular/build/es2015/lazy/src/directives/navigation/ion-tabs.js delete mode 100644 packages/angular/build/es2015/lazy/src/directives/navigation/router-link-delegate.js delete mode 100644 packages/angular/build/es2015/lazy/src/directives/overlays/modal.js delete mode 100644 packages/angular/build/es2015/lazy/src/directives/overlays/popover.js delete mode 100644 packages/angular/build/es2015/lazy/src/directives/proxies-list.js delete mode 100644 packages/angular/build/es2015/lazy/src/directives/proxies.js delete mode 100644 packages/angular/build/es2015/lazy/src/directives/validators/index.js delete mode 100644 packages/angular/build/es2015/lazy/src/directives/validators/max-validator.js delete mode 100644 packages/angular/build/es2015/lazy/src/directives/validators/min-validator.js delete mode 100644 packages/angular/build/es2015/lazy/src/index.js delete mode 100644 packages/angular/build/es2015/lazy/src/ionic-module.js delete mode 100644 packages/angular/build/es2015/lazy/src/providers/action-sheet-controller.js delete mode 100644 packages/angular/build/es2015/lazy/src/providers/alert-controller.js delete mode 100644 packages/angular/build/es2015/lazy/src/providers/animation-controller.js delete mode 100644 packages/angular/build/es2015/lazy/src/providers/gesture-controller.js delete mode 100644 packages/angular/build/es2015/lazy/src/providers/loading-controller.js delete mode 100644 packages/angular/build/es2015/lazy/src/providers/menu-controller.js delete mode 100644 packages/angular/build/es2015/lazy/src/providers/modal-controller.js delete mode 100644 packages/angular/build/es2015/lazy/src/providers/popover-controller.js delete mode 100644 packages/angular/build/es2015/lazy/src/providers/toast-controller.js delete mode 100644 packages/angular/build/es2015/standalone/src/directives/angular-component-lib/utils.js delete mode 100644 packages/angular/build/es2015/standalone/src/directives/checkbox.js delete mode 100644 packages/angular/build/es2015/standalone/src/directives/datetime.js delete mode 100644 packages/angular/build/es2015/standalone/src/directives/icon.js delete mode 100644 packages/angular/build/es2015/standalone/src/directives/index.js delete mode 100644 packages/angular/build/es2015/standalone/src/directives/input-otp.js delete mode 100644 packages/angular/build/es2015/standalone/src/directives/input.js delete mode 100644 packages/angular/build/es2015/standalone/src/directives/proxies.js delete mode 100644 packages/angular/build/es2015/standalone/src/directives/radio-group.js delete mode 100644 packages/angular/build/es2015/standalone/src/directives/range.js delete mode 100644 packages/angular/build/es2015/standalone/src/directives/searchbar.js delete mode 100644 packages/angular/build/es2015/standalone/src/directives/segment.js delete mode 100644 packages/angular/build/es2015/standalone/src/directives/select.js delete mode 100644 packages/angular/build/es2015/standalone/src/directives/textarea.js delete mode 100644 packages/angular/build/es2015/standalone/src/directives/toggle.js delete mode 100644 packages/angular/build/es2015/standalone/src/index.js delete mode 100644 packages/angular/build/es2015/standalone/src/navigation/back-button.js delete mode 100644 packages/angular/build/es2015/standalone/src/navigation/nav.js delete mode 100644 packages/angular/build/es2015/standalone/src/navigation/router-link-delegate.js delete mode 100644 packages/angular/build/es2015/standalone/src/navigation/router-outlet.js delete mode 100644 packages/angular/build/es2015/standalone/src/navigation/tabs.js delete mode 100644 packages/angular/build/es2015/standalone/src/overlays/modal.js delete mode 100644 packages/angular/build/es2015/standalone/src/overlays/popover.js delete mode 100644 packages/angular/build/es2015/standalone/src/providers/action-sheet-controller.js delete mode 100644 packages/angular/build/es2015/standalone/src/providers/alert-controller.js delete mode 100644 packages/angular/build/es2015/standalone/src/providers/animation-controller.js delete mode 100644 packages/angular/build/es2015/standalone/src/providers/gesture-controller.js delete mode 100644 packages/angular/build/es2015/standalone/src/providers/ionic-angular.js delete mode 100644 packages/angular/build/es2015/standalone/src/providers/loading-controller.js delete mode 100644 packages/angular/build/es2015/standalone/src/providers/menu-controller.js delete mode 100644 packages/angular/build/es2015/standalone/src/providers/modal-controller.js delete mode 100644 packages/angular/build/es2015/standalone/src/providers/popover-controller.js delete mode 100644 packages/angular/build/es2015/standalone/src/providers/toast-controller.js diff --git a/packages/angular/build/es2015/common/src/directives/control-value-accessors/index.js b/packages/angular/build/es2015/common/src/directives/control-value-accessors/index.js deleted file mode 100644 index e00caae1aca..00000000000 --- a/packages/angular/build/es2015/common/src/directives/control-value-accessors/index.js +++ /dev/null @@ -1 +0,0 @@ -export * from './value-accessor'; diff --git a/packages/angular/build/es2015/common/src/directives/control-value-accessors/value-accessor.js b/packages/angular/build/es2015/common/src/directives/control-value-accessors/value-accessor.js deleted file mode 100644 index 06c2d002a9d..00000000000 --- a/packages/angular/build/es2015/common/src/directives/control-value-accessors/value-accessor.js +++ /dev/null @@ -1,146 +0,0 @@ -import { __decorate } from "tslib"; -import { Directive, HostListener } from '@angular/core'; -import { NgControl } from '@angular/forms'; -import { raf } from '../../utils/util'; -// TODO(FW-2827): types -let ValueAccessor = class ValueAccessor { - constructor(injector, elementRef) { - this.injector = injector; - this.elementRef = elementRef; - this.onChange = () => { - /**/ - }; - this.onTouched = () => { - /**/ - }; - } - writeValue(value) { - this.elementRef.nativeElement.value = this.lastValue = value; - setIonicClasses(this.elementRef); - } - /** - * Notifies the ControlValueAccessor of a change in the value of the control. - * - * This is called by each of the ValueAccessor directives when we want to update - * the status and validity of the form control. For example with text components this - * is called when the ionInput event is fired. For select components this is called - * when the ionChange event is fired. - * - * This also updates the Ionic form status classes on the element. - * - * @param el The component element. - * @param value The new value of the control. - */ - handleValueChange(el, value) { - if (el === this.elementRef.nativeElement) { - if (value !== this.lastValue) { - this.lastValue = value; - this.onChange(value); - } - setIonicClasses(this.elementRef); - } - } - _handleBlurEvent(el) { - if (el === this.elementRef.nativeElement) { - this.onTouched(); - setIonicClasses(this.elementRef); - // When ion-radio is blurred, el and this.elementRef.nativeElement are - // different so we need to check if the closest ion-radio-group is the same - // as this.elementRef.nativeElement and if so, we need to mark the radio group - // as touched - } - else if (el.closest('ion-radio-group') === this.elementRef.nativeElement) { - this.onTouched(); - } - } - registerOnChange(fn) { - this.onChange = fn; - } - registerOnTouched(fn) { - this.onTouched = fn; - } - setDisabledState(isDisabled) { - this.elementRef.nativeElement.disabled = isDisabled; - } - ngOnDestroy() { - if (this.statusChanges) { - this.statusChanges.unsubscribe(); - } - } - ngAfterViewInit() { - let ngControl; - try { - ngControl = this.injector.get(NgControl); - } - catch (_a) { - /* No FormControl or ngModel binding */ - } - if (!ngControl) { - return; - } - // Listen for changes in validity, disabled, or pending states - if (ngControl.statusChanges) { - this.statusChanges = ngControl.statusChanges.subscribe(() => setIonicClasses(this.elementRef)); - } - /** - * TODO FW-2787: Remove this in favor of https://github.com/angular/angular/issues/10887 - * whenever it is implemented. - */ - const formControl = ngControl.control; - if (formControl) { - const methodsToPatch = ['markAsTouched', 'markAllAsTouched', 'markAsUntouched', 'markAsDirty', 'markAsPristine']; - methodsToPatch.forEach((method) => { - if (typeof formControl[method] !== 'undefined') { - const oldFn = formControl[method].bind(formControl); - formControl[method] = (...params) => { - oldFn(...params); - setIonicClasses(this.elementRef); - }; - } - }); - } - } -}; -__decorate([ - HostListener('ionBlur', ['$event.target']) -], ValueAccessor.prototype, "_handleBlurEvent", null); -ValueAccessor = __decorate([ - Directive() -], ValueAccessor); -export { ValueAccessor }; -export const setIonicClasses = (element) => { - raf(() => { - const input = element.nativeElement; - const hasValue = input.value != null && input.value.toString().length > 0; - const classes = getClasses(input); - setClasses(input, classes); - const item = input.closest('ion-item'); - if (item) { - if (hasValue) { - setClasses(item, [...classes, 'item-has-value']); - } - else { - setClasses(item, classes); - } - } - }); -}; -const getClasses = (element) => { - const classList = element.classList; - const classes = []; - for (let i = 0; i < classList.length; i++) { - const item = classList.item(i); - if (item !== null && startsWith(item, 'ng-')) { - classes.push(`ion-${item.substring(3)}`); - } - } - return classes; -}; -const setClasses = (element, classes) => { - const classList = element.classList; - classList.remove('ion-valid', 'ion-invalid', 'ion-touched', 'ion-untouched', 'ion-dirty', 'ion-pristine'); - classList.add(...classes); -}; -const startsWith = (input, search) => { - return input.substring(0, search.length) === search; -}; diff --git a/packages/angular/build/es2015/common/src/directives/navigation/back-button.js b/packages/angular/build/es2015/common/src/directives/navigation/back-button.js deleted file mode 100644 index d3e245dbe3c..00000000000 --- a/packages/angular/build/es2015/common/src/directives/navigation/back-button.js +++ /dev/null @@ -1,45 +0,0 @@ -import { __decorate, __param } from "tslib"; -import { HostListener, Optional, Directive } from '@angular/core'; -import { ProxyCmp } from '../../utils/proxy'; -const BACK_BUTTON_INPUTS = ['color', 'defaultHref', 'disabled', 'icon', 'mode', 'routerAnimation', 'text', 'type']; -let IonBackButton = class IonBackButton { - constructor(routerOutlet, navCtrl, config, r, z, c) { - this.routerOutlet = routerOutlet; - this.navCtrl = navCtrl; - this.config = config; - this.r = r; - this.z = z; - c.detach(); - this.el = this.r.nativeElement; - } - /** - * @internal - */ - onClick(ev) { - var _a; - const defaultHref = this.defaultHref || this.config.get('backButtonDefaultHref'); - if ((_a = this.routerOutlet) === null || _a === void 0 ? void 0 : _a.canGoBack()) { - this.navCtrl.setDirection('back', undefined, undefined, this.routerAnimation); - this.routerOutlet.pop(); - ev.preventDefault(); - } - else if (defaultHref != null) { - this.navCtrl.navigateBack(defaultHref, { animation: this.routerAnimation }); - ev.preventDefault(); - } - } -}; -__decorate([ - HostListener('click', ['$event']) -], IonBackButton.prototype, "onClick", null); -IonBackButton = __decorate([ - ProxyCmp({ - inputs: BACK_BUTTON_INPUTS, - }), - Directive({ - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: BACK_BUTTON_INPUTS, - }), - __param(0, Optional()) -], IonBackButton); -export { IonBackButton }; diff --git a/packages/angular/build/es2015/common/src/directives/navigation/nav-params.js b/packages/angular/build/es2015/common/src/directives/navigation/nav-params.js deleted file mode 100644 index 9c274ae4f49..00000000000 --- a/packages/angular/build/es2015/common/src/directives/navigation/nav-params.js +++ /dev/null @@ -1,45 +0,0 @@ -/** - * @description - * NavParams are an object that exists on a page and can contain data for that particular view. - * Similar to how data was pass to a view in V1 with `$stateParams`, NavParams offer a much more flexible - * option with a simple `get` method. - * - * @usage - * ```ts - * import { NavParams } from '@ionic/angular'; - * - * export class MyClass{ - * - * constructor(navParams: NavParams){ - * // userParams is an object we have in our nav-parameters - * navParams.get('userParams'); - * } - * - * } - * ``` - */ -export class NavParams { - constructor(data = {}) { - this.data = data; - console.warn(`[Ionic Warning]: NavParams has been deprecated in favor of using Angular's input API. Developers should migrate to either the @Input decorator or the Signals-based input API.`); - } - /** - * Get the value of a nav-parameter for the current view - * - * ```ts - * import { NavParams } from 'ionic-angular'; - * - * export class MyClass{ - * constructor(public navParams: NavParams){ - * // userParams is an object we have in our nav-parameters - * this.navParams.get('userParams'); - * } - * } - * ``` - * - * @param param Which param you want to look up - */ - get(param) { - return this.data[param]; - } -} diff --git a/packages/angular/build/es2015/common/src/directives/navigation/nav.js b/packages/angular/build/es2015/common/src/directives/navigation/nav.js deleted file mode 100644 index 9a5c62f4a81..00000000000 --- a/packages/angular/build/es2015/common/src/directives/navigation/nav.js +++ /dev/null @@ -1,39 +0,0 @@ -import { __decorate } from "tslib"; -import { Directive, } from '@angular/core'; -import { ProxyCmp, proxyOutputs } from '../../utils/proxy'; -const NAV_INPUTS = ['animated', 'animation', 'root', 'rootParams', 'swipeGesture']; -const NAV_METHODS = [ - 'push', - 'insert', - 'insertPages', - 'pop', - 'popTo', - 'popToRoot', - 'removeIndex', - 'setRoot', - 'setPages', - 'getActive', - 'getByIndex', - 'canGoBack', - 'getPrevious', -]; -let IonNav = class IonNav { - constructor(ref, environmentInjector, injector, angularDelegate, z, c) { - this.z = z; - c.detach(); - this.el = ref.nativeElement; - ref.nativeElement.delegate = angularDelegate.create(environmentInjector, injector); - proxyOutputs(this, this.el, ['ionNavDidChange', 'ionNavWillChange']); - } -}; -IonNav = __decorate([ - ProxyCmp({ - inputs: NAV_INPUTS, - methods: NAV_METHODS, - }), - Directive({ - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: NAV_INPUTS, - }) -], IonNav); -export { IonNav }; diff --git a/packages/angular/build/es2015/common/src/directives/navigation/router-link-delegate.js b/packages/angular/build/es2015/common/src/directives/navigation/router-link-delegate.js deleted file mode 100644 index a1231552e7d..00000000000 --- a/packages/angular/build/es2015/common/src/directives/navigation/router-link-delegate.js +++ /dev/null @@ -1,172 +0,0 @@ -import { __decorate, __param } from "tslib"; -import { Directive, HostListener, Input, Optional } from '@angular/core'; -/** - * Adds support for Ionic routing directions and animations to the base Angular router link directive. - * - * When the router link is clicked, the directive will assign the direction and - * animation so that the routing integration will transition correctly. - */ -let RouterLinkDelegateDirective = class RouterLinkDelegateDirective { - constructor(locationStrategy, navCtrl, elementRef, router, routerLink) { - this.locationStrategy = locationStrategy; - this.navCtrl = navCtrl; - this.elementRef = elementRef; - this.router = router; - this.routerLink = routerLink; - this.routerDirection = 'forward'; - this.onCaptureClick = (ev) => { - if (this.opensNatively(ev)) { - ev.stopImmediatePropagation(); - } - }; - } - ngOnInit() { - this.updateTargetUrlAndHref(); - this.updateTabindex(); - /** - * Ionic components like `ion-item` render a native anchor in their shadow DOM, - * so a modifier click (ctrl/meta/shift/alt) or a non-`_self` target should let - * the browser handle the navigation natively (new tab, new window, download) - * instead of navigating in-app. - * - * We listen in the capture phase so this runs before Angular's `RouterLink` - * handler and our own bubble-phase `onClick`. On a native-navigation intent it - * stops propagation to cancel the in-app navigation, but leaves `preventDefault` - * alone so the native anchor can still act. - */ - this.elementRef.nativeElement.addEventListener('click', this.onCaptureClick, { capture: true }); - } - ngOnChanges() { - this.updateTargetUrlAndHref(); - } - ngOnDestroy() { - this.elementRef.nativeElement.removeEventListener('click', this.onCaptureClick, { capture: true }); - } - /** - * True when the browser should handle the click natively instead of routing - * in-app: a modifier was held (ctrl/meta/shift/alt), or the host targets - * something other than `_self`. This mirrors the modifier set Angular's own - * `RouterLink` guards on, so an Ionic `routerLink` behaves like a plain anchor - * for new-tab, new-window, and download intents. - */ - opensNatively(ev) { - if (ev instanceof MouseEvent && (ev.ctrlKey || ev.metaKey || ev.shiftKey || ev.altKey)) { - return true; - } - const target = this.elementRef.nativeElement.target; - return target != null && target !== '' && target !== '_self'; - } - /** - * The `tabindex` is set to `0` by default on the host element when - * the `routerLink` directive is used. This causes issues with Ionic - * components that wrap an `a` or `button` element, such as `ion-item`. - * See issue https://github.com/angular/angular/issues/28345 - * - * This method removes the `tabindex` attribute from the host element - * to allow the Ionic component to manage the focus state correctly. - */ - updateTabindex() { - // Ionic components that render a native anchor or button element - const ionicComponents = [ - 'ION-BACK-BUTTON', - 'ION-BREADCRUMB', - 'ION-BUTTON', - 'ION-CARD', - 'ION-FAB-BUTTON', - 'ION-ITEM', - 'ION-ITEM-OPTION', - 'ION-MENU-BUTTON', - 'ION-SEGMENT-BUTTON', - 'ION-TAB-BUTTON', - ]; - const hostElement = this.elementRef.nativeElement; - if (ionicComponents.includes(hostElement.tagName)) { - if (hostElement.getAttribute('tabindex') === '0') { - hostElement.removeAttribute('tabindex'); - } - } - } - updateTargetUrlAndHref() { - var _a; - if ((_a = this.routerLink) === null || _a === void 0 ? void 0 : _a.urlTree) { - const href = this.locationStrategy.prepareExternalUrl(this.router.serializeUrl(this.routerLink.urlTree)); - this.elementRef.nativeElement.href = href; - } - } - /** - * @internal - */ - onClick(ev) { - this.navCtrl.setDirection(this.routerDirection, undefined, undefined, this.routerAnimation); - /** - * This prevents the browser from - * performing a page reload when pressing - * an Ionic component with routerLink. - * The page reload interferes with routing - * and causes ion-back-button to disappear - * since the local history is wiped on reload. - */ - ev.preventDefault(); - } -}; -__decorate([ - Input() -], RouterLinkDelegateDirective.prototype, "routerDirection", void 0); -__decorate([ - Input() -], RouterLinkDelegateDirective.prototype, "routerAnimation", void 0); -__decorate([ - HostListener('click', ['$event']) -], RouterLinkDelegateDirective.prototype, "onClick", null); -RouterLinkDelegateDirective = __decorate([ - Directive({ - selector: ':not(a):not(area)[routerLink]', - }), - __param(4, Optional()) -], RouterLinkDelegateDirective); -export { RouterLinkDelegateDirective }; -let RouterLinkWithHrefDelegateDirective = class RouterLinkWithHrefDelegateDirective { - constructor(locationStrategy, navCtrl, elementRef, router, routerLink) { - this.locationStrategy = locationStrategy; - this.navCtrl = navCtrl; - this.elementRef = elementRef; - this.router = router; - this.routerLink = routerLink; - this.routerDirection = 'forward'; - } - ngOnInit() { - this.updateTargetUrlAndHref(); - } - ngOnChanges() { - this.updateTargetUrlAndHref(); - } - updateTargetUrlAndHref() { - var _a; - if ((_a = this.routerLink) === null || _a === void 0 ? void 0 : _a.urlTree) { - const href = this.locationStrategy.prepareExternalUrl(this.router.serializeUrl(this.routerLink.urlTree)); - this.elementRef.nativeElement.href = href; - } - } - /** - * @internal - */ - onClick() { - this.navCtrl.setDirection(this.routerDirection, undefined, undefined, this.routerAnimation); - } -}; -__decorate([ - Input() -], RouterLinkWithHrefDelegateDirective.prototype, "routerDirection", void 0); -__decorate([ - Input() -], RouterLinkWithHrefDelegateDirective.prototype, "routerAnimation", void 0); -__decorate([ - HostListener('click') -], RouterLinkWithHrefDelegateDirective.prototype, "onClick", null); -RouterLinkWithHrefDelegateDirective = __decorate([ - Directive({ - selector: 'a[routerLink],area[routerLink]', - }), - __param(4, Optional()) -], RouterLinkWithHrefDelegateDirective); -export { RouterLinkWithHrefDelegateDirective }; diff --git a/packages/angular/build/es2015/common/src/directives/navigation/router-outlet.js b/packages/angular/build/es2015/common/src/directives/navigation/router-outlet.js deleted file mode 100644 index 1e05bbadb5b..00000000000 --- a/packages/angular/build/es2015/common/src/directives/navigation/router-outlet.js +++ /dev/null @@ -1,462 +0,0 @@ -import { __decorate, __param } from "tslib"; -import { ViewContainerRef, inject, Attribute, Directive, EventEmitter, Optional, Output, SkipSelf, EnvironmentInjector, Input, InjectionToken, Injectable, reflectComponentType, } from '@angular/core'; -import { Router, ActivatedRoute, ChildrenOutletContexts, PRIMARY_OUTLET } from '@angular/router'; -import { componentOnReady } from '@ionic/core/components'; -import { BehaviorSubject, combineLatest, of } from 'rxjs'; -import { distinctUntilChanged, filter, switchMap } from 'rxjs/operators'; -import { Config } from '../../providers/config'; -import { NavController } from '../../providers/nav-controller'; -import { StackController } from './stack-controller'; -import { getUrl, isTabSwitch } from './stack-utils'; -// TODO(FW-2827): types -let IonRouterOutlet = class IonRouterOutlet { - /** @internal */ - get activatedComponentRef() { - return this.activated; - } - set animation(animation) { - this.nativeEl.animation = animation; - } - set animated(animated) { - this.nativeEl.animated = animated; - } - set swipeGesture(swipe) { - this._swipeGesture = swipe; - this.nativeEl.swipeHandler = swipe - ? { - canStart: () => this.stackCtrl.canGoBack(1) && !this.stackCtrl.hasRunningTask(), - onStart: () => this.stackCtrl.startBackTransition(), - onEnd: (shouldContinue) => this.stackCtrl.endBackTransition(shouldContinue), - } - : undefined; - this.nativeEl.swipeGesture = swipe; - } - constructor(name, tabs, commonLocation, elementRef, router, zone, activatedRoute, parentOutlet) { - this.parentOutlet = parentOutlet; - this.activatedView = null; - // Maintain map of activated route proxies for each component instance - this.proxyMap = new WeakMap(); - // Keep the latest activated route in a subject for the proxy routes to switch map to - this.currentActivatedRoute$ = new BehaviorSubject(null); - this.activated = null; - this._activatedRoute = null; - /** - * The name of the outlet - */ - this.name = PRIMARY_OUTLET; - /** @internal */ - this.stackWillChange = new EventEmitter(); - /** @internal */ - this.stackDidChange = new EventEmitter(); - // eslint-disable-next-line @angular-eslint/no-output-rename - this.activateEvents = new EventEmitter(); - // eslint-disable-next-line @angular-eslint/no-output-rename - this.deactivateEvents = new EventEmitter(); - this.parentContexts = inject(ChildrenOutletContexts); - this.location = inject(ViewContainerRef); - this.environmentInjector = inject(EnvironmentInjector); - this.inputBinder = inject(INPUT_BINDER, { optional: true }); - /** @nodoc */ - this.supportsBindingToComponentInputs = true; - // Ionic providers - this.config = inject(Config); - this.navCtrl = inject(NavController); - this.nativeEl = elementRef.nativeElement; - this.name = name || PRIMARY_OUTLET; - this.tabsPrefix = tabs === 'true' ? getUrl(router, activatedRoute) : undefined; - this.stackCtrl = new StackController(this.tabsPrefix, this.nativeEl, router, this.navCtrl, zone, commonLocation); - this.parentContexts.onChildOutletCreated(this.name, this); - } - ngOnDestroy() { - var _a; - this.stackCtrl.destroy(); - (_a = this.inputBinder) === null || _a === void 0 ? void 0 : _a.unsubscribeFromRouteData(this); - } - getContext() { - return this.parentContexts.getContext(this.name); - } - ngOnInit() { - this.initializeOutletWithName(); - } - // Note: Ionic deviates from the Angular Router implementation here - initializeOutletWithName() { - if (!this.activated) { - // If the outlet was not instantiated at the time the route got activated we need to populate - // the outlet when it is initialized (ie inside a NgIf) - const context = this.getContext(); - if (context === null || context === void 0 ? void 0 : context.route) { - this.activateWith(context.route, context.injector); - } - } - new Promise((resolve) => componentOnReady(this.nativeEl, resolve)).then(() => { - if (this._swipeGesture === undefined) { - this.swipeGesture = this.config.getBoolean('swipeBackEnabled', this.nativeEl.mode === 'ios'); - } - }); - } - get isActivated() { - return !!this.activated; - } - get component() { - if (!this.activated) { - throw new Error('Outlet is not activated'); - } - return this.activated.instance; - } - get activatedRoute() { - if (!this.activated) { - throw new Error('Outlet is not activated'); - } - return this._activatedRoute; - } - get activatedRouteData() { - if (this._activatedRoute) { - return this._activatedRoute.snapshot.data; - } - return {}; - } - /** - * Called when the `RouteReuseStrategy` instructs to detach the subtree - */ - detach() { - throw new Error('incompatible reuse strategy'); - } - /** - * Called when the `RouteReuseStrategy` instructs to re-attach a previously detached subtree - */ - // eslint-disable-next-line @typescript-eslint/no-unused-vars - attach(_ref, _activatedRoute) { - throw new Error('incompatible reuse strategy'); - } - deactivate() { - if (this.activated) { - if (this.activatedView) { - const context = this.getContext(); - this.activatedView.savedData = new Map(context.children['contexts']); - /** - * Angular v11.2.10 introduced a change - * where this route context is cleared out when - * a router-outlet is deactivated, However, - * we need this route information in order to - * return a user back to the correct tab when - * leaving and then going back to the tab context. - */ - const primaryOutlet = this.activatedView.savedData.get('primary'); - if (primaryOutlet && context.route) { - primaryOutlet.route = Object.assign({}, context.route); - } - /** - * Ensure we are saving the NavigationExtras - * data otherwise it will be lost - */ - this.activatedView.savedExtras = {}; - if (context.route) { - const contextSnapshot = context.route.snapshot; - this.activatedView.savedExtras.queryParams = contextSnapshot.queryParams; - this.activatedView.savedExtras.fragment = contextSnapshot.fragment; - } - } - const c = this.component; - this.activatedView = null; - this.activated = null; - this._activatedRoute = null; - this.deactivateEvents.emit(c); - } - } - activateWith(activatedRoute, environmentInjector) { - var _a, _b; - if (this.isActivated) { - throw new Error('Cannot activate an already activated outlet'); - } - this._activatedRoute = activatedRoute; - let cmpRef; - let enteringView = this.stackCtrl.getExistingView(activatedRoute); - if (enteringView) { - cmpRef = this.activated = enteringView.ref; - const saved = enteringView.savedData; - if (saved) { - // self-restore - const context = this.getContext(); - context.children['contexts'] = saved; - } - // Updated activated route proxy for this component - this.updateActivatedRouteProxy(cmpRef.instance, activatedRoute); - } - else { - const snapshot = activatedRoute._futureSnapshot; - /** - * Angular 14 introduces a new `loadComponent` property to the route config. - * This function will assign a `component` property to the route snapshot. - * We check for the presence of this property to determine if the route is - * using standalone components. - */ - const childContexts = this.parentContexts.getOrCreateContext(this.name).children; - // We create an activated route proxy object that will maintain future updates for this component - // over its lifecycle in the stack. - const component$ = new BehaviorSubject(null); - const activatedRouteProxy = this.createActivatedRouteProxy(component$, activatedRoute); - const injector = new OutletInjector(activatedRouteProxy, childContexts, this.location.injector); - const component = (_a = snapshot.routeConfig.component) !== null && _a !== void 0 ? _a : snapshot.component; - /** - * View components need to be added as a child of ion-router-outlet - * for page transitions and swipe to go back. - * However, createComponent mounts components as siblings of the - * ViewContainerRef. As a result, outletContent must reference - * an ng-container inside of ion-router-outlet and not - * ion-router-outlet itself. - */ - cmpRef = this.activated = this.outletContent.createComponent(component, { - index: this.outletContent.length, - injector, - environmentInjector: environmentInjector !== null && environmentInjector !== void 0 ? environmentInjector : this.environmentInjector, - }); - // Once the component is created we can push it to our local subject supplied to the proxy - component$.next(cmpRef.instance); - // Calling `markForCheck` to make sure we will run the change detection when the - // `RouterOutlet` is inside a `ChangeDetectionStrategy.OnPush` component. - /** - * At this point this.activated has been set earlier - * in this function, so it is guaranteed to be non-null. - */ - enteringView = this.stackCtrl.createView(this.activated, activatedRoute); - // Store references to the proxy by component - this.proxyMap.set(cmpRef.instance, activatedRouteProxy); - this.currentActivatedRoute$.next({ component: cmpRef.instance, activatedRoute }); - } - (_b = this.inputBinder) === null || _b === void 0 ? void 0 : _b.bindActivatedRouteToOutletComponent(this); - this.activatedView = enteringView; - /** - * The top outlet is set prior to the entering view's transition completing, - * so that when we have nested outlets (e.g. ion-tabs inside an ion-router-outlet), - * the tabs outlet will be assigned as the top outlet when a view inside tabs is - * activated. - * - * In this scenario, activeWith is called for both the tabs and the root router outlet. - * To avoid a race condition, we assign the top outlet synchronously. - */ - this.navCtrl.setTopOutlet(this); - const leavingView = this.stackCtrl.getActiveView(); - this.stackWillChange.emit({ - enteringView, - tabSwitch: isTabSwitch(enteringView, leavingView), - }); - this.stackCtrl.setActive(enteringView).then((data) => { - this.activateEvents.emit(cmpRef.instance); - this.stackDidChange.emit(data); - }); - } - /** - * Returns `true` if there are pages in the stack to go back. - */ - canGoBack(deep = 1, stackId) { - return this.stackCtrl.canGoBack(deep, stackId); - } - /** - * Resolves to `true` if it the outlet was able to sucessfully pop the last N pages. - */ - pop(deep = 1, stackId) { - return this.stackCtrl.pop(deep, stackId); - } - /** - * Returns the URL of the active page of each stack. - */ - getLastUrl(stackId) { - const active = this.stackCtrl.getLastUrl(stackId); - return active ? active.url : undefined; - } - /** - * Returns the RouteView of the active page of each stack. - * @internal - */ - getLastRouteView(stackId) { - return this.stackCtrl.getLastUrl(stackId); - } - /** - * Returns the root view in the tab stack. - * @internal - */ - getRootView(stackId) { - return this.stackCtrl.getRootUrl(stackId); - } - /** - * Returns the active stack ID. In the context of ion-tabs, it means the active tab. - */ - getActiveStackId() { - return this.stackCtrl.getActiveStackId(); - } - /** - * Since the activated route can change over the life time of a component in an ion router outlet, we create - * a proxy so that we can update the values over time as a user navigates back to components already in the stack. - */ - createActivatedRouteProxy(component$, activatedRoute) { - const proxy = new ActivatedRoute(); - proxy._futureSnapshot = activatedRoute._futureSnapshot; - proxy._routerState = activatedRoute._routerState; - proxy.snapshot = activatedRoute.snapshot; - proxy.outlet = activatedRoute.outlet; - proxy.component = activatedRoute.component; - // Setup wrappers for the observables so consumers don't have to worry about switching to new observables as the state updates - proxy._paramMap = this.proxyObservable(component$, 'paramMap'); - proxy._queryParamMap = this.proxyObservable(component$, 'queryParamMap'); - proxy.url = this.proxyObservable(component$, 'url'); - proxy.params = this.proxyObservable(component$, 'params'); - proxy.queryParams = this.proxyObservable(component$, 'queryParams'); - proxy.fragment = this.proxyObservable(component$, 'fragment'); - proxy.data = this.proxyObservable(component$, 'data'); - return proxy; - } - /** - * Create a wrapped observable that will switch to the latest activated route matched by the given component - */ - proxyObservable(component$, path) { - return component$.pipe( - // First wait until the component instance is pushed - filter((component) => !!component), switchMap((component) => this.currentActivatedRoute$.pipe(filter((current) => current !== null && current.component === component), switchMap((current) => current && current.activatedRoute[path]), distinctUntilChanged()))); - } - /** - * Updates the activated route proxy for the given component to the new incoming router state - */ - updateActivatedRouteProxy(component, activatedRoute) { - const proxy = this.proxyMap.get(component); - if (!proxy) { - throw new Error(`Could not find activated route proxy for view`); - } - proxy._futureSnapshot = activatedRoute._futureSnapshot; - proxy._routerState = activatedRoute._routerState; - proxy.snapshot = activatedRoute.snapshot; - proxy.outlet = activatedRoute.outlet; - proxy.component = activatedRoute.component; - this.currentActivatedRoute$.next({ component, activatedRoute }); - } -}; -__decorate([ - Input() -], IonRouterOutlet.prototype, "name", void 0); -__decorate([ - Output() -], IonRouterOutlet.prototype, "stackWillChange", void 0); -__decorate([ - Output() -], IonRouterOutlet.prototype, "stackDidChange", void 0); -__decorate([ - Output('activate') -], IonRouterOutlet.prototype, "activateEvents", void 0); -__decorate([ - Output('deactivate') -], IonRouterOutlet.prototype, "deactivateEvents", void 0); -IonRouterOutlet = __decorate([ - Directive({ - selector: 'ion-router-outlet', - exportAs: 'outlet', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['animated', 'animation', 'mode', 'swipeGesture'], - }), - __param(0, Attribute('name')), - __param(1, Optional()), - __param(1, Attribute('tabs')), - __param(7, SkipSelf()), - __param(7, Optional()) -], IonRouterOutlet); -export { IonRouterOutlet }; -class OutletInjector { - constructor(route, childContexts, parent) { - this.route = route; - this.childContexts = childContexts; - this.parent = parent; - } - get(token, notFoundValue) { - if (token === ActivatedRoute) { - return this.route; - } - if (token === ChildrenOutletContexts) { - return this.childContexts; - } - return this.parent.get(token, notFoundValue); - } -} -// TODO: FW-4785 - Remove this once Angular 15 support is dropped -const INPUT_BINDER = new InjectionToken(''); -/** - * Injectable used as a tree-shakable provider for opting in to binding router data to component - * inputs. - * - * The RouterOutlet registers itself with this service when an `ActivatedRoute` is attached or - * activated. When this happens, the service subscribes to the `ActivatedRoute` observables (params, - * queryParams, data) and sets the inputs of the component using `ComponentRef.setInput`. - * Importantly, when an input does not have an item in the route data with a matching key, this - * input is set to `undefined`. If it were not done this way, the previous information would be - * retained if the data got removed from the route (i.e. if a query parameter is removed). - * - * The `RouterOutlet` should unregister itself when destroyed via `unsubscribeFromRouteData` so that - * the subscriptions are cleaned up. - */ -let RoutedComponentInputBinder = class RoutedComponentInputBinder { - constructor() { - this.outletDataSubscriptions = new Map(); - } - bindActivatedRouteToOutletComponent(outlet) { - this.unsubscribeFromRouteData(outlet); - this.subscribeToRouteData(outlet); - } - unsubscribeFromRouteData(outlet) { - var _a; - (_a = this.outletDataSubscriptions.get(outlet)) === null || _a === void 0 ? void 0 : _a.unsubscribe(); - this.outletDataSubscriptions.delete(outlet); - } - subscribeToRouteData(outlet) { - const { activatedRoute } = outlet; - const dataSubscription = combineLatest([activatedRoute.queryParams, activatedRoute.params, activatedRoute.data]) - .pipe(switchMap(([queryParams, params, data], index) => { - data = Object.assign(Object.assign(Object.assign({}, queryParams), params), data); - // Get the first result from the data subscription synchronously so it's available to - // the component as soon as possible (and doesn't require a second change detection). - if (index === 0) { - return of(data); - } - // Promise.resolve is used to avoid synchronously writing the wrong data when - // two of the Observables in the `combineLatest` stream emit one after - // another. - return Promise.resolve(data); - })) - .subscribe((data) => { - // Outlet may have been deactivated or changed names to be associated with a different - // route - if (!outlet.isActivated || - !outlet.activatedComponentRef || - outlet.activatedRoute !== activatedRoute || - activatedRoute.component === null) { - this.unsubscribeFromRouteData(outlet); - return; - } - const mirror = reflectComponentType(activatedRoute.component); - if (!mirror) { - this.unsubscribeFromRouteData(outlet); - return; - } - for (const { templateName } of mirror.inputs) { - outlet.activatedComponentRef.setInput(templateName, data[templateName]); - } - }); - this.outletDataSubscriptions.set(outlet, dataSubscription); - } -}; -RoutedComponentInputBinder = __decorate([ - Injectable() -], RoutedComponentInputBinder); -export const provideComponentInputBinding = () => { - return { - provide: INPUT_BINDER, - useFactory: componentInputBindingFactory, - deps: [Router], - }; -}; -function componentInputBindingFactory(router) { - /** - * We cast the router to any here, since the componentInputBindingEnabled - * property is not available until Angular v16. - */ - if (router === null || router === void 0 ? void 0 : router.componentInputBindingEnabled) { - return new RoutedComponentInputBinder(); - } - return null; -} diff --git a/packages/angular/build/es2015/common/src/directives/navigation/stack-controller.js b/packages/angular/build/es2015/common/src/directives/navigation/stack-controller.js deleted file mode 100644 index a0572ffeda9..00000000000 --- a/packages/angular/build/es2015/common/src/directives/navigation/stack-controller.js +++ /dev/null @@ -1,276 +0,0 @@ -import { __awaiter } from "tslib"; -import { bindLifecycleEvents } from '../../providers/angular-delegate'; -import { computeStackId, destroyView, getUrl, insertView, isTabSwitch, toSegments, } from './stack-utils'; -// TODO(FW-2827): types -export class StackController { - constructor(tabsPrefix, containerEl, router, navCtrl, zone, location) { - this.containerEl = containerEl; - this.router = router; - this.navCtrl = navCtrl; - this.zone = zone; - this.location = location; - this.views = []; - this.skipTransition = false; - this.nextId = 0; - this.tabsPrefix = tabsPrefix !== undefined ? toSegments(tabsPrefix) : undefined; - } - createView(ref, activatedRoute) { - var _a; - const url = getUrl(this.router, activatedRoute); - const element = (_a = ref === null || ref === void 0 ? void 0 : ref.location) === null || _a === void 0 ? void 0 : _a.nativeElement; - const unlistenEvents = bindLifecycleEvents(this.zone, ref.changeDetectorRef, ref.instance, element); - return { - id: this.nextId++, - stackId: computeStackId(this.tabsPrefix, url), - unlistenEvents, - element, - ref, - url, - }; - } - getExistingView(activatedRoute) { - const activatedUrlKey = getUrl(this.router, activatedRoute); - const view = this.views.find((vw) => vw.url === activatedUrlKey); - if (view) { - view.ref.changeDetectorRef.reattach(); - } - return view; - } - setActive(enteringView) { - var _a, _b; - const consumeResult = this.navCtrl.consumeTransition(); - let { direction, animation, animationBuilder } = consumeResult; - const leavingView = this.activeView; - const tabSwitch = isTabSwitch(enteringView, leavingView); - if (tabSwitch) { - direction = 'back'; - animation = undefined; - } - const viewsSnapshot = this.views.slice(); - let currentNavigation; - const router = this.router; - // Angular >= 7.2.0 - if (router.getCurrentNavigation) { - currentNavigation = router.getCurrentNavigation(); - // Angular < 7.2.0 - } - else if ((_a = router.navigations) === null || _a === void 0 ? void 0 : _a.value) { - currentNavigation = router.navigations.value; - } - /** - * If the navigation action - * sets `replaceUrl: true` - * then we need to make sure - * we remove the last item - * from our views stack - */ - if ((_b = currentNavigation === null || currentNavigation === void 0 ? void 0 : currentNavigation.extras) === null || _b === void 0 ? void 0 : _b.replaceUrl) { - if (this.views.length > 0) { - this.views.splice(-1, 1); - } - } - const reused = this.views.includes(enteringView); - const views = this.insertView(enteringView, direction); - // Trigger change detection before transition starts - // This will call ngOnInit() the first time too, just after the view - // was attached to the dom, but BEFORE the transition starts - if (!reused) { - enteringView.ref.changeDetectorRef.detectChanges(); - } - /** - * If we are going back from a page that - * was presented using a custom animation - * we should default to using that - * unless the developer explicitly - * provided another animation. - */ - const customAnimation = enteringView.animationBuilder; - if (animationBuilder === undefined && direction === 'back' && !tabSwitch && customAnimation !== undefined) { - animationBuilder = customAnimation; - } - /** - * Save any custom animation so that navigating - * back will use this custom animation by default. - */ - if (leavingView) { - leavingView.animationBuilder = animationBuilder; - } - // Wait until previous transitions finish - return this.zone.runOutsideAngular(() => { - return this.wait(() => { - // disconnect leaving page from change detection to - // reduce jank during the page transition - if (leavingView) { - leavingView.ref.changeDetectorRef.detach(); - } - // In case the enteringView is the same as the leavingPage we need to reattach() - enteringView.ref.changeDetectorRef.reattach(); - return this.transition(enteringView, leavingView, animation, this.canGoBack(1), false, animationBuilder) - .then(() => cleanupAsync(enteringView, views, viewsSnapshot, this.location, this.zone)) - .then(() => ({ - enteringView, - direction, - animation, - tabSwitch, - })); - }); - }); - } - canGoBack(deep, stackId = this.getActiveStackId()) { - return this.getStack(stackId).length > deep; - } - pop(deep, stackId = this.getActiveStackId()) { - return this.zone.run(() => { - var _a, _b; - const views = this.getStack(stackId); - if (views.length <= deep) { - return Promise.resolve(false); - } - const view = views[views.length - deep - 1]; - let url = view.url; - const viewSavedData = view.savedData; - if (viewSavedData) { - const primaryOutlet = viewSavedData.get('primary'); - if ((_b = (_a = primaryOutlet === null || primaryOutlet === void 0 ? void 0 : primaryOutlet.route) === null || _a === void 0 ? void 0 : _a._routerState) === null || _b === void 0 ? void 0 : _b.snapshot.url) { - url = primaryOutlet.route._routerState.snapshot.url; - } - } - const { animationBuilder } = this.navCtrl.consumeTransition(); - return this.navCtrl.navigateBack(url, Object.assign(Object.assign({}, view.savedExtras), { animation: animationBuilder })).then(() => true); - }); - } - startBackTransition() { - const leavingView = this.activeView; - if (leavingView) { - const views = this.getStack(leavingView.stackId); - const enteringView = views[views.length - 2]; - const customAnimation = enteringView.animationBuilder; - return this.wait(() => { - return this.transition(enteringView, // entering view - leavingView, // leaving view - 'back', this.canGoBack(2), true, customAnimation); - }); - } - return Promise.resolve(); - } - endBackTransition(shouldComplete) { - if (shouldComplete) { - this.skipTransition = true; - this.pop(1); - } - else if (this.activeView) { - cleanup(this.activeView, this.views, this.views, this.location, this.zone); - } - } - getLastUrl(stackId) { - const views = this.getStack(stackId); - return views.length > 0 ? views[views.length - 1] : undefined; - } - /** - * @internal - */ - getRootUrl(stackId) { - const views = this.getStack(stackId); - return views.length > 0 ? views[0] : undefined; - } - getActiveStackId() { - return this.activeView ? this.activeView.stackId : undefined; - } - /** - * @internal - */ - getActiveView() { - return this.activeView; - } - hasRunningTask() { - return this.runningTask !== undefined; - } - destroy() { - this.containerEl = undefined; - this.views.forEach(destroyView); - this.activeView = undefined; - this.views = []; - } - getStack(stackId) { - return this.views.filter((v) => v.stackId === stackId); - } - insertView(enteringView, direction) { - this.activeView = enteringView; - this.views = insertView(this.views, enteringView, direction); - return this.views.slice(); - } - transition(enteringView, leavingView, direction, showGoBack, progressAnimation, animationBuilder) { - if (this.skipTransition) { - this.skipTransition = false; - return Promise.resolve(false); - } - if (leavingView === enteringView) { - return Promise.resolve(false); - } - const enteringEl = enteringView ? enteringView.element : undefined; - const leavingEl = leavingView ? leavingView.element : undefined; - const containerEl = this.containerEl; - if (enteringEl && enteringEl !== leavingEl) { - enteringEl.classList.add('ion-page'); - enteringEl.classList.add('ion-page-invisible'); - if (containerEl.commit) { - return containerEl.commit(enteringEl, leavingEl, { - duration: direction === undefined ? 0 : undefined, - direction, - showGoBack, - progressAnimation, - animationBuilder, - }); - } - } - return Promise.resolve(false); - } - wait(task) { - return __awaiter(this, void 0, void 0, function* () { - if (this.runningTask !== undefined) { - yield this.runningTask; - this.runningTask = undefined; - } - const promise = (this.runningTask = task()); - promise.finally(() => (this.runningTask = undefined)); - return promise; - }); - } -} -const cleanupAsync = (activeRoute, views, viewsSnapshot, location, zone) => { - if (typeof requestAnimationFrame === 'function') { - return new Promise((resolve) => { - requestAnimationFrame(() => { - cleanup(activeRoute, views, viewsSnapshot, location, zone); - resolve(); - }); - }); - } - return Promise.resolve(); -}; -const cleanup = (activeRoute, views, viewsSnapshot, location, zone) => { - /** - * Re-enter the Angular zone when destroying page components. This will allow - * lifecycle events (`ngOnDestroy`) to be run inside the Angular zone. - */ - zone.run(() => viewsSnapshot.filter((view) => !views.includes(view)).forEach(destroyView)); - views.forEach((view) => { - /** - * In the event that a user navigated multiple - * times in rapid succession, we want to make sure - * we don't pre-emptively detach a view while - * it is in mid-transition. - * - * In this instance we also do not care about query - * params or fragments as it will be the same view regardless - */ - const locationWithoutParams = location.path().split('?')[0]; - const locationWithoutFragment = locationWithoutParams.split('#')[0]; - if (view !== activeRoute && view.url !== locationWithoutFragment) { - const element = view.element; - element.setAttribute('aria-hidden', 'true'); - element.classList.add('ion-page-hidden'); - view.ref.changeDetectorRef.detach(); - } - }); -}; diff --git a/packages/angular/build/es2015/common/src/directives/navigation/stack-utils.js b/packages/angular/build/es2015/common/src/directives/navigation/stack-utils.js deleted file mode 100644 index 28307e82711..00000000000 --- a/packages/angular/build/es2015/common/src/directives/navigation/stack-utils.js +++ /dev/null @@ -1,72 +0,0 @@ -export const insertView = (views, view, direction) => { - if (direction === 'root') { - return setRoot(views, view); - } - else if (direction === 'forward') { - return setForward(views, view); - } - else { - return setBack(views, view); - } -}; -const setRoot = (views, view) => { - views = views.filter((v) => v.stackId !== view.stackId); - views.push(view); - return views; -}; -const setForward = (views, view) => { - const index = views.indexOf(view); - if (index >= 0) { - views = views.filter((v) => v.stackId !== view.stackId || v.id <= view.id); - } - else { - views.push(view); - } - return views; -}; -const setBack = (views, view) => { - const index = views.indexOf(view); - if (index >= 0) { - return views.filter((v) => v.stackId !== view.stackId || v.id <= view.id); - } - else { - return setRoot(views, view); - } -}; -export const getUrl = (router, activatedRoute) => { - const urlTree = router.createUrlTree(['.'], { relativeTo: activatedRoute }); - return router.serializeUrl(urlTree); -}; -export const isTabSwitch = (enteringView, leavingView) => { - if (!leavingView) { - return true; - } - return enteringView.stackId !== leavingView.stackId; -}; -export const computeStackId = (prefixUrl, url) => { - if (!prefixUrl) { - return undefined; - } - const segments = toSegments(url); - for (let i = 0; i < segments.length; i++) { - if (i >= prefixUrl.length) { - return segments[i]; - } - if (segments[i] !== prefixUrl[i]) { - return undefined; - } - } - return undefined; -}; -export const toSegments = (path) => { - return path - .split('/') - .map((s) => s.trim()) - .filter((s) => s !== ''); -}; -export const destroyView = (view) => { - if (view) { - view.ref.destroy(); - view.unlistenEvents(); - } -}; diff --git a/packages/angular/build/es2015/common/src/directives/navigation/tabs.js b/packages/angular/build/es2015/common/src/directives/navigation/tabs.js deleted file mode 100644 index 1dcebfe28ac..00000000000 --- a/packages/angular/build/es2015/common/src/directives/navigation/tabs.js +++ /dev/null @@ -1,277 +0,0 @@ -import { __decorate } from "tslib"; -import { Directive, ElementRef, EventEmitter, HostListener, Output, ViewChild, } from '@angular/core'; -/** - * Extracts `queryParams` and `fragment` from a tab button's href for use - * as Angular `NavigationExtras`. Returns `undefined` when neither is present. - */ -const parseHrefExtras = (href) => { - if (!href) { - return undefined; - } - const hashIndex = href.indexOf('#'); - // Treat a bare `#` (no fragment text) as no fragment. - const fragment = hashIndex >= 0 && hashIndex < href.length - 1 ? href.slice(hashIndex + 1) : undefined; - const beforeHash = hashIndex >= 0 ? href.slice(0, hashIndex) : href; - const queryIndex = beforeHash.indexOf('?'); - const search = queryIndex >= 0 ? beforeHash.slice(queryIndex + 1) : ''; - let queryParams; - if (search) { - const params = new URLSearchParams(search); - queryParams = {}; - for (const key of new Set(params.keys())) { - const all = params.getAll(key); - queryParams[key] = all.length > 1 ? all : all[0]; - } - } - if (!queryParams && fragment === undefined) { - return undefined; - } - /** - * Build the result with only the populated keys so that a spread of the - * returned object does not overwrite saved `queryParams`/`fragment` with - * `undefined` (which `Object.assign`/spread would copy as a real key). - */ - const extras = {}; - if (queryParams) - extras.queryParams = queryParams; - if (fragment !== undefined) - extras.fragment = fragment; - return extras; -}; -let IonTabs = class IonTabs { - constructor(navCtrl) { - this.navCtrl = navCtrl; - /** - * Emitted before the tab view is changed. - */ - this.ionTabsWillChange = new EventEmitter(); - /** - * Emitted after the tab view is changed. - */ - this.ionTabsDidChange = new EventEmitter(); - this.tabBarSlot = 'bottom'; - this.hasTab = false; - } - ngAfterViewInit() { - /** - * Developers must pass at least one ion-tab - * inside of ion-tabs if they want to use a - * basic tab-based navigation without the - * history stack or URL updates associated - * with the router. - */ - const firstTab = this.tabs.length > 0 ? this.tabs.first : undefined; - if (firstTab) { - this.hasTab = true; - this.setActiveTab(firstTab.tab); - this.tabSwitch(); - } - } - ngAfterContentInit() { - this.detectSlotChanges(); - } - ngAfterContentChecked() { - this.detectSlotChanges(); - } - /** - * @internal - */ - onStackWillChange({ enteringView, tabSwitch }) { - const stackId = enteringView.stackId; - if (tabSwitch && stackId !== undefined) { - this.ionTabsWillChange.emit({ tab: stackId }); - } - } - /** - * @internal - */ - onStackDidChange({ enteringView, tabSwitch }) { - const stackId = enteringView.stackId; - if (tabSwitch && stackId !== undefined) { - if (this.tabBar) { - this.tabBar.selectedTab = stackId; - } - this.ionTabsDidChange.emit({ tab: stackId }); - } - } - /** - * Host listener for the `ionTabButtonClick` event. Angular 22 enabled stricter - * host-binding type checking, which types `$event` as the DOM `Event`. That is - * not assignable to `select`'s public `string | CustomEvent` parameter, so this - * thin wrapper narrows the event before forwarding to keep `select`'s public - * signature intact. - */ - onTabButtonClick(ev) { - return this.select(ev); - } - /** - * When a tab button is clicked, there are several scenarios: - * 1. If the selected tab is currently active (the tab button has been clicked - * again), then it should go to the root view for that tab. - * - * a. Get the saved root view from the router outlet. If the saved root view - * matches the tabRootUrl, set the route view to this view including the - * navigation extras. Any `queryParams` or `fragment` declared on the tab - * button's `href` are also forwarded. - * b. If the saved root view from the router outlet does not match, navigate - * to the tabRootUrl, forwarding any `queryParams`/`fragment` declared on - * the tab button's `href`. - * - * 2. If the current tab tab is not currently selected, get the last route - * view from the router outlet. - * - * a. If the last route view exists, navigate to that view including any - * navigation extras. - * b. If the last route view doesn't exist, then navigate to the default - * tabRootUrl, forwarding any `queryParams`/`fragment` declared on the - * tab button's `href`. - */ - select(tabOrEvent) { - var _a; - const isTabString = typeof tabOrEvent === 'string'; - const tab = isTabString ? tabOrEvent : tabOrEvent.detail.tab; - const href = isTabString ? undefined : tabOrEvent.detail.href; - /** - * If the tabs are not using the router, then - * the tab switch logic is handled by the tabs - * component itself. - */ - if (this.hasTab) { - this.setActiveTab(tab); - this.tabSwitch(); - return; - } - const alreadySelected = this.outlet.getActiveStackId() === tab; - const tabRootUrl = `${this.outlet.tabsPrefix}/${tab}`; - /** - * The href pathname is ignored here; tab routing is driven by `tabsPrefix/tab`. - * Only the query and fragment are forwarded as navigation extras. - */ - const hrefExtras = parseHrefExtras(href); - /** - * If this is a nested tab, prevent the event - * from bubbling otherwise the outer tabs - * will respond to this event too, causing - * the app to get directed to the wrong place. - */ - if (!isTabString) { - tabOrEvent.stopPropagation(); - } - if (alreadySelected) { - const activeStackId = this.outlet.getActiveStackId(); - const activeView = this.outlet.getLastRouteView(activeStackId); - // If on root tab, do not navigate to root tab again - if ((activeView === null || activeView === void 0 ? void 0 : activeView.url) === tabRootUrl) { - return; - } - const rootView = this.outlet.getRootView(tab); - // Keep the explicit rootView null-guard; an optional-chain rewrite changes the short-circuit value spread below. - // eslint-disable-next-line @typescript-eslint/prefer-optional-chain - const navigationExtras = rootView && tabRootUrl === rootView.url && rootView.savedExtras; - return this.navCtrl.navigateRoot(tabRootUrl, Object.assign(Object.assign(Object.assign({}, navigationExtras), hrefExtras), { animated: true, animationDirection: 'back' })); - } - else { - const lastRoute = this.outlet.getLastRouteView(tab); - /** - * If there is a lastRoute, goto that, otherwise goto the fallback url of the - * selected tab. When falling back to the tab root, honor query params and - * fragment declared on the tab button's href. - */ - const url = (lastRoute === null || lastRoute === void 0 ? void 0 : lastRoute.url) || tabRootUrl; - const navigationExtras = (_a = lastRoute === null || lastRoute === void 0 ? void 0 : lastRoute.savedExtras) !== null && _a !== void 0 ? _a : (url === tabRootUrl ? hrefExtras : undefined); - return this.navCtrl.navigateRoot(url, Object.assign(Object.assign({}, navigationExtras), { animated: true, animationDirection: 'back' })); - } - } - setActiveTab(tab) { - const tabs = this.tabs; - const selectedTab = tabs.find((t) => t.tab === tab); - if (!selectedTab) { - console.error(`[Ionic Error]: Tab with id: "${tab}" does not exist`); - return; - } - this.leavingTab = this.selectedTab; - this.selectedTab = selectedTab; - this.ionTabsWillChange.emit({ tab }); - selectedTab.el.active = true; - } - tabSwitch() { - const { selectedTab, leavingTab } = this; - if (this.tabBar && selectedTab) { - this.tabBar.selectedTab = selectedTab.tab; - } - if ((leavingTab === null || leavingTab === void 0 ? void 0 : leavingTab.tab) !== (selectedTab === null || selectedTab === void 0 ? void 0 : selectedTab.tab)) { - if (leavingTab === null || leavingTab === void 0 ? void 0 : leavingTab.el) { - leavingTab.el.active = false; - } - } - if (selectedTab) { - this.ionTabsDidChange.emit({ tab: selectedTab.tab }); - } - } - getSelected() { - var _a; - if (this.hasTab) { - return (_a = this.selectedTab) === null || _a === void 0 ? void 0 : _a.tab; - } - return this.outlet.getActiveStackId(); - } - /** - * Detects changes to the slot attribute of the tab bar. - * - * If the slot attribute has changed, then the tab bar - * should be relocated to the new slot position. - */ - detectSlotChanges() { - this.tabBars.forEach((tabBar) => { - // el is a protected attribute from the generated component wrapper - const currentSlot = tabBar.el.getAttribute('slot'); - if (currentSlot !== this.tabBarSlot) { - this.tabBarSlot = currentSlot; - this.relocateTabBar(); - } - }); - } - /** - * Relocates the tab bar to the new slot position. - */ - relocateTabBar() { - /** - * `el` is a protected attribute from the generated component wrapper. - * To avoid having to manually create the wrapper for tab bar, we - * cast the tab bar to any and access the protected attribute. - */ - const tabBar = this.tabBar.el; - if (this.tabBarSlot === 'top') { - /** - * A tab bar with a slot of "top" should be inserted - * at the top of the container. - */ - this.tabsInner.nativeElement.before(tabBar); - } - else { - /** - * A tab bar with a slot of "bottom" or without a slot - * should be inserted at the end of the container. - */ - this.tabsInner.nativeElement.after(tabBar); - } - } -}; -__decorate([ - ViewChild('tabsInner', { read: ElementRef, static: true }) -], IonTabs.prototype, "tabsInner", void 0); -__decorate([ - Output() -], IonTabs.prototype, "ionTabsWillChange", void 0); -__decorate([ - Output() -], IonTabs.prototype, "ionTabsDidChange", void 0); -__decorate([ - HostListener('ionTabButtonClick', ['$event']) -], IonTabs.prototype, "onTabButtonClick", null); -IonTabs = __decorate([ - Directive({ - selector: 'ion-tabs', - }) -], IonTabs); -export { IonTabs }; diff --git a/packages/angular/build/es2015/common/src/index.js b/packages/angular/build/es2015/common/src/index.js deleted file mode 100644 index 5f65e2a135b..00000000000 --- a/packages/angular/build/es2015/common/src/index.js +++ /dev/null @@ -1,19 +0,0 @@ -export { DomController } from './providers/dom-controller'; -export { MenuController } from './providers/menu-controller'; -export { NavController } from './providers/nav-controller'; -export { Config, ConfigToken } from './providers/config'; -export { Platform } from './providers/platform'; -export { AngularDelegate, IonModalToken } from './providers/angular-delegate'; -export { NavParams } from './directives/navigation/nav-params'; -export { IonModal } from './overlays/modal'; -export { IonPopover } from './overlays/popover'; -export { IonRouterOutlet, provideComponentInputBinding } from './directives/navigation/router-outlet'; -export * from './directives/control-value-accessors'; -export { IonBackButton } from './directives/navigation/back-button'; -export { IonNav } from './directives/navigation/nav'; -export { RouterLinkDelegateDirective, RouterLinkWithHrefDelegateDirective, } from './directives/navigation/router-link-delegate'; -export { IonTabs } from './directives/navigation/tabs'; -export { ProxyCmp } from './utils/proxy'; -export { OverlayBaseController } from './utils/overlay'; -export { IonicRouteStrategy } from './utils/routing'; -export { raf } from './utils/util'; diff --git a/packages/angular/build/es2015/common/src/overlays/modal.js b/packages/angular/build/es2015/common/src/overlays/modal.js deleted file mode 100644 index 6d78b0b516d..00000000000 --- a/packages/angular/build/es2015/common/src/overlays/modal.js +++ /dev/null @@ -1,86 +0,0 @@ -import { __decorate } from "tslib"; -import { ContentChild, Directive, TemplateRef, } from '@angular/core'; -import { ProxyCmp, proxyOutputs } from '../utils/proxy'; -const MODAL_INPUTS = [ - 'animated', - 'keepContentsMounted', - 'backdropBreakpoint', - 'backdropDismiss', - 'breakpoints', - 'canDismiss', - 'cssClass', - 'enterAnimation', - 'expandToScroll', - 'event', - 'focusTrap', - 'handle', - 'handleBehavior', - 'initialBreakpoint', - 'isOpen', - 'keyboardClose', - 'leaveAnimation', - 'mode', - 'presentingElement', - 'showBackdrop', - 'translucent', - 'trigger', -]; -const MODAL_METHODS = [ - 'present', - 'dismiss', - 'onDidDismiss', - 'onWillDismiss', - 'setCurrentBreakpoint', - 'getCurrentBreakpoint', -]; -let IonModal = class IonModal { - constructor(c, r, z) { - this.z = z; - this.isCmpOpen = false; - this.el = r.nativeElement; - this.el.addEventListener('ionMount', () => { - this.isCmpOpen = true; - c.detectChanges(); - }); - this.el.addEventListener('didDismiss', () => { - this.isCmpOpen = false; - c.detectChanges(); - }); - proxyOutputs(this, this.el, [ - 'ionModalDidPresent', - 'ionModalWillPresent', - 'ionModalWillDismiss', - 'ionModalDidDismiss', - 'ionBreakpointDidChange', - 'didPresent', - 'willPresent', - 'willDismiss', - 'didDismiss', - 'ionDragStart', - 'ionDragMove', - 'ionDragEnd', - ]); - } -}; -__decorate([ - ContentChild(TemplateRef, { static: false }) -], IonModal.prototype, "template", void 0); -IonModal = __decorate([ - ProxyCmp({ - inputs: MODAL_INPUTS, - methods: MODAL_METHODS, - }) - /** - * @Component extends from @Directive - * so by defining the inputs here we - * do not need to re-define them for the - * lazy loaded popover. - */ - , - Directive({ - selector: 'ion-modal', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: MODAL_INPUTS, - }) -], IonModal); -export { IonModal }; diff --git a/packages/angular/build/es2015/common/src/overlays/popover.js b/packages/angular/build/es2015/common/src/overlays/popover.js deleted file mode 100644 index c02874deef3..00000000000 --- a/packages/angular/build/es2015/common/src/overlays/popover.js +++ /dev/null @@ -1,74 +0,0 @@ -import { __decorate } from "tslib"; -import { ContentChild, Directive, TemplateRef, } from '@angular/core'; -import { ProxyCmp, proxyOutputs } from '../utils/proxy'; -const POPOVER_INPUTS = [ - 'alignment', - 'animated', - 'arrow', - 'keepContentsMounted', - 'backdropDismiss', - 'cssClass', - 'dismissOnSelect', - 'enterAnimation', - 'event', - 'focusTrap', - 'isOpen', - 'keyboardClose', - 'leaveAnimation', - 'mode', - 'showBackdrop', - 'translucent', - 'trigger', - 'triggerAction', - 'reference', - 'size', - 'side', -]; -const POPOVER_METHODS = ['present', 'dismiss', 'onDidDismiss', 'onWillDismiss']; -let IonPopover = class IonPopover { - constructor(c, r, z) { - this.z = z; - this.isCmpOpen = false; - this.el = r.nativeElement; - this.el.addEventListener('ionMount', () => { - this.isCmpOpen = true; - c.detectChanges(); - }); - this.el.addEventListener('didDismiss', () => { - this.isCmpOpen = false; - c.detectChanges(); - }); - proxyOutputs(this, this.el, [ - 'ionPopoverDidPresent', - 'ionPopoverWillPresent', - 'ionPopoverWillDismiss', - 'ionPopoverDidDismiss', - 'didPresent', - 'willPresent', - 'willDismiss', - 'didDismiss', - ]); - } -}; -__decorate([ - ContentChild(TemplateRef, { static: false }) -], IonPopover.prototype, "template", void 0); -IonPopover = __decorate([ - ProxyCmp({ - inputs: POPOVER_INPUTS, - methods: POPOVER_METHODS, - }) - /** - * @Component extends from @Directive - * so by defining the inputs here we - * do not need to re-define them for the - * lazy loaded popover. - */ - , - Directive({ - selector: 'ion-popover', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: POPOVER_INPUTS, - }) -], IonPopover); -export { IonPopover }; diff --git a/packages/angular/build/es2015/common/src/providers/angular-delegate.js b/packages/angular/build/es2015/common/src/providers/angular-delegate.js deleted file mode 100644 index 3a8f0274f93..00000000000 --- a/packages/angular/build/es2015/common/src/providers/angular-delegate.js +++ /dev/null @@ -1,221 +0,0 @@ -import { __decorate, __rest } from "tslib"; -import { ApplicationRef, createComponent, inject, Injectable, InjectionToken, Injector, NgZone, } from '@angular/core'; -import { LIFECYCLE_DID_ENTER, LIFECYCLE_DID_LEAVE, LIFECYCLE_WILL_ENTER, LIFECYCLE_WILL_LEAVE, LIFECYCLE_WILL_UNLOAD, } from '@ionic/core/components'; -import { NavParams } from '../directives/navigation/nav-params'; -import { ConfigToken } from './config'; -// Token for injecting the modal element -export const IonModalToken = new InjectionToken('IonModalToken'); -// TODO(FW-2827): types -let AngularDelegate = class AngularDelegate { - constructor() { - this.zone = inject(NgZone); - this.applicationRef = inject(ApplicationRef); - this.config = inject(ConfigToken); - } - create(environmentInjector, injector, elementReferenceKey, customInjector) { - var _a; - return new AngularFrameworkDelegate(environmentInjector, injector, this.applicationRef, this.zone, elementReferenceKey, (_a = this.config.useSetInputAPI) !== null && _a !== void 0 ? _a : false, customInjector); - } -}; -AngularDelegate = __decorate([ - Injectable() -], AngularDelegate); -export { AngularDelegate }; -export class AngularFrameworkDelegate { - constructor(environmentInjector, injector, applicationRef, zone, elementReferenceKey, enableSignalsSupport, customInjector) { - this.environmentInjector = environmentInjector; - this.injector = injector; - this.applicationRef = applicationRef; - this.zone = zone; - this.elementReferenceKey = elementReferenceKey; - this.enableSignalsSupport = enableSignalsSupport; - this.customInjector = customInjector; - this.elRefMap = new WeakMap(); - this.elEventsMap = new WeakMap(); - } - attachViewToDom(container, component, params, cssClasses) { - return this.zone.run(() => { - return new Promise((resolve) => { - const componentProps = Object.assign({}, params); - /** - * Ionic Angular passes a reference to a modal - * or popover that can be accessed using a - * variable in the overlay component. If - * elementReferenceKey is defined, then we should - * pass a reference to the component using - * elementReferenceKey as the key. - */ - if (this.elementReferenceKey !== undefined) { - componentProps[this.elementReferenceKey] = container; - } - const el = attachView(this.zone, this.environmentInjector, this.injector, this.applicationRef, this.elRefMap, this.elEventsMap, container, component, componentProps, cssClasses, this.elementReferenceKey, this.enableSignalsSupport, this.customInjector); - resolve(el); - }); - }); - } - removeViewFromDom(_container, component) { - return this.zone.run(() => { - return new Promise((resolve) => { - const componentRef = this.elRefMap.get(component); - if (componentRef) { - componentRef.destroy(); - this.elRefMap.delete(component); - const unbindEvents = this.elEventsMap.get(component); - if (unbindEvents) { - unbindEvents(); - this.elEventsMap.delete(component); - } - } - resolve(); - }); - }); - } -} -export const attachView = (zone, environmentInjector, injector, applicationRef, elRefMap, elEventsMap, container, component, params, cssClasses, elementReferenceKey, enableSignalsSupport, customInjector) => { - /** - * Wraps the injector with a custom injector that - * provides NavParams to the component. - * - * NavParams is a legacy feature from Ionic v3 that allows - * Angular developers to provide data to a component - * and access it by providing NavParams as a dependency - * in the constructor. - * - * The modern approach is to access the data directly - * from the component's class instance. - */ - const providers = getProviders(params); - // If this is an ion-modal, provide the modal element as an injectable - // so components inside the modal can inject it directly - if (container.tagName.toLowerCase() === 'ion-modal') { - providers.push({ - provide: IonModalToken, - useValue: container, - }); - } - const childInjector = Injector.create({ - providers, - parent: customInjector !== null && customInjector !== void 0 ? customInjector : injector, - }); - const componentRef = createComponent(component, { - environmentInjector, - elementInjector: childInjector, - }); - const instance = componentRef.instance; - const hostElement = componentRef.location.nativeElement; - if (params) { - /** - * For modals and popovers, a reference to the component is - * added to `params` during the call to attachViewToDom. If - * a reference using this name is already set, this means - * the app is trying to use the name as a component prop, - * which will cause collisions. - */ - if (elementReferenceKey && instance[elementReferenceKey] !== undefined) { - console.error(`[Ionic Error]: ${elementReferenceKey} is a reserved property when using ${container.tagName.toLowerCase()}. Rename or remove the "${elementReferenceKey}" property from ${component.name}.`); - } - /** - * Angular 14.1 added support for setInput - * so we need to fall back to Object.assign - * for Angular 14.0. - */ - if (enableSignalsSupport === true && componentRef.setInput !== undefined) { - const { modal, popover } = params, otherParams = __rest(params, ["modal", "popover"]); - /** - * Any key/value pairs set in componentProps - * must be set as inputs on the component instance. - */ - for (const key in otherParams) { - componentRef.setInput(key, otherParams[key]); - } - /** - * Using setInput will cause an error when - * setting modal/popover on a component that - * does not define them as an input. For backwards - * compatibility purposes we fall back to using - * Object.assign for these properties. - */ - if (modal !== undefined) { - Object.assign(instance, { modal }); - } - if (popover !== undefined) { - Object.assign(instance, { popover }); - } - } - else { - Object.assign(instance, params); - } - } - if (cssClasses) { - for (const cssClass of cssClasses) { - hostElement.classList.add(cssClass); - } - } - const unbindEvents = bindLifecycleEvents(zone, componentRef.changeDetectorRef, instance, hostElement); - container.appendChild(hostElement); - applicationRef.attachView(componentRef.hostView); - /** - * Run change detection on the freshly attached view so Angular's init hooks - * (`ngOnInit`, `ngAfterViewInit`) fire and template bindings (e.g. - * ``) apply during this synchronous pass, before the - * web component runs its load lifecycle and dispatches its Ionic lifecycle events - * (`ionViewWillEnter`, etc.). `createComponent` only runs the creation pass; the - * init hooks and binding updates run during an update pass. Under Zone.js an - * implicit tick used to cover this, but zoneless Angular schedules no such tick, - * so without this the binding could land after the element has loaded (too late - * for `ion-nav` to read it) and the first `ionViewWillEnter` could run before - * `ngOnInit`. - */ - componentRef.changeDetectorRef.detectChanges(); - elRefMap.set(hostElement, componentRef); - elEventsMap.set(hostElement, unbindEvents); - return hostElement; -}; -const LIFECYCLES = [ - LIFECYCLE_WILL_ENTER, - LIFECYCLE_DID_ENTER, - LIFECYCLE_WILL_LEAVE, - LIFECYCLE_DID_LEAVE, - LIFECYCLE_WILL_UNLOAD, -]; -export const bindLifecycleEvents = (zone, changeDetectorRef, instance, element) => { - /** - * `zone.run` keeps the listener registration (and, under Zone.js, the handler - * execution) inside the Angular zone, so async work started inside a lifecycle - * hook is still zone-tracked. Under zoneless Angular it is a passthrough. - */ - return zone.run(() => { - const unregisters = LIFECYCLES.filter((eventName) => typeof instance[eventName] === 'function').map((eventName) => { - const handler = (ev) => { - instance[eventName](ev.detail); - /** - * Ionic lifecycle events (`ionViewWillEnter`, etc.) are dispatched from - * the web component via a native event listener, so under zoneless - * Angular nothing schedules change detection for state the hook mutates. - * Mark the view dirty explicitly. This is a no-op-or-better under Zone.js. - */ - changeDetectorRef.markForCheck(); - }; - element.addEventListener(eventName, handler); - return () => element.removeEventListener(eventName, handler); - }); - return () => unregisters.forEach((fn) => fn()); - }); -}; -const NavParamsToken = new InjectionToken('NavParamsToken'); -const getProviders = (params) => { - return [ - { - provide: NavParamsToken, - useValue: params, - }, - { - provide: NavParams, - useFactory: provideNavParamsInjectable, - deps: [NavParamsToken], - }, - ]; -}; -const provideNavParamsInjectable = (params) => { - return new NavParams(params); -}; diff --git a/packages/angular/build/es2015/common/src/providers/config.js b/packages/angular/build/es2015/common/src/providers/config.js deleted file mode 100644 index a69c669caa6..00000000000 --- a/packages/angular/build/es2015/common/src/providers/config.js +++ /dev/null @@ -1,41 +0,0 @@ -import { __decorate } from "tslib"; -import { Injectable, InjectionToken } from '@angular/core'; -let Config = class Config { - get(key, fallback) { - const c = getConfig(); - if (c) { - return c.get(key, fallback); - } - return null; - } - getBoolean(key, fallback) { - const c = getConfig(); - if (c) { - return c.getBoolean(key, fallback); - } - return false; - } - getNumber(key, fallback) { - const c = getConfig(); - if (c) { - return c.getNumber(key, fallback); - } - return 0; - } -}; -Config = __decorate([ - Injectable({ - providedIn: 'root', - }) -], Config); -export { Config }; -export const ConfigToken = new InjectionToken('USERCONFIG'); -const getConfig = () => { - if (typeof window !== 'undefined') { - const Ionic = window.Ionic; - if (Ionic === null || Ionic === void 0 ? void 0 : Ionic.config) { - return Ionic.config; - } - } - return null; -}; diff --git a/packages/angular/build/es2015/common/src/providers/dom-controller.js b/packages/angular/build/es2015/common/src/providers/dom-controller.js deleted file mode 100644 index b91895997f3..00000000000 --- a/packages/angular/build/es2015/common/src/providers/dom-controller.js +++ /dev/null @@ -1,41 +0,0 @@ -import { __decorate } from "tslib"; -import { Injectable } from '@angular/core'; -let DomController = class DomController { - /** - * Schedules a task to run during the READ phase of the next frame. - * This task should only read the DOM, but never modify it. - */ - read(cb) { - getQueue().read(cb); - } - /** - * Schedules a task to run during the WRITE phase of the next frame. - * This task should write the DOM, but never READ it. - */ - write(cb) { - getQueue().write(cb); - } -}; -DomController = __decorate([ - Injectable({ - providedIn: 'root', - }) -], DomController); -export { DomController }; -const getQueue = () => { - const win = typeof window !== 'undefined' ? window : null; - if (win != null) { - const Ionic = win.Ionic; - if (Ionic === null || Ionic === void 0 ? void 0 : Ionic.queue) { - return Ionic.queue; - } - return { - read: (cb) => win.requestAnimationFrame(cb), - write: (cb) => win.requestAnimationFrame(cb), - }; - } - return { - read: (cb) => cb(), - write: (cb) => cb(), - }; -}; diff --git a/packages/angular/build/es2015/common/src/providers/menu-controller.js b/packages/angular/build/es2015/common/src/providers/menu-controller.js deleted file mode 100644 index b9758f912d3..00000000000 --- a/packages/angular/build/es2015/common/src/providers/menu-controller.js +++ /dev/null @@ -1,112 +0,0 @@ -export class MenuController { - constructor(menuController) { - this.menuController = menuController; - } - /** - * Programmatically open the Menu. - * @param [menuId] Optionally get the menu by its id, or side. - * @return returns a promise when the menu is fully opened - */ - open(menuId) { - return this.menuController.open(menuId); - } - /** - * Programmatically close the Menu. If no `menuId` is given as the first - * argument then it'll close any menu which is open. If a `menuId` - * is given then it'll close that exact menu. - * @param [menuId] Optionally get the menu by its id, or side. - * @return returns a promise when the menu is fully closed - */ - close(menuId) { - return this.menuController.close(menuId); - } - /** - * Toggle the menu. If it's closed, it will open, and if opened, it - * will close. - * @param [menuId] Optionally get the menu by its id, or side. - * @return returns a promise when the menu has been toggled - */ - toggle(menuId) { - return this.menuController.toggle(menuId); - } - /** - * Used to enable or disable a menu. For example, there could be multiple - * left menus, but only one of them should be able to be opened at the same - * time. If there are multiple menus on the same side, then enabling one menu - * will also automatically disable all the others that are on the same side. - * @param [menuId] Optionally get the menu by its id, or side. - * @return Returns the instance of the menu, which is useful for chaining. - */ - enable(shouldEnable, menuId) { - return this.menuController.enable(shouldEnable, menuId); - } - /** - * Used to enable or disable the ability to swipe open the menu. - * @param shouldEnable True if it should be swipe-able, false if not. - * @param [menuId] Optionally get the menu by its id, or side. - * @return Returns the instance of the menu, which is useful for chaining. - */ - swipeGesture(shouldEnable, menuId) { - return this.menuController.swipeGesture(shouldEnable, menuId); - } - /** - * @param [menuId] Optionally get the menu by its id, or side. - * @return Returns true if the specified menu is currently open, otherwise false. - * If the menuId is not specified, it returns true if ANY menu is currenly open. - */ - isOpen(menuId) { - return this.menuController.isOpen(menuId); - } - /** - * @param [menuId] Optionally get the menu by its id, or side. - * @return Returns true if the menu is currently enabled, otherwise false. - */ - isEnabled(menuId) { - return this.menuController.isEnabled(menuId); - } - /** - * Used to get a menu instance. If a `menuId` is not provided then it'll - * return the first menu found. If a `menuId` is `left` or `right`, then - * it'll return the enabled menu on that side. Otherwise, if a `menuId` is - * provided, then it'll try to find the menu using the menu's `id` - * property. If a menu is not found then it'll return `null`. - * @param [menuId] Optionally get the menu by its id, or side. - * @return Returns the instance of the menu if found, otherwise `null`. - */ - get(menuId) { - return this.menuController.get(menuId); - } - /** - * @return Returns the instance of the menu already opened, otherwise `null`. - */ - getOpen() { - return this.menuController.getOpen(); - } - /** - * @return Returns an array of all menu instances. - */ - getMenus() { - return this.menuController.getMenus(); - } - registerAnimation(name, animation) { - return this.menuController.registerAnimation(name, animation); - } - isAnimating() { - return this.menuController.isAnimating(); - } - _getOpenSync() { - return this.menuController._getOpenSync(); - } - _createAnimation(type, menuCmp) { - return this.menuController._createAnimation(type, menuCmp); - } - _register(menu) { - return this.menuController._register(menu); - } - _unregister(menu) { - return this.menuController._unregister(menu); - } - _setOpen(menu, shouldOpen, animated) { - return this.menuController._setOpen(menu, shouldOpen, animated); - } -} diff --git a/packages/angular/build/es2015/common/src/providers/nav-controller.js b/packages/angular/build/es2015/common/src/providers/nav-controller.js deleted file mode 100644 index f0d197a2d83..00000000000 --- a/packages/angular/build/es2015/common/src/providers/nav-controller.js +++ /dev/null @@ -1,221 +0,0 @@ -import { __awaiter, __decorate, __param } from "tslib"; -import { Injectable, Optional } from '@angular/core'; -import { NavigationStart, NavigationCancel, NavigationError, } from '@angular/router'; -let NavController = class NavController { - constructor(platform, location, serializer, router) { - this.location = location; - this.serializer = serializer; - this.router = router; - this.direction = DEFAULT_DIRECTION; - this.animated = DEFAULT_ANIMATED; - this.guessDirection = 'forward'; - this.lastNavId = -1; - // Subscribe to router events to detect direction - if (router) { - router.events.subscribe((ev) => { - if (ev instanceof NavigationStart) { - // restoredState is set if the browser back/forward button is used - const id = ev.restoredState ? ev.restoredState.navigationId : ev.id; - this.guessDirection = this.guessAnimation = id < this.lastNavId ? 'back' : 'forward'; - this.lastNavId = this.guessDirection === 'forward' ? ev.id : id; - } - // Reset explicit direction when navigation is canceled (e.g., guard rejection) - // to prevent stale direction from leaking into the next navigation - if (ev instanceof NavigationCancel || ev instanceof NavigationError) { - this.direction = DEFAULT_DIRECTION; - this.animated = DEFAULT_ANIMATED; - this.animationBuilder = undefined; - } - }); - } - // Subscribe to backButton events - platform.backButton.subscribeWithPriority(0, (processNextHandler) => { - this.pop(); - processNextHandler(); - }); - } - /** - * This method uses Angular's [Router](https://angular.io/api/router/Router) under the hood, - * it's equivalent to calling `this.router.navigateByUrl()`, but it's explicit about the **direction** of the transition. - * - * Going **forward** means that a new page is going to be pushed to the stack of the outlet (ion-router-outlet), - * and that it will show a "forward" animation by default. - * - * Navigating forward can also be triggered in a declarative manner by using the `[routerDirection]` directive: - * - * ```html - * Link - * ``` - */ - navigateForward(url, options = {}) { - this.setDirection('forward', options.animated, options.animationDirection, options.animation); - return this.navigate(url, options); - } - /** - * This method uses Angular's [Router](https://angular.io/api/router/Router) under the hood, - * it's equivalent to calling: - * - * ```ts - * this.navController.setDirection('back'); - * this.router.navigateByUrl(path); - * ``` - * - * Going **back** means that all the pages in the stack until the navigated page is found will be popped, - * and that it will show a "back" animation by default. - * - * Navigating back can also be triggered in a declarative manner by using the `[routerDirection]` directive: - * - * ```html - * Link - * ``` - */ - navigateBack(url, options = {}) { - this.setDirection('back', options.animated, options.animationDirection, options.animation); - return this.navigate(url, options); - } - /** - * This method uses Angular's [Router](https://angular.io/api/router/Router) under the hood, - * it's equivalent to calling: - * - * ```ts - * this.navController.setDirection('root'); - * this.router.navigateByUrl(path); - * ``` - * - * Going **root** means that all existing pages in the stack will be removed, - * and the navigated page will become the single page in the stack. - * - * Navigating root can also be triggered in a declarative manner by using the `[routerDirection]` directive: - * - * ```html - * Link - * ``` - */ - navigateRoot(url, options = {}) { - this.setDirection('root', options.animated, options.animationDirection, options.animation); - return this.navigate(url, options); - } - /** - * Same as [Location](https://angular.io/api/common/Location)'s back() method. - * It will use the standard `window.history.back()` under the hood, but featuring a `back` animation - * by default. - */ - back(options = { animated: true, animationDirection: 'back' }) { - this.setDirection('back', options.animated, options.animationDirection, options.animation); - return this.location.back(); - } - /** - * This methods goes back in the context of Ionic's stack navigation. - * - * It recursively finds the top active `ion-router-outlet` and calls `pop()`. - * This is the recommended way to go back when you are using `ion-router-outlet`. - * - * Resolves to `true` if it was able to pop. - */ - pop() { - return __awaiter(this, void 0, void 0, function* () { - let outlet = this.topOutlet; - while (outlet) { - if (yield outlet.pop()) { - return true; - } - else { - outlet = outlet.parentOutlet; - } - } - return false; - }); - } - /** - * This methods specifies the direction of the next navigation performed by the Angular router. - * - * `setDirection()` does not trigger any transition, it just sets some flags to be consumed by `ion-router-outlet`. - * - * It's recommended to use `navigateForward()`, `navigateBack()` and `navigateRoot()` instead of `setDirection()`. - */ - setDirection(direction, animated, animationDirection, animationBuilder) { - this.direction = direction; - this.animated = getAnimation(direction, animated, animationDirection); - this.animationBuilder = animationBuilder; - } - /** - * @internal - */ - setTopOutlet(outlet) { - this.topOutlet = outlet; - } - /** - * @internal - */ - consumeTransition() { - let direction = 'root'; - let animation; - const animationBuilder = this.animationBuilder; - if (this.direction === 'auto') { - direction = this.guessDirection; - animation = this.guessAnimation; - } - else { - animation = this.animated; - direction = this.direction; - } - this.direction = DEFAULT_DIRECTION; - this.animated = DEFAULT_ANIMATED; - this.animationBuilder = undefined; - return { - direction, - animation, - animationBuilder, - }; - } - navigate(url, options) { - if (Array.isArray(url)) { - return this.router.navigate(url, options); - } - else { - /** - * navigateByUrl ignores any properties that - * would change the url, so things like queryParams - * would be ignored unless we create a url tree - * More Info: https://github.com/angular/angular/issues/18798 - */ - const urlTree = this.serializer.parse(url.toString()); - if (options.queryParams !== undefined) { - urlTree.queryParams = Object.assign({}, options.queryParams); - } - if (options.fragment !== undefined) { - urlTree.fragment = options.fragment; - } - /** - * `navigateByUrl` will still apply `NavigationExtras` properties - * that do not modify the url, such as `replaceUrl` which is why - * `options` is passed in here. - */ - return this.router.navigateByUrl(urlTree, options); - } - } -}; -NavController = __decorate([ - Injectable({ - providedIn: 'root', - }), - __param(3, Optional()) -], NavController); -export { NavController }; -const getAnimation = (direction, animated, animationDirection) => { - if (animated === false) { - return undefined; - } - if (animationDirection !== undefined) { - return animationDirection; - } - if (direction === 'forward' || direction === 'back') { - return direction; - } - else if (direction === 'root' && animated === true) { - return 'forward'; - } - return undefined; -}; -const DEFAULT_DIRECTION = 'auto'; -const DEFAULT_ANIMATED = undefined; diff --git a/packages/angular/build/es2015/common/src/providers/platform.js b/packages/angular/build/es2015/common/src/providers/platform.js deleted file mode 100644 index 0ca805ea993..00000000000 --- a/packages/angular/build/es2015/common/src/providers/platform.js +++ /dev/null @@ -1,250 +0,0 @@ -import { __decorate, __param } from "tslib"; -import { DOCUMENT } from '@angular/common'; -import { Inject, Injectable } from '@angular/core'; -import { getPlatforms, isPlatform } from '@ionic/core/components'; -import { Subject } from 'rxjs'; -let Platform = class Platform { - constructor(doc, zone) { - this.doc = doc; - /** - * @hidden - */ - this.backButton = new Subject(); - /** - * The keyboardDidShow event emits when the - * on-screen keyboard is presented. - */ - this.keyboardDidShow = new Subject(); - /** - * The keyboardDidHide event emits when the - * on-screen keyboard is hidden. - */ - this.keyboardDidHide = new Subject(); - /** - * The pause event emits when the native platform puts the application - * into the background, typically when the user switches to a different - * application. This event would emit when a Cordova app is put into - * the background, however, it would not fire on a standard web browser. - */ - this.pause = new Subject(); - /** - * The resume event emits when the native platform pulls the application - * out from the background. This event would emit when a Cordova app comes - * out from the background, however, it would not fire on a standard web browser. - */ - this.resume = new Subject(); - /** - * The resize event emits when the browser window has changed dimensions. This - * could be from a browser window being physically resized, or from a device - * changing orientation. - */ - this.resize = new Subject(); - zone.run(() => { - var _a; - this.win = doc.defaultView; - this.backButton.subscribeWithPriority = function (priority, callback) { - return this.subscribe((ev) => { - return ev.register(priority, (processNextHandler) => zone.run(() => callback(processNextHandler))); - }); - }; - proxyEvent(this.pause, doc, 'pause', zone); - proxyEvent(this.resume, doc, 'resume', zone); - proxyEvent(this.backButton, doc, 'ionBackButton', zone); - proxyEvent(this.resize, this.win, 'resize', zone); - proxyEvent(this.keyboardDidShow, this.win, 'ionKeyboardDidShow', zone); - proxyEvent(this.keyboardDidHide, this.win, 'ionKeyboardDidHide', zone); - let readyResolve; - this._readyPromise = new Promise((res) => { - readyResolve = res; - }); - if ((_a = this.win) === null || _a === void 0 ? void 0 : _a['cordova']) { - doc.addEventListener('deviceready', () => { - readyResolve('cordova'); - }, { once: true }); - } - else { - readyResolve('dom'); - } - }); - } - /** - * @returns returns true/false based on platform. - * @description - * Depending on the platform the user is on, `is(platformName)` will - * return `true` or `false`. Note that the same app can return `true` - * for more than one platform name. For example, an app running from - * an iPad would return `true` for the platform names: `mobile`, - * `ios`, `ipad`, and `tablet`. Additionally, if the app was running - * from Cordova then `cordova` would be true, and if it was running - * from a web browser on the iPad then `mobileweb` would be `true`. - * - * ``` - * import { Platform } from 'ionic-angular'; - * - * @Component({...}) - * export MyPage { - * constructor(public platform: Platform) { - * if (this.platform.is('ios')) { - * // This will only print when on iOS - * console.log('I am an iOS device!'); - * } - * } - * } - * ``` - * - * | Platform Name | Description | - * |-----------------|------------------------------------| - * | android | on a device running Android. | - * | capacitor | on a device running Capacitor. | - * | cordova | on a device running Cordova. | - * | ios | on a device running iOS. | - * | ipad | on an iPad device. | - * | iphone | on an iPhone device. | - * | phablet | on a phablet device. | - * | tablet | on a tablet device. | - * | electron | in Electron on a desktop device. | - * | pwa | as a PWA app. | - * | mobile | on a mobile device. | - * | mobileweb | on a mobile device in a browser. | - * | desktop | on a desktop device. | - * | hybrid | is a cordova or capacitor app. | - * - */ - is(platformName) { - return isPlatform(this.win, platformName); - } - /** - * @returns the array of platforms - * @description - * Depending on what device you are on, `platforms` can return multiple values. - * Each possible value is a hierarchy of platforms. For example, on an iPhone, - * it would return `mobile`, `ios`, and `iphone`. - * - * ``` - * import { Platform } from 'ionic-angular'; - * - * @Component({...}) - * export MyPage { - * constructor(public platform: Platform) { - * // This will print an array of the current platforms - * console.log(this.platform.platforms()); - * } - * } - * ``` - */ - platforms() { - return getPlatforms(this.win); - } - /** - * Returns a promise when the platform is ready and native functionality - * can be called. If the app is running from within a web browser, then - * the promise will resolve when the DOM is ready. When the app is running - * from an application engine such as Cordova, then the promise will - * resolve when Cordova triggers the `deviceready` event. - * - * The resolved value is the `readySource`, which states which platform - * ready was used. For example, when Cordova is ready, the resolved ready - * source is `cordova`. The default ready source value will be `dom`. The - * `readySource` is useful if different logic should run depending on the - * platform the app is running from. For example, only Cordova can execute - * the status bar plugin, so the web should not run status bar plugin logic. - * - * ``` - * import { Component } from '@angular/core'; - * import { Platform } from 'ionic-angular'; - * - * @Component({...}) - * export MyApp { - * constructor(public platform: Platform) { - * this.platform.ready().then((readySource) => { - * console.log('Platform ready from', readySource); - * // Platform now ready, execute any required native code - * }); - * } - * } - * ``` - */ - ready() { - return this._readyPromise; - } - /** - * Returns if this app is using right-to-left language direction or not. - * We recommend the app's `index.html` file already has the correct `dir` - * attribute value set, such as `` or ``. - * [W3C: Structural markup and right-to-left text in HTML](http://www.w3.org/International/questions/qa-html-dir) - */ - get isRTL() { - return this.doc.dir === 'rtl'; - } - /** - * Get the query string parameter - */ - getQueryParam(key) { - return readQueryParam(this.win.location.href, key); - } - /** - * Returns `true` if the app is in landscape mode. - */ - isLandscape() { - return !this.isPortrait(); - } - /** - * Returns `true` if the app is in portrait mode. - */ - isPortrait() { - var _a, _b; - return (_b = (_a = this.win).matchMedia) === null || _b === void 0 ? void 0 : _b.call(_a, '(orientation: portrait)').matches; - } - testUserAgent(expression) { - const nav = this.win.navigator; - return !!((nav === null || nav === void 0 ? void 0 : nav.userAgent) && nav.userAgent.indexOf(expression) >= 0); - } - /** - * Get the current url. - */ - url() { - return this.win.location.href; - } - /** - * Gets the width of the platform's viewport using `window.innerWidth`. - */ - width() { - return this.win.innerWidth; - } - /** - * Gets the height of the platform's viewport using `window.innerHeight`. - */ - height() { - return this.win.innerHeight; - } -}; -Platform = __decorate([ - Injectable({ - providedIn: 'root', - }), - __param(0, Inject(DOCUMENT)) -], Platform); -export { Platform }; -const readQueryParam = (url, key) => { - key = key.replace(/[[\]\\]/g, '\\$&'); - const regex = new RegExp('[\\?&]' + key + '=([^&#]*)'); - const results = regex.exec(url); - return results ? decodeURIComponent(results[1].replace(/\+/g, ' ')) : null; -}; -const proxyEvent = (emitter, el, eventName, zone) => { - if (el) { - el.addEventListener(eventName, (ev) => { - /** - * `zone.run` is required to make sure that we are running inside the Angular zone - * at all times. This is necessary since an app that has Capacitor will - * override the `document.addEventListener` with its own implementation. - * The override causes the event to no longer be in the Angular zone. - */ - zone.run(() => { - // ?? cordova might emit "null" events - const value = ev != null ? ev.detail : undefined; - emitter.next(value); - }); - }); - } -}; diff --git a/packages/angular/build/es2015/common/src/types/interfaces.js b/packages/angular/build/es2015/common/src/types/interfaces.js deleted file mode 100644 index cb0ff5c3b54..00000000000 --- a/packages/angular/build/es2015/common/src/types/interfaces.js +++ /dev/null @@ -1 +0,0 @@ -export {}; diff --git a/packages/angular/build/es2015/common/src/types/ionic-lifecycle-hooks.js b/packages/angular/build/es2015/common/src/types/ionic-lifecycle-hooks.js deleted file mode 100644 index dd0671d39cb..00000000000 --- a/packages/angular/build/es2015/common/src/types/ionic-lifecycle-hooks.js +++ /dev/null @@ -1,4 +0,0 @@ -/** - * https://ionicframework.com/docs/api/router-outlet#life-cycle-hooks - */ -export {}; diff --git a/packages/angular/build/es2015/common/src/types/overlay-options.js b/packages/angular/build/es2015/common/src/types/overlay-options.js deleted file mode 100644 index cb0ff5c3b54..00000000000 --- a/packages/angular/build/es2015/common/src/types/overlay-options.js +++ /dev/null @@ -1 +0,0 @@ -export {}; diff --git a/packages/angular/build/es2015/common/src/utils/overlay.js b/packages/angular/build/es2015/common/src/utils/overlay.js deleted file mode 100644 index 7f3b05889ec..00000000000 --- a/packages/angular/build/es2015/common/src/utils/overlay.js +++ /dev/null @@ -1,24 +0,0 @@ -// TODO(FW-2827): types -export class OverlayBaseController { - constructor(ctrl) { - this.ctrl = ctrl; - } - /** - * Creates a new overlay - */ - create(opts) { - return this.ctrl.create((opts || {})); - } - /** - * When `id` is not provided, it dismisses the top overlay. - */ - dismiss(data, role, id) { - return this.ctrl.dismiss(data, role, id); - } - /** - * Returns the top overlay. - */ - getTop() { - return this.ctrl.getTop(); - } -} diff --git a/packages/angular/build/es2015/common/src/utils/proxy.js b/packages/angular/build/es2015/common/src/utils/proxy.js deleted file mode 100644 index 58f76a37e1c..00000000000 --- a/packages/angular/build/es2015/common/src/utils/proxy.js +++ /dev/null @@ -1,46 +0,0 @@ -// TODO: Is there a way we can grab this from angular-component-lib instead? -/* eslint-disable */ -/* tslint:disable */ -import { fromEvent } from 'rxjs'; -export const proxyInputs = (Cmp, inputs) => { - const Prototype = Cmp.prototype; - inputs.forEach((item) => { - Object.defineProperty(Prototype, item, { - get() { - return this.el[item]; - }, - set(val) { - this.z.runOutsideAngular(() => (this.el[item] = val)); - }, - }); - }); -}; -export const proxyMethods = (Cmp, methods) => { - const Prototype = Cmp.prototype; - methods.forEach((methodName) => { - Prototype[methodName] = function () { - const args = arguments; - return this.z.runOutsideAngular(() => this.el[methodName].apply(this.el, args)); - }; - }); -}; -export const proxyOutputs = (instance, el, events) => { - events.forEach((eventName) => (instance[eventName] = fromEvent(el, eventName))); -}; -// tslint:disable-next-line: only-arrow-functions -export function ProxyCmp(opts) { - const decorator = function (cls) { - const { defineCustomElementFn, inputs, methods } = opts; - if (defineCustomElementFn !== undefined) { - defineCustomElementFn(); - } - if (inputs) { - proxyInputs(cls, inputs); - } - if (methods) { - proxyMethods(cls, methods); - } - return cls; - }; - return decorator; -} diff --git a/packages/angular/build/es2015/common/src/utils/routing.js b/packages/angular/build/es2015/common/src/utils/routing.js deleted file mode 100644 index dab356197b5..00000000000 --- a/packages/angular/build/es2015/common/src/utils/routing.js +++ /dev/null @@ -1,54 +0,0 @@ -/** - * Provides a way to customize when activated routes get reused. - */ -export class IonicRouteStrategy { - /** - * Whether the given route should detach for later reuse. - */ - shouldDetach(_route) { - return false; - } - /** - * Returns `false`, meaning the route (and its subtree) is never reattached - */ - shouldAttach(_route) { - return false; - } - /** - * A no-op; the route is never stored since this strategy never detaches routes for later re-use. - */ - store(_route, _detachedTree) { - return; - } - /** - * Returns `null` because this strategy does not store routes for later re-use. - */ - retrieve(_route) { - return null; - } - /** - * Determines if a route should be reused. - * This strategy returns `true` when the future route config and - * current route config are identical and all route parameters are identical. - */ - shouldReuseRoute(future, curr) { - if (future.routeConfig !== curr.routeConfig) { - return false; - } - // checking router params - const futureParams = future.params; - const currentParams = curr.params; - const keysA = Object.keys(futureParams); - const keysB = Object.keys(currentParams); - if (keysA.length !== keysB.length) { - return false; - } - // Test for A's keys different from B. - for (const key of keysA) { - if (currentParams[key] !== futureParams[key]) { - return false; - } - } - return true; - } -} diff --git a/packages/angular/build/es2015/common/src/utils/util.js b/packages/angular/build/es2015/common/src/utils/util.js deleted file mode 100644 index 861e1910a92..00000000000 --- a/packages/angular/build/es2015/common/src/utils/util.js +++ /dev/null @@ -1,9 +0,0 @@ -export const raf = (h) => { - if (typeof __zone_symbol__requestAnimationFrame === 'function') { - return __zone_symbol__requestAnimationFrame(h); - } - if (typeof requestAnimationFrame === 'function') { - return requestAnimationFrame(h); - } - return setTimeout(h); -}; diff --git a/packages/angular/build/es2015/lazy/src/app-initialize.js b/packages/angular/build/es2015/lazy/src/app-initialize.js deleted file mode 100644 index 0b8ffcffa1a..00000000000 --- a/packages/angular/build/es2015/lazy/src/app-initialize.js +++ /dev/null @@ -1,25 +0,0 @@ -import { raf } from '@ionic/angular/common'; -import { setupConfig } from '@ionic/core'; -import { defineCustomElements } from '@ionic/core/loader'; -// TODO(FW-2827): types -export const appInitialize = (config, doc, zone) => { - return () => { - const win = doc.defaultView; - if (win && typeof window !== 'undefined') { - setupConfig(Object.assign(Object.assign({}, config), { _zoneGate: (h) => zone.run(h) })); - const aelFn = '__zone_symbol__addEventListener' in doc.body ? '__zone_symbol__addEventListener' : 'addEventListener'; - return defineCustomElements(win, { - exclude: ['ion-tabs'], - syncQueue: true, - raf, - jmp: (h) => zone.runOutsideAngular(h), - ael(elm, eventName, cb, opts) { - elm[aelFn](eventName, cb, opts); - }, - rel(elm, eventName, cb, opts) { - elm.removeEventListener(eventName, cb, opts); - }, - }); - } - }; -}; diff --git a/packages/angular/build/es2015/lazy/src/directives/angular-component-lib/utils.js b/packages/angular/build/es2015/lazy/src/directives/angular-component-lib/utils.js deleted file mode 100644 index 4bfe4ea9066..00000000000 --- a/packages/angular/build/es2015/lazy/src/directives/angular-component-lib/utils.js +++ /dev/null @@ -1,58 +0,0 @@ -/* eslint-disable */ -/* tslint:disable */ -import { fromEvent } from 'rxjs'; -export const proxyInputs = (Cmp, inputs) => { - const Prototype = Cmp.prototype; - inputs.forEach((item) => { - Object.defineProperty(Prototype, item, { - get() { - return this.el[item]; - }, - set(val) { - this.z.runOutsideAngular(() => (this.el[item] = val)); - }, - /** - * In the event that proxyInputs is called - * multiple times re-defining these inputs - * will cause an error to be thrown. As a result - * we set configurable: true to indicate these - * properties can be changed. - */ - configurable: true, - }); - }); -}; -export const proxyMethods = (Cmp, methods) => { - const Prototype = Cmp.prototype; - methods.forEach((methodName) => { - Prototype[methodName] = function () { - const args = arguments; - return this.z.runOutsideAngular(() => this.el[methodName].apply(this.el, args)); - }; - }); -}; -export const proxyOutputs = (instance, el, events) => { - events.forEach((eventName) => (instance[eventName] = fromEvent(el, eventName))); -}; -export const defineCustomElement = (tagName, customElement) => { - if (customElement !== undefined && typeof customElements !== 'undefined' && !customElements.get(tagName)) { - customElements.define(tagName, customElement); - } -}; -// tslint:disable-next-line: only-arrow-functions -export function ProxyCmp(opts) { - const decorator = function (cls) { - const { defineCustomElementFn, inputs, methods } = opts; - if (defineCustomElementFn !== undefined) { - defineCustomElementFn(); - } - if (inputs) { - proxyInputs(cls, inputs); - } - if (methods) { - proxyMethods(cls, methods); - } - return cls; - }; - return decorator; -} diff --git a/packages/angular/build/es2015/lazy/src/directives/control-value-accessors/boolean-value-accessor.js b/packages/angular/build/es2015/lazy/src/directives/control-value-accessors/boolean-value-accessor.js deleted file mode 100644 index 1387a1d54a9..00000000000 --- a/packages/angular/build/es2015/lazy/src/directives/control-value-accessors/boolean-value-accessor.js +++ /dev/null @@ -1,38 +0,0 @@ -import { __decorate } from "tslib"; -import { Directive, HostListener } from '@angular/core'; -import { NG_VALUE_ACCESSOR } from '@angular/forms'; -import { ValueAccessor, setIonicClasses } from '@ionic/angular/common'; -let BooleanValueAccessorDirective = class BooleanValueAccessorDirective extends ValueAccessor { - constructor(injector, el) { - super(injector, el); - } - writeValue(value) { - this.elementRef.nativeElement.checked = this.lastValue = value; - setIonicClasses(this.elementRef); - } - // Bind `$event` and cast `.target` in the body rather than `['$event.target']`: - // this directive's multi-element selector makes Angular 22's stricter host-binding - // type checking infer `$event` as the DOM `Event` (target: `EventTarget | null`), - // not the concrete element. The single-element standalone CVAs keep `['$event.target']`. - _handleIonChange(ev) { - const el = ev.target; - this.handleValueChange(el, el.checked); - } -}; -__decorate([ - HostListener('ionChange', ['$event']) -], BooleanValueAccessorDirective.prototype, "_handleIonChange", null); -BooleanValueAccessorDirective = __decorate([ - Directive({ - standalone: false, - selector: 'ion-checkbox,ion-toggle', - providers: [ - { - provide: NG_VALUE_ACCESSOR, - useExisting: BooleanValueAccessorDirective, - multi: true, - }, - ], - }) -], BooleanValueAccessorDirective); -export { BooleanValueAccessorDirective }; diff --git a/packages/angular/build/es2015/lazy/src/directives/control-value-accessors/index.js b/packages/angular/build/es2015/lazy/src/directives/control-value-accessors/index.js deleted file mode 100644 index 84a18e0b925..00000000000 --- a/packages/angular/build/es2015/lazy/src/directives/control-value-accessors/index.js +++ /dev/null @@ -1,4 +0,0 @@ -export * from './boolean-value-accessor'; -export * from './numeric-value-accessor'; -export * from './select-value-accessor'; -export * from './text-value-accessor'; diff --git a/packages/angular/build/es2015/lazy/src/directives/control-value-accessors/numeric-value-accessor.js b/packages/angular/build/es2015/lazy/src/directives/control-value-accessors/numeric-value-accessor.js deleted file mode 100644 index 027fe915630..00000000000 --- a/packages/angular/build/es2015/lazy/src/directives/control-value-accessors/numeric-value-accessor.js +++ /dev/null @@ -1,45 +0,0 @@ -import { __decorate } from "tslib"; -import { Directive, HostListener } from '@angular/core'; -import { NG_VALUE_ACCESSOR } from '@angular/forms'; -import { ValueAccessor } from '@ionic/angular/common'; -let NumericValueAccessorDirective = class NumericValueAccessorDirective extends ValueAccessor { - constructor(injector, el) { - super(injector, el); - this.el = el; - } - // Bind `$event` and cast `.target` in the body rather than `['$event.target']`: - // this directive's multi-element selector makes Angular 22's stricter host-binding - // type checking infer `$event` as the DOM `Event` (target: `EventTarget | null`), - // not the concrete element. The single-element standalone CVAs keep `['$event.target']`. - handleInputEvent(ev) { - const el = ev.target; - this.handleValueChange(el, el.value); - } - registerOnChange(fn) { - if (this.el.nativeElement.tagName === 'ION-INPUT' || this.el.nativeElement.tagName === 'ION-INPUT-OTP') { - super.registerOnChange((value) => { - fn(value === '' ? null : parseFloat(value)); - }); - } - else { - super.registerOnChange(fn); - } - } -}; -__decorate([ - HostListener('ionInput', ['$event']) -], NumericValueAccessorDirective.prototype, "handleInputEvent", null); -NumericValueAccessorDirective = __decorate([ - Directive({ - standalone: false, - selector: 'ion-input[type=number],ion-input-otp:not([type=text]),ion-range', - providers: [ - { - provide: NG_VALUE_ACCESSOR, - useExisting: NumericValueAccessorDirective, - multi: true, - }, - ], - }) -], NumericValueAccessorDirective); -export { NumericValueAccessorDirective }; diff --git a/packages/angular/build/es2015/lazy/src/directives/control-value-accessors/select-value-accessor.js b/packages/angular/build/es2015/lazy/src/directives/control-value-accessors/select-value-accessor.js deleted file mode 100644 index d4cd780c645..00000000000 --- a/packages/angular/build/es2015/lazy/src/directives/control-value-accessors/select-value-accessor.js +++ /dev/null @@ -1,35 +0,0 @@ -import { __decorate } from "tslib"; -import { Directive, HostListener } from '@angular/core'; -import { NG_VALUE_ACCESSOR } from '@angular/forms'; -import { ValueAccessor } from '@ionic/angular/common'; -let SelectValueAccessorDirective = class SelectValueAccessorDirective extends ValueAccessor { - constructor(injector, el) { - super(injector, el); - } - // Bind `$event` and cast `.target` in the body rather than `['$event.target']`: - // this directive's multi-element selector makes Angular 22's stricter host-binding - // type checking infer `$event` as the DOM `Event` (target: `EventTarget | null`), - // not the concrete element. The single-element standalone CVAs keep `['$event.target']`. - _handleChangeEvent(ev) { - const el = ev.target; - this.handleValueChange(el, el.value); - } -}; -__decorate([ - HostListener('ionChange', ['$event']) -], SelectValueAccessorDirective.prototype, "_handleChangeEvent", null); -SelectValueAccessorDirective = __decorate([ - Directive({ - standalone: false, - /* tslint:disable-next-line:directive-selector */ - selector: 'ion-select, ion-radio-group, ion-segment, ion-datetime', - providers: [ - { - provide: NG_VALUE_ACCESSOR, - useExisting: SelectValueAccessorDirective, - multi: true, - }, - ], - }) -], SelectValueAccessorDirective); -export { SelectValueAccessorDirective }; diff --git a/packages/angular/build/es2015/lazy/src/directives/control-value-accessors/text-value-accessor.js b/packages/angular/build/es2015/lazy/src/directives/control-value-accessors/text-value-accessor.js deleted file mode 100644 index d97091c6373..00000000000 --- a/packages/angular/build/es2015/lazy/src/directives/control-value-accessors/text-value-accessor.js +++ /dev/null @@ -1,34 +0,0 @@ -import { __decorate } from "tslib"; -import { Directive, HostListener } from '@angular/core'; -import { NG_VALUE_ACCESSOR } from '@angular/forms'; -import { ValueAccessor } from '@ionic/angular/common'; -let TextValueAccessorDirective = class TextValueAccessorDirective extends ValueAccessor { - constructor(injector, el) { - super(injector, el); - } - // Bind `$event` and cast `.target` in the body rather than `['$event.target']`: - // this directive's multi-element selector makes Angular 22's stricter host-binding - // type checking infer `$event` as the DOM `Event` (target: `EventTarget | null`), - // not the concrete element. The single-element standalone CVAs keep `['$event.target']`. - _handleInputEvent(ev) { - const el = ev.target; - this.handleValueChange(el, el.value); - } -}; -__decorate([ - HostListener('ionInput', ['$event']) -], TextValueAccessorDirective.prototype, "_handleInputEvent", null); -TextValueAccessorDirective = __decorate([ - Directive({ - standalone: false, - selector: 'ion-input:not([type=number]),ion-input-otp[type=text],ion-textarea,ion-searchbar', - providers: [ - { - provide: NG_VALUE_ACCESSOR, - useExisting: TextValueAccessorDirective, - multi: true, - }, - ], - }) -], TextValueAccessorDirective); -export { TextValueAccessorDirective }; diff --git a/packages/angular/build/es2015/lazy/src/directives/navigation/ion-back-button.js b/packages/angular/build/es2015/lazy/src/directives/navigation/ion-back-button.js deleted file mode 100644 index 640b1614164..00000000000 --- a/packages/angular/build/es2015/lazy/src/directives/navigation/ion-back-button.js +++ /dev/null @@ -1,18 +0,0 @@ -import { __decorate, __param } from "tslib"; -import { Optional, Component, ChangeDetectionStrategy } from '@angular/core'; -import { IonBackButton as IonBackButtonBase } from '@ionic/angular/common'; -let IonBackButton = class IonBackButton extends IonBackButtonBase { - constructor(routerOutlet, navCtrl, config, r, z, c) { - super(routerOutlet, navCtrl, config, r, z, c); - } -}; -IonBackButton = __decorate([ - Component({ - standalone: false, - selector: 'ion-back-button', - template: '', - changeDetection: ChangeDetectionStrategy.OnPush, - }), - __param(0, Optional()) -], IonBackButton); -export { IonBackButton }; diff --git a/packages/angular/build/es2015/lazy/src/directives/navigation/ion-nav.js b/packages/angular/build/es2015/lazy/src/directives/navigation/ion-nav.js deleted file mode 100644 index 7ba45134b96..00000000000 --- a/packages/angular/build/es2015/lazy/src/directives/navigation/ion-nav.js +++ /dev/null @@ -1,17 +0,0 @@ -import { __decorate } from "tslib"; -import { Component, ChangeDetectionStrategy, } from '@angular/core'; -import { IonNav as IonNavBase } from '@ionic/angular/common'; -let IonNav = class IonNav extends IonNavBase { - constructor(ref, environmentInjector, injector, angularDelegate, z, c) { - super(ref, environmentInjector, injector, angularDelegate, z, c); - } -}; -IonNav = __decorate([ - Component({ - standalone: false, - selector: 'ion-nav', - template: '', - changeDetection: ChangeDetectionStrategy.OnPush, - }) -], IonNav); -export { IonNav }; diff --git a/packages/angular/build/es2015/lazy/src/directives/navigation/ion-router-outlet.js b/packages/angular/build/es2015/lazy/src/directives/navigation/ion-router-outlet.js deleted file mode 100644 index e26c07e1df0..00000000000 --- a/packages/angular/build/es2015/lazy/src/directives/navigation/ion-router-outlet.js +++ /dev/null @@ -1,31 +0,0 @@ -import { __decorate, __param } from "tslib"; -import { ViewChild, ViewContainerRef, Component, Attribute, Optional, SkipSelf, } from '@angular/core'; -import { IonRouterOutlet as IonRouterOutletBase } from '@ionic/angular/common'; -let IonRouterOutlet = class IonRouterOutlet extends IonRouterOutletBase { - /** - * We need to pass in the correct instance of IonRouterOutlet - * otherwise parentOutlet will be null in a nested outlet context. - * This results in APIs such as NavController.pop not working - * in nested outlets because the parent outlet cannot be found. - */ - constructor(name, tabs, commonLocation, elementRef, router, zone, activatedRoute, parentOutlet) { - super(name, tabs, commonLocation, elementRef, router, zone, activatedRoute, parentOutlet); - this.parentOutlet = parentOutlet; - } -}; -__decorate([ - ViewChild('outletContent', { read: ViewContainerRef, static: true }) -], IonRouterOutlet.prototype, "outletContent", void 0); -IonRouterOutlet = __decorate([ - Component({ - standalone: false, - selector: 'ion-router-outlet', - template: '', - }), - __param(0, Attribute('name')), - __param(1, Optional()), - __param(1, Attribute('tabs')), - __param(7, SkipSelf()), - __param(7, Optional()) -], IonRouterOutlet); -export { IonRouterOutlet }; diff --git a/packages/angular/build/es2015/lazy/src/directives/navigation/ion-tabs.js b/packages/angular/build/es2015/lazy/src/directives/navigation/ion-tabs.js deleted file mode 100644 index ee50ce7e387..00000000000 --- a/packages/angular/build/es2015/lazy/src/directives/navigation/ion-tabs.js +++ /dev/null @@ -1,66 +0,0 @@ -import { __decorate } from "tslib"; -import { Component, ContentChild, ContentChildren, ViewChild } from '@angular/core'; -import { IonTabs as IonTabsBase } from '@ionic/angular/common'; -import { IonTabBar, IonTab } from '../proxies'; -import { IonRouterOutlet } from './ion-router-outlet'; -let IonTabs = class IonTabs extends IonTabsBase { -}; -__decorate([ - ViewChild('outlet', { read: IonRouterOutlet, static: false }) -], IonTabs.prototype, "outlet", void 0); -__decorate([ - ContentChild(IonTabBar, { static: false }) -], IonTabs.prototype, "tabBar", void 0); -__decorate([ - ContentChildren(IonTabBar) -], IonTabs.prototype, "tabBars", void 0); -__decorate([ - ContentChildren(IonTab) -], IonTabs.prototype, "tabs", void 0); -IonTabs = __decorate([ - Component({ - standalone: false, - selector: 'ion-tabs', - template: ` - -
- - -
- - `, - styles: [ - ` - :host { - display: flex; - position: absolute; - top: 0; - left: 0; - right: 0; - bottom: 0; - - flex-direction: column; - - width: 100%; - height: 100%; - - contain: layout size style; - } - .tabs-inner { - position: relative; - - flex: 1; - - contain: layout size style; - } - `, - ], - }) -], IonTabs); -export { IonTabs }; diff --git a/packages/angular/build/es2015/lazy/src/directives/navigation/router-link-delegate.js b/packages/angular/build/es2015/lazy/src/directives/navigation/router-link-delegate.js deleted file mode 100644 index c3544e1358b..00000000000 --- a/packages/angular/build/es2015/lazy/src/directives/navigation/router-link-delegate.js +++ /dev/null @@ -1,27 +0,0 @@ -import { __decorate } from "tslib"; -import { Directive } from '@angular/core'; -import { RouterLinkDelegateDirective as RouterLinkDelegateBase, RouterLinkWithHrefDelegateDirective as RouterLinkHrefDelegateBase, } from '@ionic/angular/common'; -/** - * Adds support for Ionic routing directions and animations to the base Angular router link directive. - * - * When the router link is clicked, the directive will assign the direction and - * animation so that the routing integration will transition correctly. - */ -let RouterLinkDelegateDirective = class RouterLinkDelegateDirective extends RouterLinkDelegateBase { -}; -RouterLinkDelegateDirective = __decorate([ - Directive({ - standalone: false, - selector: ':not(a):not(area)[routerLink]', - }) -], RouterLinkDelegateDirective); -export { RouterLinkDelegateDirective }; -let RouterLinkWithHrefDelegateDirective = class RouterLinkWithHrefDelegateDirective extends RouterLinkHrefDelegateBase { -}; -RouterLinkWithHrefDelegateDirective = __decorate([ - Directive({ - standalone: false, - selector: 'a[routerLink],area[routerLink]', - }) -], RouterLinkWithHrefDelegateDirective); -export { RouterLinkWithHrefDelegateDirective }; diff --git a/packages/angular/build/es2015/lazy/src/directives/overlays/modal.js b/packages/angular/build/es2015/lazy/src/directives/overlays/modal.js deleted file mode 100644 index 22c67b1d573..00000000000 --- a/packages/angular/build/es2015/lazy/src/directives/overlays/modal.js +++ /dev/null @@ -1,16 +0,0 @@ -import { __decorate } from "tslib"; -import { ChangeDetectionStrategy, Component } from '@angular/core'; -import { IonModal as IonModalBase } from '@ionic/angular/common'; -let IonModal = class IonModal extends IonModalBase { -}; -IonModal = __decorate([ - Component({ - standalone: false, - selector: 'ion-modal', - changeDetection: ChangeDetectionStrategy.OnPush, - template: `
- -
`, - }) -], IonModal); -export { IonModal }; diff --git a/packages/angular/build/es2015/lazy/src/directives/overlays/popover.js b/packages/angular/build/es2015/lazy/src/directives/overlays/popover.js deleted file mode 100644 index 81bac9d6a1e..00000000000 --- a/packages/angular/build/es2015/lazy/src/directives/overlays/popover.js +++ /dev/null @@ -1,14 +0,0 @@ -import { __decorate } from "tslib"; -import { ChangeDetectionStrategy, Component } from '@angular/core'; -import { IonPopover as IonPopoverBase } from '@ionic/angular/common'; -let IonPopover = class IonPopover extends IonPopoverBase { -}; -IonPopover = __decorate([ - Component({ - standalone: false, - selector: 'ion-popover', - changeDetection: ChangeDetectionStrategy.OnPush, - template: ``, - }) -], IonPopover); -export { IonPopover }; diff --git a/packages/angular/build/es2015/lazy/src/directives/proxies-list.js b/packages/angular/build/es2015/lazy/src/directives/proxies-list.js deleted file mode 100644 index 8e588f754c0..00000000000 --- a/packages/angular/build/es2015/lazy/src/directives/proxies-list.js +++ /dev/null @@ -1,88 +0,0 @@ -import * as d from './proxies'; -export const DIRECTIVES = [ - d.IonAccordion, - d.IonAccordionGroup, - d.IonActionSheet, - d.IonAlert, - d.IonApp, - d.IonAvatar, - d.IonBackdrop, - d.IonBadge, - d.IonBreadcrumb, - d.IonBreadcrumbs, - d.IonButton, - d.IonButtons, - d.IonCard, - d.IonCardContent, - d.IonCardHeader, - d.IonCardSubtitle, - d.IonCardTitle, - d.IonCheckbox, - d.IonChip, - d.IonCol, - d.IonContent, - d.IonDatetime, - d.IonDatetimeButton, - d.IonFab, - d.IonFabButton, - d.IonFabList, - d.IonFooter, - d.IonGrid, - d.IonHeader, - d.IonIcon, - d.IonImg, - d.IonInfiniteScroll, - d.IonInfiniteScrollContent, - d.IonInput, - d.IonInputOtp, - d.IonInputPasswordToggle, - d.IonItem, - d.IonItemDivider, - d.IonItemGroup, - d.IonItemOption, - d.IonItemOptions, - d.IonItemSliding, - d.IonLabel, - d.IonList, - d.IonListHeader, - d.IonLoading, - d.IonMenu, - d.IonMenuButton, - d.IonMenuToggle, - d.IonNavLink, - d.IonNote, - d.IonPicker, - d.IonPickerColumn, - d.IonPickerColumnOption, - d.IonProgressBar, - d.IonRadio, - d.IonRadioGroup, - d.IonRange, - d.IonRefresher, - d.IonRefresherContent, - d.IonReorder, - d.IonReorderGroup, - d.IonRippleEffect, - d.IonRow, - d.IonSearchbar, - d.IonSegment, - d.IonSegmentButton, - d.IonSegmentContent, - d.IonSegmentView, - d.IonSelect, - d.IonSelectModal, - d.IonSelectOption, - d.IonSkeletonText, - d.IonSpinner, - d.IonSplitPane, - d.IonTab, - d.IonTabBar, - d.IonTabButton, - d.IonText, - d.IonTextarea, - d.IonThumbnail, - d.IonTitle, - d.IonToast, - d.IonToggle, - d.IonToolbar -]; diff --git a/packages/angular/build/es2015/lazy/src/directives/proxies.js b/packages/angular/build/es2015/lazy/src/directives/proxies.js deleted file mode 100644 index a93098dea6b..00000000000 --- a/packages/angular/build/es2015/lazy/src/directives/proxies.js +++ /dev/null @@ -1,2272 +0,0 @@ -import { __decorate } from "tslib"; -/* tslint:disable */ -/* auto-generated angular directive proxies */ -import { ChangeDetectionStrategy, Component, EventEmitter, Output } from '@angular/core'; -import { ProxyCmp } from './angular-component-lib/utils'; -let IonAccordion = class IonAccordion { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonAccordion = __decorate([ - ProxyCmp({ - inputs: ['disabled', 'mode', 'readonly', 'toggleIcon', 'toggleIconSlot', 'value'] - }), - Component({ - selector: 'ion-accordion', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['disabled', 'mode', 'readonly', 'toggleIcon', 'toggleIconSlot', 'value'], - standalone: false - }) -], IonAccordion); -export { IonAccordion }; -let IonAccordionGroup = class IonAccordionGroup { - constructor(c, r, z) { - this.z = z; - this.ionChange = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonAccordionGroup.prototype, "ionChange", void 0); -IonAccordionGroup = __decorate([ - ProxyCmp({ - inputs: ['animated', 'disabled', 'expand', 'mode', 'multiple', 'readonly', 'value'] - }), - Component({ - selector: 'ion-accordion-group', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['animated', 'disabled', 'expand', 'mode', 'multiple', 'readonly', 'value'], - outputs: ['ionChange'], - standalone: false - }) -], IonAccordionGroup); -export { IonAccordionGroup }; -let IonActionSheet = class IonActionSheet { - constructor(c, r, z) { - this.z = z; - this.ionActionSheetDidPresent = new EventEmitter(); - this.ionActionSheetWillPresent = new EventEmitter(); - this.ionActionSheetWillDismiss = new EventEmitter(); - this.ionActionSheetDidDismiss = new EventEmitter(); - this.didPresent = new EventEmitter(); - this.willPresent = new EventEmitter(); - this.willDismiss = new EventEmitter(); - this.didDismiss = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonActionSheet.prototype, "ionActionSheetDidPresent", void 0); -__decorate([ - Output() -], IonActionSheet.prototype, "ionActionSheetWillPresent", void 0); -__decorate([ - Output() -], IonActionSheet.prototype, "ionActionSheetWillDismiss", void 0); -__decorate([ - Output() -], IonActionSheet.prototype, "ionActionSheetDidDismiss", void 0); -__decorate([ - Output() -], IonActionSheet.prototype, "didPresent", void 0); -__decorate([ - Output() -], IonActionSheet.prototype, "willPresent", void 0); -__decorate([ - Output() -], IonActionSheet.prototype, "willDismiss", void 0); -__decorate([ - Output() -], IonActionSheet.prototype, "didDismiss", void 0); -IonActionSheet = __decorate([ - ProxyCmp({ - inputs: ['animated', 'backdropDismiss', 'buttons', 'cssClass', 'enterAnimation', 'header', 'htmlAttributes', 'isOpen', 'keyboardClose', 'leaveAnimation', 'mode', 'subHeader', 'translucent', 'trigger'], - methods: ['present', 'dismiss', 'onDidDismiss', 'onWillDismiss'] - }), - Component({ - selector: 'ion-action-sheet', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['animated', 'backdropDismiss', 'buttons', 'cssClass', 'enterAnimation', 'header', 'htmlAttributes', 'isOpen', 'keyboardClose', 'leaveAnimation', 'mode', 'subHeader', 'translucent', 'trigger'], - outputs: ['ionActionSheetDidPresent', 'ionActionSheetWillPresent', 'ionActionSheetWillDismiss', 'ionActionSheetDidDismiss', 'didPresent', 'willPresent', 'willDismiss', 'didDismiss'], - standalone: false - }) -], IonActionSheet); -export { IonActionSheet }; -let IonAlert = class IonAlert { - constructor(c, r, z) { - this.z = z; - this.ionAlertDidPresent = new EventEmitter(); - this.ionAlertWillPresent = new EventEmitter(); - this.ionAlertWillDismiss = new EventEmitter(); - this.ionAlertDidDismiss = new EventEmitter(); - this.didPresent = new EventEmitter(); - this.willPresent = new EventEmitter(); - this.willDismiss = new EventEmitter(); - this.didDismiss = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonAlert.prototype, "ionAlertDidPresent", void 0); -__decorate([ - Output() -], IonAlert.prototype, "ionAlertWillPresent", void 0); -__decorate([ - Output() -], IonAlert.prototype, "ionAlertWillDismiss", void 0); -__decorate([ - Output() -], IonAlert.prototype, "ionAlertDidDismiss", void 0); -__decorate([ - Output() -], IonAlert.prototype, "didPresent", void 0); -__decorate([ - Output() -], IonAlert.prototype, "willPresent", void 0); -__decorate([ - Output() -], IonAlert.prototype, "willDismiss", void 0); -__decorate([ - Output() -], IonAlert.prototype, "didDismiss", void 0); -IonAlert = __decorate([ - ProxyCmp({ - inputs: ['animated', 'backdropDismiss', 'buttons', 'cssClass', 'enterAnimation', 'header', 'htmlAttributes', 'inputs', 'isOpen', 'keyboardClose', 'leaveAnimation', 'message', 'mode', 'subHeader', 'translucent', 'trigger'], - methods: ['present', 'dismiss', 'onDidDismiss', 'onWillDismiss'] - }), - Component({ - selector: 'ion-alert', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['animated', 'backdropDismiss', 'buttons', 'cssClass', 'enterAnimation', 'header', 'htmlAttributes', 'inputs', 'isOpen', 'keyboardClose', 'leaveAnimation', 'message', 'mode', 'subHeader', 'translucent', 'trigger'], - outputs: ['ionAlertDidPresent', 'ionAlertWillPresent', 'ionAlertWillDismiss', 'ionAlertDidDismiss', 'didPresent', 'willPresent', 'willDismiss', 'didDismiss'], - standalone: false - }) -], IonAlert); -export { IonAlert }; -let IonApp = class IonApp { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonApp = __decorate([ - ProxyCmp({ - methods: ['setFocus'] - }), - Component({ - selector: 'ion-app', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: [], - standalone: false - }) -], IonApp); -export { IonApp }; -let IonAvatar = class IonAvatar { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonAvatar = __decorate([ - ProxyCmp({}), - Component({ - selector: 'ion-avatar', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: [], - standalone: false - }) -], IonAvatar); -export { IonAvatar }; -let IonBackdrop = class IonBackdrop { - constructor(c, r, z) { - this.z = z; - this.ionBackdropTap = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonBackdrop.prototype, "ionBackdropTap", void 0); -IonBackdrop = __decorate([ - ProxyCmp({ - inputs: ['stopPropagation', 'tappable', 'visible'] - }), - Component({ - selector: 'ion-backdrop', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['stopPropagation', 'tappable', 'visible'], - outputs: ['ionBackdropTap'], - standalone: false - }) -], IonBackdrop); -export { IonBackdrop }; -let IonBadge = class IonBadge { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonBadge = __decorate([ - ProxyCmp({ - inputs: ['color', 'mode'] - }), - Component({ - selector: 'ion-badge', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'mode'], - standalone: false - }) -], IonBadge); -export { IonBadge }; -let IonBreadcrumb = class IonBreadcrumb { - constructor(c, r, z) { - this.z = z; - this.ionFocus = new EventEmitter(); - this.ionBlur = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonBreadcrumb.prototype, "ionFocus", void 0); -__decorate([ - Output() -], IonBreadcrumb.prototype, "ionBlur", void 0); -IonBreadcrumb = __decorate([ - ProxyCmp({ - inputs: ['active', 'color', 'disabled', 'download', 'href', 'mode', 'rel', 'routerAnimation', 'routerDirection', 'separator', 'target'] - }), - Component({ - selector: 'ion-breadcrumb', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['active', 'color', 'disabled', 'download', 'href', 'mode', 'rel', 'routerAnimation', 'routerDirection', 'separator', 'target'], - outputs: ['ionFocus', 'ionBlur'], - standalone: false - }) -], IonBreadcrumb); -export { IonBreadcrumb }; -let IonBreadcrumbs = class IonBreadcrumbs { - constructor(c, r, z) { - this.z = z; - this.ionCollapsedClick = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonBreadcrumbs.prototype, "ionCollapsedClick", void 0); -IonBreadcrumbs = __decorate([ - ProxyCmp({ - inputs: ['color', 'itemsAfterCollapse', 'itemsBeforeCollapse', 'maxItems', 'mode'] - }), - Component({ - selector: 'ion-breadcrumbs', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'itemsAfterCollapse', 'itemsBeforeCollapse', 'maxItems', 'mode'], - outputs: ['ionCollapsedClick'], - standalone: false - }) -], IonBreadcrumbs); -export { IonBreadcrumbs }; -let IonButton = class IonButton { - constructor(c, r, z) { - this.z = z; - this.ionFocus = new EventEmitter(); - this.ionBlur = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonButton.prototype, "ionFocus", void 0); -__decorate([ - Output() -], IonButton.prototype, "ionBlur", void 0); -IonButton = __decorate([ - ProxyCmp({ - inputs: ['buttonType', 'color', 'disabled', 'download', 'expand', 'fill', 'form', 'href', 'mode', 'rel', 'routerAnimation', 'routerDirection', 'shape', 'size', 'strong', 'target', 'type'] - }), - Component({ - selector: 'ion-button', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['buttonType', 'color', 'disabled', 'download', 'expand', 'fill', 'form', 'href', 'mode', 'rel', 'routerAnimation', 'routerDirection', 'shape', 'size', 'strong', 'target', 'type'], - outputs: ['ionFocus', 'ionBlur'], - standalone: false - }) -], IonButton); -export { IonButton }; -let IonButtons = class IonButtons { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonButtons = __decorate([ - ProxyCmp({ - inputs: ['collapse'] - }), - Component({ - selector: 'ion-buttons', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['collapse'], - standalone: false - }) -], IonButtons); -export { IonButtons }; -let IonCard = class IonCard { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonCard = __decorate([ - ProxyCmp({ - inputs: ['button', 'color', 'disabled', 'download', 'href', 'mode', 'rel', 'routerAnimation', 'routerDirection', 'target', 'type'] - }), - Component({ - selector: 'ion-card', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['button', 'color', 'disabled', 'download', 'href', 'mode', 'rel', 'routerAnimation', 'routerDirection', 'target', 'type'], - standalone: false - }) -], IonCard); -export { IonCard }; -let IonCardContent = class IonCardContent { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonCardContent = __decorate([ - ProxyCmp({ - inputs: ['mode'] - }), - Component({ - selector: 'ion-card-content', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['mode'], - standalone: false - }) -], IonCardContent); -export { IonCardContent }; -let IonCardHeader = class IonCardHeader { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonCardHeader = __decorate([ - ProxyCmp({ - inputs: ['color', 'mode', 'translucent'] - }), - Component({ - selector: 'ion-card-header', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'mode', 'translucent'], - standalone: false - }) -], IonCardHeader); -export { IonCardHeader }; -let IonCardSubtitle = class IonCardSubtitle { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonCardSubtitle = __decorate([ - ProxyCmp({ - inputs: ['color', 'mode'] - }), - Component({ - selector: 'ion-card-subtitle', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'mode'], - standalone: false - }) -], IonCardSubtitle); -export { IonCardSubtitle }; -let IonCardTitle = class IonCardTitle { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonCardTitle = __decorate([ - ProxyCmp({ - inputs: ['color', 'mode'] - }), - Component({ - selector: 'ion-card-title', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'mode'], - standalone: false - }) -], IonCardTitle); -export { IonCardTitle }; -let IonCheckbox = class IonCheckbox { - constructor(c, r, z) { - this.z = z; - this.ionChange = new EventEmitter(); - this.ionFocus = new EventEmitter(); - this.ionBlur = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonCheckbox.prototype, "ionChange", void 0); -__decorate([ - Output() -], IonCheckbox.prototype, "ionFocus", void 0); -__decorate([ - Output() -], IonCheckbox.prototype, "ionBlur", void 0); -IonCheckbox = __decorate([ - ProxyCmp({ - inputs: ['alignment', 'checked', 'color', 'disabled', 'errorText', 'helperText', 'indeterminate', 'justify', 'labelPlacement', 'mode', 'name', 'required', 'value'] - }), - Component({ - selector: 'ion-checkbox', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['alignment', 'checked', 'color', 'disabled', 'errorText', 'helperText', 'indeterminate', 'justify', 'labelPlacement', 'mode', 'name', 'required', 'value'], - outputs: ['ionChange', 'ionFocus', 'ionBlur'], - standalone: false - }) -], IonCheckbox); -export { IonCheckbox }; -let IonChip = class IonChip { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonChip = __decorate([ - ProxyCmp({ - inputs: ['color', 'disabled', 'mode', 'outline'] - }), - Component({ - selector: 'ion-chip', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'disabled', 'mode', 'outline'], - standalone: false - }) -], IonChip); -export { IonChip }; -let IonCol = class IonCol { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonCol = __decorate([ - 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'] - }), - Component({ - selector: 'ion-col', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - 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'], - standalone: false - }) -], IonCol); -export { IonCol }; -let IonContent = class IonContent { - constructor(c, r, z) { - this.z = z; - this.ionScrollStart = new EventEmitter(); - this.ionScroll = new EventEmitter(); - this.ionScrollEnd = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonContent.prototype, "ionScrollStart", void 0); -__decorate([ - Output() -], IonContent.prototype, "ionScroll", void 0); -__decorate([ - Output() -], IonContent.prototype, "ionScrollEnd", void 0); -IonContent = __decorate([ - ProxyCmp({ - inputs: ['color', 'fixedSlotPlacement', 'forceOverscroll', 'fullscreen', 'scrollEvents', 'scrollX', 'scrollY'], - methods: ['getScrollElement', 'scrollToTop', 'scrollToBottom', 'scrollByPoint', 'scrollToPoint'] - }), - Component({ - selector: 'ion-content', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'fixedSlotPlacement', 'forceOverscroll', 'fullscreen', 'scrollEvents', 'scrollX', 'scrollY'], - outputs: ['ionScrollStart', 'ionScroll', 'ionScrollEnd'], - standalone: false - }) -], IonContent); -export { IonContent }; -let IonDatetime = class IonDatetime { - constructor(c, r, z) { - this.z = z; - this.ionCancel = new EventEmitter(); - this.ionChange = new EventEmitter(); - this.ionFocus = new EventEmitter(); - this.ionBlur = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonDatetime.prototype, "ionCancel", void 0); -__decorate([ - Output() -], IonDatetime.prototype, "ionChange", void 0); -__decorate([ - Output() -], IonDatetime.prototype, "ionFocus", void 0); -__decorate([ - Output() -], IonDatetime.prototype, "ionBlur", void 0); -IonDatetime = __decorate([ - ProxyCmp({ - inputs: ['cancelText', 'clearText', 'color', 'dayValues', 'disabled', 'doneText', 'firstDayOfWeek', 'formatOptions', 'highlightedDates', 'hourCycle', 'hourValues', 'isDateEnabled', 'locale', 'max', 'min', 'minuteValues', 'mode', 'monthValues', 'multiple', 'name', 'preferWheel', 'presentation', 'readonly', 'showAdjacentDays', 'showClearButton', 'showDefaultButtons', 'showDefaultTimeLabel', 'showDefaultTitle', 'size', 'titleSelectedDatesFormatter', 'value', 'yearValues'], - methods: ['confirm', 'reset', 'cancel'] - }), - Component({ - selector: 'ion-datetime', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['cancelText', 'clearText', 'color', 'dayValues', 'disabled', 'doneText', 'firstDayOfWeek', 'formatOptions', 'highlightedDates', 'hourCycle', 'hourValues', 'isDateEnabled', 'locale', 'max', 'min', 'minuteValues', 'mode', 'monthValues', 'multiple', 'name', 'preferWheel', 'presentation', 'readonly', 'showAdjacentDays', 'showClearButton', 'showDefaultButtons', 'showDefaultTimeLabel', 'showDefaultTitle', 'size', 'titleSelectedDatesFormatter', 'value', 'yearValues'], - outputs: ['ionCancel', 'ionChange', 'ionFocus', 'ionBlur'], - standalone: false - }) -], IonDatetime); -export { IonDatetime }; -let IonDatetimeButton = class IonDatetimeButton { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonDatetimeButton = __decorate([ - ProxyCmp({ - inputs: ['color', 'datetime', 'disabled', 'mode'] - }), - Component({ - selector: 'ion-datetime-button', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'datetime', 'disabled', 'mode'], - standalone: false - }) -], IonDatetimeButton); -export { IonDatetimeButton }; -let IonFab = class IonFab { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonFab = __decorate([ - ProxyCmp({ - inputs: ['activated', 'edge', 'horizontal', 'vertical'], - methods: ['close'] - }), - Component({ - selector: 'ion-fab', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['activated', 'edge', 'horizontal', 'vertical'], - standalone: false - }) -], IonFab); -export { IonFab }; -let IonFabButton = class IonFabButton { - constructor(c, r, z) { - this.z = z; - this.ionFocus = new EventEmitter(); - this.ionBlur = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonFabButton.prototype, "ionFocus", void 0); -__decorate([ - Output() -], IonFabButton.prototype, "ionBlur", void 0); -IonFabButton = __decorate([ - ProxyCmp({ - inputs: ['activated', 'closeIcon', 'color', 'disabled', 'download', 'href', 'mode', 'rel', 'routerAnimation', 'routerDirection', 'show', 'size', 'target', 'translucent', 'type'] - }), - Component({ - selector: 'ion-fab-button', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['activated', 'closeIcon', 'color', 'disabled', 'download', 'href', 'mode', 'rel', 'routerAnimation', 'routerDirection', 'show', 'size', 'target', 'translucent', 'type'], - outputs: ['ionFocus', 'ionBlur'], - standalone: false - }) -], IonFabButton); -export { IonFabButton }; -let IonFabList = class IonFabList { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonFabList = __decorate([ - ProxyCmp({ - inputs: ['activated', 'side'] - }), - Component({ - selector: 'ion-fab-list', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['activated', 'side'], - standalone: false - }) -], IonFabList); -export { IonFabList }; -let IonFooter = class IonFooter { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonFooter = __decorate([ - ProxyCmp({ - inputs: ['collapse', 'mode', 'translucent'] - }), - Component({ - selector: 'ion-footer', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['collapse', 'mode', 'translucent'], - standalone: false - }) -], IonFooter); -export { IonFooter }; -let IonGrid = class IonGrid { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonGrid = __decorate([ - ProxyCmp({ - inputs: ['fixed'] - }), - Component({ - selector: 'ion-grid', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['fixed'], - standalone: false - }) -], IonGrid); -export { IonGrid }; -let IonHeader = class IonHeader { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonHeader = __decorate([ - ProxyCmp({ - inputs: ['collapse', 'mode', 'translucent'] - }), - Component({ - selector: 'ion-header', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['collapse', 'mode', 'translucent'], - standalone: false - }) -], IonHeader); -export { IonHeader }; -let IonIcon = class IonIcon { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonIcon = __decorate([ - ProxyCmp({ - inputs: ['color', 'flipRtl', 'icon', 'ios', 'lazy', 'md', 'mode', 'name', 'sanitize', 'size', 'src'] - }), - Component({ - selector: 'ion-icon', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'flipRtl', 'icon', 'ios', 'lazy', 'md', 'mode', 'name', 'sanitize', 'size', 'src'], - standalone: false - }) -], IonIcon); -export { IonIcon }; -let IonImg = class IonImg { - constructor(c, r, z) { - this.z = z; - this.ionImgWillLoad = new EventEmitter(); - this.ionImgDidLoad = new EventEmitter(); - this.ionError = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonImg.prototype, "ionImgWillLoad", void 0); -__decorate([ - Output() -], IonImg.prototype, "ionImgDidLoad", void 0); -__decorate([ - Output() -], IonImg.prototype, "ionError", void 0); -IonImg = __decorate([ - ProxyCmp({ - inputs: ['alt', 'src'] - }), - Component({ - selector: 'ion-img', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['alt', 'src'], - outputs: ['ionImgWillLoad', 'ionImgDidLoad', 'ionError'], - standalone: false - }) -], IonImg); -export { IonImg }; -let IonInfiniteScroll = class IonInfiniteScroll { - constructor(c, r, z) { - this.z = z; - this.ionInfinite = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonInfiniteScroll.prototype, "ionInfinite", void 0); -IonInfiniteScroll = __decorate([ - ProxyCmp({ - inputs: ['disabled', 'position', 'threshold'], - methods: ['complete'] - }), - Component({ - selector: 'ion-infinite-scroll', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['disabled', 'position', 'threshold'], - outputs: ['ionInfinite'], - standalone: false - }) -], IonInfiniteScroll); -export { IonInfiniteScroll }; -let IonInfiniteScrollContent = class IonInfiniteScrollContent { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonInfiniteScrollContent = __decorate([ - ProxyCmp({ - inputs: ['loadingSpinner', 'loadingText'] - }), - Component({ - selector: 'ion-infinite-scroll-content', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['loadingSpinner', 'loadingText'], - standalone: false - }) -], IonInfiniteScrollContent); -export { IonInfiniteScrollContent }; -let IonInput = class IonInput { - constructor(c, r, z) { - this.z = z; - this.ionInput = new EventEmitter(); - this.ionChange = new EventEmitter(); - this.ionBlur = new EventEmitter(); - this.ionFocus = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonInput.prototype, "ionInput", void 0); -__decorate([ - Output() -], IonInput.prototype, "ionChange", void 0); -__decorate([ - Output() -], IonInput.prototype, "ionBlur", void 0); -__decorate([ - Output() -], IonInput.prototype, "ionFocus", void 0); -IonInput = __decorate([ - ProxyCmp({ - inputs: ['autocapitalize', 'autocomplete', 'autocorrect', 'autofocus', 'clearInput', 'clearInputIcon', 'clearOnEdit', 'color', 'counter', 'counterFormatter', 'debounce', 'disabled', 'enterkeyhint', 'errorText', 'fill', 'helperText', 'inputmode', 'label', 'labelPlacement', 'max', 'maxlength', 'min', 'minlength', 'mode', 'multiple', 'name', 'pattern', 'placeholder', 'readonly', 'required', 'shape', 'spellcheck', 'step', 'type', 'value'], - methods: ['setFocus', 'getInputElement'] - }), - Component({ - selector: 'ion-input', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['autocapitalize', 'autocomplete', 'autocorrect', 'autofocus', 'clearInput', 'clearInputIcon', 'clearOnEdit', 'color', 'counter', 'counterFormatter', 'debounce', 'disabled', 'enterkeyhint', 'errorText', 'fill', 'helperText', 'inputmode', 'label', 'labelPlacement', 'max', 'maxlength', 'min', 'minlength', 'mode', 'multiple', 'name', 'pattern', 'placeholder', 'readonly', 'required', 'shape', 'spellcheck', 'step', 'type', 'value'], - outputs: ['ionInput', 'ionChange', 'ionBlur', 'ionFocus'], - standalone: false - }) -], IonInput); -export { IonInput }; -let IonInputOtp = class IonInputOtp { - constructor(c, r, z) { - this.z = z; - this.ionInput = new EventEmitter(); - this.ionChange = new EventEmitter(); - this.ionComplete = new EventEmitter(); - this.ionBlur = new EventEmitter(); - this.ionFocus = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonInputOtp.prototype, "ionInput", void 0); -__decorate([ - Output() -], IonInputOtp.prototype, "ionChange", void 0); -__decorate([ - Output() -], IonInputOtp.prototype, "ionComplete", void 0); -__decorate([ - Output() -], IonInputOtp.prototype, "ionBlur", void 0); -__decorate([ - Output() -], IonInputOtp.prototype, "ionFocus", void 0); -IonInputOtp = __decorate([ - ProxyCmp({ - inputs: ['autocapitalize', 'color', 'disabled', 'fill', 'inputmode', 'length', 'pattern', 'readonly', 'separators', 'shape', 'size', 'type', 'value'], - methods: ['setFocus'] - }), - Component({ - selector: 'ion-input-otp', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['autocapitalize', 'color', 'disabled', 'fill', 'inputmode', 'length', 'pattern', 'readonly', 'separators', 'shape', 'size', 'type', 'value'], - outputs: ['ionInput', 'ionChange', 'ionComplete', 'ionBlur', 'ionFocus'], - standalone: false - }) -], IonInputOtp); -export { IonInputOtp }; -let IonInputPasswordToggle = class IonInputPasswordToggle { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonInputPasswordToggle = __decorate([ - ProxyCmp({ - inputs: ['color', 'hideIcon', 'mode', 'showIcon'] - }), - Component({ - selector: 'ion-input-password-toggle', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'hideIcon', 'mode', 'showIcon'], - standalone: false - }) -], IonInputPasswordToggle); -export { IonInputPasswordToggle }; -let IonItem = class IonItem { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonItem = __decorate([ - ProxyCmp({ - inputs: ['button', 'color', 'detail', 'detailIcon', 'disabled', 'download', 'href', 'lines', 'mode', 'rel', 'routerAnimation', 'routerDirection', 'target', 'type'] - }), - Component({ - selector: 'ion-item', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['button', 'color', 'detail', 'detailIcon', 'disabled', 'download', 'href', 'lines', 'mode', 'rel', 'routerAnimation', 'routerDirection', 'target', 'type'], - standalone: false - }) -], IonItem); -export { IonItem }; -let IonItemDivider = class IonItemDivider { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonItemDivider = __decorate([ - ProxyCmp({ - inputs: ['color', 'mode', 'sticky'] - }), - Component({ - selector: 'ion-item-divider', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'mode', 'sticky'], - standalone: false - }) -], IonItemDivider); -export { IonItemDivider }; -let IonItemGroup = class IonItemGroup { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonItemGroup = __decorate([ - ProxyCmp({}), - Component({ - selector: 'ion-item-group', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: [], - standalone: false - }) -], IonItemGroup); -export { IonItemGroup }; -let IonItemOption = class IonItemOption { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonItemOption = __decorate([ - ProxyCmp({ - inputs: ['color', 'disabled', 'download', 'expandable', 'href', 'mode', 'rel', 'target', 'type'] - }), - Component({ - selector: 'ion-item-option', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'disabled', 'download', 'expandable', 'href', 'mode', 'rel', 'target', 'type'], - standalone: false - }) -], IonItemOption); -export { IonItemOption }; -let IonItemOptions = class IonItemOptions { - constructor(c, r, z) { - this.z = z; - this.ionSwipe = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonItemOptions.prototype, "ionSwipe", void 0); -IonItemOptions = __decorate([ - ProxyCmp({ - inputs: ['side'] - }), - Component({ - selector: 'ion-item-options', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['side'], - outputs: ['ionSwipe'], - standalone: false - }) -], IonItemOptions); -export { IonItemOptions }; -let IonItemSliding = class IonItemSliding { - constructor(c, r, z) { - this.z = z; - this.ionDrag = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonItemSliding.prototype, "ionDrag", void 0); -IonItemSliding = __decorate([ - ProxyCmp({ - inputs: ['disabled'], - methods: ['getOpenAmount', 'getSlidingRatio', 'open', 'close', 'closeOpened'] - }), - Component({ - selector: 'ion-item-sliding', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['disabled'], - outputs: ['ionDrag'], - standalone: false - }) -], IonItemSliding); -export { IonItemSliding }; -let IonLabel = class IonLabel { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonLabel = __decorate([ - ProxyCmp({ - inputs: ['color', 'mode', 'position'] - }), - Component({ - selector: 'ion-label', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'mode', 'position'], - standalone: false - }) -], IonLabel); -export { IonLabel }; -let IonList = class IonList { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonList = __decorate([ - ProxyCmp({ - inputs: ['inset', 'lines', 'mode'], - methods: ['closeSlidingItems'] - }), - Component({ - selector: 'ion-list', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['inset', 'lines', 'mode'], - standalone: false - }) -], IonList); -export { IonList }; -let IonListHeader = class IonListHeader { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonListHeader = __decorate([ - ProxyCmp({ - inputs: ['color', 'lines', 'mode'] - }), - Component({ - selector: 'ion-list-header', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'lines', 'mode'], - standalone: false - }) -], IonListHeader); -export { IonListHeader }; -let IonLoading = class IonLoading { - constructor(c, r, z) { - this.z = z; - this.ionLoadingDidPresent = new EventEmitter(); - this.ionLoadingWillPresent = new EventEmitter(); - this.ionLoadingWillDismiss = new EventEmitter(); - this.ionLoadingDidDismiss = new EventEmitter(); - this.didPresent = new EventEmitter(); - this.willPresent = new EventEmitter(); - this.willDismiss = new EventEmitter(); - this.didDismiss = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonLoading.prototype, "ionLoadingDidPresent", void 0); -__decorate([ - Output() -], IonLoading.prototype, "ionLoadingWillPresent", void 0); -__decorate([ - Output() -], IonLoading.prototype, "ionLoadingWillDismiss", void 0); -__decorate([ - Output() -], IonLoading.prototype, "ionLoadingDidDismiss", void 0); -__decorate([ - Output() -], IonLoading.prototype, "didPresent", void 0); -__decorate([ - Output() -], IonLoading.prototype, "willPresent", void 0); -__decorate([ - Output() -], IonLoading.prototype, "willDismiss", void 0); -__decorate([ - Output() -], IonLoading.prototype, "didDismiss", void 0); -IonLoading = __decorate([ - ProxyCmp({ - inputs: ['animated', 'backdropDismiss', 'cssClass', 'duration', 'enterAnimation', 'htmlAttributes', 'isOpen', 'keyboardClose', 'leaveAnimation', 'message', 'mode', 'showBackdrop', 'spinner', 'translucent', 'trigger'], - methods: ['present', 'dismiss', 'onDidDismiss', 'onWillDismiss'] - }), - Component({ - selector: 'ion-loading', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['animated', 'backdropDismiss', 'cssClass', 'duration', 'enterAnimation', 'htmlAttributes', 'isOpen', 'keyboardClose', 'leaveAnimation', 'message', 'mode', 'showBackdrop', 'spinner', 'translucent', 'trigger'], - outputs: ['ionLoadingDidPresent', 'ionLoadingWillPresent', 'ionLoadingWillDismiss', 'ionLoadingDidDismiss', 'didPresent', 'willPresent', 'willDismiss', 'didDismiss'], - standalone: false - }) -], IonLoading); -export { IonLoading }; -let IonMenu = class IonMenu { - constructor(c, r, z) { - this.z = z; - this.ionWillOpen = new EventEmitter(); - this.ionWillClose = new EventEmitter(); - this.ionDidOpen = new EventEmitter(); - this.ionDidClose = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonMenu.prototype, "ionWillOpen", void 0); -__decorate([ - Output() -], IonMenu.prototype, "ionWillClose", void 0); -__decorate([ - Output() -], IonMenu.prototype, "ionDidOpen", void 0); -__decorate([ - Output() -], IonMenu.prototype, "ionDidClose", void 0); -IonMenu = __decorate([ - ProxyCmp({ - inputs: ['contentId', 'disabled', 'maxEdgeStart', 'menuId', 'side', 'swipeGesture', 'type'], - methods: ['isOpen', 'isActive', 'open', 'close', 'toggle', 'setOpen'] - }), - Component({ - selector: 'ion-menu', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['contentId', 'disabled', 'maxEdgeStart', 'menuId', 'side', 'swipeGesture', 'type'], - outputs: ['ionWillOpen', 'ionWillClose', 'ionDidOpen', 'ionDidClose'], - standalone: false - }) -], IonMenu); -export { IonMenu }; -let IonMenuButton = class IonMenuButton { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonMenuButton = __decorate([ - ProxyCmp({ - inputs: ['autoHide', 'color', 'disabled', 'menu', 'mode', 'type'] - }), - Component({ - selector: 'ion-menu-button', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['autoHide', 'color', 'disabled', 'menu', 'mode', 'type'], - standalone: false - }) -], IonMenuButton); -export { IonMenuButton }; -let IonMenuToggle = class IonMenuToggle { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonMenuToggle = __decorate([ - ProxyCmp({ - inputs: ['autoHide', 'menu'] - }), - Component({ - selector: 'ion-menu-toggle', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['autoHide', 'menu'], - standalone: false - }) -], IonMenuToggle); -export { IonMenuToggle }; -let IonNavLink = class IonNavLink { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonNavLink = __decorate([ - ProxyCmp({ - inputs: ['component', 'componentProps', 'routerAnimation', 'routerDirection'] - }), - Component({ - selector: 'ion-nav-link', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['component', 'componentProps', 'routerAnimation', 'routerDirection'], - standalone: false - }) -], IonNavLink); -export { IonNavLink }; -let IonNote = class IonNote { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonNote = __decorate([ - ProxyCmp({ - inputs: ['color', 'mode'] - }), - Component({ - selector: 'ion-note', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'mode'], - standalone: false - }) -], IonNote); -export { IonNote }; -let IonPicker = class IonPicker { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonPicker = __decorate([ - ProxyCmp({ - inputs: ['mode'] - }), - Component({ - selector: 'ion-picker', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['mode'], - standalone: false - }) -], IonPicker); -export { IonPicker }; -let IonPickerColumn = class IonPickerColumn { - constructor(c, r, z) { - this.z = z; - this.ionChange = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonPickerColumn.prototype, "ionChange", void 0); -IonPickerColumn = __decorate([ - ProxyCmp({ - inputs: ['color', 'disabled', 'mode', 'value'], - methods: ['setFocus'] - }), - Component({ - selector: 'ion-picker-column', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'disabled', 'mode', 'value'], - outputs: ['ionChange'], - standalone: false - }) -], IonPickerColumn); -export { IonPickerColumn }; -let IonPickerColumnOption = class IonPickerColumnOption { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonPickerColumnOption = __decorate([ - ProxyCmp({ - inputs: ['color', 'disabled', 'value'] - }), - Component({ - selector: 'ion-picker-column-option', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'disabled', 'value'], - standalone: false - }) -], IonPickerColumnOption); -export { IonPickerColumnOption }; -let IonProgressBar = class IonProgressBar { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonProgressBar = __decorate([ - ProxyCmp({ - inputs: ['buffer', 'color', 'mode', 'reversed', 'type', 'value'] - }), - Component({ - selector: 'ion-progress-bar', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['buffer', 'color', 'mode', 'reversed', 'type', 'value'], - standalone: false - }) -], IonProgressBar); -export { IonProgressBar }; -let IonRadio = class IonRadio { - constructor(c, r, z) { - this.z = z; - this.ionFocus = new EventEmitter(); - this.ionBlur = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonRadio.prototype, "ionFocus", void 0); -__decorate([ - Output() -], IonRadio.prototype, "ionBlur", void 0); -IonRadio = __decorate([ - ProxyCmp({ - inputs: ['alignment', 'color', 'disabled', 'justify', 'labelPlacement', 'mode', 'name', 'value'] - }), - Component({ - selector: 'ion-radio', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['alignment', 'color', 'disabled', 'justify', 'labelPlacement', 'mode', 'name', 'value'], - outputs: ['ionFocus', 'ionBlur'], - standalone: false - }) -], IonRadio); -export { IonRadio }; -let IonRadioGroup = class IonRadioGroup { - constructor(c, r, z) { - this.z = z; - this.ionChange = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonRadioGroup.prototype, "ionChange", void 0); -IonRadioGroup = __decorate([ - ProxyCmp({ - inputs: ['allowEmptySelection', 'compareWith', 'errorText', 'helperText', 'name', 'value'] - }), - Component({ - selector: 'ion-radio-group', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['allowEmptySelection', 'compareWith', 'errorText', 'helperText', 'name', 'value'], - outputs: ['ionChange'], - standalone: false - }) -], IonRadioGroup); -export { IonRadioGroup }; -let IonRange = class IonRange { - constructor(c, r, z) { - this.z = z; - this.ionChange = new EventEmitter(); - this.ionInput = new EventEmitter(); - this.ionFocus = new EventEmitter(); - this.ionBlur = new EventEmitter(); - this.ionKnobMoveStart = new EventEmitter(); - this.ionKnobMoveEnd = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonRange.prototype, "ionChange", void 0); -__decorate([ - Output() -], IonRange.prototype, "ionInput", void 0); -__decorate([ - Output() -], IonRange.prototype, "ionFocus", void 0); -__decorate([ - Output() -], IonRange.prototype, "ionBlur", void 0); -__decorate([ - Output() -], IonRange.prototype, "ionKnobMoveStart", void 0); -__decorate([ - Output() -], IonRange.prototype, "ionKnobMoveEnd", void 0); -IonRange = __decorate([ - ProxyCmp({ - inputs: ['activeBarStart', 'color', 'debounce', 'disabled', 'dualKnobs', 'label', 'labelPlacement', 'max', 'min', 'mode', 'name', 'pin', 'pinFormatter', 'snaps', 'step', 'ticks', 'value'] - }), - Component({ - selector: 'ion-range', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['activeBarStart', 'color', 'debounce', 'disabled', 'dualKnobs', 'label', 'labelPlacement', 'max', 'min', 'mode', 'name', 'pin', 'pinFormatter', 'snaps', 'step', 'ticks', 'value'], - outputs: ['ionChange', 'ionInput', 'ionFocus', 'ionBlur', 'ionKnobMoveStart', 'ionKnobMoveEnd'], - standalone: false - }) -], IonRange); -export { IonRange }; -let IonRefresher = class IonRefresher { - constructor(c, r, z) { - this.z = z; - this.ionRefresh = new EventEmitter(); - this.ionPull = new EventEmitter(); - this.ionStart = new EventEmitter(); - this.ionPullStart = new EventEmitter(); - this.ionPullEnd = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonRefresher.prototype, "ionRefresh", void 0); -__decorate([ - Output() -], IonRefresher.prototype, "ionPull", void 0); -__decorate([ - Output() -], IonRefresher.prototype, "ionStart", void 0); -__decorate([ - Output() -], IonRefresher.prototype, "ionPullStart", void 0); -__decorate([ - Output() -], IonRefresher.prototype, "ionPullEnd", void 0); -IonRefresher = __decorate([ - ProxyCmp({ - inputs: ['closeDuration', 'disabled', 'mode', 'pullFactor', 'pullMax', 'pullMin', 'snapbackDuration'], - methods: ['complete', 'cancel', 'getProgress'] - }), - Component({ - selector: 'ion-refresher', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['closeDuration', 'disabled', 'mode', 'pullFactor', 'pullMax', 'pullMin', 'snapbackDuration'], - outputs: ['ionRefresh', 'ionPull', 'ionStart', 'ionPullStart', 'ionPullEnd'], - standalone: false - }) -], IonRefresher); -export { IonRefresher }; -let IonRefresherContent = class IonRefresherContent { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonRefresherContent = __decorate([ - ProxyCmp({ - inputs: ['pullingIcon', 'pullingText', 'refreshingSpinner', 'refreshingText'] - }), - Component({ - selector: 'ion-refresher-content', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['pullingIcon', 'pullingText', 'refreshingSpinner', 'refreshingText'], - standalone: false - }) -], IonRefresherContent); -export { IonRefresherContent }; -let IonReorder = class IonReorder { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonReorder = __decorate([ - ProxyCmp({}), - Component({ - selector: 'ion-reorder', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: [], - standalone: false - }) -], IonReorder); -export { IonReorder }; -let IonReorderGroup = class IonReorderGroup { - constructor(c, r, z) { - this.z = z; - this.ionItemReorder = new EventEmitter(); - this.ionReorderStart = new EventEmitter(); - this.ionReorderMove = new EventEmitter(); - this.ionReorderEnd = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonReorderGroup.prototype, "ionItemReorder", void 0); -__decorate([ - Output() -], IonReorderGroup.prototype, "ionReorderStart", void 0); -__decorate([ - Output() -], IonReorderGroup.prototype, "ionReorderMove", void 0); -__decorate([ - Output() -], IonReorderGroup.prototype, "ionReorderEnd", void 0); -IonReorderGroup = __decorate([ - ProxyCmp({ - inputs: ['disabled'], - methods: ['complete'] - }), - Component({ - selector: 'ion-reorder-group', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['disabled'], - outputs: ['ionItemReorder', 'ionReorderStart', 'ionReorderMove', 'ionReorderEnd'], - standalone: false - }) -], IonReorderGroup); -export { IonReorderGroup }; -let IonRippleEffect = class IonRippleEffect { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonRippleEffect = __decorate([ - ProxyCmp({ - inputs: ['type'], - methods: ['addRipple'] - }), - Component({ - selector: 'ion-ripple-effect', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['type'], - standalone: false - }) -], IonRippleEffect); -export { IonRippleEffect }; -let IonRow = class IonRow { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonRow = __decorate([ - ProxyCmp({}), - Component({ - selector: 'ion-row', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: [], - standalone: false - }) -], IonRow); -export { IonRow }; -let IonSearchbar = class IonSearchbar { - constructor(c, r, z) { - this.z = z; - this.ionInput = new EventEmitter(); - this.ionChange = new EventEmitter(); - this.ionCancel = new EventEmitter(); - this.ionClear = new EventEmitter(); - this.ionBlur = new EventEmitter(); - this.ionFocus = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonSearchbar.prototype, "ionInput", void 0); -__decorate([ - Output() -], IonSearchbar.prototype, "ionChange", void 0); -__decorate([ - Output() -], IonSearchbar.prototype, "ionCancel", void 0); -__decorate([ - Output() -], IonSearchbar.prototype, "ionClear", void 0); -__decorate([ - Output() -], IonSearchbar.prototype, "ionBlur", void 0); -__decorate([ - Output() -], IonSearchbar.prototype, "ionFocus", void 0); -IonSearchbar = __decorate([ - ProxyCmp({ - inputs: ['animated', 'autocapitalize', 'autocomplete', 'autocorrect', 'cancelButtonIcon', 'cancelButtonText', 'clearIcon', 'color', 'debounce', 'disabled', 'enterkeyhint', 'inputmode', 'maxlength', 'minlength', 'mode', 'name', 'placeholder', 'searchIcon', 'showCancelButton', 'showClearButton', 'spellcheck', 'type', 'value'], - methods: ['setFocus', 'getInputElement'] - }), - Component({ - selector: 'ion-searchbar', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['animated', 'autocapitalize', 'autocomplete', 'autocorrect', 'cancelButtonIcon', 'cancelButtonText', 'clearIcon', 'color', 'debounce', 'disabled', 'enterkeyhint', 'inputmode', 'maxlength', 'minlength', 'mode', 'name', 'placeholder', 'searchIcon', 'showCancelButton', 'showClearButton', 'spellcheck', 'type', 'value'], - outputs: ['ionInput', 'ionChange', 'ionCancel', 'ionClear', 'ionBlur', 'ionFocus'], - standalone: false - }) -], IonSearchbar); -export { IonSearchbar }; -let IonSegment = class IonSegment { - constructor(c, r, z) { - this.z = z; - this.ionChange = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonSegment.prototype, "ionChange", void 0); -IonSegment = __decorate([ - ProxyCmp({ - inputs: ['color', 'disabled', 'mode', 'scrollable', 'selectOnFocus', 'swipeGesture', 'value'] - }), - Component({ - selector: 'ion-segment', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'disabled', 'mode', 'scrollable', 'selectOnFocus', 'swipeGesture', 'value'], - outputs: ['ionChange'], - standalone: false - }) -], IonSegment); -export { IonSegment }; -let IonSegmentButton = class IonSegmentButton { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonSegmentButton = __decorate([ - ProxyCmp({ - inputs: ['contentId', 'disabled', 'layout', 'mode', 'type', 'value'] - }), - Component({ - selector: 'ion-segment-button', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['contentId', 'disabled', 'layout', 'mode', 'type', 'value'], - standalone: false - }) -], IonSegmentButton); -export { IonSegmentButton }; -let IonSegmentContent = class IonSegmentContent { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonSegmentContent = __decorate([ - ProxyCmp({}), - Component({ - selector: 'ion-segment-content', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: [], - standalone: false - }) -], IonSegmentContent); -export { IonSegmentContent }; -let IonSegmentView = class IonSegmentView { - constructor(c, r, z) { - this.z = z; - this.ionSegmentViewScroll = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonSegmentView.prototype, "ionSegmentViewScroll", void 0); -IonSegmentView = __decorate([ - ProxyCmp({ - inputs: ['disabled', 'swipeGesture'] - }), - Component({ - selector: 'ion-segment-view', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['disabled', 'swipeGesture'], - outputs: ['ionSegmentViewScroll'], - standalone: false - }) -], IonSegmentView); -export { IonSegmentView }; -let IonSelect = class IonSelect { - constructor(c, r, z) { - this.z = z; - this.ionChange = new EventEmitter(); - this.ionCancel = new EventEmitter(); - this.ionDismiss = new EventEmitter(); - this.ionFocus = new EventEmitter(); - this.ionBlur = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonSelect.prototype, "ionChange", void 0); -__decorate([ - Output() -], IonSelect.prototype, "ionCancel", void 0); -__decorate([ - Output() -], IonSelect.prototype, "ionDismiss", void 0); -__decorate([ - Output() -], IonSelect.prototype, "ionFocus", void 0); -__decorate([ - Output() -], IonSelect.prototype, "ionBlur", void 0); -IonSelect = __decorate([ - ProxyCmp({ - inputs: ['cancelText', 'color', 'compareWith', 'disabled', 'errorText', 'expandedIcon', 'fill', 'helperText', 'interface', 'interfaceOptions', 'justify', 'label', 'labelPlacement', 'mode', 'multiple', 'name', 'okText', 'placeholder', 'required', 'selectedText', 'shape', 'toggleIcon', 'value'], - methods: ['open'] - }), - Component({ - selector: 'ion-select', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['cancelText', 'color', 'compareWith', 'disabled', 'errorText', 'expandedIcon', 'fill', 'helperText', 'interface', 'interfaceOptions', 'justify', 'label', 'labelPlacement', 'mode', 'multiple', 'name', 'okText', 'placeholder', 'required', 'selectedText', 'shape', 'toggleIcon', 'value'], - outputs: ['ionChange', 'ionCancel', 'ionDismiss', 'ionFocus', 'ionBlur'], - standalone: false - }) -], IonSelect); -export { IonSelect }; -let IonSelectModal = class IonSelectModal { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonSelectModal = __decorate([ - ProxyCmp({ - inputs: ['cancelText', 'header', 'multiple', 'options'] - }), - Component({ - selector: 'ion-select-modal', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['cancelText', 'header', 'multiple', 'options'], - standalone: false - }) -], IonSelectModal); -export { IonSelectModal }; -let IonSelectOption = class IonSelectOption { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonSelectOption = __decorate([ - ProxyCmp({ - inputs: ['description', 'disabled', 'justify', 'labelPlacement', 'mode', 'value'] - }), - Component({ - selector: 'ion-select-option', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['description', 'disabled', 'justify', 'labelPlacement', 'mode', 'value'], - standalone: false - }) -], IonSelectOption); -export { IonSelectOption }; -let IonSkeletonText = class IonSkeletonText { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonSkeletonText = __decorate([ - ProxyCmp({ - inputs: ['animated'] - }), - Component({ - selector: 'ion-skeleton-text', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['animated'], - standalone: false - }) -], IonSkeletonText); -export { IonSkeletonText }; -let IonSpinner = class IonSpinner { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonSpinner = __decorate([ - ProxyCmp({ - inputs: ['color', 'duration', 'name', 'paused'] - }), - Component({ - selector: 'ion-spinner', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'duration', 'name', 'paused'], - standalone: false - }) -], IonSpinner); -export { IonSpinner }; -let IonSplitPane = class IonSplitPane { - constructor(c, r, z) { - this.z = z; - this.ionSplitPaneVisible = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonSplitPane.prototype, "ionSplitPaneVisible", void 0); -IonSplitPane = __decorate([ - ProxyCmp({ - inputs: ['contentId', 'disabled', 'when'] - }), - Component({ - selector: 'ion-split-pane', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['contentId', 'disabled', 'when'], - outputs: ['ionSplitPaneVisible'], - standalone: false - }) -], IonSplitPane); -export { IonSplitPane }; -let IonTab = class IonTab { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonTab = __decorate([ - ProxyCmp({ - inputs: ['component', 'tab'], - methods: ['setActive'] - }), - Component({ - selector: 'ion-tab', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['component', { name: 'tab', required: true }], - standalone: false - }) -], IonTab); -export { IonTab }; -let IonTabBar = class IonTabBar { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonTabBar = __decorate([ - ProxyCmp({ - inputs: ['color', 'mode', 'selectedTab', 'translucent'] - }), - Component({ - selector: 'ion-tab-bar', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'mode', 'selectedTab', 'translucent'], - standalone: false - }) -], IonTabBar); -export { IonTabBar }; -let IonTabButton = class IonTabButton { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonTabButton = __decorate([ - ProxyCmp({ - inputs: ['disabled', 'download', 'href', 'layout', 'mode', 'rel', 'selected', 'tab', 'target'] - }), - Component({ - selector: 'ion-tab-button', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['disabled', 'download', 'href', 'layout', 'mode', 'rel', 'selected', 'tab', 'target'], - standalone: false - }) -], IonTabButton); -export { IonTabButton }; -let IonText = class IonText { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonText = __decorate([ - ProxyCmp({ - inputs: ['color', 'mode'] - }), - Component({ - selector: 'ion-text', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'mode'], - standalone: false - }) -], IonText); -export { IonText }; -let IonTextarea = class IonTextarea { - constructor(c, r, z) { - this.z = z; - this.ionChange = new EventEmitter(); - this.ionInput = new EventEmitter(); - this.ionBlur = new EventEmitter(); - this.ionFocus = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonTextarea.prototype, "ionChange", void 0); -__decorate([ - Output() -], IonTextarea.prototype, "ionInput", void 0); -__decorate([ - Output() -], IonTextarea.prototype, "ionBlur", void 0); -__decorate([ - Output() -], IonTextarea.prototype, "ionFocus", void 0); -IonTextarea = __decorate([ - ProxyCmp({ - inputs: ['autoGrow', 'autocapitalize', 'autofocus', 'clearOnEdit', 'color', 'cols', 'counter', 'counterFormatter', 'debounce', 'disabled', 'enterkeyhint', 'errorText', 'fill', 'helperText', 'inputmode', 'label', 'labelPlacement', 'maxlength', 'minlength', 'mode', 'name', 'placeholder', 'readonly', 'required', 'rows', 'shape', 'spellcheck', 'value', 'wrap'], - methods: ['setFocus', 'getInputElement'] - }), - Component({ - selector: 'ion-textarea', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['autoGrow', 'autocapitalize', 'autofocus', 'clearOnEdit', 'color', 'cols', 'counter', 'counterFormatter', 'debounce', 'disabled', 'enterkeyhint', 'errorText', 'fill', 'helperText', 'inputmode', 'label', 'labelPlacement', 'maxlength', 'minlength', 'mode', 'name', 'placeholder', 'readonly', 'required', 'rows', 'shape', 'spellcheck', 'value', 'wrap'], - outputs: ['ionChange', 'ionInput', 'ionBlur', 'ionFocus'], - standalone: false - }) -], IonTextarea); -export { IonTextarea }; -let IonThumbnail = class IonThumbnail { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonThumbnail = __decorate([ - ProxyCmp({}), - Component({ - selector: 'ion-thumbnail', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: [], - standalone: false - }) -], IonThumbnail); -export { IonThumbnail }; -let IonTitle = class IonTitle { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonTitle = __decorate([ - ProxyCmp({ - inputs: ['color', 'size'] - }), - Component({ - selector: 'ion-title', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'size'], - standalone: false - }) -], IonTitle); -export { IonTitle }; -let IonToast = class IonToast { - constructor(c, r, z) { - this.z = z; - this.ionToastDidPresent = new EventEmitter(); - this.ionToastWillPresent = new EventEmitter(); - this.ionToastWillDismiss = new EventEmitter(); - this.ionToastDidDismiss = new EventEmitter(); - this.didPresent = new EventEmitter(); - this.willPresent = new EventEmitter(); - this.willDismiss = new EventEmitter(); - this.didDismiss = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonToast.prototype, "ionToastDidPresent", void 0); -__decorate([ - Output() -], IonToast.prototype, "ionToastWillPresent", void 0); -__decorate([ - Output() -], IonToast.prototype, "ionToastWillDismiss", void 0); -__decorate([ - Output() -], IonToast.prototype, "ionToastDidDismiss", void 0); -__decorate([ - Output() -], IonToast.prototype, "didPresent", void 0); -__decorate([ - Output() -], IonToast.prototype, "willPresent", void 0); -__decorate([ - Output() -], IonToast.prototype, "willDismiss", void 0); -__decorate([ - Output() -], IonToast.prototype, "didDismiss", void 0); -IonToast = __decorate([ - ProxyCmp({ - inputs: ['animated', 'buttons', 'color', 'cssClass', 'duration', 'enterAnimation', 'header', 'htmlAttributes', 'icon', 'isOpen', 'keyboardClose', 'layout', 'leaveAnimation', 'message', 'mode', 'position', 'positionAnchor', 'swipeGesture', 'translucent', 'trigger'], - methods: ['present', 'dismiss', 'onDidDismiss', 'onWillDismiss'] - }), - Component({ - selector: 'ion-toast', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['animated', 'buttons', 'color', 'cssClass', 'duration', 'enterAnimation', 'header', 'htmlAttributes', 'icon', 'isOpen', 'keyboardClose', 'layout', 'leaveAnimation', 'message', 'mode', 'position', 'positionAnchor', 'swipeGesture', 'translucent', 'trigger'], - outputs: ['ionToastDidPresent', 'ionToastWillPresent', 'ionToastWillDismiss', 'ionToastDidDismiss', 'didPresent', 'willPresent', 'willDismiss', 'didDismiss'], - standalone: false - }) -], IonToast); -export { IonToast }; -let IonToggle = class IonToggle { - constructor(c, r, z) { - this.z = z; - this.ionChange = new EventEmitter(); - this.ionFocus = new EventEmitter(); - this.ionBlur = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonToggle.prototype, "ionChange", void 0); -__decorate([ - Output() -], IonToggle.prototype, "ionFocus", void 0); -__decorate([ - Output() -], IonToggle.prototype, "ionBlur", void 0); -IonToggle = __decorate([ - ProxyCmp({ - inputs: ['alignment', 'checked', 'color', 'disabled', 'enableOnOffLabels', 'errorText', 'helperText', 'justify', 'labelPlacement', 'mode', 'name', 'required', 'value'] - }), - Component({ - selector: 'ion-toggle', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['alignment', 'checked', 'color', 'disabled', 'enableOnOffLabels', 'errorText', 'helperText', 'justify', 'labelPlacement', 'mode', 'name', 'required', 'value'], - outputs: ['ionChange', 'ionFocus', 'ionBlur'], - standalone: false - }) -], IonToggle); -export { IonToggle }; -let IonToolbar = class IonToolbar { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonToolbar = __decorate([ - ProxyCmp({ - inputs: ['color', 'mode'] - }), - Component({ - selector: 'ion-toolbar', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'mode'], - standalone: false - }) -], IonToolbar); -export { IonToolbar }; diff --git a/packages/angular/build/es2015/lazy/src/directives/validators/index.js b/packages/angular/build/es2015/lazy/src/directives/validators/index.js deleted file mode 100644 index 50edda4ec57..00000000000 --- a/packages/angular/build/es2015/lazy/src/directives/validators/index.js +++ /dev/null @@ -1,2 +0,0 @@ -export * from './max-validator'; -export * from './min-validator'; diff --git a/packages/angular/build/es2015/lazy/src/directives/validators/max-validator.js b/packages/angular/build/es2015/lazy/src/directives/validators/max-validator.js deleted file mode 100644 index 1c194ac2539..00000000000 --- a/packages/angular/build/es2015/lazy/src/directives/validators/max-validator.js +++ /dev/null @@ -1,23 +0,0 @@ -import { __decorate } from "tslib"; -import { Directive, forwardRef } from '@angular/core'; -import { MaxValidator, NG_VALIDATORS } from '@angular/forms'; -/** - * @description - * Provider which adds `MaxValidator` to the `NG_VALIDATORS` multi-provider list. - */ -export const ION_MAX_VALIDATOR = { - provide: NG_VALIDATORS, - useExisting: forwardRef(() => IonMaxValidator), - multi: true, -}; -let IonMaxValidator = class IonMaxValidator extends MaxValidator { -}; -IonMaxValidator = __decorate([ - Directive({ - standalone: false, - selector: 'ion-input[type=number][max][formControlName],ion-input[type=number][max][formControl],ion-input[type=number][max][ngModel]', - providers: [ION_MAX_VALIDATOR], - host: { '[attr.max]': 'enabled(max) ? max : null' }, - }) -], IonMaxValidator); -export { IonMaxValidator }; diff --git a/packages/angular/build/es2015/lazy/src/directives/validators/min-validator.js b/packages/angular/build/es2015/lazy/src/directives/validators/min-validator.js deleted file mode 100644 index a4a0eeede53..00000000000 --- a/packages/angular/build/es2015/lazy/src/directives/validators/min-validator.js +++ /dev/null @@ -1,23 +0,0 @@ -import { __decorate } from "tslib"; -import { Directive, forwardRef } from '@angular/core'; -import { MinValidator, NG_VALIDATORS } from '@angular/forms'; -/** - * @description - * Provider which adds `MinValidator` to the `NG_VALIDATORS` multi-provider list. - */ -export const ION_MIN_VALIDATOR = { - provide: NG_VALIDATORS, - useExisting: forwardRef(() => IonMinValidator), - multi: true, -}; -let IonMinValidator = class IonMinValidator extends MinValidator { -}; -IonMinValidator = __decorate([ - Directive({ - standalone: false, - selector: 'ion-input[type=number][min][formControlName],ion-input[type=number][min][formControl],ion-input[type=number][min][ngModel]', - providers: [ION_MIN_VALIDATOR], - host: { '[attr.min]': 'enabled(min) ? min : null' }, - }) -], IonMinValidator); -export { IonMinValidator }; diff --git a/packages/angular/build/es2015/lazy/src/index.js b/packages/angular/build/es2015/lazy/src/index.js deleted file mode 100644 index c636c0dace7..00000000000 --- a/packages/angular/build/es2015/lazy/src/index.js +++ /dev/null @@ -1,35 +0,0 @@ -// DIRECTIVES -export { BooleanValueAccessorDirective as BooleanValueAccessor } from './directives/control-value-accessors/boolean-value-accessor'; -export { NumericValueAccessorDirective as NumericValueAccessor } from './directives/control-value-accessors/numeric-value-accessor'; -export { SelectValueAccessorDirective as SelectValueAccessor } from './directives/control-value-accessors/select-value-accessor'; -export { TextValueAccessorDirective as TextValueAccessor } from './directives/control-value-accessors/text-value-accessor'; -export { IonTabs } from './directives/navigation/ion-tabs'; -export { IonBackButton } from './directives/navigation/ion-back-button'; -export { IonNav } from './directives/navigation/ion-nav'; -export { IonRouterOutlet } from './directives/navigation/ion-router-outlet'; -export { RouterLinkDelegateDirective as RouterLinkDelegate, RouterLinkWithHrefDelegateDirective as RouterLinkWithHrefDelegate, } from './directives/navigation/router-link-delegate'; -export { IonModal } from './directives/overlays/modal'; -export { IonPopover } from './directives/overlays/popover'; -export * from './directives/proxies'; -export * from './directives/validators'; -// PROVIDERS -export { DomController, NavController, Config, Platform, AngularDelegate, NavParams, IonicRouteStrategy, IonModalToken, } from '@ionic/angular/common'; -export { AlertController } from './providers/alert-controller'; -export { AnimationController } from './providers/animation-controller'; -export { ActionSheetController } from './providers/action-sheet-controller'; -export { GestureController } from './providers/gesture-controller'; -export { LoadingController } from './providers/loading-controller'; -export { MenuController } from './providers/menu-controller'; -export { ModalController } from './providers/modal-controller'; -export { PopoverController } from './providers/popover-controller'; -export { ToastController } from './providers/toast-controller'; -/* - * PACKAGE MODULE - * `IonicModule` is deprecated and will be removed in a future major version. - * Use `provideIonicAngular()` from `@ionic/angular` instead. The deprecation is - * declared on the class itself, so consumers importing it here see the notice. - */ -export { IonicModule } from './ionic-module'; -export { -// UTILS -createAnimation, createGesture, iosTransitionAnimation, mdTransitionAnimation, IonicSlides, getPlatforms, isPlatform, getTimeGivenProgression, getIonPageElement, IonicSafeString, openURL, } from '@ionic/core'; diff --git a/packages/angular/build/es2015/lazy/src/ionic-module.js b/packages/angular/build/es2015/lazy/src/ionic-module.js deleted file mode 100644 index 0d126bf6b8c..00000000000 --- a/packages/angular/build/es2015/lazy/src/ionic-module.js +++ /dev/null @@ -1,81 +0,0 @@ -var IonicModule_1; -import { __decorate } from "tslib"; -import { CommonModule, DOCUMENT } from '@angular/common'; -import { APP_INITIALIZER, NgModule, NgZone } from '@angular/core'; -import { ConfigToken, AngularDelegate, provideComponentInputBinding } from '@ionic/angular/common'; -import { appInitialize } from './app-initialize'; -import { BooleanValueAccessorDirective, NumericValueAccessorDirective, SelectValueAccessorDirective, TextValueAccessorDirective, } from './directives/control-value-accessors'; -import { IonBackButton } from './directives/navigation/ion-back-button'; -import { IonNav } from './directives/navigation/ion-nav'; -import { IonRouterOutlet } from './directives/navigation/ion-router-outlet'; -import { IonTabs } from './directives/navigation/ion-tabs'; -import { RouterLinkDelegateDirective, RouterLinkWithHrefDelegateDirective, } from './directives/navigation/router-link-delegate'; -import { IonModal } from './directives/overlays/modal'; -import { IonPopover } from './directives/overlays/popover'; -import { DIRECTIVES } from './directives/proxies-list'; -import { IonMaxValidator, IonMinValidator } from './directives/validators'; -import { ModalController } from './providers/modal-controller'; -import { PopoverController } from './providers/popover-controller'; -const DECLARATIONS = [ - // generated proxies - ...DIRECTIVES, - // manual proxies - IonModal, - IonPopover, - // ngModel accessors - BooleanValueAccessorDirective, - NumericValueAccessorDirective, - SelectValueAccessorDirective, - TextValueAccessorDirective, - // navigation - IonTabs, - IonRouterOutlet, - IonBackButton, - IonNav, - RouterLinkDelegateDirective, - RouterLinkWithHrefDelegateDirective, - // validators - IonMinValidator, - IonMaxValidator, -]; -/** - * @deprecated `IonicModule` is deprecated and will be removed in a future major version. - * Use `provideIonicAngular()` instead, which works in both standalone and NgModule-based - * applications. Refer to https://ionicframework.com/docs/angular/build-options for migration steps. - */ -let IonicModule = IonicModule_1 = class IonicModule { - /** - * @deprecated `IonicModule.forRoot()` is deprecated and will be removed in a future major version. - * Use `provideIonicAngular()` instead. Any config passed here can be passed as an object to that - * function. Refer to https://ionicframework.com/docs/angular/build-options for migration steps. - */ - static forRoot(config = {}) { - console.warn(`[Ionic Warning]: IonicModule has been deprecated in favor of provideIonicAngular() and will be removed in a future major version. Refer to https://ionicframework.com/docs/angular/build-options for migration steps.`); - return { - ngModule: IonicModule_1, - providers: [ - { - provide: ConfigToken, - useValue: config, - }, - { - provide: APP_INITIALIZER, - useFactory: appInitialize, - multi: true, - deps: [ConfigToken, DOCUMENT, NgZone], - }, - AngularDelegate, - provideComponentInputBinding(), - ], - }; - } -}; -IonicModule = IonicModule_1 = __decorate([ - NgModule({ - declarations: DECLARATIONS, - exports: DECLARATIONS, - providers: [ModalController, PopoverController], - imports: [CommonModule], - }) -], IonicModule); -export { IonicModule }; diff --git a/packages/angular/build/es2015/lazy/src/providers/action-sheet-controller.js b/packages/angular/build/es2015/lazy/src/providers/action-sheet-controller.js deleted file mode 100644 index 048fa9fb491..00000000000 --- a/packages/angular/build/es2015/lazy/src/providers/action-sheet-controller.js +++ /dev/null @@ -1,15 +0,0 @@ -import { __decorate } from "tslib"; -import { Injectable } from '@angular/core'; -import { OverlayBaseController } from '@ionic/angular/common'; -import { actionSheetController } from '@ionic/core'; -let ActionSheetController = class ActionSheetController extends OverlayBaseController { - constructor() { - super(actionSheetController); - } -}; -ActionSheetController = __decorate([ - Injectable({ - providedIn: 'root', - }) -], ActionSheetController); -export { ActionSheetController }; diff --git a/packages/angular/build/es2015/lazy/src/providers/alert-controller.js b/packages/angular/build/es2015/lazy/src/providers/alert-controller.js deleted file mode 100644 index 92e0d8f63e2..00000000000 --- a/packages/angular/build/es2015/lazy/src/providers/alert-controller.js +++ /dev/null @@ -1,15 +0,0 @@ -import { __decorate } from "tslib"; -import { Injectable } from '@angular/core'; -import { OverlayBaseController } from '@ionic/angular/common'; -import { alertController } from '@ionic/core'; -let AlertController = class AlertController extends OverlayBaseController { - constructor() { - super(alertController); - } -}; -AlertController = __decorate([ - Injectable({ - providedIn: 'root', - }) -], AlertController); -export { AlertController }; diff --git a/packages/angular/build/es2015/lazy/src/providers/animation-controller.js b/packages/angular/build/es2015/lazy/src/providers/animation-controller.js deleted file mode 100644 index 167e338d52c..00000000000 --- a/packages/angular/build/es2015/lazy/src/providers/animation-controller.js +++ /dev/null @@ -1,34 +0,0 @@ -import { __decorate } from "tslib"; -import { Injectable } from '@angular/core'; -import { createAnimation, getTimeGivenProgression } from '@ionic/core'; -let AnimationController = class AnimationController { - /** - * Create a new animation - */ - create(animationId) { - return createAnimation(animationId); - } - /** - * EXPERIMENTAL - * - * Given a progression and a cubic bezier function, - * this utility returns the time value(s) at which the - * cubic bezier reaches the given time progression. - * - * If the cubic bezier never reaches the progression - * the result will be an empty array. - * - * This is most useful for switching between easing curves - * when doing a gesture animation (i.e. going from linear easing - * during a drag, to another easing when `progressEnd` is called) - */ - easingTime(p0, p1, p2, p3, progression) { - return getTimeGivenProgression(p0, p1, p2, p3, progression); - } -}; -AnimationController = __decorate([ - Injectable({ - providedIn: 'root', - }) -], AnimationController); -export { AnimationController }; diff --git a/packages/angular/build/es2015/lazy/src/providers/gesture-controller.js b/packages/angular/build/es2015/lazy/src/providers/gesture-controller.js deleted file mode 100644 index b57b81286bf..00000000000 --- a/packages/angular/build/es2015/lazy/src/providers/gesture-controller.js +++ /dev/null @@ -1,28 +0,0 @@ -import { __decorate } from "tslib"; -import { Injectable } from '@angular/core'; -import { createGesture } from '@ionic/core'; -let GestureController = class GestureController { - constructor(zone) { - this.zone = zone; - } - /** - * Create a new gesture - */ - create(opts, runInsideAngularZone = false) { - if (runInsideAngularZone) { - Object.getOwnPropertyNames(opts).forEach((key) => { - if (typeof opts[key] === 'function') { - const fn = opts[key]; - opts[key] = (...props) => this.zone.run(() => fn(...props)); - } - }); - } - return createGesture(opts); - } -}; -GestureController = __decorate([ - Injectable({ - providedIn: 'root', - }) -], GestureController); -export { GestureController }; diff --git a/packages/angular/build/es2015/lazy/src/providers/loading-controller.js b/packages/angular/build/es2015/lazy/src/providers/loading-controller.js deleted file mode 100644 index 29d4ae9227b..00000000000 --- a/packages/angular/build/es2015/lazy/src/providers/loading-controller.js +++ /dev/null @@ -1,15 +0,0 @@ -import { __decorate } from "tslib"; -import { Injectable } from '@angular/core'; -import { OverlayBaseController } from '@ionic/angular/common'; -import { loadingController } from '@ionic/core'; -let LoadingController = class LoadingController extends OverlayBaseController { - constructor() { - super(loadingController); - } -}; -LoadingController = __decorate([ - Injectable({ - providedIn: 'root', - }) -], LoadingController); -export { LoadingController }; diff --git a/packages/angular/build/es2015/lazy/src/providers/menu-controller.js b/packages/angular/build/es2015/lazy/src/providers/menu-controller.js deleted file mode 100644 index acbcb1a69b6..00000000000 --- a/packages/angular/build/es2015/lazy/src/providers/menu-controller.js +++ /dev/null @@ -1,15 +0,0 @@ -import { __decorate } from "tslib"; -import { Injectable } from '@angular/core'; -import { MenuController as MenuControllerBase } from '@ionic/angular/common'; -import { menuController } from '@ionic/core'; -let MenuController = class MenuController extends MenuControllerBase { - constructor() { - super(menuController); - } -}; -MenuController = __decorate([ - Injectable({ - providedIn: 'root', - }) -], MenuController); -export { MenuController }; diff --git a/packages/angular/build/es2015/lazy/src/providers/modal-controller.js b/packages/angular/build/es2015/lazy/src/providers/modal-controller.js deleted file mode 100644 index e315f7928cc..00000000000 --- a/packages/angular/build/es2015/lazy/src/providers/modal-controller.js +++ /dev/null @@ -1,20 +0,0 @@ -import { __decorate, __rest } from "tslib"; -import { Injector, Injectable, EnvironmentInjector, inject } from '@angular/core'; -import { AngularDelegate, OverlayBaseController } from '@ionic/angular/common'; -import { modalController } from '@ionic/core'; -let ModalController = class ModalController extends OverlayBaseController { - constructor() { - super(modalController); - this.angularDelegate = inject(AngularDelegate); - this.injector = inject(Injector); - this.environmentInjector = inject(EnvironmentInjector); - } - create(opts) { - const { injector: customInjector } = opts, restOpts = __rest(opts, ["injector"]); - return super.create(Object.assign(Object.assign({}, restOpts), { delegate: this.angularDelegate.create(this.environmentInjector, this.injector, 'modal', customInjector) })); - } -}; -ModalController = __decorate([ - Injectable() -], ModalController); -export { ModalController }; diff --git a/packages/angular/build/es2015/lazy/src/providers/popover-controller.js b/packages/angular/build/es2015/lazy/src/providers/popover-controller.js deleted file mode 100644 index 79e9cb0f8ba..00000000000 --- a/packages/angular/build/es2015/lazy/src/providers/popover-controller.js +++ /dev/null @@ -1,16 +0,0 @@ -import { __rest } from "tslib"; -import { Injector, inject, EnvironmentInjector } from '@angular/core'; -import { AngularDelegate, OverlayBaseController } from '@ionic/angular/common'; -import { popoverController } from '@ionic/core'; -export class PopoverController extends OverlayBaseController { - constructor() { - super(popoverController); - this.angularDelegate = inject(AngularDelegate); - this.injector = inject(Injector); - this.environmentInjector = inject(EnvironmentInjector); - } - create(opts) { - const { injector: customInjector } = opts, restOpts = __rest(opts, ["injector"]); - return super.create(Object.assign(Object.assign({}, restOpts), { delegate: this.angularDelegate.create(this.environmentInjector, this.injector, 'popover', customInjector) })); - } -} diff --git a/packages/angular/build/es2015/lazy/src/providers/toast-controller.js b/packages/angular/build/es2015/lazy/src/providers/toast-controller.js deleted file mode 100644 index 994e4bb428a..00000000000 --- a/packages/angular/build/es2015/lazy/src/providers/toast-controller.js +++ /dev/null @@ -1,15 +0,0 @@ -import { __decorate } from "tslib"; -import { Injectable } from '@angular/core'; -import { OverlayBaseController } from '@ionic/angular/common'; -import { toastController } from '@ionic/core'; -let ToastController = class ToastController extends OverlayBaseController { - constructor() { - super(toastController); - } -}; -ToastController = __decorate([ - Injectable({ - providedIn: 'root', - }) -], ToastController); -export { ToastController }; diff --git a/packages/angular/build/es2015/standalone/src/directives/angular-component-lib/utils.js b/packages/angular/build/es2015/standalone/src/directives/angular-component-lib/utils.js deleted file mode 100644 index 4bfe4ea9066..00000000000 --- a/packages/angular/build/es2015/standalone/src/directives/angular-component-lib/utils.js +++ /dev/null @@ -1,58 +0,0 @@ -/* eslint-disable */ -/* tslint:disable */ -import { fromEvent } from 'rxjs'; -export const proxyInputs = (Cmp, inputs) => { - const Prototype = Cmp.prototype; - inputs.forEach((item) => { - Object.defineProperty(Prototype, item, { - get() { - return this.el[item]; - }, - set(val) { - this.z.runOutsideAngular(() => (this.el[item] = val)); - }, - /** - * In the event that proxyInputs is called - * multiple times re-defining these inputs - * will cause an error to be thrown. As a result - * we set configurable: true to indicate these - * properties can be changed. - */ - configurable: true, - }); - }); -}; -export const proxyMethods = (Cmp, methods) => { - const Prototype = Cmp.prototype; - methods.forEach((methodName) => { - Prototype[methodName] = function () { - const args = arguments; - return this.z.runOutsideAngular(() => this.el[methodName].apply(this.el, args)); - }; - }); -}; -export const proxyOutputs = (instance, el, events) => { - events.forEach((eventName) => (instance[eventName] = fromEvent(el, eventName))); -}; -export const defineCustomElement = (tagName, customElement) => { - if (customElement !== undefined && typeof customElements !== 'undefined' && !customElements.get(tagName)) { - customElements.define(tagName, customElement); - } -}; -// tslint:disable-next-line: only-arrow-functions -export function ProxyCmp(opts) { - const decorator = function (cls) { - const { defineCustomElementFn, inputs, methods } = opts; - if (defineCustomElementFn !== undefined) { - defineCustomElementFn(); - } - if (inputs) { - proxyInputs(cls, inputs); - } - if (methods) { - proxyMethods(cls, methods); - } - return cls; - }; - return decorator; -} diff --git a/packages/angular/build/es2015/standalone/src/directives/checkbox.js b/packages/angular/build/es2015/standalone/src/directives/checkbox.js deleted file mode 100644 index 94949152a75..00000000000 --- a/packages/angular/build/es2015/standalone/src/directives/checkbox.js +++ /dev/null @@ -1,67 +0,0 @@ -import { __decorate } from "tslib"; -import { ChangeDetectionStrategy, Component, HostListener, forwardRef, } from '@angular/core'; -import { NG_VALUE_ACCESSOR } from '@angular/forms'; -import { ValueAccessor, setIonicClasses } from '@ionic/angular/common'; -import { defineCustomElement } from '@ionic/core/components/ion-checkbox.js'; -import { ProxyCmp, proxyOutputs } from './angular-component-lib/utils'; -const CHECKBOX_INPUTS = [ - 'checked', - 'color', - 'disabled', - 'errorText', - 'helperText', - 'indeterminate', - 'justify', - 'labelPlacement', - 'mode', - 'name', - 'value', -]; -/** - * Pulling the provider into an object and using PURE works - * around an ng-packagr issue that causes - * components with multiple decorators and - * a provider to be re-assigned. This re-assignment - * is not supported by Webpack and causes treeshaking - * to not work on these kinds of components. - */ -const accessorProvider = { - provide: NG_VALUE_ACCESSOR, - useExisting: /*@__PURE__*/ forwardRef(() => IonCheckbox), - multi: true, -}; -let IonCheckbox = class IonCheckbox extends ValueAccessor { - constructor(c, r, z, injector) { - super(injector, r); - this.z = z; - c.detach(); - this.el = r.nativeElement; - proxyOutputs(this, this.el, ['ionChange', 'ionFocus', 'ionBlur']); - } - writeValue(value) { - this.elementRef.nativeElement.checked = this.lastValue = value; - setIonicClasses(this.elementRef); - } - handleIonChange(el) { - this.handleValueChange(el, el.checked); - } -}; -__decorate([ - HostListener('ionChange', ['$event.target']) -], IonCheckbox.prototype, "handleIonChange", null); -IonCheckbox = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineCustomElement, - inputs: CHECKBOX_INPUTS, - }), - Component({ - selector: 'ion-checkbox', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: CHECKBOX_INPUTS, - providers: [accessorProvider], - standalone: true, - }) -], IonCheckbox); -export { IonCheckbox }; diff --git a/packages/angular/build/es2015/standalone/src/directives/datetime.js b/packages/angular/build/es2015/standalone/src/directives/datetime.js deleted file mode 100644 index 9d436ca9d13..00000000000 --- a/packages/angular/build/es2015/standalone/src/directives/datetime.js +++ /dev/null @@ -1,86 +0,0 @@ -import { __decorate } from "tslib"; -import { ChangeDetectionStrategy, Component, HostListener, forwardRef, } from '@angular/core'; -import { NG_VALUE_ACCESSOR } from '@angular/forms'; -import { ValueAccessor } from '@ionic/angular/common'; -import { defineCustomElement } from '@ionic/core/components/ion-datetime.js'; -import { ProxyCmp, proxyOutputs } from './angular-component-lib/utils'; -const DATETIME_INPUTS = [ - 'cancelText', - 'clearText', - 'color', - 'dayValues', - 'disabled', - 'doneText', - 'firstDayOfWeek', - 'formatOptions', - 'highlightedDates', - 'hourCycle', - 'hourValues', - 'isDateEnabled', - 'locale', - 'max', - 'min', - 'minuteValues', - 'mode', - 'monthValues', - 'multiple', - 'name', - 'preferWheel', - 'presentation', - 'readonly', - 'showAdjacentDays', - 'showClearButton', - 'showDefaultButtons', - 'showDefaultTimeLabel', - 'showDefaultTitle', - 'size', - 'titleSelectedDatesFormatter', - 'value', - 'yearValues', -]; -/** - * Pulling the provider into an object and using PURE works - * around an ng-packagr issue that causes - * components with multiple decorators and - * a provider to be re-assigned. This re-assignment - * is not supported by Webpack and causes treeshaking - * to not work on these kinds of components. - - */ -const accessorProvider = { - provide: NG_VALUE_ACCESSOR, - useExisting: /*@__PURE__*/ forwardRef(() => IonDatetime), - multi: true, -}; -let IonDatetime = class IonDatetime extends ValueAccessor { - constructor(c, r, z, injector) { - super(injector, r); - this.z = z; - c.detach(); - this.el = r.nativeElement; - proxyOutputs(this, this.el, ['ionCancel', 'ionChange', 'ionFocus', 'ionBlur']); - } - handleIonChange(el) { - this.handleValueChange(el, el.value); - } -}; -__decorate([ - HostListener('ionChange', ['$event.target']) -], IonDatetime.prototype, "handleIonChange", null); -IonDatetime = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineCustomElement, - inputs: DATETIME_INPUTS, - methods: ['confirm', 'reset', 'cancel'], - }), - Component({ - selector: 'ion-datetime', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: DATETIME_INPUTS, - providers: [accessorProvider], - standalone: true, - }) -], IonDatetime); -export { IonDatetime }; diff --git a/packages/angular/build/es2015/standalone/src/directives/icon.js b/packages/angular/build/es2015/standalone/src/directives/icon.js deleted file mode 100644 index ac54a2367a4..00000000000 --- a/packages/angular/build/es2015/standalone/src/directives/icon.js +++ /dev/null @@ -1,26 +0,0 @@ -import { __decorate } from "tslib"; -import { ChangeDetectionStrategy, Component } from '@angular/core'; -import { defineCustomElement as defineIonIcon } from 'ionicons/components/ion-icon.js'; -import { ProxyCmp } from './angular-component-lib/utils'; -let IonIcon = class IonIcon { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonIcon = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonIcon, - inputs: ['color', 'flipRtl', 'icon', 'ios', 'lazy', 'md', 'mode', 'name', 'sanitize', 'size', 'src'], - }), - Component({ - selector: 'ion-icon', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'flipRtl', 'icon', 'ios', 'lazy', 'md', 'mode', 'name', 'sanitize', 'size', 'src'], - standalone: true, - }) -], IonIcon); -export { IonIcon }; diff --git a/packages/angular/build/es2015/standalone/src/directives/index.js b/packages/angular/build/es2015/standalone/src/directives/index.js deleted file mode 100644 index 95ce727fe0b..00000000000 --- a/packages/angular/build/es2015/standalone/src/directives/index.js +++ /dev/null @@ -1,12 +0,0 @@ -export * from './checkbox'; -export * from './datetime'; -export * from './icon'; -export * from './input'; -export * from './input-otp'; -export * from './radio-group'; -export * from './range'; -export * from './searchbar'; -export * from './segment'; -export * from './select'; -export * from './textarea'; -export * from './toggle'; diff --git a/packages/angular/build/es2015/standalone/src/directives/input-otp.js b/packages/angular/build/es2015/standalone/src/directives/input-otp.js deleted file mode 100644 index c6627525df4..00000000000 --- a/packages/angular/build/es2015/standalone/src/directives/input-otp.js +++ /dev/null @@ -1,81 +0,0 @@ -import { __decorate } from "tslib"; -import { ChangeDetectionStrategy, Component, HostListener, forwardRef, } from '@angular/core'; -import { NG_VALUE_ACCESSOR } from '@angular/forms'; -import { ValueAccessor } from '@ionic/angular/common'; -import { defineCustomElement } from '@ionic/core/components/ion-input-otp.js'; -import { ProxyCmp, proxyOutputs } from './angular-component-lib/utils'; -const INPUT_OTP_INPUTS = [ - 'autocapitalize', - 'color', - 'disabled', - 'fill', - 'inputmode', - 'length', - 'pattern', - 'readonly', - 'separators', - 'shape', - 'size', - 'type', - 'value', -]; -/** - * Pulling the provider into an object and using PURE works - * around an ng-packagr issue that causes - * components with multiple decorators and - * a provider to be re-assigned. This re-assignment - * is not supported by Webpack and causes treeshaking - * to not work on these kinds of components. - */ -const accessorProvider = { - provide: NG_VALUE_ACCESSOR, - useExisting: /*@__PURE__*/ forwardRef(() => IonInputOtp), - multi: true, -}; -let IonInputOtp = class IonInputOtp extends ValueAccessor { - constructor(c, r, z, injector) { - super(injector, r); - this.z = z; - c.detach(); - this.el = r.nativeElement; - proxyOutputs(this, this.el, ['ionInput', 'ionChange', 'ionComplete', 'ionBlur', 'ionFocus']); - } - handleIonInput(el) { - this.handleValueChange(el, el.value); - } - registerOnChange(fn) { - super.registerOnChange((value) => { - if (this.type === 'number') { - /** - * If the input type is `number`, we need to convert the value to a number - * when the value is not empty. If the value is empty, we want to treat - * the value as null. - */ - fn(value === '' ? null : parseFloat(value)); - } - else { - fn(value); - } - }); - } -}; -__decorate([ - HostListener('ionInput', ['$event.target']) -], IonInputOtp.prototype, "handleIonInput", null); -IonInputOtp = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineCustomElement, - inputs: INPUT_OTP_INPUTS, - methods: ['setFocus'], - }), - Component({ - selector: 'ion-input-otp', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: INPUT_OTP_INPUTS, - providers: [accessorProvider], - standalone: true, - }) -], IonInputOtp); -export { IonInputOtp }; diff --git a/packages/angular/build/es2015/standalone/src/directives/input.js b/packages/angular/build/es2015/standalone/src/directives/input.js deleted file mode 100644 index 851529186cc..00000000000 --- a/packages/angular/build/es2015/standalone/src/directives/input.js +++ /dev/null @@ -1,104 +0,0 @@ -import { __decorate } from "tslib"; -import { ChangeDetectionStrategy, Component, HostListener, forwardRef, } from '@angular/core'; -import { NG_VALUE_ACCESSOR } from '@angular/forms'; -import { ValueAccessor } from '@ionic/angular/common'; -import { defineCustomElement } from '@ionic/core/components/ion-input.js'; -import { ProxyCmp, proxyOutputs } from './angular-component-lib/utils'; -const INPUT_INPUTS = [ - 'accept', - 'autocapitalize', - 'autocomplete', - 'autocorrect', - 'autofocus', - 'clearInput', - 'clearOnEdit', - 'color', - 'counter', - 'counterFormatter', - 'debounce', - 'disabled', - 'enterkeyhint', - 'errorText', - 'fill', - 'helperText', - 'inputmode', - 'label', - 'labelPlacement', - 'max', - 'maxlength', - 'min', - 'minlength', - 'mode', - 'multiple', - 'name', - 'pattern', - 'placeholder', - 'readonly', - 'required', - 'shape', - 'size', - 'spellcheck', - 'step', - 'type', - 'value', -]; -/** - * Pulling the provider into an object and using PURE works - * around an ng-packagr issue that causes - * components with multiple decorators and - * a provider to be re-assigned. This re-assignment - * is not supported by Webpack and causes treeshaking - * to not work on these kinds of components. - */ -const accessorProvider = { - provide: NG_VALUE_ACCESSOR, - useExisting: /*@__PURE__*/ forwardRef(() => IonInput), - multi: true, -}; -let IonInput = class IonInput extends ValueAccessor { - constructor(c, r, z, injector) { - super(injector, r); - this.z = z; - c.detach(); - this.el = r.nativeElement; - proxyOutputs(this, this.el, ['ionInput', 'ionChange', 'ionBlur', 'ionFocus']); - } - handleIonInput(el) { - this.handleValueChange(el, el.value); - } - registerOnChange(fn) { - super.registerOnChange((value) => { - if (this.type === 'number') { - /** - * If the input type is `number`, we need to convert the value to a number - * when the value is not empty. If the value is empty, we want to treat - * the value as null. - */ - fn(value === '' ? null : parseFloat(value)); - } - else { - fn(value); - } - }); - } -}; -__decorate([ - HostListener('ionInput', ['$event.target']) -], IonInput.prototype, "handleIonInput", null); -IonInput = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineCustomElement, - inputs: INPUT_INPUTS, - methods: ['setFocus', 'getInputElement'], - }), - Component({ - selector: 'ion-input', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: INPUT_INPUTS, - providers: [accessorProvider], - standalone: true, - }) -], IonInput); -export { IonInput }; diff --git a/packages/angular/build/es2015/standalone/src/directives/proxies.js b/packages/angular/build/es2015/standalone/src/directives/proxies.js deleted file mode 100644 index 719304e9049..00000000000 --- a/packages/angular/build/es2015/standalone/src/directives/proxies.js +++ /dev/null @@ -1,1914 +0,0 @@ -import { __decorate } from "tslib"; -/* tslint:disable */ -/* auto-generated angular directive proxies */ -import { ChangeDetectionStrategy, Component, EventEmitter, Output } from '@angular/core'; -import { ProxyCmp } from './angular-component-lib/utils'; -import { defineCustomElement as defineIonAccordion } from '@ionic/core/components/ion-accordion.js'; -import { defineCustomElement as defineIonAccordionGroup } from '@ionic/core/components/ion-accordion-group.js'; -import { defineCustomElement as defineIonActionSheet } from '@ionic/core/components/ion-action-sheet.js'; -import { defineCustomElement as defineIonAlert } from '@ionic/core/components/ion-alert.js'; -import { defineCustomElement as defineIonApp } from '@ionic/core/components/ion-app.js'; -import { defineCustomElement as defineIonAvatar } from '@ionic/core/components/ion-avatar.js'; -import { defineCustomElement as defineIonBackdrop } from '@ionic/core/components/ion-backdrop.js'; -import { defineCustomElement as defineIonBadge } from '@ionic/core/components/ion-badge.js'; -import { defineCustomElement as defineIonBreadcrumb } from '@ionic/core/components/ion-breadcrumb.js'; -import { defineCustomElement as defineIonBreadcrumbs } from '@ionic/core/components/ion-breadcrumbs.js'; -import { defineCustomElement as defineIonButton } from '@ionic/core/components/ion-button.js'; -import { defineCustomElement as defineIonButtons } from '@ionic/core/components/ion-buttons.js'; -import { defineCustomElement as defineIonCard } from '@ionic/core/components/ion-card.js'; -import { defineCustomElement as defineIonCardContent } from '@ionic/core/components/ion-card-content.js'; -import { defineCustomElement as defineIonCardHeader } from '@ionic/core/components/ion-card-header.js'; -import { defineCustomElement as defineIonCardSubtitle } from '@ionic/core/components/ion-card-subtitle.js'; -import { defineCustomElement as defineIonCardTitle } from '@ionic/core/components/ion-card-title.js'; -import { defineCustomElement as defineIonChip } from '@ionic/core/components/ion-chip.js'; -import { defineCustomElement as defineIonCol } from '@ionic/core/components/ion-col.js'; -import { defineCustomElement as defineIonContent } from '@ionic/core/components/ion-content.js'; -import { defineCustomElement as defineIonDatetimeButton } from '@ionic/core/components/ion-datetime-button.js'; -import { defineCustomElement as defineIonFab } from '@ionic/core/components/ion-fab.js'; -import { defineCustomElement as defineIonFabButton } from '@ionic/core/components/ion-fab-button.js'; -import { defineCustomElement as defineIonFabList } from '@ionic/core/components/ion-fab-list.js'; -import { defineCustomElement as defineIonFooter } from '@ionic/core/components/ion-footer.js'; -import { defineCustomElement as defineIonGrid } from '@ionic/core/components/ion-grid.js'; -import { defineCustomElement as defineIonHeader } from '@ionic/core/components/ion-header.js'; -import { defineCustomElement as defineIonImg } from '@ionic/core/components/ion-img.js'; -import { defineCustomElement as defineIonInfiniteScroll } from '@ionic/core/components/ion-infinite-scroll.js'; -import { defineCustomElement as defineIonInfiniteScrollContent } from '@ionic/core/components/ion-infinite-scroll-content.js'; -import { defineCustomElement as defineIonInputPasswordToggle } from '@ionic/core/components/ion-input-password-toggle.js'; -import { defineCustomElement as defineIonItem } from '@ionic/core/components/ion-item.js'; -import { defineCustomElement as defineIonItemDivider } from '@ionic/core/components/ion-item-divider.js'; -import { defineCustomElement as defineIonItemGroup } from '@ionic/core/components/ion-item-group.js'; -import { defineCustomElement as defineIonItemOption } from '@ionic/core/components/ion-item-option.js'; -import { defineCustomElement as defineIonItemOptions } from '@ionic/core/components/ion-item-options.js'; -import { defineCustomElement as defineIonItemSliding } from '@ionic/core/components/ion-item-sliding.js'; -import { defineCustomElement as defineIonLabel } from '@ionic/core/components/ion-label.js'; -import { defineCustomElement as defineIonList } from '@ionic/core/components/ion-list.js'; -import { defineCustomElement as defineIonListHeader } from '@ionic/core/components/ion-list-header.js'; -import { defineCustomElement as defineIonLoading } from '@ionic/core/components/ion-loading.js'; -import { defineCustomElement as defineIonMenu } from '@ionic/core/components/ion-menu.js'; -import { defineCustomElement as defineIonMenuButton } from '@ionic/core/components/ion-menu-button.js'; -import { defineCustomElement as defineIonMenuToggle } from '@ionic/core/components/ion-menu-toggle.js'; -import { defineCustomElement as defineIonNavLink } from '@ionic/core/components/ion-nav-link.js'; -import { defineCustomElement as defineIonNote } from '@ionic/core/components/ion-note.js'; -import { defineCustomElement as defineIonPicker } from '@ionic/core/components/ion-picker.js'; -import { defineCustomElement as defineIonPickerColumn } from '@ionic/core/components/ion-picker-column.js'; -import { defineCustomElement as defineIonPickerColumnOption } from '@ionic/core/components/ion-picker-column-option.js'; -import { defineCustomElement as defineIonProgressBar } from '@ionic/core/components/ion-progress-bar.js'; -import { defineCustomElement as defineIonRadio } from '@ionic/core/components/ion-radio.js'; -import { defineCustomElement as defineIonRefresher } from '@ionic/core/components/ion-refresher.js'; -import { defineCustomElement as defineIonRefresherContent } from '@ionic/core/components/ion-refresher-content.js'; -import { defineCustomElement as defineIonReorder } from '@ionic/core/components/ion-reorder.js'; -import { defineCustomElement as defineIonReorderGroup } from '@ionic/core/components/ion-reorder-group.js'; -import { defineCustomElement as defineIonRippleEffect } from '@ionic/core/components/ion-ripple-effect.js'; -import { defineCustomElement as defineIonRow } from '@ionic/core/components/ion-row.js'; -import { defineCustomElement as defineIonSegmentButton } from '@ionic/core/components/ion-segment-button.js'; -import { defineCustomElement as defineIonSegmentContent } from '@ionic/core/components/ion-segment-content.js'; -import { defineCustomElement as defineIonSegmentView } from '@ionic/core/components/ion-segment-view.js'; -import { defineCustomElement as defineIonSelectModal } from '@ionic/core/components/ion-select-modal.js'; -import { defineCustomElement as defineIonSelectOption } from '@ionic/core/components/ion-select-option.js'; -import { defineCustomElement as defineIonSkeletonText } from '@ionic/core/components/ion-skeleton-text.js'; -import { defineCustomElement as defineIonSpinner } from '@ionic/core/components/ion-spinner.js'; -import { defineCustomElement as defineIonSplitPane } from '@ionic/core/components/ion-split-pane.js'; -import { defineCustomElement as defineIonTab } from '@ionic/core/components/ion-tab.js'; -import { defineCustomElement as defineIonTabBar } from '@ionic/core/components/ion-tab-bar.js'; -import { defineCustomElement as defineIonTabButton } from '@ionic/core/components/ion-tab-button.js'; -import { defineCustomElement as defineIonText } from '@ionic/core/components/ion-text.js'; -import { defineCustomElement as defineIonThumbnail } from '@ionic/core/components/ion-thumbnail.js'; -import { defineCustomElement as defineIonTitle } from '@ionic/core/components/ion-title.js'; -import { defineCustomElement as defineIonToast } from '@ionic/core/components/ion-toast.js'; -import { defineCustomElement as defineIonToolbar } from '@ionic/core/components/ion-toolbar.js'; -let IonAccordion = class IonAccordion { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonAccordion = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonAccordion, - inputs: ['disabled', 'mode', 'readonly', 'toggleIcon', 'toggleIconSlot', 'value'] - }), - Component({ - selector: 'ion-accordion', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['disabled', 'mode', 'readonly', 'toggleIcon', 'toggleIconSlot', 'value'], - }) -], IonAccordion); -export { IonAccordion }; -let IonAccordionGroup = class IonAccordionGroup { - constructor(c, r, z) { - this.z = z; - this.ionChange = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonAccordionGroup.prototype, "ionChange", void 0); -IonAccordionGroup = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonAccordionGroup, - inputs: ['animated', 'disabled', 'expand', 'mode', 'multiple', 'readonly', 'value'] - }), - Component({ - selector: 'ion-accordion-group', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['animated', 'disabled', 'expand', 'mode', 'multiple', 'readonly', 'value'], - outputs: ['ionChange'], - }) -], IonAccordionGroup); -export { IonAccordionGroup }; -let IonActionSheet = class IonActionSheet { - constructor(c, r, z) { - this.z = z; - this.ionActionSheetDidPresent = new EventEmitter(); - this.ionActionSheetWillPresent = new EventEmitter(); - this.ionActionSheetWillDismiss = new EventEmitter(); - this.ionActionSheetDidDismiss = new EventEmitter(); - this.didPresent = new EventEmitter(); - this.willPresent = new EventEmitter(); - this.willDismiss = new EventEmitter(); - this.didDismiss = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonActionSheet.prototype, "ionActionSheetDidPresent", void 0); -__decorate([ - Output() -], IonActionSheet.prototype, "ionActionSheetWillPresent", void 0); -__decorate([ - Output() -], IonActionSheet.prototype, "ionActionSheetWillDismiss", void 0); -__decorate([ - Output() -], IonActionSheet.prototype, "ionActionSheetDidDismiss", void 0); -__decorate([ - Output() -], IonActionSheet.prototype, "didPresent", void 0); -__decorate([ - Output() -], IonActionSheet.prototype, "willPresent", void 0); -__decorate([ - Output() -], IonActionSheet.prototype, "willDismiss", void 0); -__decorate([ - Output() -], IonActionSheet.prototype, "didDismiss", void 0); -IonActionSheet = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonActionSheet, - inputs: ['animated', 'backdropDismiss', 'buttons', 'cssClass', 'enterAnimation', 'header', 'htmlAttributes', 'isOpen', 'keyboardClose', 'leaveAnimation', 'mode', 'subHeader', 'translucent', 'trigger'], - methods: ['present', 'dismiss', 'onDidDismiss', 'onWillDismiss'] - }), - Component({ - selector: 'ion-action-sheet', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['animated', 'backdropDismiss', 'buttons', 'cssClass', 'enterAnimation', 'header', 'htmlAttributes', 'isOpen', 'keyboardClose', 'leaveAnimation', 'mode', 'subHeader', 'translucent', 'trigger'], - outputs: ['ionActionSheetDidPresent', 'ionActionSheetWillPresent', 'ionActionSheetWillDismiss', 'ionActionSheetDidDismiss', 'didPresent', 'willPresent', 'willDismiss', 'didDismiss'], - }) -], IonActionSheet); -export { IonActionSheet }; -let IonAlert = class IonAlert { - constructor(c, r, z) { - this.z = z; - this.ionAlertDidPresent = new EventEmitter(); - this.ionAlertWillPresent = new EventEmitter(); - this.ionAlertWillDismiss = new EventEmitter(); - this.ionAlertDidDismiss = new EventEmitter(); - this.didPresent = new EventEmitter(); - this.willPresent = new EventEmitter(); - this.willDismiss = new EventEmitter(); - this.didDismiss = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonAlert.prototype, "ionAlertDidPresent", void 0); -__decorate([ - Output() -], IonAlert.prototype, "ionAlertWillPresent", void 0); -__decorate([ - Output() -], IonAlert.prototype, "ionAlertWillDismiss", void 0); -__decorate([ - Output() -], IonAlert.prototype, "ionAlertDidDismiss", void 0); -__decorate([ - Output() -], IonAlert.prototype, "didPresent", void 0); -__decorate([ - Output() -], IonAlert.prototype, "willPresent", void 0); -__decorate([ - Output() -], IonAlert.prototype, "willDismiss", void 0); -__decorate([ - Output() -], IonAlert.prototype, "didDismiss", void 0); -IonAlert = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonAlert, - inputs: ['animated', 'backdropDismiss', 'buttons', 'cssClass', 'enterAnimation', 'header', 'htmlAttributes', 'inputs', 'isOpen', 'keyboardClose', 'leaveAnimation', 'message', 'mode', 'subHeader', 'translucent', 'trigger'], - methods: ['present', 'dismiss', 'onDidDismiss', 'onWillDismiss'] - }), - Component({ - selector: 'ion-alert', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['animated', 'backdropDismiss', 'buttons', 'cssClass', 'enterAnimation', 'header', 'htmlAttributes', 'inputs', 'isOpen', 'keyboardClose', 'leaveAnimation', 'message', 'mode', 'subHeader', 'translucent', 'trigger'], - outputs: ['ionAlertDidPresent', 'ionAlertWillPresent', 'ionAlertWillDismiss', 'ionAlertDidDismiss', 'didPresent', 'willPresent', 'willDismiss', 'didDismiss'], - }) -], IonAlert); -export { IonAlert }; -let IonApp = class IonApp { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonApp = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonApp, - methods: ['setFocus'] - }), - Component({ - selector: 'ion-app', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: [], - }) -], IonApp); -export { IonApp }; -let IonAvatar = class IonAvatar { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonAvatar = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonAvatar - }), - Component({ - selector: 'ion-avatar', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: [], - }) -], IonAvatar); -export { IonAvatar }; -let IonBackdrop = class IonBackdrop { - constructor(c, r, z) { - this.z = z; - this.ionBackdropTap = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonBackdrop.prototype, "ionBackdropTap", void 0); -IonBackdrop = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonBackdrop, - inputs: ['stopPropagation', 'tappable', 'visible'] - }), - Component({ - selector: 'ion-backdrop', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['stopPropagation', 'tappable', 'visible'], - outputs: ['ionBackdropTap'], - }) -], IonBackdrop); -export { IonBackdrop }; -let IonBadge = class IonBadge { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonBadge = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonBadge, - inputs: ['color', 'mode'] - }), - Component({ - selector: 'ion-badge', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'mode'], - }) -], IonBadge); -export { IonBadge }; -let IonBreadcrumb = class IonBreadcrumb { - constructor(c, r, z) { - this.z = z; - this.ionFocus = new EventEmitter(); - this.ionBlur = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonBreadcrumb.prototype, "ionFocus", void 0); -__decorate([ - Output() -], IonBreadcrumb.prototype, "ionBlur", void 0); -IonBreadcrumb = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonBreadcrumb, - inputs: ['active', 'color', 'disabled', 'download', 'href', 'mode', 'rel', 'routerAnimation', 'routerDirection', 'separator', 'target'] - }), - Component({ - selector: 'ion-breadcrumb', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['active', 'color', 'disabled', 'download', 'href', 'mode', 'rel', 'routerAnimation', 'routerDirection', 'separator', 'target'], - outputs: ['ionFocus', 'ionBlur'], - }) -], IonBreadcrumb); -export { IonBreadcrumb }; -let IonBreadcrumbs = class IonBreadcrumbs { - constructor(c, r, z) { - this.z = z; - this.ionCollapsedClick = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonBreadcrumbs.prototype, "ionCollapsedClick", void 0); -IonBreadcrumbs = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonBreadcrumbs, - inputs: ['color', 'itemsAfterCollapse', 'itemsBeforeCollapse', 'maxItems', 'mode'] - }), - Component({ - selector: 'ion-breadcrumbs', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'itemsAfterCollapse', 'itemsBeforeCollapse', 'maxItems', 'mode'], - outputs: ['ionCollapsedClick'], - }) -], IonBreadcrumbs); -export { IonBreadcrumbs }; -let IonButton = class IonButton { - constructor(c, r, z) { - this.z = z; - this.ionFocus = new EventEmitter(); - this.ionBlur = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonButton.prototype, "ionFocus", void 0); -__decorate([ - Output() -], IonButton.prototype, "ionBlur", void 0); -IonButton = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonButton, - inputs: ['buttonType', 'color', 'disabled', 'download', 'expand', 'fill', 'form', 'href', 'mode', 'rel', 'routerAnimation', 'routerDirection', 'shape', 'size', 'strong', 'target', 'type'] - }), - Component({ - selector: 'ion-button', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['buttonType', 'color', 'disabled', 'download', 'expand', 'fill', 'form', 'href', 'mode', 'rel', 'routerAnimation', 'routerDirection', 'shape', 'size', 'strong', 'target', 'type'], - outputs: ['ionFocus', 'ionBlur'], - }) -], IonButton); -export { IonButton }; -let IonButtons = class IonButtons { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonButtons = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonButtons, - inputs: ['collapse'] - }), - Component({ - selector: 'ion-buttons', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['collapse'], - }) -], IonButtons); -export { IonButtons }; -let IonCard = class IonCard { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonCard = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonCard, - inputs: ['button', 'color', 'disabled', 'download', 'href', 'mode', 'rel', 'routerAnimation', 'routerDirection', 'target', 'type'] - }), - Component({ - selector: 'ion-card', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['button', 'color', 'disabled', 'download', 'href', 'mode', 'rel', 'routerAnimation', 'routerDirection', 'target', 'type'], - }) -], IonCard); -export { IonCard }; -let IonCardContent = class IonCardContent { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonCardContent = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonCardContent, - inputs: ['mode'] - }), - Component({ - selector: 'ion-card-content', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['mode'], - }) -], IonCardContent); -export { IonCardContent }; -let IonCardHeader = class IonCardHeader { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonCardHeader = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonCardHeader, - inputs: ['color', 'mode', 'translucent'] - }), - Component({ - selector: 'ion-card-header', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'mode', 'translucent'], - }) -], IonCardHeader); -export { IonCardHeader }; -let IonCardSubtitle = class IonCardSubtitle { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonCardSubtitle = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonCardSubtitle, - inputs: ['color', 'mode'] - }), - Component({ - selector: 'ion-card-subtitle', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'mode'], - }) -], IonCardSubtitle); -export { IonCardSubtitle }; -let IonCardTitle = class IonCardTitle { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonCardTitle = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonCardTitle, - inputs: ['color', 'mode'] - }), - Component({ - selector: 'ion-card-title', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'mode'], - }) -], IonCardTitle); -export { IonCardTitle }; -let IonChip = class IonChip { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonChip = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonChip, - inputs: ['color', 'disabled', 'mode', 'outline'] - }), - Component({ - selector: 'ion-chip', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'disabled', 'mode', 'outline'], - }) -], IonChip); -export { IonChip }; -let IonCol = class IonCol { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonCol = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonCol, - 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'] - }), - Component({ - selector: 'ion-col', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - 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'], - }) -], IonCol); -export { IonCol }; -let IonContent = class IonContent { - constructor(c, r, z) { - this.z = z; - this.ionScrollStart = new EventEmitter(); - this.ionScroll = new EventEmitter(); - this.ionScrollEnd = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonContent.prototype, "ionScrollStart", void 0); -__decorate([ - Output() -], IonContent.prototype, "ionScroll", void 0); -__decorate([ - Output() -], IonContent.prototype, "ionScrollEnd", void 0); -IonContent = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonContent, - inputs: ['color', 'fixedSlotPlacement', 'forceOverscroll', 'fullscreen', 'scrollEvents', 'scrollX', 'scrollY'], - methods: ['getScrollElement', 'scrollToTop', 'scrollToBottom', 'scrollByPoint', 'scrollToPoint'] - }), - Component({ - selector: 'ion-content', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'fixedSlotPlacement', 'forceOverscroll', 'fullscreen', 'scrollEvents', 'scrollX', 'scrollY'], - outputs: ['ionScrollStart', 'ionScroll', 'ionScrollEnd'], - }) -], IonContent); -export { IonContent }; -let IonDatetimeButton = class IonDatetimeButton { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonDatetimeButton = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonDatetimeButton, - inputs: ['color', 'datetime', 'disabled', 'mode'] - }), - Component({ - selector: 'ion-datetime-button', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'datetime', 'disabled', 'mode'], - }) -], IonDatetimeButton); -export { IonDatetimeButton }; -let IonFab = class IonFab { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonFab = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonFab, - inputs: ['activated', 'edge', 'horizontal', 'vertical'], - methods: ['close'] - }), - Component({ - selector: 'ion-fab', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['activated', 'edge', 'horizontal', 'vertical'], - }) -], IonFab); -export { IonFab }; -let IonFabButton = class IonFabButton { - constructor(c, r, z) { - this.z = z; - this.ionFocus = new EventEmitter(); - this.ionBlur = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonFabButton.prototype, "ionFocus", void 0); -__decorate([ - Output() -], IonFabButton.prototype, "ionBlur", void 0); -IonFabButton = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonFabButton, - inputs: ['activated', 'closeIcon', 'color', 'disabled', 'download', 'href', 'mode', 'rel', 'routerAnimation', 'routerDirection', 'show', 'size', 'target', 'translucent', 'type'] - }), - Component({ - selector: 'ion-fab-button', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['activated', 'closeIcon', 'color', 'disabled', 'download', 'href', 'mode', 'rel', 'routerAnimation', 'routerDirection', 'show', 'size', 'target', 'translucent', 'type'], - outputs: ['ionFocus', 'ionBlur'], - }) -], IonFabButton); -export { IonFabButton }; -let IonFabList = class IonFabList { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonFabList = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonFabList, - inputs: ['activated', 'side'] - }), - Component({ - selector: 'ion-fab-list', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['activated', 'side'], - }) -], IonFabList); -export { IonFabList }; -let IonFooter = class IonFooter { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonFooter = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonFooter, - inputs: ['collapse', 'mode', 'translucent'] - }), - Component({ - selector: 'ion-footer', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['collapse', 'mode', 'translucent'], - }) -], IonFooter); -export { IonFooter }; -let IonGrid = class IonGrid { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonGrid = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonGrid, - inputs: ['fixed'] - }), - Component({ - selector: 'ion-grid', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['fixed'], - }) -], IonGrid); -export { IonGrid }; -let IonHeader = class IonHeader { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonHeader = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonHeader, - inputs: ['collapse', 'mode', 'translucent'] - }), - Component({ - selector: 'ion-header', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['collapse', 'mode', 'translucent'], - }) -], IonHeader); -export { IonHeader }; -let IonImg = class IonImg { - constructor(c, r, z) { - this.z = z; - this.ionImgWillLoad = new EventEmitter(); - this.ionImgDidLoad = new EventEmitter(); - this.ionError = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonImg.prototype, "ionImgWillLoad", void 0); -__decorate([ - Output() -], IonImg.prototype, "ionImgDidLoad", void 0); -__decorate([ - Output() -], IonImg.prototype, "ionError", void 0); -IonImg = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonImg, - inputs: ['alt', 'src'] - }), - Component({ - selector: 'ion-img', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['alt', 'src'], - outputs: ['ionImgWillLoad', 'ionImgDidLoad', 'ionError'], - }) -], IonImg); -export { IonImg }; -let IonInfiniteScroll = class IonInfiniteScroll { - constructor(c, r, z) { - this.z = z; - this.ionInfinite = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonInfiniteScroll.prototype, "ionInfinite", void 0); -IonInfiniteScroll = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonInfiniteScroll, - inputs: ['disabled', 'position', 'threshold'], - methods: ['complete'] - }), - Component({ - selector: 'ion-infinite-scroll', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['disabled', 'position', 'threshold'], - outputs: ['ionInfinite'], - }) -], IonInfiniteScroll); -export { IonInfiniteScroll }; -let IonInfiniteScrollContent = class IonInfiniteScrollContent { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonInfiniteScrollContent = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonInfiniteScrollContent, - inputs: ['loadingSpinner', 'loadingText'] - }), - Component({ - selector: 'ion-infinite-scroll-content', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['loadingSpinner', 'loadingText'], - }) -], IonInfiniteScrollContent); -export { IonInfiniteScrollContent }; -let IonInputPasswordToggle = class IonInputPasswordToggle { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonInputPasswordToggle = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonInputPasswordToggle, - inputs: ['color', 'hideIcon', 'mode', 'showIcon'] - }), - Component({ - selector: 'ion-input-password-toggle', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'hideIcon', 'mode', 'showIcon'], - }) -], IonInputPasswordToggle); -export { IonInputPasswordToggle }; -let IonItem = class IonItem { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonItem = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonItem, - inputs: ['button', 'color', 'detail', 'detailIcon', 'disabled', 'download', 'href', 'lines', 'mode', 'rel', 'routerAnimation', 'routerDirection', 'target', 'type'] - }), - Component({ - selector: 'ion-item', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['button', 'color', 'detail', 'detailIcon', 'disabled', 'download', 'href', 'lines', 'mode', 'rel', 'routerAnimation', 'routerDirection', 'target', 'type'], - }) -], IonItem); -export { IonItem }; -let IonItemDivider = class IonItemDivider { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonItemDivider = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonItemDivider, - inputs: ['color', 'mode', 'sticky'] - }), - Component({ - selector: 'ion-item-divider', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'mode', 'sticky'], - }) -], IonItemDivider); -export { IonItemDivider }; -let IonItemGroup = class IonItemGroup { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonItemGroup = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonItemGroup - }), - Component({ - selector: 'ion-item-group', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: [], - }) -], IonItemGroup); -export { IonItemGroup }; -let IonItemOption = class IonItemOption { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonItemOption = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonItemOption, - inputs: ['color', 'disabled', 'download', 'expandable', 'href', 'mode', 'rel', 'target', 'type'] - }), - Component({ - selector: 'ion-item-option', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'disabled', 'download', 'expandable', 'href', 'mode', 'rel', 'target', 'type'], - }) -], IonItemOption); -export { IonItemOption }; -let IonItemOptions = class IonItemOptions { - constructor(c, r, z) { - this.z = z; - this.ionSwipe = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonItemOptions.prototype, "ionSwipe", void 0); -IonItemOptions = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonItemOptions, - inputs: ['side'] - }), - Component({ - selector: 'ion-item-options', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['side'], - outputs: ['ionSwipe'], - }) -], IonItemOptions); -export { IonItemOptions }; -let IonItemSliding = class IonItemSliding { - constructor(c, r, z) { - this.z = z; - this.ionDrag = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonItemSliding.prototype, "ionDrag", void 0); -IonItemSliding = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonItemSliding, - inputs: ['disabled'], - methods: ['getOpenAmount', 'getSlidingRatio', 'open', 'close', 'closeOpened'] - }), - Component({ - selector: 'ion-item-sliding', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['disabled'], - outputs: ['ionDrag'], - }) -], IonItemSliding); -export { IonItemSliding }; -let IonLabel = class IonLabel { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonLabel = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonLabel, - inputs: ['color', 'mode', 'position'] - }), - Component({ - selector: 'ion-label', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'mode', 'position'], - }) -], IonLabel); -export { IonLabel }; -let IonList = class IonList { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonList = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonList, - inputs: ['inset', 'lines', 'mode'], - methods: ['closeSlidingItems'] - }), - Component({ - selector: 'ion-list', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['inset', 'lines', 'mode'], - }) -], IonList); -export { IonList }; -let IonListHeader = class IonListHeader { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonListHeader = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonListHeader, - inputs: ['color', 'lines', 'mode'] - }), - Component({ - selector: 'ion-list-header', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'lines', 'mode'], - }) -], IonListHeader); -export { IonListHeader }; -let IonLoading = class IonLoading { - constructor(c, r, z) { - this.z = z; - this.ionLoadingDidPresent = new EventEmitter(); - this.ionLoadingWillPresent = new EventEmitter(); - this.ionLoadingWillDismiss = new EventEmitter(); - this.ionLoadingDidDismiss = new EventEmitter(); - this.didPresent = new EventEmitter(); - this.willPresent = new EventEmitter(); - this.willDismiss = new EventEmitter(); - this.didDismiss = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonLoading.prototype, "ionLoadingDidPresent", void 0); -__decorate([ - Output() -], IonLoading.prototype, "ionLoadingWillPresent", void 0); -__decorate([ - Output() -], IonLoading.prototype, "ionLoadingWillDismiss", void 0); -__decorate([ - Output() -], IonLoading.prototype, "ionLoadingDidDismiss", void 0); -__decorate([ - Output() -], IonLoading.prototype, "didPresent", void 0); -__decorate([ - Output() -], IonLoading.prototype, "willPresent", void 0); -__decorate([ - Output() -], IonLoading.prototype, "willDismiss", void 0); -__decorate([ - Output() -], IonLoading.prototype, "didDismiss", void 0); -IonLoading = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonLoading, - inputs: ['animated', 'backdropDismiss', 'cssClass', 'duration', 'enterAnimation', 'htmlAttributes', 'isOpen', 'keyboardClose', 'leaveAnimation', 'message', 'mode', 'showBackdrop', 'spinner', 'translucent', 'trigger'], - methods: ['present', 'dismiss', 'onDidDismiss', 'onWillDismiss'] - }), - Component({ - selector: 'ion-loading', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['animated', 'backdropDismiss', 'cssClass', 'duration', 'enterAnimation', 'htmlAttributes', 'isOpen', 'keyboardClose', 'leaveAnimation', 'message', 'mode', 'showBackdrop', 'spinner', 'translucent', 'trigger'], - outputs: ['ionLoadingDidPresent', 'ionLoadingWillPresent', 'ionLoadingWillDismiss', 'ionLoadingDidDismiss', 'didPresent', 'willPresent', 'willDismiss', 'didDismiss'], - }) -], IonLoading); -export { IonLoading }; -let IonMenu = class IonMenu { - constructor(c, r, z) { - this.z = z; - this.ionWillOpen = new EventEmitter(); - this.ionWillClose = new EventEmitter(); - this.ionDidOpen = new EventEmitter(); - this.ionDidClose = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonMenu.prototype, "ionWillOpen", void 0); -__decorate([ - Output() -], IonMenu.prototype, "ionWillClose", void 0); -__decorate([ - Output() -], IonMenu.prototype, "ionDidOpen", void 0); -__decorate([ - Output() -], IonMenu.prototype, "ionDidClose", void 0); -IonMenu = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonMenu, - inputs: ['contentId', 'disabled', 'maxEdgeStart', 'menuId', 'side', 'swipeGesture', 'type'], - methods: ['isOpen', 'isActive', 'open', 'close', 'toggle', 'setOpen'] - }), - Component({ - selector: 'ion-menu', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['contentId', 'disabled', 'maxEdgeStart', 'menuId', 'side', 'swipeGesture', 'type'], - outputs: ['ionWillOpen', 'ionWillClose', 'ionDidOpen', 'ionDidClose'], - }) -], IonMenu); -export { IonMenu }; -let IonMenuButton = class IonMenuButton { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonMenuButton = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonMenuButton, - inputs: ['autoHide', 'color', 'disabled', 'menu', 'mode', 'type'] - }), - Component({ - selector: 'ion-menu-button', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['autoHide', 'color', 'disabled', 'menu', 'mode', 'type'], - }) -], IonMenuButton); -export { IonMenuButton }; -let IonMenuToggle = class IonMenuToggle { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonMenuToggle = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonMenuToggle, - inputs: ['autoHide', 'menu'] - }), - Component({ - selector: 'ion-menu-toggle', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['autoHide', 'menu'], - }) -], IonMenuToggle); -export { IonMenuToggle }; -let IonNavLink = class IonNavLink { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonNavLink = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonNavLink, - inputs: ['component', 'componentProps', 'routerAnimation', 'routerDirection'] - }), - Component({ - selector: 'ion-nav-link', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['component', 'componentProps', 'routerAnimation', 'routerDirection'], - }) -], IonNavLink); -export { IonNavLink }; -let IonNote = class IonNote { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonNote = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonNote, - inputs: ['color', 'mode'] - }), - Component({ - selector: 'ion-note', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'mode'], - }) -], IonNote); -export { IonNote }; -let IonPicker = class IonPicker { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonPicker = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonPicker, - inputs: ['mode'] - }), - Component({ - selector: 'ion-picker', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['mode'], - }) -], IonPicker); -export { IonPicker }; -let IonPickerColumn = class IonPickerColumn { - constructor(c, r, z) { - this.z = z; - this.ionChange = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonPickerColumn.prototype, "ionChange", void 0); -IonPickerColumn = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonPickerColumn, - inputs: ['color', 'disabled', 'mode', 'value'], - methods: ['setFocus'] - }), - Component({ - selector: 'ion-picker-column', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'disabled', 'mode', 'value'], - outputs: ['ionChange'], - }) -], IonPickerColumn); -export { IonPickerColumn }; -let IonPickerColumnOption = class IonPickerColumnOption { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonPickerColumnOption = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonPickerColumnOption, - inputs: ['color', 'disabled', 'value'] - }), - Component({ - selector: 'ion-picker-column-option', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'disabled', 'value'], - }) -], IonPickerColumnOption); -export { IonPickerColumnOption }; -let IonProgressBar = class IonProgressBar { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonProgressBar = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonProgressBar, - inputs: ['buffer', 'color', 'mode', 'reversed', 'type', 'value'] - }), - Component({ - selector: 'ion-progress-bar', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['buffer', 'color', 'mode', 'reversed', 'type', 'value'], - }) -], IonProgressBar); -export { IonProgressBar }; -let IonRadio = class IonRadio { - constructor(c, r, z) { - this.z = z; - this.ionFocus = new EventEmitter(); - this.ionBlur = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonRadio.prototype, "ionFocus", void 0); -__decorate([ - Output() -], IonRadio.prototype, "ionBlur", void 0); -IonRadio = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonRadio, - inputs: ['alignment', 'color', 'disabled', 'justify', 'labelPlacement', 'mode', 'name', 'value'] - }), - Component({ - selector: 'ion-radio', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['alignment', 'color', 'disabled', 'justify', 'labelPlacement', 'mode', 'name', 'value'], - outputs: ['ionFocus', 'ionBlur'], - }) -], IonRadio); -export { IonRadio }; -let IonRefresher = class IonRefresher { - constructor(c, r, z) { - this.z = z; - this.ionRefresh = new EventEmitter(); - this.ionPull = new EventEmitter(); - this.ionStart = new EventEmitter(); - this.ionPullStart = new EventEmitter(); - this.ionPullEnd = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonRefresher.prototype, "ionRefresh", void 0); -__decorate([ - Output() -], IonRefresher.prototype, "ionPull", void 0); -__decorate([ - Output() -], IonRefresher.prototype, "ionStart", void 0); -__decorate([ - Output() -], IonRefresher.prototype, "ionPullStart", void 0); -__decorate([ - Output() -], IonRefresher.prototype, "ionPullEnd", void 0); -IonRefresher = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonRefresher, - inputs: ['closeDuration', 'disabled', 'mode', 'pullFactor', 'pullMax', 'pullMin', 'snapbackDuration'], - methods: ['complete', 'cancel', 'getProgress'] - }), - Component({ - selector: 'ion-refresher', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['closeDuration', 'disabled', 'mode', 'pullFactor', 'pullMax', 'pullMin', 'snapbackDuration'], - outputs: ['ionRefresh', 'ionPull', 'ionStart', 'ionPullStart', 'ionPullEnd'], - }) -], IonRefresher); -export { IonRefresher }; -let IonRefresherContent = class IonRefresherContent { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonRefresherContent = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonRefresherContent, - inputs: ['pullingIcon', 'pullingText', 'refreshingSpinner', 'refreshingText'] - }), - Component({ - selector: 'ion-refresher-content', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['pullingIcon', 'pullingText', 'refreshingSpinner', 'refreshingText'], - }) -], IonRefresherContent); -export { IonRefresherContent }; -let IonReorder = class IonReorder { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonReorder = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonReorder - }), - Component({ - selector: 'ion-reorder', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: [], - }) -], IonReorder); -export { IonReorder }; -let IonReorderGroup = class IonReorderGroup { - constructor(c, r, z) { - this.z = z; - this.ionItemReorder = new EventEmitter(); - this.ionReorderStart = new EventEmitter(); - this.ionReorderMove = new EventEmitter(); - this.ionReorderEnd = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonReorderGroup.prototype, "ionItemReorder", void 0); -__decorate([ - Output() -], IonReorderGroup.prototype, "ionReorderStart", void 0); -__decorate([ - Output() -], IonReorderGroup.prototype, "ionReorderMove", void 0); -__decorate([ - Output() -], IonReorderGroup.prototype, "ionReorderEnd", void 0); -IonReorderGroup = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonReorderGroup, - inputs: ['disabled'], - methods: ['complete'] - }), - Component({ - selector: 'ion-reorder-group', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['disabled'], - outputs: ['ionItemReorder', 'ionReorderStart', 'ionReorderMove', 'ionReorderEnd'], - }) -], IonReorderGroup); -export { IonReorderGroup }; -let IonRippleEffect = class IonRippleEffect { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonRippleEffect = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonRippleEffect, - inputs: ['type'], - methods: ['addRipple'] - }), - Component({ - selector: 'ion-ripple-effect', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['type'], - }) -], IonRippleEffect); -export { IonRippleEffect }; -let IonRow = class IonRow { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonRow = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonRow - }), - Component({ - selector: 'ion-row', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: [], - }) -], IonRow); -export { IonRow }; -let IonSegmentButton = class IonSegmentButton { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonSegmentButton = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonSegmentButton, - inputs: ['contentId', 'disabled', 'layout', 'mode', 'type', 'value'] - }), - Component({ - selector: 'ion-segment-button', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['contentId', 'disabled', 'layout', 'mode', 'type', 'value'], - }) -], IonSegmentButton); -export { IonSegmentButton }; -let IonSegmentContent = class IonSegmentContent { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonSegmentContent = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonSegmentContent - }), - Component({ - selector: 'ion-segment-content', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: [], - }) -], IonSegmentContent); -export { IonSegmentContent }; -let IonSegmentView = class IonSegmentView { - constructor(c, r, z) { - this.z = z; - this.ionSegmentViewScroll = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonSegmentView.prototype, "ionSegmentViewScroll", void 0); -IonSegmentView = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonSegmentView, - inputs: ['disabled', 'swipeGesture'] - }), - Component({ - selector: 'ion-segment-view', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['disabled', 'swipeGesture'], - outputs: ['ionSegmentViewScroll'], - }) -], IonSegmentView); -export { IonSegmentView }; -let IonSelectModal = class IonSelectModal { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonSelectModal = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonSelectModal, - inputs: ['cancelText', 'header', 'multiple', 'options'] - }), - Component({ - selector: 'ion-select-modal', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['cancelText', 'header', 'multiple', 'options'], - }) -], IonSelectModal); -export { IonSelectModal }; -let IonSelectOption = class IonSelectOption { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonSelectOption = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonSelectOption, - inputs: ['description', 'disabled', 'justify', 'labelPlacement', 'mode', 'value'] - }), - Component({ - selector: 'ion-select-option', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['description', 'disabled', 'justify', 'labelPlacement', 'mode', 'value'], - }) -], IonSelectOption); -export { IonSelectOption }; -let IonSkeletonText = class IonSkeletonText { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonSkeletonText = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonSkeletonText, - inputs: ['animated'] - }), - Component({ - selector: 'ion-skeleton-text', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['animated'], - }) -], IonSkeletonText); -export { IonSkeletonText }; -let IonSpinner = class IonSpinner { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonSpinner = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonSpinner, - inputs: ['color', 'duration', 'name', 'paused'] - }), - Component({ - selector: 'ion-spinner', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'duration', 'name', 'paused'], - }) -], IonSpinner); -export { IonSpinner }; -let IonSplitPane = class IonSplitPane { - constructor(c, r, z) { - this.z = z; - this.ionSplitPaneVisible = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonSplitPane.prototype, "ionSplitPaneVisible", void 0); -IonSplitPane = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonSplitPane, - inputs: ['contentId', 'disabled', 'when'] - }), - Component({ - selector: 'ion-split-pane', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['contentId', 'disabled', 'when'], - outputs: ['ionSplitPaneVisible'], - }) -], IonSplitPane); -export { IonSplitPane }; -let IonTab = class IonTab { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonTab = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonTab, - inputs: ['component', 'tab'], - methods: ['setActive'] - }), - Component({ - selector: 'ion-tab', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['component', { name: 'tab', required: true }], - }) -], IonTab); -export { IonTab }; -let IonTabBar = class IonTabBar { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonTabBar = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonTabBar, - inputs: ['color', 'mode', 'selectedTab', 'translucent'] - }), - Component({ - selector: 'ion-tab-bar', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'mode', 'selectedTab', 'translucent'], - }) -], IonTabBar); -export { IonTabBar }; -let IonTabButton = class IonTabButton { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonTabButton = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonTabButton, - inputs: ['disabled', 'download', 'href', 'layout', 'mode', 'rel', 'selected', 'tab', 'target'] - }), - Component({ - selector: 'ion-tab-button', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['disabled', 'download', 'href', 'layout', 'mode', 'rel', 'selected', 'tab', 'target'], - }) -], IonTabButton); -export { IonTabButton }; -let IonText = class IonText { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonText = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonText, - inputs: ['color', 'mode'] - }), - Component({ - selector: 'ion-text', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'mode'], - }) -], IonText); -export { IonText }; -let IonThumbnail = class IonThumbnail { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonThumbnail = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonThumbnail - }), - Component({ - selector: 'ion-thumbnail', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: [], - }) -], IonThumbnail); -export { IonThumbnail }; -let IonTitle = class IonTitle { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonTitle = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonTitle, - inputs: ['color', 'size'] - }), - Component({ - selector: 'ion-title', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'size'], - }) -], IonTitle); -export { IonTitle }; -let IonToast = class IonToast { - constructor(c, r, z) { - this.z = z; - this.ionToastDidPresent = new EventEmitter(); - this.ionToastWillPresent = new EventEmitter(); - this.ionToastWillDismiss = new EventEmitter(); - this.ionToastDidDismiss = new EventEmitter(); - this.didPresent = new EventEmitter(); - this.willPresent = new EventEmitter(); - this.willDismiss = new EventEmitter(); - this.didDismiss = new EventEmitter(); - c.detach(); - this.el = r.nativeElement; - } -}; -__decorate([ - Output() -], IonToast.prototype, "ionToastDidPresent", void 0); -__decorate([ - Output() -], IonToast.prototype, "ionToastWillPresent", void 0); -__decorate([ - Output() -], IonToast.prototype, "ionToastWillDismiss", void 0); -__decorate([ - Output() -], IonToast.prototype, "ionToastDidDismiss", void 0); -__decorate([ - Output() -], IonToast.prototype, "didPresent", void 0); -__decorate([ - Output() -], IonToast.prototype, "willPresent", void 0); -__decorate([ - Output() -], IonToast.prototype, "willDismiss", void 0); -__decorate([ - Output() -], IonToast.prototype, "didDismiss", void 0); -IonToast = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonToast, - inputs: ['animated', 'buttons', 'color', 'cssClass', 'duration', 'enterAnimation', 'header', 'htmlAttributes', 'icon', 'isOpen', 'keyboardClose', 'layout', 'leaveAnimation', 'message', 'mode', 'position', 'positionAnchor', 'swipeGesture', 'translucent', 'trigger'], - methods: ['present', 'dismiss', 'onDidDismiss', 'onWillDismiss'] - }), - Component({ - selector: 'ion-toast', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['animated', 'buttons', 'color', 'cssClass', 'duration', 'enterAnimation', 'header', 'htmlAttributes', 'icon', 'isOpen', 'keyboardClose', 'layout', 'leaveAnimation', 'message', 'mode', 'position', 'positionAnchor', 'swipeGesture', 'translucent', 'trigger'], - outputs: ['ionToastDidPresent', 'ionToastWillPresent', 'ionToastWillDismiss', 'ionToastDidDismiss', 'didPresent', 'willPresent', 'willDismiss', 'didDismiss'], - }) -], IonToast); -export { IonToast }; -let IonToolbar = class IonToolbar { - constructor(c, r, z) { - this.z = z; - c.detach(); - this.el = r.nativeElement; - } -}; -IonToolbar = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineIonToolbar, - inputs: ['color', 'mode'] - }), - Component({ - selector: 'ion-toolbar', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: ['color', 'mode'], - }) -], IonToolbar); -export { IonToolbar }; diff --git a/packages/angular/build/es2015/standalone/src/directives/radio-group.js b/packages/angular/build/es2015/standalone/src/directives/radio-group.js deleted file mode 100644 index 247e5203301..00000000000 --- a/packages/angular/build/es2015/standalone/src/directives/radio-group.js +++ /dev/null @@ -1,51 +0,0 @@ -import { __decorate } from "tslib"; -import { ChangeDetectionStrategy, Component, HostListener, forwardRef, } from '@angular/core'; -import { NG_VALUE_ACCESSOR } from '@angular/forms'; -import { ValueAccessor } from '@ionic/angular/common'; -import { defineCustomElement } from '@ionic/core/components/ion-radio-group.js'; -import { ProxyCmp, proxyOutputs } from './angular-component-lib/utils'; -const RADIO_GROUP_INPUTS = ['allowEmptySelection', 'compareWith', 'errorText', 'helperText', 'name', 'value']; -/** - * Pulling the provider into an object and using PURE works - * around an ng-packagr issue that causes - * components with multiple decorators and - * a provider to be re-assigned. This re-assignment - * is not supported by Webpack and causes treeshaking - * to not work on these kinds of components. - */ -const accessorProvider = { - provide: NG_VALUE_ACCESSOR, - useExisting: /*@__PURE__*/ forwardRef(() => IonRadioGroup), - multi: true, -}; -let IonRadioGroup = class IonRadioGroup extends ValueAccessor { - constructor(c, r, z, injector) { - super(injector, r); - this.z = z; - c.detach(); - this.el = r.nativeElement; - proxyOutputs(this, this.el, ['ionChange']); - } - handleIonChange(el) { - this.handleValueChange(el, el.value); - } -}; -__decorate([ - HostListener('ionChange', ['$event.target']) -], IonRadioGroup.prototype, "handleIonChange", null); -IonRadioGroup = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineCustomElement, - inputs: RADIO_GROUP_INPUTS, - }), - Component({ - selector: 'ion-radio-group', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: RADIO_GROUP_INPUTS, - providers: [accessorProvider], - standalone: true, - }) -], IonRadioGroup); -export { IonRadioGroup }; diff --git a/packages/angular/build/es2015/standalone/src/directives/range.js b/packages/angular/build/es2015/standalone/src/directives/range.js deleted file mode 100644 index 0fc436b59ae..00000000000 --- a/packages/angular/build/es2015/standalone/src/directives/range.js +++ /dev/null @@ -1,69 +0,0 @@ -import { __decorate } from "tslib"; -import { ChangeDetectionStrategy, Component, HostListener, forwardRef, } from '@angular/core'; -import { NG_VALUE_ACCESSOR } from '@angular/forms'; -import { ValueAccessor } from '@ionic/angular/common'; -import { defineCustomElement } from '@ionic/core/components/ion-range.js'; -import { ProxyCmp, proxyOutputs } from './angular-component-lib/utils'; -const RANGE_INPUTS = [ - 'activeBarStart', - 'color', - 'debounce', - 'disabled', - 'dualKnobs', - 'label', - 'labelPlacement', - 'max', - 'min', - 'mode', - 'name', - 'pin', - 'pinFormatter', - 'snaps', - 'step', - 'ticks', - 'value', -]; -/** - * Pulling the provider into an object and using PURE works - * around an ng-packagr issue that causes - * components with multiple decorators and - * a provider to be re-assigned. This re-assignment - * is not supported by Webpack and causes treeshaking - * to not work on these kinds of components. - */ -const accessorProvider = { - provide: NG_VALUE_ACCESSOR, - useExisting: /*@__PURE__*/ forwardRef(() => IonRange), - multi: true, -}; -let IonRange = class IonRange extends ValueAccessor { - constructor(c, r, z, injector) { - super(injector, r); - this.z = z; - c.detach(); - this.el = r.nativeElement; - proxyOutputs(this, this.el, ['ionChange', 'ionInput', 'ionFocus', 'ionBlur', 'ionKnobMoveStart', 'ionKnobMoveEnd']); - } - handleIonInput(el) { - this.handleValueChange(el, el.value); - } -}; -__decorate([ - HostListener('ionInput', ['$event.target']) -], IonRange.prototype, "handleIonInput", null); -IonRange = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineCustomElement, - inputs: RANGE_INPUTS, - }), - Component({ - selector: 'ion-range', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: RANGE_INPUTS, - providers: [accessorProvider], - standalone: true, - }) -], IonRange); -export { IonRange }; diff --git a/packages/angular/build/es2015/standalone/src/directives/searchbar.js b/packages/angular/build/es2015/standalone/src/directives/searchbar.js deleted file mode 100644 index fbab630c96b..00000000000 --- a/packages/angular/build/es2015/standalone/src/directives/searchbar.js +++ /dev/null @@ -1,73 +0,0 @@ -import { __decorate } from "tslib"; -import { ChangeDetectionStrategy, Component, HostListener, forwardRef, } from '@angular/core'; -import { NG_VALUE_ACCESSOR } from '@angular/forms'; -import { ValueAccessor } from '@ionic/angular/common'; -import { defineCustomElement } from '@ionic/core/components/ion-searchbar.js'; -import { ProxyCmp, proxyOutputs } from './angular-component-lib/utils'; -const SEARCHBAR_INPUTS = [ - 'animated', - 'autocomplete', - 'autocorrect', - 'cancelButtonIcon', - 'cancelButtonText', - 'clearIcon', - 'color', - 'debounce', - 'disabled', - 'enterkeyhint', - 'inputmode', - 'mode', - 'name', - 'placeholder', - 'searchIcon', - 'showCancelButton', - 'showClearButton', - 'spellcheck', - 'type', - 'value', -]; -/** - * Pulling the provider into an object and using PURE works - * around an ng-packagr issue that causes - * components with multiple decorators and - * a provider to be re-assigned. This re-assignment - * is not supported by Webpack and causes treeshaking - * to not work on these kinds of components. - */ -const accessorProvider = { - provide: NG_VALUE_ACCESSOR, - useExisting: /*@__PURE__*/ forwardRef(() => IonSearchbar), - multi: true, -}; -let IonSearchbar = class IonSearchbar extends ValueAccessor { - constructor(c, r, z, injector) { - super(injector, r); - this.z = z; - c.detach(); - this.el = r.nativeElement; - proxyOutputs(this, this.el, ['ionInput', 'ionChange', 'ionCancel', 'ionClear', 'ionBlur', 'ionFocus']); - } - handleIonInput(el) { - this.handleValueChange(el, el.value); - } -}; -__decorate([ - HostListener('ionInput', ['$event.target']) -], IonSearchbar.prototype, "handleIonInput", null); -IonSearchbar = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineCustomElement, - inputs: SEARCHBAR_INPUTS, - methods: ['setFocus', 'getInputElement'], - }), - Component({ - selector: 'ion-searchbar', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: SEARCHBAR_INPUTS, - providers: [accessorProvider], - standalone: true, - }) -], IonSearchbar); -export { IonSearchbar }; diff --git a/packages/angular/build/es2015/standalone/src/directives/segment.js b/packages/angular/build/es2015/standalone/src/directives/segment.js deleted file mode 100644 index 2730cbba77e..00000000000 --- a/packages/angular/build/es2015/standalone/src/directives/segment.js +++ /dev/null @@ -1,51 +0,0 @@ -import { __decorate } from "tslib"; -import { ChangeDetectionStrategy, Component, HostListener, forwardRef, } from '@angular/core'; -import { NG_VALUE_ACCESSOR } from '@angular/forms'; -import { ValueAccessor } from '@ionic/angular/common'; -import { defineCustomElement } from '@ionic/core/components/ion-segment.js'; -import { ProxyCmp, proxyOutputs } from './angular-component-lib/utils'; -const SEGMENT_INPUTS = ['color', 'disabled', 'mode', 'scrollable', 'selectOnFocus', 'swipeGesture', 'value']; -/** - * Pulling the provider into an object and using PURE works - * around an ng-packagr issue that causes - * components with multiple decorators and - * a provider to be re-assigned. This re-assignment - * is not supported by Webpack and causes treeshaking - * to not work on these kinds of components. - */ -const accessorProvider = { - provide: NG_VALUE_ACCESSOR, - useExisting: /*@__PURE__*/ forwardRef(() => IonSegment), - multi: true, -}; -let IonSegment = class IonSegment extends ValueAccessor { - constructor(c, r, z, injector) { - super(injector, r); - this.z = z; - c.detach(); - this.el = r.nativeElement; - proxyOutputs(this, this.el, ['ionChange']); - } - handleIonChange(el) { - this.handleValueChange(el, el.value); - } -}; -__decorate([ - HostListener('ionChange', ['$event.target']) -], IonSegment.prototype, "handleIonChange", null); -IonSegment = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineCustomElement, - inputs: SEGMENT_INPUTS, - }), - Component({ - selector: 'ion-segment', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: SEGMENT_INPUTS, - providers: [accessorProvider], - standalone: true, - }) -], IonSegment); -export { IonSegment }; diff --git a/packages/angular/build/es2015/standalone/src/directives/select.js b/packages/angular/build/es2015/standalone/src/directives/select.js deleted file mode 100644 index 7c48992ee06..00000000000 --- a/packages/angular/build/es2015/standalone/src/directives/select.js +++ /dev/null @@ -1,75 +0,0 @@ -import { __decorate } from "tslib"; -import { ChangeDetectionStrategy, Component, HostListener, forwardRef, } from '@angular/core'; -import { NG_VALUE_ACCESSOR } from '@angular/forms'; -import { ValueAccessor } from '@ionic/angular/common'; -import { defineCustomElement } from '@ionic/core/components/ion-select.js'; -import { ProxyCmp, proxyOutputs } from './angular-component-lib/utils'; -const SELECT_INPUTS = [ - 'cancelText', - 'color', - 'compareWith', - 'disabled', - 'errorText', - 'expandedIcon', - 'fill', - 'helperText', - 'interface', - 'interfaceOptions', - 'justify', - 'label', - 'labelPlacement', - 'mode', - 'multiple', - 'name', - 'okText', - 'placeholder', - 'selectedText', - 'shape', - 'toggleIcon', - 'value', -]; -/** - * Pulling the provider into an object and using PURE works - * around an ng-packagr issue that causes - * components with multiple decorators and - * a provider to be re-assigned. This re-assignment - * is not supported by Webpack and causes treeshaking - * to not work on these kinds of components. - */ -const accessorProvider = { - provide: NG_VALUE_ACCESSOR, - useExisting: /*@__PURE__*/ forwardRef(() => IonSelect), - multi: true, -}; -let IonSelect = class IonSelect extends ValueAccessor { - constructor(c, r, z, injector) { - super(injector, r); - this.z = z; - c.detach(); - this.el = r.nativeElement; - proxyOutputs(this, this.el, ['ionChange', 'ionCancel', 'ionDismiss', 'ionFocus', 'ionBlur']); - } - handleIonChange(el) { - this.handleValueChange(el, el.value); - } -}; -__decorate([ - HostListener('ionChange', ['$event.target']) -], IonSelect.prototype, "handleIonChange", null); -IonSelect = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineCustomElement, - inputs: SELECT_INPUTS, - methods: ['open'], - }), - Component({ - selector: 'ion-select', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: SELECT_INPUTS, - providers: [accessorProvider], - standalone: true, - }) -], IonSelect); -export { IonSelect }; diff --git a/packages/angular/build/es2015/standalone/src/directives/textarea.js b/packages/angular/build/es2015/standalone/src/directives/textarea.js deleted file mode 100644 index ffe4da4fd43..00000000000 --- a/packages/angular/build/es2015/standalone/src/directives/textarea.js +++ /dev/null @@ -1,82 +0,0 @@ -import { __decorate } from "tslib"; -import { ChangeDetectionStrategy, Component, HostListener, forwardRef, } from '@angular/core'; -import { NG_VALUE_ACCESSOR } from '@angular/forms'; -import { ValueAccessor } from '@ionic/angular/common'; -import { defineCustomElement } from '@ionic/core/components/ion-textarea.js'; -import { ProxyCmp, proxyOutputs } from './angular-component-lib/utils'; -const TEXTAREA_INPUTS = [ - 'autoGrow', - 'autocapitalize', - 'autofocus', - 'clearOnEdit', - 'color', - 'cols', - 'counter', - 'counterFormatter', - 'debounce', - 'disabled', - 'enterkeyhint', - 'errorText', - 'fill', - 'helperText', - 'inputmode', - 'label', - 'labelPlacement', - 'maxlength', - 'minlength', - 'mode', - 'name', - 'placeholder', - 'readonly', - 'required', - 'rows', - 'shape', - 'spellcheck', - 'value', - 'wrap', -]; -/** - * Pulling the provider into an object and using PURE works - * around an ng-packagr issue that causes - * components with multiple decorators and - * a provider to be re-assigned. This re-assignment - * is not supported by Webpack and causes treeshaking - * to not work on these kinds of components. - */ -const accessorProvider = { - provide: NG_VALUE_ACCESSOR, - useExisting: /*@__PURE__*/ forwardRef(() => IonTextarea), - multi: true, -}; -let IonTextarea = class IonTextarea extends ValueAccessor { - constructor(c, r, z, injector) { - super(injector, r); - this.z = z; - c.detach(); - this.el = r.nativeElement; - proxyOutputs(this, this.el, ['ionChange', 'ionInput', 'ionBlur', 'ionFocus']); - } - handleIonInput(el) { - this.handleValueChange(el, el.value); - } -}; -__decorate([ - HostListener('ionInput', ['$event.target']) -], IonTextarea.prototype, "handleIonInput", null); -IonTextarea = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineCustomElement, - inputs: TEXTAREA_INPUTS, - methods: ['setFocus', 'getInputElement'], - }), - Component({ - selector: 'ion-textarea', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: TEXTAREA_INPUTS, - providers: [accessorProvider], - standalone: true, - }) -], IonTextarea); -export { IonTextarea }; diff --git a/packages/angular/build/es2015/standalone/src/directives/toggle.js b/packages/angular/build/es2015/standalone/src/directives/toggle.js deleted file mode 100644 index 696a86e014b..00000000000 --- a/packages/angular/build/es2015/standalone/src/directives/toggle.js +++ /dev/null @@ -1,67 +0,0 @@ -import { __decorate } from "tslib"; -import { ChangeDetectionStrategy, Component, HostListener, forwardRef, } from '@angular/core'; -import { NG_VALUE_ACCESSOR } from '@angular/forms'; -import { ValueAccessor, setIonicClasses } from '@ionic/angular/common'; -import { defineCustomElement } from '@ionic/core/components/ion-toggle.js'; -import { ProxyCmp, proxyOutputs } from './angular-component-lib/utils'; -const TOGGLE_INPUTS = [ - 'checked', - 'color', - 'disabled', - 'enableOnOffLabels', - 'errorText', - 'helperText', - 'justify', - 'labelPlacement', - 'mode', - 'name', - 'value', -]; -/** - * Pulling the provider into an object and using PURE works - * around an ng-packagr issue that causes - * components with multiple decorators and - * a provider to be re-assigned. This re-assignment - * is not supported by Webpack and causes treeshaking - * to not work on these kinds of components. - */ -const accessorProvider = { - provide: NG_VALUE_ACCESSOR, - useExisting: /*@__PURE__*/ forwardRef(() => IonToggle), - multi: true, -}; -let IonToggle = class IonToggle extends ValueAccessor { - constructor(c, r, z, injector) { - super(injector, r); - this.z = z; - c.detach(); - this.el = r.nativeElement; - proxyOutputs(this, this.el, ['ionChange', 'ionFocus', 'ionBlur']); - } - writeValue(value) { - this.elementRef.nativeElement.checked = this.lastValue = value; - setIonicClasses(this.elementRef); - } - handleIonChange(el) { - this.handleValueChange(el, el.checked); - } -}; -__decorate([ - HostListener('ionChange', ['$event.target']) -], IonToggle.prototype, "handleIonChange", null); -IonToggle = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineCustomElement, - inputs: TOGGLE_INPUTS, - }), - Component({ - selector: 'ion-toggle', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property - inputs: TOGGLE_INPUTS, - providers: [accessorProvider], - standalone: true, - }) -], IonToggle); -export { IonToggle }; diff --git a/packages/angular/build/es2015/standalone/src/index.js b/packages/angular/build/es2015/standalone/src/index.js deleted file mode 100644 index 9545b9e29bd..00000000000 --- a/packages/angular/build/es2015/standalone/src/index.js +++ /dev/null @@ -1,23 +0,0 @@ -export { IonBackButton } from './navigation/back-button'; -export { IonModal } from './overlays/modal'; -export { IonPopover } from './overlays/popover'; -export { IonRouterOutlet } from './navigation/router-outlet'; -export { IonRouterLink, IonRouterLinkWithHref } from './navigation/router-link-delegate'; -export { IonTabs } from './navigation/tabs'; -export { provideIonicAngular } from './providers/ionic-angular'; -export { ActionSheetController } from './providers/action-sheet-controller'; -export { AlertController } from './providers/alert-controller'; -export { AnimationController } from './providers/animation-controller'; -export { GestureController } from './providers/gesture-controller'; -export { LoadingController } from './providers/loading-controller'; -export { MenuController } from './providers/menu-controller'; -export { ModalController } from './providers/modal-controller'; -export { PopoverController } from './providers/popover-controller'; -export { ToastController } from './providers/toast-controller'; -export { DomController, NavController, Config, Platform, NavParams, IonModalToken, IonicRouteStrategy, } from '@ionic/angular/common'; -export { IonNav } from './navigation/nav'; -export { IonCheckbox, IonDatetime, IonInput, IonInputOtp, IonIcon, IonRadioGroup, IonRange, IonSearchbar, IonSegment, IonSelect, IonTextarea, IonToggle, } from './directives'; -export * from './directives/proxies'; -export { -// UTILS -createAnimation, createGesture, iosTransitionAnimation, mdTransitionAnimation, IonicSlides, getPlatforms, isPlatform, getTimeGivenProgression, IonicSafeString, } from '@ionic/core/components'; diff --git a/packages/angular/build/es2015/standalone/src/navigation/back-button.js b/packages/angular/build/es2015/standalone/src/navigation/back-button.js deleted file mode 100644 index b204f687de3..00000000000 --- a/packages/angular/build/es2015/standalone/src/navigation/back-button.js +++ /dev/null @@ -1,22 +0,0 @@ -import { __decorate, __param } from "tslib"; -import { Component, Optional, ChangeDetectionStrategy } from '@angular/core'; -import { IonBackButton as IonBackButtonBase, ProxyCmp } from '@ionic/angular/common'; -import { defineCustomElement } from '@ionic/core/components/ion-back-button.js'; -let IonBackButton = class IonBackButton extends IonBackButtonBase { - constructor(routerOutlet, navCtrl, config, r, z, c) { - super(routerOutlet, navCtrl, config, r, z, c); - } -}; -IonBackButton = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineCustomElement, - }), - Component({ - selector: 'ion-back-button', - changeDetection: ChangeDetectionStrategy.OnPush, - template: '', - standalone: true, - }), - __param(0, Optional()) -], IonBackButton); -export { IonBackButton }; diff --git a/packages/angular/build/es2015/standalone/src/navigation/nav.js b/packages/angular/build/es2015/standalone/src/navigation/nav.js deleted file mode 100644 index e69035fb3f0..00000000000 --- a/packages/angular/build/es2015/standalone/src/navigation/nav.js +++ /dev/null @@ -1,20 +0,0 @@ -import { __decorate } from "tslib"; -import { Component } from '@angular/core'; -import { IonNav as IonNavBase, ProxyCmp } from '@ionic/angular/common'; -import { defineCustomElement } from '@ionic/core/components/ion-nav.js'; -let IonNav = class IonNav extends IonNavBase { - constructor(ref, environmentInjector, injector, angularDelegate, z, c) { - super(ref, environmentInjector, injector, angularDelegate, z, c); - } -}; -IonNav = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineCustomElement, - }), - Component({ - selector: 'ion-nav', - template: '', - standalone: true, - }) -], IonNav); -export { IonNav }; diff --git a/packages/angular/build/es2015/standalone/src/navigation/router-link-delegate.js b/packages/angular/build/es2015/standalone/src/navigation/router-link-delegate.js deleted file mode 100644 index 33f48efc98c..00000000000 --- a/packages/angular/build/es2015/standalone/src/navigation/router-link-delegate.js +++ /dev/null @@ -1,21 +0,0 @@ -import { __decorate } from "tslib"; -import { Directive } from '@angular/core'; -import { RouterLinkDelegateDirective as RouterLinkDelegateBase, RouterLinkWithHrefDelegateDirective as RouterLinkHrefDelegateBase, } from '@ionic/angular/common'; -let IonRouterLink = class IonRouterLink extends RouterLinkDelegateBase { -}; -IonRouterLink = __decorate([ - Directive({ - selector: ':not(a):not(area)[routerLink]', - standalone: true, - }) -], IonRouterLink); -export { IonRouterLink }; -let IonRouterLinkWithHref = class IonRouterLinkWithHref extends RouterLinkHrefDelegateBase { -}; -IonRouterLinkWithHref = __decorate([ - Directive({ - selector: 'a[routerLink],area[routerLink]', - standalone: true, - }) -], IonRouterLinkWithHref); -export { IonRouterLinkWithHref }; diff --git a/packages/angular/build/es2015/standalone/src/navigation/router-outlet.js b/packages/angular/build/es2015/standalone/src/navigation/router-outlet.js deleted file mode 100644 index 09eb8db1a4d..00000000000 --- a/packages/angular/build/es2015/standalone/src/navigation/router-outlet.js +++ /dev/null @@ -1,35 +0,0 @@ -import { __decorate, __param } from "tslib"; -import { ViewChild, ViewContainerRef, Component, Attribute, Optional, SkipSelf, } from '@angular/core'; -import { IonRouterOutlet as IonRouterOutletBase, ProxyCmp } from '@ionic/angular/common'; -import { defineCustomElement } from '@ionic/core/components/ion-router-outlet.js'; -let IonRouterOutlet = class IonRouterOutlet extends IonRouterOutletBase { - /** - * We need to pass in the correct instance of IonRouterOutlet - * otherwise parentOutlet will be null in a nested outlet context. - * This results in APIs such as NavController.pop not working - * in nested outlets because the parent outlet cannot be found. - */ - constructor(name, tabs, commonLocation, elementRef, router, zone, activatedRoute, parentOutlet) { - super(name, tabs, commonLocation, elementRef, router, zone, activatedRoute, parentOutlet); - this.parentOutlet = parentOutlet; - } -}; -__decorate([ - ViewChild('outletContent', { read: ViewContainerRef, static: true }) -], IonRouterOutlet.prototype, "outletContent", void 0); -IonRouterOutlet = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineCustomElement, - }), - Component({ - selector: 'ion-router-outlet', - standalone: true, - template: '', - }), - __param(0, Attribute('name')), - __param(1, Optional()), - __param(1, Attribute('tabs')), - __param(7, SkipSelf()), - __param(7, Optional()) -], IonRouterOutlet); -export { IonRouterOutlet }; diff --git a/packages/angular/build/es2015/standalone/src/navigation/tabs.js b/packages/angular/build/es2015/standalone/src/navigation/tabs.js deleted file mode 100644 index 802ec66ed4f..00000000000 --- a/packages/angular/build/es2015/standalone/src/navigation/tabs.js +++ /dev/null @@ -1,68 +0,0 @@ -import { __decorate } from "tslib"; -import { NgIf } from '@angular/common'; -import { Component, ContentChild, ContentChildren, ViewChild } from '@angular/core'; -import { IonTabs as IonTabsBase } from '@ionic/angular/common'; -import { IonTabBar, IonTab } from '../directives/proxies'; -import { IonRouterOutlet } from './router-outlet'; -let IonTabs = class IonTabs extends IonTabsBase { -}; -__decorate([ - ViewChild('outlet', { read: IonRouterOutlet, static: false }) -], IonTabs.prototype, "outlet", void 0); -__decorate([ - ContentChild(IonTabBar, { static: false }) -], IonTabs.prototype, "tabBar", void 0); -__decorate([ - ContentChildren(IonTabBar) -], IonTabs.prototype, "tabBars", void 0); -__decorate([ - ContentChildren(IonTab) -], IonTabs.prototype, "tabs", void 0); -IonTabs = __decorate([ - Component({ - selector: 'ion-tabs', - template: ` - -
- - -
- - `, - standalone: true, - styles: [ - ` - :host { - display: flex; - position: absolute; - top: 0; - left: 0; - right: 0; - bottom: 0; - - flex-direction: column; - - width: 100%; - height: 100%; - - contain: layout size style; - } - .tabs-inner { - position: relative; - - flex: 1; - - contain: layout size style; - } - `, - ], - imports: [IonRouterOutlet, NgIf], - }) -], IonTabs); -export { IonTabs }; diff --git a/packages/angular/build/es2015/standalone/src/overlays/modal.js b/packages/angular/build/es2015/standalone/src/overlays/modal.js deleted file mode 100644 index d3e6b584717..00000000000 --- a/packages/angular/build/es2015/standalone/src/overlays/modal.js +++ /dev/null @@ -1,22 +0,0 @@ -import { __decorate } from "tslib"; -import { CommonModule } from '@angular/common'; -import { ChangeDetectionStrategy, Component } from '@angular/core'; -import { IonModal as IonModalBase, ProxyCmp } from '@ionic/angular/common'; -import { defineCustomElement } from '@ionic/core/components/ion-modal.js'; -let IonModal = class IonModal extends IonModalBase { -}; -IonModal = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineCustomElement, - }), - Component({ - selector: 'ion-modal', - changeDetection: ChangeDetectionStrategy.OnPush, - template: `
- -
`, - standalone: true, - imports: [CommonModule], - }) -], IonModal); -export { IonModal }; diff --git a/packages/angular/build/es2015/standalone/src/overlays/popover.js b/packages/angular/build/es2015/standalone/src/overlays/popover.js deleted file mode 100644 index a5b8b139979..00000000000 --- a/packages/angular/build/es2015/standalone/src/overlays/popover.js +++ /dev/null @@ -1,20 +0,0 @@ -import { __decorate } from "tslib"; -import { CommonModule } from '@angular/common'; -import { ChangeDetectionStrategy, Component } from '@angular/core'; -import { IonPopover as IonPopoverBase, ProxyCmp } from '@ionic/angular/common'; -import { defineCustomElement } from '@ionic/core/components/ion-popover.js'; -let IonPopover = class IonPopover extends IonPopoverBase { -}; -IonPopover = __decorate([ - ProxyCmp({ - defineCustomElementFn: defineCustomElement, - }), - Component({ - selector: 'ion-popover', - changeDetection: ChangeDetectionStrategy.OnPush, - template: ``, - standalone: true, - imports: [CommonModule], - }) -], IonPopover); -export { IonPopover }; diff --git a/packages/angular/build/es2015/standalone/src/providers/action-sheet-controller.js b/packages/angular/build/es2015/standalone/src/providers/action-sheet-controller.js deleted file mode 100644 index 0f340dcbe3d..00000000000 --- a/packages/angular/build/es2015/standalone/src/providers/action-sheet-controller.js +++ /dev/null @@ -1,17 +0,0 @@ -import { __decorate } from "tslib"; -import { Injectable } from '@angular/core'; -import { OverlayBaseController } from '@ionic/angular/common'; -import { actionSheetController } from '@ionic/core/components'; -import { defineCustomElement } from '@ionic/core/components/ion-action-sheet.js'; -let ActionSheetController = class ActionSheetController extends OverlayBaseController { - constructor() { - super(actionSheetController); - defineCustomElement(); - } -}; -ActionSheetController = __decorate([ - Injectable({ - providedIn: 'root', - }) -], ActionSheetController); -export { ActionSheetController }; diff --git a/packages/angular/build/es2015/standalone/src/providers/alert-controller.js b/packages/angular/build/es2015/standalone/src/providers/alert-controller.js deleted file mode 100644 index 6ebcc1023a8..00000000000 --- a/packages/angular/build/es2015/standalone/src/providers/alert-controller.js +++ /dev/null @@ -1,17 +0,0 @@ -import { __decorate } from "tslib"; -import { Injectable } from '@angular/core'; -import { OverlayBaseController } from '@ionic/angular/common'; -import { alertController } from '@ionic/core/components'; -import { defineCustomElement } from '@ionic/core/components/ion-alert.js'; -let AlertController = class AlertController extends OverlayBaseController { - constructor() { - super(alertController); - defineCustomElement(); - } -}; -AlertController = __decorate([ - Injectable({ - providedIn: 'root', - }) -], AlertController); -export { AlertController }; diff --git a/packages/angular/build/es2015/standalone/src/providers/animation-controller.js b/packages/angular/build/es2015/standalone/src/providers/animation-controller.js deleted file mode 100644 index 64b671b0e15..00000000000 --- a/packages/angular/build/es2015/standalone/src/providers/animation-controller.js +++ /dev/null @@ -1,34 +0,0 @@ -import { __decorate } from "tslib"; -import { Injectable } from '@angular/core'; -import { createAnimation, getTimeGivenProgression } from '@ionic/core/components'; -let AnimationController = class AnimationController { - /** - * Create a new animation - */ - create(animationId) { - return createAnimation(animationId); - } - /** - * EXPERIMENTAL - * - * Given a progression and a cubic bezier function, - * this utility returns the time value(s) at which the - * cubic bezier reaches the given time progression. - * - * If the cubic bezier never reaches the progression - * the result will be an empty array. - * - * This is most useful for switching between easing curves - * when doing a gesture animation (i.e. going from linear easing - * during a drag, to another easing when `progressEnd` is called) - */ - easingTime(p0, p1, p2, p3, progression) { - return getTimeGivenProgression(p0, p1, p2, p3, progression); - } -}; -AnimationController = __decorate([ - Injectable({ - providedIn: 'root', - }) -], AnimationController); -export { AnimationController }; diff --git a/packages/angular/build/es2015/standalone/src/providers/gesture-controller.js b/packages/angular/build/es2015/standalone/src/providers/gesture-controller.js deleted file mode 100644 index c83f0fbf261..00000000000 --- a/packages/angular/build/es2015/standalone/src/providers/gesture-controller.js +++ /dev/null @@ -1,28 +0,0 @@ -import { __decorate } from "tslib"; -import { Injectable } from '@angular/core'; -import { createGesture } from '@ionic/core/components'; -let GestureController = class GestureController { - constructor(zone) { - this.zone = zone; - } - /** - * Create a new gesture - */ - create(opts, runInsideAngularZone = false) { - if (runInsideAngularZone) { - Object.getOwnPropertyNames(opts).forEach((key) => { - if (typeof opts[key] === 'function') { - const fn = opts[key]; - opts[key] = (...props) => this.zone.run(() => fn(...props)); - } - }); - } - return createGesture(opts); - } -}; -GestureController = __decorate([ - Injectable({ - providedIn: 'root', - }) -], GestureController); -export { GestureController }; diff --git a/packages/angular/build/es2015/standalone/src/providers/ionic-angular.js b/packages/angular/build/es2015/standalone/src/providers/ionic-angular.js deleted file mode 100644 index 002b6085dd3..00000000000 --- a/packages/angular/build/es2015/standalone/src/providers/ionic-angular.js +++ /dev/null @@ -1,37 +0,0 @@ -import { DOCUMENT } from '@angular/common'; -import { APP_INITIALIZER, makeEnvironmentProviders } from '@angular/core'; -import { AngularDelegate, ConfigToken, provideComponentInputBinding } from '@ionic/angular/common'; -import { initialize } from '@ionic/core/components'; -import { ModalController } from './modal-controller'; -import { PopoverController } from './popover-controller'; -export const provideIonicAngular = (config = {}) => { - return makeEnvironmentProviders([ - { - provide: ConfigToken, - useValue: config, - }, - { - provide: APP_INITIALIZER, - useFactory: initializeIonicAngular, - multi: true, - deps: [ConfigToken, DOCUMENT], - }, - provideComponentInputBinding(), - AngularDelegate, - ModalController, - PopoverController, - ]); -}; -const initializeIonicAngular = (config, doc) => { - return () => { - /** - * By default Ionic Framework hides elements that - * are not hydrated, but in the CE build there is no - * hydration. - * TODO FW-2797: Remove when all integrations have been - * migrated to CE build. - */ - doc.documentElement.classList.add('ion-ce'); - initialize(config); - }; -}; diff --git a/packages/angular/build/es2015/standalone/src/providers/loading-controller.js b/packages/angular/build/es2015/standalone/src/providers/loading-controller.js deleted file mode 100644 index 3caed2088f6..00000000000 --- a/packages/angular/build/es2015/standalone/src/providers/loading-controller.js +++ /dev/null @@ -1,17 +0,0 @@ -import { __decorate } from "tslib"; -import { Injectable } from '@angular/core'; -import { OverlayBaseController } from '@ionic/angular/common'; -import { loadingController } from '@ionic/core/components'; -import { defineCustomElement } from '@ionic/core/components/ion-loading.js'; -let LoadingController = class LoadingController extends OverlayBaseController { - constructor() { - super(loadingController); - defineCustomElement(); - } -}; -LoadingController = __decorate([ - Injectable({ - providedIn: 'root', - }) -], LoadingController); -export { LoadingController }; diff --git a/packages/angular/build/es2015/standalone/src/providers/menu-controller.js b/packages/angular/build/es2015/standalone/src/providers/menu-controller.js deleted file mode 100644 index 5865b4b7b0a..00000000000 --- a/packages/angular/build/es2015/standalone/src/providers/menu-controller.js +++ /dev/null @@ -1,15 +0,0 @@ -import { __decorate } from "tslib"; -import { Injectable } from '@angular/core'; -import { MenuController as MenuControllerBase } from '@ionic/angular/common'; -import { menuController } from '@ionic/core/components'; -let MenuController = class MenuController extends MenuControllerBase { - constructor() { - super(menuController); - } -}; -MenuController = __decorate([ - Injectable({ - providedIn: 'root', - }) -], MenuController); -export { MenuController }; diff --git a/packages/angular/build/es2015/standalone/src/providers/modal-controller.js b/packages/angular/build/es2015/standalone/src/providers/modal-controller.js deleted file mode 100644 index 11842feb50d..00000000000 --- a/packages/angular/build/es2015/standalone/src/providers/modal-controller.js +++ /dev/null @@ -1,22 +0,0 @@ -import { __decorate, __rest } from "tslib"; -import { Injector, Injectable, EnvironmentInjector, inject } from '@angular/core'; -import { AngularDelegate, OverlayBaseController } from '@ionic/angular/common'; -import { modalController } from '@ionic/core/components'; -import { defineCustomElement } from '@ionic/core/components/ion-modal.js'; -let ModalController = class ModalController extends OverlayBaseController { - constructor() { - super(modalController); - this.angularDelegate = inject(AngularDelegate); - this.injector = inject(Injector); - this.environmentInjector = inject(EnvironmentInjector); - defineCustomElement(); - } - create(opts) { - const { injector: customInjector } = opts, restOpts = __rest(opts, ["injector"]); - return super.create(Object.assign(Object.assign({}, restOpts), { delegate: this.angularDelegate.create(this.environmentInjector, this.injector, 'modal', customInjector) })); - } -}; -ModalController = __decorate([ - Injectable() -], ModalController); -export { ModalController }; diff --git a/packages/angular/build/es2015/standalone/src/providers/popover-controller.js b/packages/angular/build/es2015/standalone/src/providers/popover-controller.js deleted file mode 100644 index 05af778c792..00000000000 --- a/packages/angular/build/es2015/standalone/src/providers/popover-controller.js +++ /dev/null @@ -1,18 +0,0 @@ -import { __rest } from "tslib"; -import { Injector, inject, EnvironmentInjector } from '@angular/core'; -import { AngularDelegate, OverlayBaseController } from '@ionic/angular/common'; -import { popoverController } from '@ionic/core/components'; -import { defineCustomElement } from '@ionic/core/components/ion-popover.js'; -export class PopoverController extends OverlayBaseController { - constructor() { - super(popoverController); - this.angularDelegate = inject(AngularDelegate); - this.injector = inject(Injector); - this.environmentInjector = inject(EnvironmentInjector); - defineCustomElement(); - } - create(opts) { - const { injector: customInjector } = opts, restOpts = __rest(opts, ["injector"]); - return super.create(Object.assign(Object.assign({}, restOpts), { delegate: this.angularDelegate.create(this.environmentInjector, this.injector, 'popover', customInjector) })); - } -} diff --git a/packages/angular/build/es2015/standalone/src/providers/toast-controller.js b/packages/angular/build/es2015/standalone/src/providers/toast-controller.js deleted file mode 100644 index cee49b63403..00000000000 --- a/packages/angular/build/es2015/standalone/src/providers/toast-controller.js +++ /dev/null @@ -1,17 +0,0 @@ -import { __decorate } from "tslib"; -import { Injectable } from '@angular/core'; -import { OverlayBaseController } from '@ionic/angular/common'; -import { toastController } from '@ionic/core/components'; -import { defineCustomElement } from '@ionic/core/components/ion-toast.js'; -let ToastController = class ToastController extends OverlayBaseController { - constructor() { - super(toastController); - defineCustomElement(); - } -}; -ToastController = __decorate([ - Injectable({ - providedIn: 'root', - }) -], ToastController); -export { ToastController }; From ed4b8c3df403b8a6cdf2a7754f8687a3a51e2948 Mon Sep 17 00:00:00 2001 From: Maria Hutt Date: Fri, 17 Jul 2026 14:54:16 -0700 Subject: [PATCH 4/6] docs(angular): replace with todo --- packages/angular/lazy/src/index.ts | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/packages/angular/lazy/src/index.ts b/packages/angular/lazy/src/index.ts index 0b7475f58ef..ffa3409fdf2 100644 --- a/packages/angular/lazy/src/index.ts +++ b/packages/angular/lazy/src/index.ts @@ -45,9 +45,7 @@ export { ToastController } from './providers/toast-controller'; /* * PACKAGE MODULE - * `IonicModule` is deprecated and will be removed in a future major version. - * Use `provideIonicAngular()` from `@ionic/angular` instead. The deprecation is - * declared on the class itself, so consumers importing it here see the notice. + * TODO(FW-7617): Remove the `IonicModule` export once the deprecated module is removed. */ export { IonicModule } from './ionic-module'; From c4d9d74a943926238bdf0b86b391d87746d45d40 Mon Sep 17 00:00:00 2001 From: Maria Hutt Date: Fri, 17 Jul 2026 14:55:32 -0700 Subject: [PATCH 5/6] docs(angular): update caution Co-authored-by: Brandy Smith --- docs/angular/testing.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/angular/testing.md b/docs/angular/testing.md index be1819ffc94..b73f391e3cf 100644 --- a/docs/angular/testing.md +++ b/docs/angular/testing.md @@ -83,7 +83,7 @@ If you need to add E2E tests that are only run on a specific version of the JS F Tests for lazy loaded Ionic UI components should only be added under the `/lazy` route. This ensures the `IonicModule` is added. > [!CAUTION] -> The lazy loaded build and its `IonicModule` are deprecated and will be removed in a future major version. New components should be tested as standalone components (see below). These lazy tests remain to verify that the deprecated build keeps working while it is still supported. +> The lazy loaded build, including `IonicModule`, is deprecated and will be removed in a future major version. New components should be tested as standalone components (see below). These lazy tests remain to verify that the deprecated build keeps working while it is still supported. ### Testing Standalone Ionic Components From 254ca2f45d5f31bbf905d8e68ca0974e1e456f47 Mon Sep 17 00:00:00 2001 From: Maria Hutt Date: Fri, 17 Jul 2026 14:55:57 -0700 Subject: [PATCH 6/6] docs(angular): update caution again Co-authored-by: Brandy Smith --- packages/angular/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/angular/README.md b/packages/angular/README.md index 1d23db92827..e38d99b3f81 100644 --- a/packages/angular/README.md +++ b/packages/angular/README.md @@ -114,4 +114,4 @@ This is where the lazy loaded component implementations live. Ionic developers can access this by importing from `@ionic/angular/lazy`. > [!CAUTION] -> The lazy loaded build and its `IonicModule` are deprecated and will be removed in a future major version. New code should use the standalone components and `provideIonicAngular()` imported from `@ionic/angular`. +> The lazy loaded build, including `IonicModule`, is deprecated and will be removed in a future major version. New code should use the standalone components and `provideIonicAngular()` imported from `@ionic/angular`.