askui 0.11.6 → 0.12.0

package/dist/esm/execution/reporter.d.ts

@@ -1,132 +0,0 @@
-import { DetectedElement } from "@/core/model/annotation-result/detected-element";
-import { CustomElement } from "@/core/model/custom-element";
-export interface Snapshot {
-    readonly createdAt: Date;
-    readonly screenshot?: string | undefined;
-    readonly detectedElements?: Readonly<Readonly<DetectedElement>>[] | undefined;
-}
-export interface Instruction {
-    readonly value: string;
-    readonly valueHumanReadable: string;
-    readonly customElements?: Readonly<Readonly<CustomElement>>[];
-    readonly secretText?: string | undefined;
-}
-export interface Step {
-    readonly instruction: Readonly<Instruction>;
-    readonly status: StepStatus;
-    /**
-     * A snapshot of the state of the screen before the step is ran which is nearly immediately after the call to `.exec()`
-     */
-    readonly begin?: Snapshot | undefined;
-    /**
-     * The duration of the step in milliseconds based on the start and end time. If the step is still running, this property is undefined.
-     */
-    readonly duration?: number | undefined;
-    /**
-     * A snapshot of the state of the screen after the step has been run. If the step is still running or still pending, this property is undefined.
-     */
-    readonly end?: Snapshot | undefined;
-    /**
-     * When a step failed or is erroneous, this property contains the error.
-     */
-    readonly error?: Error | undefined;
-    readonly runs: Readonly<StepRun[]>;
-    readonly retries: Readonly<StepRun[]>;
-    readonly retryCount: number;
-    readonly firstRun?: StepRun | undefined;
-    readonly lastRun?: StepRun | undefined;
-    /**
-     * retryCount > 0.
-     */
-    readonly flaky: boolean;
-}
-export interface StepRun {
-    readonly status: StepStatus;
-    readonly begin?: Snapshot | undefined;
-    readonly end?: Snapshot | undefined;
-    readonly duration?: number | undefined;
-    readonly error?: Error | undefined;
-}
-declare class askuiStep implements Step {
-    instruction: Instruction;
-    runs: Readonly<StepRun[]>;
-    constructor(instruction: Instruction);
-    get status(): StepStatus;
-    get begin(): Snapshot | undefined;
-    get end(): Snapshot | undefined;
-    get error(): Error | undefined;
-    get retries(): StepRun[];
-    get retryCount(): number;
-    get firstRun(): StepRun | undefined;
-    get lastRun(): StepRun | undefined;
-    get flaky(): boolean;
-    get duration(): number | undefined;
-    onBegin(snapshot: Snapshot): askuiStep;
-    onRetry(snapshot: Snapshot, error: Error): askuiStep;
-    onEnd(snapshot: Snapshot, error?: Error): askuiStep;
-    private determineLastRunStatus;
-}
-/**
- * - `passed`: the step passed
- * - `failed`: the step failed because of a failed (implicit/explicit) assertion, e.g., an element could not be found
- * - `pending`: the step is waiting for a previous step to pass
- * - `running`: the step is currently running (including retries)
- * - `skipped`: the step was skipped, e.g., because a previous step failed or because workflow was skipped
- * - `erroneous`: the step could not be run because of a runtime error, e.g., the user has no usage left, response of inference backend cannot be processed, e.g., because lib version is outdated, etc. (currently not supported, everything "failed")
- */
-export declare type StepStatus = 'passed' | 'failed' | 'pending' | 'running' | 'erroneous';
-export declare type StepStatusEnd = 'passed' | 'failed' | 'erroneous';
-/**
- * Can be used to report on a step run.
- *
- * The reporter is an interface (instead of a class) so that the it may be implemented by a class that already extends another class, e.g., the reporter of a test framework.
- */
-export interface Reporter {
-    config?: ReporterConfig;
-    onStepBegin?(step: Step): Promise<void>;
-    onStepRetry?(step: Step): Promise<void>;
-    onStepEnd?(step: Step): Promise<void>;
-}
-export declare type SnapshotDetailLevel = 
-/**
- * Details of snapshot, e.g., screenshot or detected elements, may or may not be available depending on if they are required by the step. There are not guarantees made.
- */
-'required' | 
-/**
- * Details are available when the step fails, e.g., for debugging. Includes everything of required.
- */
-'onFailure' | 
-/**
- * Details are available also when the command is started, e.g., for detecting why a certain element was interacted with. Includes everything of onFailure.
- */
-'begin' | 
-/**
- * Details are available always, e.g., before and after a step has been run no matter if it failed or not for debugging.
- */
-'always';
-export interface ReporterConfig {
-    withScreenshots?: SnapshotDetailLevel;
-    withDetectedElements?: SnapshotDetailLevel;
-}
-export declare const DEFAULT_REPORTER: {
-    config: {
-        readonly withScreenshots: "onFailure";
-        readonly withDetectedElements: "onFailure";
-    };
-    onStepBegin: (_step: Step) => Promise<void>;
-    onStepRetry: (_step: Step) => Promise<void>;
-    onStepEnd: (_step: Step) => Promise<void>;
-};
-export declare class StepReporter {
-    private reporter;
-    currentStep?: askuiStep | undefined;
-    constructor(reporter: Required<Reporter> & {
-        config: Required<ReporterConfig>;
-    });
-    get config(): Required<ReporterConfig>;
-    resetStep(instruction: Instruction): void;
-    onStepBegin(snapshot: Snapshot): Promise<void>;
-    onStepRetry(snapshot: Snapshot, error: Error): Promise<void>;
-    onStepEnd(snapshot: Snapshot, error?: Error): Promise<void>;
-}
-export {};

package/dist/esm/execution/reporter.js

@@ -1,142 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-// retries could be modeled as totally new steps only that we set the retry no at the beginning, it is undefined if there is no retry or 0 --> user could filter out the retries for the report and has to get the last retry to find out when the step actually ended and the snapshot at that point in time
-// Where do I save the error of the first step, what state does the first step have?
-// We could point back from retry to original step, but then we have to save the original step in the retry step, which is not nice
-// retry should be handled like completely new step but the state of the whole state is not failed --> if a passed step can have an error, then this is fine 
-// how do we determine if it is erroneous or failed?
-class askuiStep {
-    constructor(instruction) {
-        this.instruction = instruction;
-        this.runs = [];
-    }
-    get status() {
-        var _a, _b;
-        return (_b = (_a = this.lastRun) === null || _a === void 0 ? void 0 : _a.status) !== null && _b !== void 0 ? _b : 'pending';
-    }
-    get begin() {
-        var _a;
-        return (_a = this.firstRun) === null || _a === void 0 ? void 0 : _a.begin;
-    }
-    get end() {
-        var _a;
-        return (_a = this.lastRun) === null || _a === void 0 ? void 0 : _a.end;
-    }
-    get error() {
-        var _a;
-        return (_a = this.lastRun) === null || _a === void 0 ? void 0 : _a.error;
-    }
-    get retries() {
-        var _a, _b;
-        return (_b = (_a = this.runs) === null || _a === void 0 ? void 0 : _a.slice(1)) !== null && _b !== void 0 ? _b : [];
-    }
-    get retryCount() {
-        var _a, _b;
-        return (_b = (_a = this.retries) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
-    }
-    get firstRun() {
-        var _a;
-        return (_a = this.runs) === null || _a === void 0 ? void 0 : _a[0];
-    }
-    get lastRun() {
-        var _a;
-        return (_a = this.runs) === null || _a === void 0 ? void 0 : _a[this.runs.length - 1];
-    }
-    get flaky() {
-        return this.retryCount > 0;
-    }
-    get duration() {
-        if (this.begin !== undefined && this.end !== undefined) {
-            return this.end.createdAt.getTime() - this.begin.createdAt.getTime();
-        }
-        return undefined;
-    }
-    onBegin(snapshot) {
-        this.runs = [...this.runs, {
-                status: 'running',
-                begin: snapshot,
-            }];
-        return this;
-    }
-    onRetry(snapshot, error) {
-        this.onEnd(snapshot, error);
-        this.onBegin(snapshot);
-        return this;
-    }
-    onEnd(snapshot, error) {
-        this.runs = [...this.runs.slice(0, -1), Object.assign(Object.assign({}, this.lastRun), { status: this.determineLastRunStatus(error), end: snapshot, error, duration: snapshot.createdAt.getTime() - this.lastRun.begin.createdAt.getTime() })];
-        return this;
-    }
-    determineLastRunStatus(error) {
-        if (error !== undefined) {
-            return 'failed';
-        }
-        return 'passed';
-    }
-}
-export const DEFAULT_REPORTER = {
-    config: {
-        withScreenshots: 'onFailure',
-        withDetectedElements: 'onFailure',
-    },
-    onStepBegin: (_step) => {
-        return Promise.resolve();
-    },
-    onStepRetry: (_step) => {
-        return Promise.resolve();
-    },
-    onStepEnd: (_step) => {
-        return Promise.resolve();
-    },
-};
-export class StepReporter {
-    constructor(reporter) {
-        this.reporter = reporter;
-    }
-    get config() {
-        return this.reporter.config;
-    }
-    resetStep(instruction) {
-        this.currentStep = new askuiStep(instruction);
-    }
-    onStepBegin(snapshot) {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.currentStep === undefined)
-                throw new Error('Cannot begin step if step is undefined.');
-            if (this.currentStep.status !== 'pending')
-                throw new Error('Cannot begin step that is not pending.');
-            this.currentStep.onBegin(snapshot);
-            yield ((_b = (_a = this.reporter).onStepBegin) === null || _b === void 0 ? void 0 : _b.call(_a, this.currentStep));
-        });
-    }
-    onStepRetry(snapshot, error) {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.currentStep === undefined)
-                throw new Error('Cannot retry step if step is undefined.');
-            if (this.currentStep.status !== 'running')
-                throw new Error('Cannot retry step that has not been running.');
-            this.currentStep.onRetry(snapshot, error);
-            yield ((_b = (_a = this.reporter).onStepRetry) === null || _b === void 0 ? void 0 : _b.call(_a, this.currentStep));
-        });
-    }
-    onStepEnd(snapshot, error) {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.currentStep === undefined)
-                throw new Error('Cannot end step if step is undefined.');
-            if (this.currentStep.status !== 'running')
-                throw new Error('Cannot end step that has not been running.');
-            this.currentStep.onEnd(snapshot, error);
-            yield ((_b = (_a = this.reporter).onStepEnd) === null || _b === void 0 ? void 0 : _b.call(_a, this.currentStep));
-        });
-    }
-}