voyager-ionic-core 7.2.3

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

@@ -0,0 +1,114 @@
+import type { Page, Response } from '@playwright/test';
+import type { TestConfig } from './generator';
+import type { EventSpy } from './page/event-spy';
+import type { LocatorOptions, E2ELocator } from './page/utils/locator';
+export interface E2EPageOptions extends PageOptions, TestConfig {
+}
+interface PageOptions {
+  /**
+   * Referer header value. If provided it will take preference over the referer header value set by
+   * [page.setExtraHTTPHeaders(headers)](https://playwright.dev/docs/api/class-page#page-set-extra-http-headers).
+   */
+  referer?: string;
+  /**
+   * Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be
+   * changed by using the
+   * [browserContext.setDefaultNavigationTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-navigation-timeout),
+   * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout),
+   * [page.setDefaultNavigationTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-navigation-timeout)
+   * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.
+   */
+  timeout?: number;
+  /**
+   * When to consider operation succeeded, defaults to `load`. Events can be either:
+   * - `'domcontentloaded'` - consider operation to be finished when the `DOMContentLoaded` event is fired.
+   * - `'load'` - consider operation to be finished when the `load` event is fired.
+   * - `'networkidle'` - consider operation to be finished when there are no network connections for at least `500` ms.
+   * - `'commit'` - consider operation to be finished when network response is received and the document started loading.
+   */
+  waitUntil?: 'load' | 'domcontentloaded' | 'networkidle' | 'commit';
+}
+export interface E2EPage extends Page {
+  /**
+   * Returns the main resource response. In case of multiple redirects, the navigation will resolve with the response of the
+   * last redirect.
+   *
+   * The method will throw an error if:
+   * - there's an SSL error (e.g. in case of self-signed certificates).
+   * - target URL is invalid.
+   * - the `timeout` is exceeded during navigation.
+   * - the remote server does not respond or is unreachable.
+   * - the main resource failed to load.
+   *
+   * The method will not throw an error when any valid HTTP status code is returned by the remote server, including 404 "Not
+   * Found" and 500 "Internal Server Error".  The status code for such responses can be retrieved by calling
+   * [response.status()](https://playwright.dev/docs/api/class-response#response-status).
+   *
+   * > NOTE: The method either throws an error or returns a main resource response. The only exceptions are navigation to
+   * `about:blank` or navigation to the same URL with a different hash, which would succeed and return `null`.
+   * > NOTE: Headless mode doesn't support navigation to a PDF document. See the
+   * [upstream issue](https://bugs.chromium.org/p/chromium/issues/detail?id=761295).
+   *
+   * Shortcut for main frame's [frame.goto(url[, options])](https://playwright.dev/docs/api/class-frame#frame-goto)
+   * @param url URL to navigate page to. The url should include scheme, e.g. `https://`. When a `baseURL` via the context options was provided and the passed URL is a path, it gets merged via the
+   * [`new URL()`](https://developer.mozilla.org/en-US/docs/Web/API/URL/URL) constructor.
+   */
+  goto: (url: string, options?: E2EPageOptions) => Promise<null | Response>;
+  /**
+   * Assigns HTML markup to a page.
+   * @param html - The HTML markup to assign to the page
+   * @param options - Ionic config options or Playwright options for the page
+   */
+  setContent: (html: string, options?: E2EPageOptions) => Promise<void>;
+  /**
+   * Find an element by selector.
+   * See https://playwright.dev/docs/locators for more information.
+   */
+  locator: (selector: string, options?: LocatorOptions) => E2ELocator;
+  /**
+   * Increases the size of the page viewport to match the `ion-content` contents.
+   * Use this method when taking full-screen screenshots.
+   */
+  setIonViewport: (options?: SetIonViewportOptions) => Promise<void>;
+  /**
+   * This provides metadata that can be used to create a unique screenshot URL.
+   * For example, we need to be able to differentiate between iOS in LTR mode and iOS in RTL mode.
+   */
+  getSnapshotSettings: () => string;
+  /**
+   * After changes have been made to a component, such as an update to a property or attribute,
+   * we need to wait until the changes have been applied to the DOM.
+   */
+  waitForChanges: (timeoutMs?: number) => Promise<void>;
+  /**
+   * Creates a new EventSpy and listens
+   * on the window for an event.
+   * The test will timeout if the event
+   * never fires.
+   *
+   * Usage:
+   * ```ts
+   * const ionChange = await page.spyOnEvent('ionChange');
+   * ...
+   * await ionChange.next();
+   * ```
+   */
+  spyOnEvent: (eventName: string) => Promise<EventSpy>;
+  _e2eEventsIds: number;
+  _e2eEvents: Map<number, any>;
+}
+type BrowserName = 'chromium' | 'firefox' | 'webkit';
+export type BrowserNameOrCallback = BrowserName | ((browserName: BrowserName) => boolean);
+export interface E2ESkip {
+  rtl: (reason?: string) => void;
+  browser: (browserNameOrCallback: BrowserNameOrCallback, reason?: string) => void;
+  mode: (mode: 'md' | 'ios', reason?: string) => void;
+}
+export interface SetIonViewportOptions {
+  /**
+   * `true` if the viewport should be scaled to match the `ion-content`
+   * scrollable width. Defaults to `false`.
+   */
+  resizeViewportWidth?: boolean;
+}
+export {};

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

@@ -0,0 +1,17 @@
+import type { PlaywrightTestArgs, PlaywrightTestOptions, PlaywrightWorkerArgs, PlaywrightWorkerOptions, TestInfo } from '@playwright/test';
+import { PageUtils } from '../press-keys';
+import type { E2EPage, E2ESkip } from './playwright-declarations';
+type CustomFixtures = {
+  page: E2EPage;
+  skip: E2ESkip;
+  pageUtils: PageUtils;
+};
+/**
+ * Extends the base `page` test figure within Playwright.
+ * @param page The page to extend.
+ * @param testInfo The test info.
+ * @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 {};

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

@@ -0,0 +1,21 @@
+interface CustomMatchers<R = unknown> {
+  /**
+   * Will check if the event spy received the expected event.
+   */
+  toHaveReceivedEvent(): R;
+  /**
+   * Will check if the event spy received the expected event with the expected detail.
+   * @param eventDetail The expected detail of the event.
+   */
+  toHaveReceivedEventDetail(eventDetail: any): R;
+
+  /**
+   * Will check how many times the event has been received.
+   */
+  toHaveReceivedEventTimes(count: number): R;
+}
+
+declare namespace PlaywrightTest {
+  // eslint-disable-next-line @typescript-eslint/no-empty-interface
+  interface Matchers<R> extends CustomMatchers<R> {}
+}

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

@@ -0,0 +1,12 @@
+export declare const Viewports: {
+  tablet: {
+    portrait: {
+      width: number;
+      height: number;
+    };
+  };
+  large: {
+    width: number;
+    height: number;
+  };
+};

package/dist/types/utils/test/press-keys.d.ts

@@ -0,0 +1,38 @@
+import type { Browser, BrowserContext, Page } from '@playwright/test';
+/**
+ * Source: https://github.com/WordPress/gutenberg/blob/f0d0d569a06c42833670c9b5285d04a63968a220/packages/e2e-test-utils-playwright/src/page-utils/press-keys.ts
+ * Slimmed down version of WordPress' pressKeys utility.
+ */
+export declare class PageUtils {
+  browser: Browser;
+  page: Page;
+  context: BrowserContext;
+  constructor({ page }: {
+    page: Page;
+  });
+  pressKeys: typeof pressKeys;
+}
+type Options = {
+  /**
+   * Number of times to press the key.
+   */
+  times?: number;
+  /**
+   * Delay between each key press in milliseconds.
+   */
+  delay?: number;
+};
+/**
+ * Presses a key combination.
+ * @param key - Key combination to press.
+ * @param options - Options for the key press.
+ * @example
+ * ```ts
+ * await pressKeys('a');
+ * await pressKeys('a', { times: 2 });
+ * await pressKeys('a', { delay: 100 });
+ * await pressKeys('Shift+Tab');
+ * ```
+ */
+export declare function pressKeys(this: PageUtils, key: string, { times, ...pressOptions }?: Options): Promise<void>;
+export {};

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

@@ -0,0 +1,10 @@
+import type { RouterDirection } from '../components/router/utils/interface';
+import type { AnimationBuilder, Color, CssClassMap } from '../interface';
+export declare const hostContext: (selector: string, el: HTMLElement) => boolean;
+/**
+ * Create the mode and color classes for the component based on the classes passed in
+ */
+export declare const createColorClasses: (color: Color | undefined | null, cssClassMap: CssClassMap) => CssClassMap;
+export declare const getClassList: (classes: string | (string | null | undefined)[] | undefined) => string[];
+export declare const getClassMap: (classes: string | string[] | undefined) => CssClassMap;
+export declare const openURL: (url: string | undefined | null, ev: Event | undefined | null, direction: RouterDirection, animation?: AnimationBuilder) => Promise<boolean>;

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

@@ -0,0 +1,31 @@
+import type { NavOptions } from '../../components/nav/nav-interface';
+import type { Animation } from '../animation/animation-interface';
+export declare const transition: (opts: TransitionOptions) => Promise<TransitionResult>;
+export declare const lifecycle: (el: HTMLElement | undefined, eventName: string) => void;
+/**
+ * Wait two request animation frame loops.
+ * This allows the framework implementations enough time to mount
+ * the user-defined contents. This is often needed when using inline
+ * modals and popovers that accept user components. For popover,
+ * the contents must be mounted for the popover to be sized correctly.
+ * For modals, the contents must be mounted for iOS to run the
+ * transition correctly.
+ *
+ * On Angular and React, a single raf is enough time, but for Vue
+ * we need to wait two rafs. As a result we are using two rafs for
+ * all frameworks to ensure contents are mounted.
+ */
+export declare const waitForMount: () => Promise<void>;
+export declare const deepReady: (el: any | undefined) => Promise<void>;
+export declare const setPageHidden: (el: HTMLElement, hidden: boolean) => void;
+export declare const getIonPageElement: (element: HTMLElement) => Element;
+export interface TransitionOptions extends NavOptions {
+  progressCallback?: (ani: Animation | undefined) => void;
+  baseEl: any;
+  enteringEl: HTMLElement;
+  leavingEl: HTMLElement | undefined;
+}
+export interface TransitionResult {
+  hasCompleted: boolean;
+  animation?: Animation;
+}

package/dist/types/utils/transition/ios.transition.d.ts

@@ -0,0 +1,4 @@
+import type { Animation } from '../../interface';
+import type { TransitionOptions } from '../transition';
+export declare const shadow: <T extends Element>(el: T) => ShadowRoot | T;
+export declare const iosTransitionAnimation: (navEl: HTMLElement, opts: TransitionOptions) => Animation;

package/dist/types/utils/transition/md.transition.d.ts

@@ -0,0 +1,3 @@
+import type { Animation } from '../../interface';
+import type { TransitionOptions } from '../transition';
+export declare const mdTransitionAnimation: (_: HTMLElement, opts: TransitionOptions) => Animation;

package/dist/types/utils/watch-options.d.ts

@@ -0,0 +1,2 @@
+export declare const watchForOptions: <T extends HTMLElement>(containerEl: HTMLElement, tagName: string, onChange: (el: T | undefined) => void) => MutationObserver | undefined;
+export declare const findCheckedOption: (el: any, tagName: string) => HTMLElement | undefined;

package/hydrate/index.d.ts

@@ -0,0 +1,218 @@
+// Generated by dts-bundle-generator v7.2.0
+
+export declare function createWindowFromHtml(templateHtml: string, uniqueId: string): any;
+export interface HydrateDocumentOptions {
+	/**
+	 * Build ID that will be added to `<html data-stencil-build="BUILD_ID">`. By default
+	 * a random ID will be generated
+	 */
+	buildId?: string;
+	/**
+	 * Sets the `href` attribute on the `<link rel="canonical">`
+	 * tag within the `<head>`. If the value is not defined it will
+	 * ensure a canonical link tag is no included in the `<head>`.
+	 */
+	canonicalUrl?: string;
+	/**
+	 * Include the HTML comments and attributes used by the clientside
+	 * JavaScript to read the structure of the HTML and rebuild each
+	 * component. Defaults to `true`.
+	 */
+	clientHydrateAnnotations?: boolean;
+	/**
+	 * Constrain `setTimeout()` to 1ms, but still async. Also
+	 * only allows `setInterval()` to fire once, also constrained to 1ms.
+	 * Defaults to `true`.
+	 */
+	constrainTimeouts?: boolean;
+	/**
+	 * Sets `document.cookie`
+	 */
+	cookie?: string;
+	/**
+	 * Sets the `dir` attribute on the top level `<html>`.
+	 */
+	direction?: string;
+	/**
+	 * Component tag names listed here will not be prerendered, nor will
+	 * hydrated on the clientside. Components listed here will be ignored
+	 * as custom elements and treated no differently than a `<div>`.
+	 */
+	excludeComponents?: string[];
+	/**
+	 * Sets the `lang` attribute on the top level `<html>`.
+	 */
+	language?: string;
+	/**
+	 * Maximum number of components to hydrate on one page. Defaults to `300`.
+	 */
+	maxHydrateCount?: number;
+	/**
+	 * Sets `document.referrer`
+	 */
+	referrer?: string;
+	/**
+	 * Removes every `<script>` element found in the `document`. Defaults to `false`.
+	 */
+	removeScripts?: boolean;
+	/**
+	 * Removes CSS not used by elements within the `document`. Defaults to `true`.
+	 */
+	removeUnusedStyles?: boolean;
+	/**
+	 * The url the runtime uses for the resources, such as the assets directory.
+	 */
+	resourcesUrl?: string;
+	/**
+	 * Prints out runtime console logs to the NodeJS process. Defaults to `false`.
+	 */
+	runtimeLogging?: boolean;
+	/**
+	 * Component tags listed here will only be prerendered or serverside-rendered
+	 * and will not be clientside hydrated. This is useful for components that
+	 * are not dynamic and do not need to be defined as a custom element within the
+	 * browser. For example, a header or footer component would be a good example that
+	 * may not require any clientside JavaScript.
+	 */
+	staticComponents?: string[];
+	/**
+	 * The amount of milliseconds to wait for a page to finish rendering until
+	 * a timeout error is thrown. Defaults to `15000`.
+	 */
+	timeout?: number;
+	/**
+	 * Sets `document.title`.
+	 */
+	title?: string;
+	/**
+	 * Sets `location.href`
+	 */
+	url?: string;
+	/**
+	 * Sets `navigator.userAgent`
+	 */
+	userAgent?: string;
+}
+export interface SerializeDocumentOptions extends HydrateDocumentOptions {
+	/**
+	 * Runs after the `document` has been hydrated.
+	 */
+	afterHydrate?(document: any): any | Promise<any>;
+	/**
+	 * Sets an approximate line width the HTML should attempt to stay within.
+	 * Note that this is "approximate", in that HTML may often not be able
+	 * to be split at an exact line width. Additionally, new lines created
+	 * is where HTML naturally already has whitespace, such as before an
+	 * attribute or spaces between words. Defaults to `100`.
+	 */
+	approximateLineWidth?: number;
+	/**
+	 * Runs before the `document` has been hydrated.
+	 */
+	beforeHydrate?(document: any): any | Promise<any>;
+	/**
+	 * Format the HTML in a nicely indented format.
+	 * Defaults to `false`.
+	 */
+	prettyHtml?: boolean;
+	/**
+	 * Remove quotes from attribute values when possible.
+	 * Defaults to `true`.
+	 */
+	removeAttributeQuotes?: boolean;
+	/**
+	 * Remove the `=""` from standardized `boolean` attributes,
+	 * such as `hidden` or `checked`. Defaults to `true`.
+	 */
+	removeBooleanAttributeQuotes?: boolean;
+	/**
+	 * Remove these standardized attributes when their value is empty:
+	 * `class`, `dir`, `id`, `lang`, and `name`, `title`. Defaults to `true`.
+	 */
+	removeEmptyAttributes?: boolean;
+	/**
+	 * Remove HTML comments. Defaults to `true`.
+	 */
+	removeHtmlComments?: boolean;
+}
+export interface HydrateFactoryOptions extends SerializeDocumentOptions {
+	serializeToHtml: boolean;
+	destroyWindow: boolean;
+	destroyDocument: boolean;
+}
+export interface Diagnostic {
+	absFilePath?: string | undefined;
+	code?: string;
+	columnNumber?: number | undefined;
+	debugText?: string;
+	header?: string;
+	language?: string;
+	level: "error" | "warn" | "info" | "log" | "debug";
+	lineNumber?: number | undefined;
+	lines: PrintLine[];
+	messageText: string;
+	relFilePath?: string | undefined;
+	type: string;
+}
+export interface PrintLine {
+	lineIndex: number;
+	lineNumber: number;
+	text?: string;
+	errorCharStart: number;
+	errorLength?: number;
+}
+export interface HydrateResults {
+	buildId: string;
+	diagnostics: Diagnostic[];
+	url: string;
+	host: string;
+	hostname: string;
+	href: string;
+	port: string;
+	pathname: string;
+	search: string;
+	hash: string;
+	html: string;
+	components: HydrateComponent[];
+	anchors: HydrateAnchorElement[];
+	imgs: HydrateImgElement[];
+	scripts: HydrateScriptElement[];
+	styles: HydrateStyleElement[];
+	staticData: HydrateStaticData[];
+	title: string;
+	hydratedCount: number;
+	httpStatus: number;
+}
+export interface HydrateComponent {
+	tag: string;
+	mode: string;
+	count: number;
+	depth: number;
+}
+export interface HydrateElement {
+	[attrName: string]: string | undefined;
+}
+export interface HydrateAnchorElement extends HydrateElement {
+	href?: string;
+	target?: string;
+}
+export interface HydrateImgElement extends HydrateElement {
+	src?: string;
+}
+export interface HydrateScriptElement extends HydrateElement {
+	src?: string;
+	type?: string;
+}
+export interface HydrateStyleElement extends HydrateElement {
+	href?: string;
+}
+export interface HydrateStaticData {
+	id: string;
+	type: string;
+	content: string;
+}
+export declare function renderToString(html: string | any, options?: SerializeDocumentOptions): Promise<HydrateResults>;
+export declare function hydrateDocument(doc: any | string, options?: HydrateDocumentOptions): Promise<HydrateResults>;
+export declare function serializeDocumentToString(doc: any, opts: HydrateFactoryOptions): string;
+
+export {};