voyager-ionic-core 7.7.3 → 8.0.0-beta.2

package/dist/types/components/item/item.d.ts

@@ -1,17 +1,13 @@
 import type { ComponentInterface } from '../../stencil-public-runtime';
 import type { AnchorInterface, ButtonInterface } from "../../utils/element-interface";
 import type { AnimationBuilder, Color, StyleEventDetail } from '../../interface';
-import type { InputInputEventDetail } from '../input/input-interface';
 import type { RouterDirection } from '../router/utils/interface';
-import type { CounterFormatter } from './item-interface';
 /**
  * @virtualProp {"ios" | "md"} mode - The mode determines which platform styles to use.
  *
  * @slot - Content is placed between the named slots if provided without a slot.
  * @slot start - Content is placed to the left of the item text in LTR, and to the right in RTL.
  * @slot end - Content is placed to the right of the item text in LTR, and to the left in RTL.
- * @slot helper - Content is placed under the item and displayed when no error is detected. **DEPRECATED** Use the "helperText" property on ion-input or ion-textarea instead.
- * @slot error - Content is placed under the item and displayed when an error is detected. **DEPRECATED** Use the "errorText" property on ion-input or ion-textarea instead.
  *
  * @part native - The native HTML button, anchor or div element that wraps all child elements.
  * @part detail-icon - The chevron icon for the item. Only applies when `detail="true"`.
@@ -53,17 +49,6 @@ export declare class Item implements ComponentInterface, AnchorInterface, Button
      * (the user can still change the file name if they want).
      */
     download: string | undefined;
-    /**
-     * The fill for the item. If `"solid"` the item will have a background. If
-     * `"outline"` the item will be transparent with a border. Only available in `md` mode.
-     * @deprecated Use the `fill` property on `ion-input` or `ion-textarea` instead.
-     */
-    fill?: 'outline' | 'solid';
-    /**
-     * The shape of the item. If "round" it will have increased
-     * border radius.
-     */
-    shape?: 'round';
     /**
      * Contains a URL or a URL fragment that the hyperlink points to.
      * If this property is set, an anchor tag will be rendered.
@@ -78,11 +63,6 @@ export declare class Item implements ComponentInterface, AnchorInterface, Button
      * How the bottom border should be displayed on the item.
      */
     lines?: 'full' | 'inset' | 'none';
-    /**
-     * If `true`, a character counter will display the ratio of characters used and the total character limit. Only applies when the `maxlength` property is set on the inner `ion-input` or `ion-textarea`.
-     * @deprecated Use the `counter` property on `ion-input` or `ion-textarea` instead.
-     */
-    counter: boolean;
     /**
      * When using a router, it specifies the transition animation when navigating to
      * another page using `href`.
@@ -103,16 +83,7 @@ export declare class Item implements ComponentInterface, AnchorInterface, Button
      * The type of the button. Only used when an `onclick` or `button` property is present.
      */
     type: 'submit' | 'reset' | 'button';
-    /**
-     * A callback used to format the counter text.
-     * By default the counter text is set to "itemLength / maxLength".
-     * @deprecated Use the `counterFormatter` property on `ion-input` or `ion-textarea` instead.
-     */
-    counterFormatter?: CounterFormatter;
-    counterString: string | null | undefined;
     buttonChanged(): void;
-    counterFormatterChanged(): void;
-    handleIonInput(ev: CustomEvent<InputInputEventDetail>): void;
     labelColorChanged(ev: CustomEvent<string>): void;
     itemStyle(ev: CustomEvent<StyleEventDetail>): void;
     connectedCallback(): void;
@@ -123,9 +94,6 @@ export declare class Item implements ComponentInterface, AnchorInterface, Button
     private isClickable;
     private canActivate;
     private isFocusable;
-    private getFirstInput;
-    private updateCounterOutput;
-    private defaultCounterFormatter;
     private hasStartEl;
     private getFirstInteractive;
     render(): any;

package/dist/types/components/menu/menu-interface.d.ts

@@ -47,3 +47,4 @@ export interface MenuCustomEvent<T = any> extends CustomEvent {
     detail: T;
     target: HTMLIonMenuElement;
 }
+export type MenuType = 'overlay' | 'reveal' | 'push';

package/dist/types/components/menu/menu.d.ts

@@ -1,5 +1,5 @@
 import type { ComponentInterface, EventEmitter } from '../../stencil-public-runtime';
-import type { MenuChangeEventDetail, MenuI, Side } from './menu-interface';
+import type { MenuChangeEventDetail, MenuI, MenuType, Side } from './menu-interface';
 /**
  * @part container - The container for the menu content.
  * @part backdrop - The backdrop that appears over the main content when the menu is open.
@@ -21,13 +21,21 @@ export declare class Menu implements ComponentInterface, MenuI {
     isAnimating: boolean;
     width: number;
     _isOpen: boolean;
-    backdropEl?: HTMLElement;
+    backdropEl?: HTMLIonBackdropElement;
     menuInnerEl?: HTMLElement;
     contentEl?: HTMLElement;
     lastFocus?: HTMLElement;
     private inheritedAttributes;
     private handleFocus;
     el: HTMLIonMenuElement;
+    /**
+     * If true, then the menu should be
+     * visible within a split pane.
+     * If false, then the menu is hidden.
+     * However, the menu-button/menu-toggle
+     * components can be used to open the
+     * menu.
+     */
     isPaneVisible: boolean;
     isEndSide: boolean;
     /**
@@ -46,7 +54,7 @@ export declare class Menu implements ComponentInterface, MenuI {
      * The display type of the menu.
      * Available options: `"overlay"`, `"reveal"`, `"push"`.
      */
-    type?: string;
+    type?: MenuType;
     typeChanged(type: string, oldType: string | undefined): void;
     /**
      * If `true`, the menu is disabled.
@@ -94,7 +102,9 @@ export declare class Menu implements ComponentInterface, MenuI {
     componentDidLoad(): Promise<void>;
     private menuChanged;
     disconnectedCallback(): Promise<void>;
-    onSplitPaneChanged(ev: CustomEvent): void;
+    onSplitPaneChanged(ev: CustomEvent<{
+        visible: boolean;
+    }>): void;
     onBackdropClick(ev: any): void;
     onKeydown(ev: KeyboardEvent): void;
     /**
@@ -128,8 +138,6 @@ export declare class Menu implements ComponentInterface, MenuI {
      * If the operation can't be completed successfully, it returns `false`.
      */
     setOpen(shouldOpen: boolean, animated?: boolean): Promise<boolean>;
-    private focusFirstDescendant;
-    private focusLastDescendant;
     private trapKeyboardFocus;
     _setOpen(shouldOpen: boolean, animated?: boolean): Promise<boolean>;
     private loadAnimation;

package/dist/types/components/modal/utils.d.ts

@@ -15,10 +15,6 @@ export declare const getBackdropValueForSheet: (x: number, backdropBreakpoint: n
  * is not transformed, so we do not need to
  * adjust the status bar color.
  *
- * Note: We check supportsDefaultStatusBarStyle so that
- * Capacitor <= 2 users do not get their status bar
- * stuck in an inconsistent state due to a lack of
- * support for Style.Default.
  */
 export declare const setCardStatusBarDark: () => void;
 export declare const setCardStatusBarDefault: (defaultStyle?: Style) => void;

package/dist/types/components/nav/nav.d.ts

@@ -181,7 +181,10 @@ export declare class Nav implements NavOutlet {
      * @param view The view to get.
      */
     getPrevious(view?: ViewController): Promise<ViewController | undefined>;
-    getLength(): number;
+    /**
+     * Returns the number of views in the stack.
+     */
+    getLength(): Promise<number>;
     private getActiveSync;
     private canGoBackSync;
     private getPreviousSync;

package/dist/types/components/picker/picker-interfaces.d.ts

@@ -0,0 +1,8 @@
+export interface PickerChangeEventDetail {
+    useInputMode: boolean;
+    inputModeColumn?: HTMLIonPickerColumnElement;
+}
+export interface PickerCustomEvent extends CustomEvent {
+    target: HTMLIonPickerElement;
+    detail: PickerChangeEventDetail;
+}

package/dist/types/components/picker/picker.d.ts

@@ -1,162 +1,104 @@
 import type { ComponentInterface, EventEmitter } from '../../stencil-public-runtime';
-import type { AnimationBuilder, OverlayInterface, FrameworkDelegate } from '../../interface';
-import type { OverlayEventDetail } from '../../utils/overlays-interface';
-import type { PickerButton, PickerColumn } from './picker-interface';
+import type { PickerChangeEventDetail } from './picker-interfaces';
 /**
  * @virtualProp {"ios" | "md"} mode - The mode determines which platform styles to use.
  */
-export declare class Picker implements ComponentInterface, OverlayInterface {
-    private readonly delegateController;
-    private readonly lockController;
-    private readonly triggerController;
-    private durationTimeout?;
-    lastFocus?: HTMLElement;
+export declare class Picker implements ComponentInterface {
+    private inputEl?;
+    private useInputMode;
+    private inputModeColumn?;
+    private highlightEl?;
+    private actionOnClick?;
+    private destroyKeypressListener?;
+    private singleColumnSearchTimeout?;
     el: HTMLIonPickerElement;
-    presented: boolean;
-    /** @internal */
-    overlayIndex: number;
-    /** @internal */
-    delegate?: FrameworkDelegate;
-    /** @internal */
-    hasController: boolean;
     /**
-     * If `true`, the keyboard will be automatically dismissed when the overlay is presented.
+     * @internal
      */
-    keyboardClose: boolean;
+    ionInputModeChange: EventEmitter<PickerChangeEventDetail>;
     /**
-     * Animation to use when the picker is presented.
+     * When the picker is interacted with
+     * we need to prevent touchstart so other
+     * gestures do not fire. For example,
+     * scrolling on the wheel picker
+     * in ion-datetime should not cause
+     * a card modal to swipe to close.
      */
-    enterAnimation?: AnimationBuilder;
-    /**
-     * Animation to use when the picker is dismissed.
-     */
-    leaveAnimation?: AnimationBuilder;
-    /**
-     * Array of buttons to be displayed at the top of the picker.
-     */
-    buttons: PickerButton[];
-    /**
-     * Array of columns to be displayed in the picker.
-     */
-    columns: PickerColumn[];
-    /**
-     * Additional classes to apply for custom CSS. If multiple classes are
-     * provided they should be separated by spaces.
-     */
-    cssClass?: string | string[];
-    /**
-     * Number of milliseconds to wait before dismissing the picker.
-     */
-    duration: number;
-    /**
-     * If `true`, a backdrop will be displayed behind the picker.
-     */
-    showBackdrop: boolean;
-    /**
-     * If `true`, the picker will be dismissed when the backdrop is clicked.
-     */
-    backdropDismiss: boolean;
-    /**
-     * If `true`, the picker will animate.
-     */
-    animated: boolean;
-    /**
-     * Additional attributes to pass to the picker.
-     */
-    htmlAttributes?: {
-        [key: string]: any;
-    };
-    /**
-     * If `true`, the picker will open. If `false`, the picker will close.
-     * Use this if you need finer grained control over presentation, otherwise
-     * just use the pickerController or the `trigger` property.
-     * Note: `isOpen` will not automatically be set back to `false` when
-     * the picker dismisses. You will need to do that in your code.
-     */
-    isOpen: boolean;
-    onIsOpenChange(newValue: boolean, oldValue: boolean): void;
-    /**
-     * An ID corresponding to the trigger element that
-     * causes the picker to open when clicked.
-     */
-    trigger: string | undefined;
-    triggerChanged(): void;
-    /**
-     * Emitted after the picker has presented.
-     */
-    didPresent: EventEmitter<void>;
-    /**
-     * Emitted before the picker has presented.
-     */
-    willPresent: EventEmitter<void>;
-    /**
-     * Emitted before the picker has dismissed.
-     */
-    willDismiss: EventEmitter<OverlayEventDetail>;
-    /**
-     * Emitted after the picker has dismissed.
-     */
-    didDismiss: EventEmitter<OverlayEventDetail>;
+    preventTouchStartPropagation(ev: TouchEvent): void;
+    componentWillLoad(): void;
+    private isInHighlightBounds;
     /**
-     * Emitted after the picker has presented.
-     * Shorthand for ionPickerWillDismiss.
+     * If we are no longer focused
+     * on a picker column, then we should
+     * exit input mode. An exception is made
+     * for the input in the picker since having
+     * that focused means we are still in input mode.
      */
-    didPresentShorthand: EventEmitter<void>;
+    private onFocusOut;
     /**
-     * Emitted before the picker has presented.
-     * Shorthand for ionPickerWillPresent.
+     * When picker columns receive focus
+     * the parent picker needs to determine
+     * whether to enter/exit input mode.
      */
-    willPresentShorthand: EventEmitter<void>;
+    private onFocusIn;
     /**
-     * Emitted before the picker has dismissed.
-     * Shorthand for ionPickerWillDismiss.
+     * On click we need to run an actionOnClick
+     * function that has been set in onPointerDown
+     * so that we enter/exit input mode correctly.
      */
-    willDismissShorthand: EventEmitter<OverlayEventDetail>;
+    private onClick;
     /**
-     * Emitted after the picker has dismissed.
-     * Shorthand for ionPickerDidDismiss.
+     * Clicking a column also focuses the column on
+     * certain browsers, so we use onPointerDown
+     * to tell the onFocusIn function that users
+     * are trying to click the column rather than
+     * focus the column using the keyboard. When the
+     * user completes the click, the onClick function
+     * runs and runs the actionOnClick callback.
      */
-    didDismissShorthand: EventEmitter<OverlayEventDetail>;
-    connectedCallback(): void;
-    disconnectedCallback(): void;
-    componentWillLoad(): void;
-    componentDidLoad(): void;
+    private onPointerDown;
     /**
-     * Present the picker overlay after it has been created.
+     * Enters input mode to allow
+     * for text entry of numeric values.
+     * If on mobile, we focus a hidden input
+     * field so that the on screen keyboard
+     * is brought up. When tabbing using a
+     * keyboard, picker columns receive an outline
+     * to indicate they are focused. As a result,
+     * we should not focus the hidden input as it
+     * would cause the outline to go away, preventing
+     * users from having any visual indication of which
+     * column is focused.
      */
-    present(): Promise<void>;
+    private enterInputMode;
     /**
-     * Dismiss the picker overlay after it has been presented.
-     *
-     * @param data Any data to emit in the dismiss events.
-     * @param role The role of the element that is dismissing the picker.
-     * This can be useful in a button handler for determining which button was
-     * clicked to dismiss the picker.
-     * Some examples include: ``"cancel"`, `"destructive"`, "selected"`, and `"backdrop"`.
-     *
-     * This is a no-op if the overlay has not been presented yet. If you want
-     * to remove an overlay from the DOM that was never presented, use the
-     * [remove](https://developer.mozilla.org/en-US/docs/Web/API/Element/remove) method.
+     * @internal
+     * Exits text entry mode for the picker
+     * This method blurs the hidden input
+     * and cause the keyboard to dismiss.
      */
-    dismiss(data?: any, role?: string): Promise<boolean>;
+    exitInputMode(): Promise<void>;
+    private onKeyPress;
+    private selectSingleColumn;
     /**
-     * Returns a promise that resolves when the picker did dismiss.
+     * Searches a list of column items for a particular
+     * value. This is currently used for numeric values.
+     * The zeroBehavior can be set to account for leading
+     * or trailing zeros when looking at the item text.
      */
-    onDidDismiss<T = any>(): Promise<OverlayEventDetail<T>>;
+    private searchColumn;
+    private selectMultiColumn;
     /**
-     * Returns a promise that resolves when the picker will dismiss.
+     * Searches the value of the active column
+     * to determine which value users are trying
+     * to select
      */
-    onWillDismiss<T = any>(): Promise<OverlayEventDetail<T>>;
+    private onInputChange;
     /**
-     * Get the column that matches the specified name.
-     *
-     * @param name The name of the column.
+     * Emit ionInputModeChange. Picker columns
+     * listen for this event to determine whether
+     * or not their column is "active" for text input.
      */
-    getColumn(name: string): Promise<PickerColumn | undefined>;
-    private buttonClick;
-    private callButtonHandler;
-    private getSelected;
-    private onBackdropTap;
-    private dispatchCancelHandler;
+    private emitInputModeChange;
     render(): any;
 }

package/dist/types/components/picker-column/picker-column-interfaces.d.ts

@@ -0,0 +1,4 @@
+export interface PickerColumnChangeEventDetail {
+    value: PickerColumnValue;
+}
+export type PickerColumnValue = string | number | undefined;

package/dist/types/components/picker-column/picker-column.d.ts

@@ -1,46 +1,106 @@
 import type { ComponentInterface, EventEmitter } from '../../stencil-public-runtime';
-import type { PickerColumn } from '../picker/picker-interface';
+import type { Color } from '../../interface';
+import type { PickerColumnChangeEventDetail, PickerColumnValue } from './picker-column-interfaces';
 /**
- * @internal
+ * @virtualProp {"ios" | "md"} mode - The mode determines which platform styles to use.
+ *
+ * @slot prefix - Content to show on the left side of the picker options.
+ * @slot suffix - Content to show on the right side of the picker options.
  */
-export declare class PickerColumnCmp implements ComponentInterface {
-    private bounceFrom;
-    private lastIndex?;
-    private minY;
-    private maxY;
-    private optHeight;
-    private rotateFactor;
-    private scaleFactor;
-    private velocity;
-    private y;
-    private optsEl?;
-    private gesture?;
-    private rafId?;
-    private tmrId?;
-    private noAnimate;
-    private colDidChange;
-    el: HTMLElement;
-    /**
-     * Emitted when the selected value has changed
+export declare class PickerColumn implements ComponentInterface {
+    private scrollEl?;
+    private destroyScrollListener?;
+    private isScrolling;
+    private scrollEndCallback?;
+    private isColumnVisible;
+    private parentEl?;
+    private canExitInputMode;
+    isActive: boolean;
+    el: HTMLIonPickerColumnElement;
+    /**
+     * If `true`, the user cannot interact with the picker.
+     */
+    disabled: boolean;
+    /**
+     * The selected option in the picker.
+     */
+    value?: string | number;
+    /**
+     * The color to use from your application's color palette.
+     * Default options are: `"primary"`, `"secondary"`, `"tertiary"`, `"success"`, `"warning"`, `"danger"`, `"light"`, `"medium"`, and `"dark"`.
+     * For more information on colors, see [theming](/docs/theming/basics).
+     */
+    color?: Color;
+    /**
+     * If `true`, tapping the picker will
+     * reveal a number input keyboard that lets
+     * the user type in values for each picker
+     * column. This is useful when working
+     * with time pickers.
+     *
+     * @internal
+     */
+    numericInput: boolean;
+    /**
+     * Emitted when the value has changed.
+     */
+    ionChange: EventEmitter<PickerColumnChangeEventDetail>;
+    valueChange(): void;
+    /**
+     * Only setup scroll listeners
+     * when the picker is visible, otherwise
+     * the container will have a scroll
+     * height of 0px.
+     */
+    componentWillLoad(): void;
+    componentDidRender(): void;
+    /** @internal  */
+    scrollActiveItemIntoView(smooth?: boolean): Promise<void>;
+    /**
+     * Sets the value prop and fires the ionChange event.
+     * This is used when we need to fire ionChange from
+     * user-generated events that cannot be caught with normal
+     * input/change event listeners.
      * @internal
      */
-    ionPickerColChange: EventEmitter<PickerColumn>;
-    /** Picker column data */
-    col: PickerColumn;
-    protected colChanged(): void;
-    connectedCallback(): Promise<void>;
-    componentDidLoad(): void;
-    componentDidUpdate(): void;
-    disconnectedCallback(): void;
-    private emitColChange;
-    private setSelected;
-    private update;
-    private decelerate;
-    private indexForY;
-    private onStart;
-    private onMove;
-    private onEnd;
-    private refresh;
-    private onDomChange;
+    setValue(value: PickerColumnValue): Promise<void>;
+    /**
+     * Sets focus on the scrollable container within the picker column.
+     * Use this method instead of the global `pickerColumn.focus()`.
+     */
+    setFocus(): Promise<void>;
+    private centerPickerItemInView;
+    private setPickerItemActiveState;
+    /**
+     * When ionInputModeChange is emitted, each column
+     * needs to check if it is the one being made available
+     * for text entry.
+     */
+    private inputModeChange;
+    /**
+     * Setting isActive will cause a re-render.
+     * As a result, we do not want to cause the
+     * re-render mid scroll as this will cause
+     * the picker column to jump back to
+     * whatever value was selected at the
+     * start of the scroll interaction.
+     */
+    private setInputModeActive;
+    /**
+     * When the column scrolls, the component
+     * needs to determine which item is centered
+     * in the view and will emit an ionChange with
+     * the item object.
+     */
+    private initializeScrollListener;
+    /**
+     * Tells the parent picker to
+     * exit text entry mode. This is only called
+     * when the selected item changes during scroll, so
+     * we know that the user likely wants to scroll
+     * instead of type.
+     */
+    private exitInputMode;
+    get activeItem(): HTMLIonPickerColumnOptionElement | undefined;
     render(): any;
 }

package/dist/types/components/picker-column-option/picker-column-option.d.ts

@@ -0,0 +1,66 @@
+import type { ComponentInterface } from '../../stencil-public-runtime';
+import type { Color } from '../../interface';
+export declare class PickerColumnOption implements ComponentInterface {
+    /**
+     * We keep track of the parent picker column
+     * so we can update the value of it when
+     * clicking an enable option.
+     */
+    private pickerColumn;
+    el: HTMLElement;
+    /**
+     * The aria-label of the option.
+     *
+     * If the value changes, then it will trigger a
+     * re-render of the picker since it's a @State variable.
+     * Otherwise, the `aria-label` attribute cannot be updated
+     * after the component is loaded.
+     */
+    ariaLabel?: string | null;
+    /**
+     * If `true`, the user cannot interact with the picker column option.
+     */
+    disabled: boolean;
+    /**
+     * The text value of the option.
+     */
+    value?: any | null;
+    /**
+     * The color to use from your application's color palette.
+     * Default options are: `"primary"`, `"secondary"`, `"tertiary"`, `"success"`, `"warning"`, `"danger"`, `"light"`, `"medium"`, and `"dark"`.
+     * For more information on colors, see [theming](/docs/theming/basics).
+     */
+    color?: Color;
+    /**
+     * The aria-label of the option has changed after the
+     * first render and needs to be updated within the component.
+     *
+     * @param ariaLbl The new aria-label value.
+     */
+    onAriaLabelChange(ariaLbl: string): void;
+    componentWillLoad(): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    /**
+     * The column options can load at any time
+     * so the options needs to tell the
+     * parent picker column when it is loaded
+     * so the picker column can ensure it is
+     * centered in the view.
+     *
+     * We intentionally run this for every
+     * option. If we only ran this from
+     * the selected option then if the newly
+     * loaded options were not selected then
+     * scrollActiveItemIntoView would not be called.
+     */
+    componentDidLoad(): void;
+    /**
+     * When an option is clicked, update the
+     * parent picker column value. This
+     * component will handle centering the option
+     * in the column view.
+     */
+    onClick(): void;
+    render(): any;
+}