orphic-cypress/dist/cypress/add.d.ts

Set of utilities and typescript transformers to cover storybook stories with cypress component tests

/**
 * @module cypress
 */
/**
 * Add cypress commands from raw typescript functions.
 * This allows smaller definition footprints while keeping documentation
 * and go to definition IDE utils.
 *
 * ```ts
 * // original
 * Cypress.Commands.add('clickLink', (label) => {
 *   cy.get('a').contains(label).click()
 * });
 * // with addCommands
 * export const clickLink = (label: string) =>
 *   cy.get('a').contains(label).click();
 * // likely create object with `import * as commands from ...`
 * const commands = { clickLink };
 * addCommands(commands);
 * // type def
 * type Commands = typeof commands;
 * declare global {
 *   namespace Cypress {
 *     interface Chainable extends Commands {
 *       // can still put types here defined in the old Cypress.Commands.add way
 *       getInDocument(selector: string): Chainable;
 *       // overwrite default type, should really accept string | number
 *       type(text: string | number, options?: Partial<TypeOptions>): Chainable;
 *     }
 *   }
 * }
 * ```
 */
export declare const addCommands: <T extends Record<string, any>>(commands: T) => void;
/**
 * Raw task function where the argument is either empty or the arg to pass to the task
 */
export type TaskFn = (arg?: any) => any;
/** Task promise without arg */
export type TaskPromise<T extends {
    [event: string]: TaskFn;
}, Key extends keyof T> = () => Promise<ReturnType<T[Key]>>;
/** Task promise with arg */
export type TaskPromiseWithArg<T extends {
    [event: string]: TaskFn;
}, Key extends keyof T> = (arg: Parameters<T[Key]>[0]) => Promise<ReturnType<T[Key]>>;
/**
 * Map as promise returning versions of the tasks
 */
export type Tasks<T extends {
    [event: string]: TaskFn;
}> = {
    [Key in keyof T]: Parameters<T[Key]>[0] extends undefined ? TaskPromise<T, Key> : TaskPromiseWithArg<T, Key>;
};
/**
 * Add cypress tasks defined as commands so that
 * ```ts
 * cy.task("doSomething", 1)
 * // becomes
 * cy.doSomething(1)
 * ```
 * with type support and go to definition IDE utils.
 *
 * ```ts
 * // likely create object with `import * as tasks from ...`
 * const tasks = { getUUID: () => 'a uuid' };
 * addTasks(tasks);
 * // type def, see above `addCommands` for further namespace extension details
 * type Commands = typeof commands & Tasks<typeof tasks>;
 * declare global { // ...
 * ```
 * Then also add tasks in cypress.config.ts
 * ```ts
 * import * as tasks from "./cypress/support/tasks";
 *
 * export default defineConfig({
 *   // ... other config
 *   setupNodeEvents: (on, config) => {
 *     on("task", tasks);
 *   },
 * });
 * ```
 * afterwards, tasks will be available as commands that return well-typed promises
 * ```ts
 * cy.getUUID().then(uuid => ...)`
 * ```
 */
export declare const addTasks: <T extends {
    [event: string]: TaskFn;
}>(tasks: T) => void;