aps-data-api/src/typings/browser.ts

package for data extraction from APS company for omnimetic project

import {
  ClickOptions,
  EvaluateFunc,
  EventEmitter,
  KeyInput,
  PageEventObject,
  Protocol,
  ProtocolMapping,
  WaitForOptions,
} from 'puppeteer';

export interface Browser {
  newPage(): Promise<Page>;
  close(): Promise<void>;
}

export interface ElementHandle {
  click(options?: ClickOptions): Promise<void>;
}

export interface HTTPResponse {
  url(): string;
  json(): Promise<any>;
}

export interface Document {
  querySelector(selector: string): Promise<HTMLElement | null>;
}

export interface Keyboard {
  press(
    key: KeyInput,
    options?: {
      delay?: number;
      text?: string;
    },
  ): Promise<void>;
}

export interface Target {
  createCDPSession(): Promise<CDPSession>;
}

export interface CDPSession {
  send<T extends keyof ProtocolMapping.Commands>(
    method: T,
    ...paramArgs: ProtocolMapping.Commands[T]['paramsType']
  ): Promise<ProtocolMapping.Commands[T]['returnType']>;
}

export interface Page {
  keyboard: Keyboard;

  goto(
    url: string,
    options?: WaitForOptions & {
      referer?: string;
    },
  ): Promise<HTTPResponse>;

  type(
    selector: string,
    text: string,
    options?: {
      delay: number;
    },
  ): Promise<void>;

  waitForResponse(
    urlOrPredicate:
      | string
      | ((res: HTTPResponse) => boolean | Promise<boolean>),
    options?: {
      timeout?: number;
    },
  ): Promise<HTTPResponse>;

  waitForSelector(
    selector: string,
    options?: {
      visible?: boolean;
      hidden?: boolean;
      timeout?: number;
    },
  ): Promise<ElementHandle | null>;

  waitForNavigation(options?: {
    timeout: number;
    waitUntil: 'load' | 'domcontentloaded' | 'networkidle0' | 'networkidle2';
  }): Promise<HTTPResponse>;

  $eval<ReturnType>(
    selector: string,
    pageFunction: (
      element: Element,
      ...args: unknown[]
    ) => ReturnType | Promise<ReturnType>,
  ): Promise<Awaited<ReturnType>>;

  select(selector: string, ...values: string[]): Promise<string[]>;

  $$eval<ReturnType>(
    selector: string,
    pageFunction: (
      elements: Element[],
      ...args: unknown[]
    ) => ReturnType | Promise<ReturnType>,
  ): Promise<Awaited<ReturnType>>;

  evaluate<
    Params extends unknown[],
    Func extends EvaluateFunc<Params> = EvaluateFunc<Params>
  >(
    pageFunction: Func | string,
    ...args: Params
  ): Promise<Awaited<ReturnType<Func>>>;

  $$<T extends Element = Element>(selector: string): Promise<ElementHandle[]>;

  target(): Target;

  setDefaultTimeout(timeout: number): void;

  setRequestInterception(value: boolean): Promise<void>;

  on<K extends keyof PageEventObject>(
    eventName: K,
    handler: (event: PageEventObject[K]) => void,
  ): EventEmitter;

  setCookie(...cookies: Protocol.Network.CookieParam[]): Promise<void>;
}