voyager-ionic-core 8.8.17 → 9.0.3

package/dist/types/index.d.ts

@@ -14,5 +14,5 @@ export { IonicConfig, getMode, setupConfig } from './utils/config';
 export { openURL } from './utils/theme';
 export { LIFECYCLE_WILL_ENTER, LIFECYCLE_DID_ENTER, LIFECYCLE_WILL_LEAVE, LIFECYCLE_DID_LEAVE, LIFECYCLE_WILL_UNLOAD, } from './components/nav/constants';
 export { menuController } from './utils/menu-controller';
-export { alertController, actionSheetController, modalController, loadingController, pickerController, popoverController, toastController, } from './utils/overlays';
+export { alertController, actionSheetController, modalController, loadingController, popoverController, toastController, } from './utils/overlays';
 export { IonicSlides } from './components/slides/IonicSlides';

package/dist/types/interface.d.ts

@@ -19,7 +19,6 @@ export { LoadingOptions } from './components/loading/loading-interface';
 export { MenuCustomEvent, MenuI, MenuControllerI } from './components/menu/menu-interface';
 export { ModalOptions, ModalCustomEvent, ModalDragEventDetail } from './components/modal/modal-interface';
 export { NavDirection, NavCustomEvent } from './components/nav/nav-interface';
-export { PickerOptions, PickerColumnOption } from './components/picker-legacy/picker-interface';
 export { PopoverOptions } from './components/popover/popover-interface';
 export { RadioGroupCustomEvent } from './components/radio-group/radio-group-interface';
 export { RangeCustomEvent, PinFormatter } from './components/range/range-interface';

package/dist/types/stencil-public-runtime.d.ts

@@ -1008,6 +1008,7 @@ export declare namespace JSXBase {
         onClose?: (event: Event) => void;
         open?: boolean;
         returnValue?: string;
+        closedby?: 'any' | 'closerequest' | 'none';
     }
     interface EmbedHTMLAttributes<T> extends HTMLAttributes<T> {
         height?: number | string;
@@ -1045,6 +1046,8 @@ export declare namespace JSXBase {
         allowtransparency?: string | boolean;
         frameBorder?: number | string;
         frameborder?: number | string;
+        fetchPriority?: 'high' | 'low' | 'auto';
+        fetchpriority?: 'high' | 'low' | 'auto';
         importance?: 'low' | 'auto' | 'high';
         height?: number | string;
         loading?: 'lazy' | 'auto' | 'eager';
@@ -1067,6 +1070,8 @@ export declare namespace JSXBase {
         crossOrigin?: string;
         crossorigin?: string;
         decoding?: 'async' | 'auto' | 'sync';
+        fetchPriority?: 'high' | 'low' | 'auto';
+        fetchpriority?: 'high' | 'low' | 'auto';
         importance?: 'low' | 'auto' | 'high';
         height?: number | string;
         loading?: 'lazy' | 'auto' | 'eager';
@@ -1166,6 +1171,8 @@ export declare namespace JSXBase {
     }
     interface LinkHTMLAttributes<T> extends HTMLAttributes<T> {
         as?: string;
+        fetchPriority?: 'high' | 'low' | 'auto';
+        fetchpriority?: 'high' | 'low' | 'auto';
         href?: string;
         hrefLang?: string;
         hreflang?: string;
@@ -1289,6 +1296,8 @@ export declare namespace JSXBase {
         crossOrigin?: string;
         crossorigin?: string;
         defer?: boolean;
+        fetchPriority?: 'high' | 'low' | 'auto';
+        fetchpriority?: 'high' | 'low' | 'auto';
         importance?: 'low' | 'auto' | 'high';
         integrity?: string;
         nonce?: string;
@@ -1404,7 +1413,10 @@ export declare namespace JSXBase {
         tabIndex?: number;
         tabindex?: number | string;
         title?: string;
+        translate?: 'yes' | 'no' | (string & {});
         popover?: string | null;
+        focusgroup?: string;
+        focusgroupstart?: boolean;
         inputMode?: string;
         inputmode?: string;
         enterKeyHint?: string;

package/dist/types/utils/config.d.ts

@@ -117,10 +117,6 @@ export interface IonicConfig {
      * Provides a custom enter animation for all `ion-toast`, overriding the default "animation".
      */
     toastEnter?: AnimationBuilder;
-    /**
-     * Provides a custom enter animation for all `ion-picker-legacy`, overriding the default "animation".
-     */
-    pickerEnter?: AnimationBuilder;
     /**
      * Provides a custom leave animation for all `ion-action-sheet`, overriding the default "animation".
      */
@@ -145,10 +141,6 @@ export interface IonicConfig {
      * Provides a custom leave animation for all `ion-toast`, overriding the default "animation".
      */
     toastLeave?: AnimationBuilder;
-    /**
-     * Provides a custom leave animation for all `ion-picker-legacy`, overriding the default "animation".
-     */
-    pickerLeave?: AnimationBuilder;
     /**
      * If `true`, Ionic will enable a basic DOM sanitizer on component properties that accept custom HTML.
      */
@@ -186,6 +178,7 @@ export interface IonicConfig {
      * - `'OFF'`: No errors or warnings are logged.
      * - `'ERROR'`: Logs only errors.
      * - `'WARN'`: Logs errors and warnings.
+     * - `'DEBUG'`: Logs errors, warnings, and Ionic's internal diagnostics.
      */
     logLevel?: LogLevel;
     keyboardHeight?: number;

package/dist/types/utils/content/index.d.ts

@@ -21,6 +21,18 @@ export declare const findIonContent: (el: Element) => HTMLElement | null;
  * Queries the closest element matching the selector for IonContent.
  */
 export declare const findClosestIonContent: (el: Element) => HTMLElement | null;
+/**
+ * Queries the custom scroll host an `ion-refresher` scrolls with in the given
+ * `ion-content`. A refresher only pairs with the first host.
+ */
+export declare const findRefresherScrollHost: (ionContent: Element) => HTMLElement | null;
+/**
+ * Queries the `ion-refresher` that scrolls with the given content element,
+ * which may be an `ion-content` or a custom scroll host. A refresher is a
+ * `slot="fixed"` child of `ion-content`, so it is a sibling of a scroll host
+ * rather than a descendant of it.
+ */
+export declare const findRefresherInContent: (contentEl: Element) => HTMLIonRefresherElement | null;
 /**
  * Scrolls to the top of the element. If an `ion-content` is found, it will scroll
  * using the public API `scrollToTop` with a duration.

package/dist/types/utils/forms/index.d.ts

@@ -1,4 +1,5 @@
 export * from './notch-controller';
+export * from './start-container-controller';
 export * from './compare-with-utils';
 export * from './item-multiple-inputs';
 export * from './validity';

package/dist/types/utils/forms/start-container-controller.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Applied to the host while the label is being repositioned. The
+ * component stylesheets style this class, so it must stay in sync with
+ * the `skip-label-transition` selector in those files. Renaming it here
+ * requires renaming it there too.
+ */
+export declare const SKIP_LABEL_TRANSITION_CLASS = "skip-label-transition";
+/**
+ * Set on the host as an inline style. The component stylesheets declare
+ * this property and read it with `var()`, so it must stay in sync with
+ * the `--internal-start-container-adjustment` references in those files.
+ * Renaming it here requires renaming it there too.
+ */
+export declare const START_CONTAINER_ADJUSTMENT_VAR = "--internal-start-container-adjustment";
+/**
+ * A utility to measure and update the start container width adjustment
+ * for form components (input, textarea, select) with `fill="outline"`.
+ * This adjustment compensates for the start container width when
+ * positioning floating/stacked labels within the outline border.
+ *
+ * Measurement is deferred with raf() to avoid forcing layout during
+ * component updates, and a ResizeObserver watches for dynamic width
+ * changes (e.g., when web fonts load or async content changes).
+ *
+ * @internal
+ * @param el - The host element (ion-input, ion-textarea, or ion-select).
+ * @param getStartContainer - A callback that returns the start container element.
+ * @param shouldApplyAdjustment - A callback that determines whether the adjustment should be applied.
+ */
+export declare const createStartContainerController: (el: HTMLElement, getStartContainer: () => HTMLElement | undefined, shouldApplyAdjustment: () => boolean) => StartContainerController;
+export type StartContainerController = {
+    calculateStartContainerWidth: () => void;
+    destroy: () => void;
+};

package/dist/types/utils/helpers.d.ts

@@ -83,12 +83,15 @@ export declare const pointerCoord: (ev: any) => {
 };
 /**
  * @hidden
- * Given a side, return if it should be on the end
- * based on the value of dir
- * @param side the side
- * @param isRTL whether the application dir is rtl
+ * Given a side, returns whether it resolves to the end side for the current
+ * direction. In RTL `start` is the end side, and in LTR `end` is.
+ *
+ * @param side The current side before being redefined based on the direction.
+ * @param hostEl The component's host element. The direction is resolved from
+ * it or its nearest ancestor that declares one. When omitted, the direction
+ * is resolved from the document.
  */
-export declare const isEndSide: (side: Side) => boolean;
+export declare const isEndSide: (side: Side, hostEl?: HTMLElement) => boolean;
 export declare const deferEvent: (event: EventEmitter) => EventEmitter;
 export declare const debounceEvent: (event: EventEmitter, wait: number) => EventEmitter;
 export declare const debounce: (func: (...args: any[]) => void, wait?: number) => (...args: any[]) => any;

package/dist/types/utils/logging/index.d.ts

@@ -1,7 +1,8 @@
 export declare enum LogLevel {
     OFF = "OFF",
     ERROR = "ERROR",
-    WARN = "WARN"
+    WARN = "WARN",
+    DEBUG = "DEBUG"
 }
 /**
  * Logs a warning to the console with an Ionic prefix

package/dist/types/utils/overlay-control-label.d.ts

@@ -0,0 +1,32 @@
+import type { Mode } from '../interface';
+/**
+ * Returns the default `labelPlacement` for a radio or checkbox option
+ * rendered inside an overlay. Defaults follow each mode's established
+ * option-row layout:
+ * - `ios`: `"start"` for radio in `alert` and `popover`. The `modal`
+ *   interface flips iOS radio back to `"end"`. Checkbox is always
+ *   `"end"` on iOS.
+ * - everything else (e.g. `md`): `"end"`.
+ *
+ * `interfaceType` is optional; only `"modal"` changes the result, so
+ * callers that aren't a modal can omit it.
+ *
+ * Used by `select-popover` and `select-modal` as the fallback when an
+ * option doesn't explicitly set `labelPlacement`.
+ */
+export declare const getOverlayLabelPlacement: (mode: Mode, control: "radio" | "checkbox", interfaceType?: "alert" | "popover" | "modal") => "start" | "end";
+/**
+ * Returns the default `justify` for a radio or checkbox option rendered
+ * inside an overlay. Defaults follow each mode's option-row layout:
+ * - `ios`: `"space-between"` for radio in `alert` and `popover`. The
+ *   `modal` interface falls back to `"start"`. Checkbox is always `"start"`
+ *   on iOS.
+ * - everything else (e.g. `md`): `"start"`.
+ *
+ * `interfaceType` is optional; only `"modal"` changes the result, so
+ * callers that aren't a modal can omit it.
+ *
+ * Used by `select-popover` and `select-modal` as the fallback when an
+ * option doesn't explicitly set `justify`.
+ */
+export declare const getOverlayLabelJustify: (mode: Mode, control: "radio" | "checkbox", interfaceType?: "alert" | "popover" | "modal") => "start" | "end" | "space-between";

package/dist/types/utils/overlays.d.ts

@@ -1,4 +1,4 @@
-import type { ActionSheetOptions, AlertOptions, Animation, AnimationBuilder, FrameworkDelegate, HTMLIonOverlayElement, IonicConfig, LoadingOptions, ModalOptions, OverlayInterface, PickerOptions, PopoverOptions, ToastOptions } from '../interface';
+import type { ActionSheetOptions, AlertOptions, Animation, AnimationBuilder, FrameworkDelegate, HTMLIonOverlayElement, IonicConfig, LoadingOptions, ModalOptions, OverlayInterface, PopoverOptions, ToastOptions } from '../interface';
 export declare const activeAnimations: WeakMap<OverlayInterface, Animation[]>;
 export declare const alertController: {
     create(options: AlertOptions): Promise<HTMLIonAlertElement>;
@@ -20,14 +20,6 @@ export declare const modalController: {
     dismiss(data?: any, role?: string, id?: string): Promise<boolean>;
     getTop(): Promise<HTMLIonModalElement | undefined>;
 };
-/**
- * @deprecated Use the inline ion-picker component instead.
- */
-export declare const pickerController: {
-    create(options: PickerOptions): Promise<HTMLIonPickerLegacyElement>;
-    dismiss(data?: any, role?: string, id?: string): Promise<boolean>;
-    getTop(): Promise<HTMLIonPickerLegacyElement | undefined>;
-};
 export declare const popoverController: {
     create(options: PopoverOptions<import("../interface").ComponentRef>): Promise<HTMLIonPopoverElement>;
     dismiss(data?: any, role?: string, id?: string): Promise<boolean>;
@@ -86,6 +78,25 @@ export declare const getPresentedOverlay: (doc: Document, overlayTag?: string, i
  * for main content.
  */
 export declare const setRootAriaHidden: (hidden?: boolean) => void;
+/**
+ * Cleans up root `aria-hidden` and `backdrop-no-scroll` when
+ * an overlay is removed from the DOM without going through
+ * the `dismiss()` flow (e.g., when a framework unmounts the
+ * overlay during a route change).
+ *
+ * Should be called from an overlay's `disconnectedCallback`
+ * when the overlay was still presented at the time of removal.
+ */
+export declare const cleanupRootFocusTrapAccessibility: () => void;
+/**
+ * Re-applies the root lock that `cleanupRootFocusTrapAccessibility()` released.
+ * Call from `connectedCallback` when the overlay is still presented.
+ *
+ * A synchronous move keeps the overlay connected, so the lock survives. A
+ * detach with a re-insert in a later task releases it, which is the shape a
+ * framework produces when it takes a subtree out and puts it back.
+ */
+export declare const restoreRootFocusTrapAccessibility: (overlayEl: HTMLIonOverlayElement) => void;
 export declare const present: <OverlayPresentOptions>(overlay: OverlayInterface, name: keyof IonicConfig, iosEnterAnimation: AnimationBuilder, mdEnterAnimation: AnimationBuilder, opts?: OverlayPresentOptions) => Promise<void>;
 export declare const dismiss: <OverlayDismissOptions>(overlay: OverlayInterface, data: any | undefined, role: string | undefined, name: keyof IonicConfig, iosLeaveAnimation: AnimationBuilder, mdLeaveAnimation: AnimationBuilder, opts?: OverlayDismissOptions) => Promise<boolean>;
 export declare const eventMethod: <T>(element: HTMLElement, eventName: string) => Promise<T>;

package/dist/types/utils/rtl/dir.d.ts

@@ -1,6 +1,12 @@
 /**
- * Returns `true` if the document or host element
- * has a `dir` set to `rtl`. The host value will always
- * take priority over the root document value.
+ * Returns `true` if the direction resolves to `rtl` for the given element.
+ *
+ * The direction comes from the nearest ancestor that declares one, starting
+ * with `hostEl` itself, and falls back to the root document value. Setting
+ * `dir="auto"` or setting `dir` to an empty string are skipped rather than
+ * treated as `ltr`. When nothing declares a direction, including the document,
+ * the direction is `ltr`.
+ *
+ * @param hostEl the element to resolve the direction for.
  */
-export declare const isRTL: (hostEl?: Pick<HTMLElement, "dir">) => boolean;
+export declare const isRTL: (hostEl?: Element | null) => boolean;

package/dist/types/utils/sanitization/index.d.ts

@@ -1,8 +1,64 @@
 /**
- * Does a simple sanitization of all elements
- * in an untrusted string
+ * Sanitize an untrusted HTML string.
+ *
+ * Parses the string into a detached DOM, removes blocked tags, strips
+ * attributes outside the narrow `domStringAllowedAttributes` list (refer
+ * `sanitizeElement`), and scrubs script-scheme URLs. Returns the sanitized
+ * HTML string.
+ *
+ * Use this when you have an HTML string from an unknown source and need to
+ * render it via `innerHTML`. Use `sanitizeDOMTree` instead when you already
+ * have a DOM tree and want to sanitize it in place without a string round
+ * trip. The two apply the same dangerous-vector scrubbing but different
+ * attribute allowlists: this path stays narrow so existing consumers
+ * (toast, loading, alert message, etc.) are unaffected, while
+ * `sanitizeDOMTree` uses the wider rich-content allowlist.
+ *
+ * @param untrustedString - The HTML string to sanitize. Pass an
+ * `IonicSafeString` to bypass sanitization, or `undefined` to short-circuit.
+ * @returns The sanitized HTML string, or `undefined` if the input was
+ * `undefined`. Returns `''` if sanitization fails or the input appears to
+ * carry an inline `onload` handler.
  */
 export declare const sanitizeDOMString: (untrustedString: IonicSafeString | string | undefined) => string | undefined;
+/**
+ * Sanitize an entire trusted DOM tree in place.
+ *
+ * Removes blocked tags (`script`, `iframe`, etc.) from the subtree and
+ * then sanitizes attributes on every remaining element using the wider
+ * `richContentAllowedAttributes` allowlist (refer `sanitizeElement`).
+ * Component presentational attributes (`size`, `color`, `shape`, inline
+ * SVG, `aria-*`, `data-*`) are preserved; `style`, event handlers (`on*`),
+ * form/navigation-hijack attributes, script-scheme URLs, and non-image
+ * `data:` URLs are stripped.
+ *
+ * Use this when you have a DOM tree the developer controls (e.g.
+ * cloned slot content from a component) and you need to render it
+ * elsewhere safely.
+ *
+ * @param root - The root element whose subtree will be sanitized in
+ * place. No-op when the sanitizer is disabled via `Ionic.config`.
+ */
+export declare const sanitizeDOMTree: (root: HTMLElement) => void;
+/**
+ * Mirror known custom-element DOM properties onto attributes so they
+ * survive `cloneNode`. Call this on a DOM subtree before cloning it for
+ * rendering elsewhere (e.g. cloning slotted option content into an
+ * overlay).
+ *
+ * Only sets the attribute when the property holds a non-empty string
+ * and the attribute isn't already present, so existing attributes
+ * take precedence.
+ *
+ * @param root - The root element whose subtree (and itself) will be
+ * inspected.
+ */
+export declare const reflectPropertiesToAttributes: (root: Element) => void;
+/**
+ * Tags removed entirely (with their subtree) before attribute sanitization.
+ * Exported so tests can assert the set without hardcoding it.
+ */
+export declare const blockedTags: string[];
 export declare class IonicSafeString {
     value: string;
     constructor(value: string);

package/dist/types/utils/select-option-render.d.ts

@@ -0,0 +1,53 @@
+import type { VNode } from '../stencil-public-runtime';
+import type { RichContentOption as RichContentOpt } from '../components/select/select-interface';
+interface RichContentOption extends RichContentOpt {
+    /** Unique identifier for stable virtual DOM keys across re-renders. */
+    id: string;
+    /** The main label for the option as a string or an HTMLElement. */
+    label?: string | HTMLElement;
+}
+/**
+ * Converts a DOM node into a Stencil VNode (or text string) so the
+ * resulting tree is rendered through the component's normal render
+ * path. Rendering through Stencil ensures that scoped CSS classes
+ * (e.g. `sc-ion-action-sheet-ionic`) are applied to every element.
+ *
+ * Highly recommended to pre-sanitize the source DOM (see
+ * `getOptionContent` in select.tsx). This function performs pure
+ * structural conversion — no security filtering.
+ *
+ * Preserves attributes only — properties set imperatively on the source
+ * element (e.g. `input.value` after a user types) won't carry through.
+ * In practice this isn't a concern: interactive controls shouldn't
+ * appear in select-option rich content since they'd nest inside the
+ * overlay's button/radio/checkbox wrapper, which is invalid HTML and
+ * an accessibility issue.
+ *
+ * @param node - The DOM node to convert. Text nodes become strings,
+ * element nodes become VNodes, and any other node types are skipped.
+ * @param keyPrefix - String prefix used to build a stable VNode key,
+ * so Stencil's diff can preserve elements across re-renders.
+ * @param index - Position of this node among its siblings. Combined
+ * with `keyPrefix` to form the final unique key.
+ * @returns The converted VNode, a text string, or `null` if the node
+ * type isn't supported.
+ *
+ * @internal Exported only so it can be unit tested; not part of the
+ * public API.
+ */
+export declare const cloneToVNode: (node: Node, keyPrefix: string, index: number) => VNode | string | null;
+/**
+ * Renders the label content for a select option within an overlay
+ * interface based on the presence of rich content.
+ *
+ * Span elements should be used when this content renders within buttons,
+ * depending on the select interface. Buttons can only have phrasing
+ * content to prevent accessibility issues.
+ *
+ * @param option - The content option data containing label, slots,
+ * and description.
+ * @param className - The base CSS class for the label element.
+ * @param useSpan - Whether to use a span element instead of a div for the label.
+ */
+export declare const renderOptionLabel: (option: RichContentOption, className: string, useSpan?: boolean) => HTMLElement | string | undefined;
+export {};

package/dist/types/utils/test/playwright/detach-reattach.d.ts

@@ -0,0 +1,13 @@
+import type { Locator } from '@playwright/test';
+/**
+ * Detaches an element and puts it back in a later task, the way a framework
+ * binding relocates a subtree it owns.
+ *
+ * A single `appendChild` won't do it. Custom element reactions run at the end
+ * of the same task, so `disconnectedCallback` fires with the element already
+ * back and nothing tears down. The detach has to survive a task before the
+ * disconnect is observable.
+ *
+ * Pass `containerSelector` to hold the element somewhere other than the body.
+ */
+export declare const detachAndReattach: (locator: Locator, containerSelector?: string) => Promise<void>;

package/dist/types/utils/test/playwright/index.d.ts

@@ -7,3 +7,4 @@ export * from './apply-keyboard-focus';
 export * from './matchers';
 export * from './viewports';
 export * from './generator';
+export * from './detach-reattach';

package/dist/types/utils/test/playwright/playwright-page.d.ts

@@ -13,5 +13,5 @@ type CustomFixtures = {
  * @returns The modified playwright page with extended functionality.
  */
 export declare function extendPageFixture(page: E2EPage, testInfo: TestInfo): Promise<E2EPage>;
-export declare const test: import("@playwright/test").TestType<PlaywrightTestArgs & PlaywrightTestOptions & CustomFixtures, PlaywrightWorkerArgs & PlaywrightWorkerOptions>;
+export declare const test: import("playwright/test").TestType<PlaywrightTestArgs & PlaywrightTestOptions & CustomFixtures, PlaywrightWorkerArgs & PlaywrightWorkerOptions>;
 export {};

package/dist/types/utils/test/playwright/testExpect.d.ts

@@ -16,6 +16,6 @@ interface CustomMatchers<R = unknown> {
 }
 
 declare namespace PlaywrightTest {
-  // eslint-disable-next-line @typescript-eslint/no-empty-interface
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
   interface Matchers<R> extends CustomMatchers<R> {}
 }