cypress 10.11.0 → 11.0.0

package/react/dist/createMount.d.ts

@@ -1,31 +0,0 @@
-/// <reference types="cypress" />
-/// <reference types="cypress" />
-/// <reference types="cypress" />
-/// <reference types="cypress" />
-import * as React from 'react';
-import type { InternalMountOptions, MountOptions, MountReturn, UnmountArgs } from './types';
-/**
- * Create an `mount` function. Performs all the non-React-version specific
- * behavior related to mounting. The React-version-specific code
- * is injected. This helps us to maintain a consistent public API
- * and handle breaking changes in React's rendering API.
- *
- * This is designed to be consumed by `npm/react{16,17,18}`, and other React adapters,
- * or people writing adapters for third-party, custom adapters.
- */
-export declare const makeMountFn: (type: 'mount' | 'rerender', jsx: React.ReactNode, options?: MountOptions, rerenderKey?: string, internalMountOptions?: InternalMountOptions) => globalThis.Cypress.Chainable<MountReturn>;
-/**
- * Create an `unmount` function. Performs all the non-React-version specific
- * behavior related to unmounting.
- *
- * This is designed to be consumed by `npm/react{16,17,18}`, and other React adapters,
- * or people writing adapters for third-party, custom adapters.
- */
-export declare const makeUnmountFn: (options: UnmountArgs) => Cypress.Chainable<undefined>;
-declare const _mount: (jsx: React.ReactNode, options?: MountOptions) => Cypress.Chainable<MountReturn>;
-export declare const createMount: (defaultOptions: MountOptions) => (element: React.ReactElement, options?: MountOptions) => Cypress.Chainable<MountReturn>;
-/** @deprecated Should be removed in the next major version */
-export default _mount;
-export interface JSX extends Function {
-    displayName: string;
-}

package/react/dist/getDisplayName.d.ts

@@ -1,8 +0,0 @@
-import { JSX } from './createMount';
-/**
- * Gets the display name of the component when possible.
- * @param type {JSX} The type object returned from creating the react element.
- * @param fallbackName {string} The alias, or fallback name to use when the name cannot be derived.
- * @link https://github.com/facebook/react-devtools/blob/master/backend/getDisplayName.js
- */
-export default function getDisplayName(type: JSX, fallbackName?: string): string;

package/react/dist/mount.d.ts

@@ -1,8 +0,0 @@
-/// <reference types="cypress" />
-/// <reference types="cypress" />
-import React from 'react';
-import type { MountOptions } from './types';
-export declare function mount(jsx: React.ReactNode, options?: MountOptions, rerenderKey?: string): Cypress.Chainable<import("./types").MountReturn>;
-export declare function unmount(options?: {
-    log: boolean;
-}): Cypress.Chainable<undefined>;

package/react/dist/mountHook.d.ts

@@ -1,12 +0,0 @@
-/// <reference types="cypress" />
-/// <reference types="cypress" />
-declare type MountHookResult<T> = {
-    readonly current: T | null | undefined;
-    readonly error: Error | null;
-};
-/**
- * Mounts a React hook function in a test component for testing.
- *
- */
-export declare const mountHook: <T>(hookFn: (...args: any[]) => T) => Cypress.Chainable<MountHookResult<T>>;
-export {};

package/react/dist/types.d.ts

@@ -1,45 +0,0 @@
-/// <reference types="cypress" />
-/// <reference types="cypress" />
-import type React from 'react';
-import type { StyleOptions } from '@cypress/mount-utils';
-export interface UnmountArgs {
-    log: boolean;
-    boundComponentMessage?: string;
-}
-export declare type MountOptions = Partial<StyleOptions & MountReactComponentOptions>;
-export interface MountReactComponentOptions {
-    alias: string;
-    ReactDom: typeof import('react-dom');
-    /**
-     * Log the mounting command into Cypress Command Log,
-     * true by default.
-     */
-    log: boolean;
-    /**
-     * Render component in React [strict mode](https://reactjs.org/docs/strict-mode.html)
-     * It activates additional checks and warnings for child components.
-     */
-    strict: boolean;
-}
-export interface InternalMountOptions {
-    reactDom: typeof import('react-dom');
-    render: (reactComponent: ReturnType<typeof React.createElement>, el: HTMLElement, reactDomToUse: typeof import('react-dom')) => void;
-    unmount: (options: UnmountArgs) => void;
-    cleanup: () => boolean;
-}
-export interface MountReturn {
-    /**
-     * The component that was rendered.
-     */
-    component: React.ReactNode;
-    /**
-     * Rerenders the specified component with new props. This allows testing of components that store state (`setState`)
-     * or have asynchronous updates (`useEffect`, `useLayoutEffect`).
-     */
-    rerender: (component: React.ReactNode) => globalThis.Cypress.Chainable<MountReturn>;
-    /**
-     * Removes the mounted component.
-     * @see `unmount`
-     */
-    unmount: (payload: UnmountArgs) => void;
-}

package/svelte/dist/mount.d.ts

@@ -1,30 +0,0 @@
-/// <reference types="cypress" />
-/// <reference types="cypress" />
-import { StyleOptions } from '@cypress/mount-utils';
-import type { ComponentConstructorOptions, ComponentProps, SvelteComponent } from 'svelte';
-declare type SvelteConstructor<T> = new (...args: any[]) => T;
-declare type SvelteComponentOptions<T extends SvelteComponent> = Omit<ComponentConstructorOptions<ComponentProps<T>>, 'hydrate' | 'target' | '$$inline'>;
-export interface MountOptions<T extends SvelteComponent> extends SvelteComponentOptions<T>, Partial<StyleOptions> {
-    log?: boolean;
-}
-export interface MountReturn<T extends SvelteComponent> {
-    component: T;
-}
-/**
- * Mounts a Svelte component inside the Cypress browser
- *
- * @param {SvelteConstructor<T>} Component Svelte component being mounted
- * @param {MountReturn<T extends SvelteComponent>} options options to customize the component being mounted
- * @returns Cypress.Chainable<MountReturn>
- *
- * @example
- * import Counter from './Counter.svelte'
- * import { mount } from 'cypress/svelte'
- *
- * it('should render', () => {
- *   mount(Counter, { props: { count: 42 } })
- *   cy.get('button').contains(42)
- * })
- */
-export declare function mount<T extends SvelteComponent>(Component: SvelteConstructor<T>, options?: MountOptions<T>): Cypress.Chainable<MountReturn<T>>;
-export {};

package/vue/dist/@vue/test-utils/baseWrapper.d.ts

@@ -1,63 +0,0 @@
-import type { TriggerOptions } from './createDomEvent';
-import { ComponentInternalInstance, ComponentOptions, ComponentPublicInstance, ComputedOptions, CreateComponentPublicInstance, FunctionalComponent, MethodOptions } from 'vue';
-import { DomEventNameWithModifier } from './constants/dom-events';
-import type { VueWrapper } from './vueWrapper';
-import { DefinedComponent, FindAllComponentsSelector, FindComponentSelector, NameSelector, RefSelector, VueNode } from './types';
-import WrapperLike from './interfaces/wrapperLike';
-import type { DOMWrapper } from './domWrapper';
-export default abstract class BaseWrapper<ElementType extends Node> implements WrapperLike {
-    protected readonly wrapperElement: VueNode<ElementType>;
-    protected abstract getRootNodes(): VueNode[];
-    get element(): VueNode<ElementType>;
-    constructor(element: ElementType);
-    protected findAllDOMElements(selector: string): Element[];
-    find<K extends keyof HTMLElementTagNameMap>(selector: K): DOMWrapper<HTMLElementTagNameMap[K]>;
-    find<K extends keyof SVGElementTagNameMap>(selector: K): DOMWrapper<SVGElementTagNameMap[K]>;
-    find<T extends Element = Element>(selector: string): DOMWrapper<T>;
-    find<T extends Node = Node>(selector: string | RefSelector): DOMWrapper<T>;
-    abstract findAll<K extends keyof HTMLElementTagNameMap>(selector: K): DOMWrapper<HTMLElementTagNameMap[K]>[];
-    abstract findAll<K extends keyof SVGElementTagNameMap>(selector: K): DOMWrapper<SVGElementTagNameMap[K]>[];
-    abstract findAll<T extends Element>(selector: string): DOMWrapper<T>[];
-    abstract findAll(selector: string): DOMWrapper<Element>[];
-    findComponent<T extends never>(selector: string): WrapperLike;
-    findComponent<Props, RawBindings = any, D = any, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions>(selector: ComponentOptions<Props, RawBindings, D, C, M>): VueWrapper<CreateComponentPublicInstance<Props, RawBindings, D, C, M>>;
-    findComponent<T extends ComponentOptions>(selector: string): VueWrapper<T extends ComponentOptions<infer Props, infer RawBindings, infer D, infer C, infer M> ? CreateComponentPublicInstance<Props, RawBindings, D, C, M> : VueWrapper<CreateComponentPublicInstance>>;
-    findComponent<T extends DefinedComponent>(selector: T | Exclude<FindComponentSelector, FunctionalComponent>): VueWrapper<InstanceType<T>>;
-    findComponent<T extends FunctionalComponent>(selector: T): DOMWrapper<Node>;
-    findComponent<T extends FunctionalComponent>(selector: string): DOMWrapper<Element>;
-    findComponent<T extends never>(selector: NameSelector | RefSelector): VueWrapper;
-    findComponent<T extends ComponentPublicInstance>(selector: T | FindComponentSelector): VueWrapper<T>;
-    findComponent<T extends never>(selector: FindComponentSelector): WrapperLike;
-    findAllComponents<T extends never>(selector: string): WrapperLike[];
-    findAllComponents<T extends DefinedComponent>(selector: T | Exclude<FindAllComponentsSelector, FunctionalComponent>): VueWrapper<InstanceType<T>>[];
-    findAllComponents<T extends FunctionalComponent>(selector: T): DOMWrapper<Node>[];
-    findAllComponents<T extends FunctionalComponent>(selector: string): DOMWrapper<Element>[];
-    findAllComponents<T extends never>(selector: NameSelector): VueWrapper[];
-    findAllComponents<T extends ComponentPublicInstance>(selector: T | FindAllComponentsSelector): VueWrapper<T>[];
-    findAllComponents<T extends never>(selector: FindAllComponentsSelector): WrapperLike[];
-    abstract setValue(value?: any): Promise<void>;
-    html(): string;
-    classes(): string[];
-    classes(className: string): boolean;
-    attributes(): {
-        [key: string]: string;
-    };
-    attributes(key: string): string | undefined;
-    text(): string;
-    exists(): boolean;
-    get<K extends keyof HTMLElementTagNameMap>(selector: K): Omit<DOMWrapper<HTMLElementTagNameMap[K]>, 'exists'>;
-    get<K extends keyof SVGElementTagNameMap>(selector: K): Omit<DOMWrapper<SVGElementTagNameMap[K]>, 'exists'>;
-    get<T extends Element = Element>(selector: string): Omit<DOMWrapper<T>, 'exists'>;
-    get<T extends Node = Node>(selector: string | RefSelector): Omit<DOMWrapper<T>, 'exists'>;
-    getComponent<T extends never>(selector: string): Omit<WrapperLike, 'exists'>;
-    getComponent<T extends DefinedComponent>(selector: T | Exclude<FindComponentSelector, FunctionalComponent>): Omit<VueWrapper<InstanceType<T>>, 'exists'>;
-    getComponent<T extends FunctionalComponent>(selector: T | string): Omit<DOMWrapper<Element>, 'exists'>;
-    getComponent<T extends never>(selector: NameSelector | RefSelector): Omit<VueWrapper, 'exists'>;
-    getComponent<T extends ComponentPublicInstance>(selector: T | FindComponentSelector): Omit<VueWrapper<T>, 'exists'>;
-    getComponent<T extends never>(selector: FindComponentSelector): Omit<WrapperLike, 'exists'>;
-    protected isDisabled: () => boolean;
-    isVisible(): boolean;
-    protected abstract getCurrentComponent(): ComponentInternalInstance | void;
-    trigger(eventString: DomEventNameWithModifier, options?: TriggerOptions): Promise<void>;
-    trigger(eventString: string, options?: TriggerOptions): Promise<void>;
-}

package/vue/dist/@vue/test-utils/components/RouterLinkStub.d.ts

@@ -1,21 +0,0 @@
-export declare const RouterLinkStub: import("vue").DefineComponent<{
-    to: {
-        type: (StringConstructor | ObjectConstructor)[];
-        required: true;
-    };
-    custom: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-}, unknown, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
-    to: {
-        type: (StringConstructor | ObjectConstructor)[];
-        required: true;
-    };
-    custom: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-}>>, {
-    custom: boolean;
-}>;

package/vue/dist/@vue/test-utils/config.d.ts

@@ -1,30 +0,0 @@
-import { GlobalMountOptions, Stub } from './types';
-import { VueWrapper } from './vueWrapper';
-import { DOMWrapper } from './domWrapper';
-import { CustomCreateStub } from './stubs';
-export interface GlobalConfigOptions {
-    global: Required<Omit<GlobalMountOptions, 'stubs'>> & {
-        stubs: Record<string, Stub>;
-    };
-    plugins: {
-        VueWrapper: Pluggable<VueWrapper>;
-        DOMWrapper: Pluggable<DOMWrapper<Node>>;
-        createStubs?: CustomCreateStub;
-    };
-    renderStubDefaultSlot: boolean;
-}
-interface Plugin<Instance, O> {
-    handler(instance: Instance): Record<string, any>;
-    handler(instance: Instance, options: O): Record<string, any>;
-    options: O;
-}
-declare class Pluggable<Instance = DOMWrapper<Node>> {
-    installedPlugins: Plugin<Instance, any>[];
-    install<O>(handler: (instance: Instance) => Record<string, any>): void;
-    install<O>(handler: (instance: Instance, options: O) => Record<string, any>, options: O): void;
-    extend(instance: Instance): void;
-    /** For testing */
-    reset(): void;
-}
-export declare const config: GlobalConfigOptions;
-export {};