tomation 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Facundo Crego
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,81 @@
+## Tomation - Framework for automating tasks in browsers
+
+Tomation is an innovative framework designed for streamlining the automation of tasks within a web browser environment.
+
+The core concept behind Tomation is its seamless integration as a browser extension, offering an efficient solution for test management and execution log handling.
+
+## Installation
+
+Clone project locally and link it to your project.
+
+At `tomation` run
+```bash
+npm link 
+```
+
+In your project run
+```bash
+npm link tomation
+```
+
+## Usage
+
+It's recommended to use Page Object Model (POM) to implement automated tests. Create a file to automate a login page for example.
+login-page.ts
+
+```typescript
+import { Task, Click, Type, TypePassword } from 'tomation'
+
+// --- UI Elements ---
+const loginButton = is.BUTTON
+  .where(innerTextIs('Login'))
+  .as('Login Button')
+
+const usernameInput = is.INPUT
+  .where((elem: HTMLElement) => elem?.parentElement?.parentElement?.children[1]?.textContent?.trim() === 'Username')
+  .as('Username Input')
+
+const passwordInput = is.INPUT
+  .where((elem: HTMLElement) => elem?.parentElement?.parentElement?.children[1]?.textContent?.trim() === 'Password')
+  .as('Password Input')
+
+// --- UI Actions ---
+const login = Task('Login task', (params: { username: string, password: string }) => {
+  Type(params.username).in(usernameInput)
+  TypePassword(params.password).in(passwordInput)
+  Click(loginButton)
+})
+
+export default {
+  // UI Elements
+  loginButton,
+  usernameInput,
+  passwordInput,
+  // Actions
+  login,
+}
+```
+
+```typescript
+import LoginPage from '~/login-page'
+
+function LoginTest() {
+  Test('Login', () => {
+    LoginPage.login({
+      username: 'admin',
+      password: '12345',
+    })
+  })
+}
+
+export {
+  LoginTest
+}
+
+```
+
+## Contributing
+
+Pull requests are welcome. For major changes, please open an issue first
+to discuss what you would like to change.
+

package/dist/.vite/manifest.json

@@ -0,0 +1,8 @@
+{
+  "src/main.ts": {
+    "file": "main.cjs",
+    "name": "main",
+    "src": "src/main.ts",
+    "isEntry": true
+  }
+}

package/dist/actions.d.ts

@@ -0,0 +1,396 @@
+import { UIElement } from "./ui-element-builder";
+interface ActionContext {
+    url: string;
+    beforeHTML: string;
+    beforeInputValues: Object;
+    afterHTML: string;
+    afterInputValues: Object;
+    startTimestamp: string;
+    endTimestamp: string;
+}
+declare enum ACTION_STATUS {
+    WAITING = "waiting",
+    RUNNING = "running",
+    STOPPED = "stopped",
+    PAUSED = "paused",
+    SUCCESS = "success",
+    ERROR = "error",
+    SKIPPED = "skipped"
+}
+declare abstract class AbstractAction {
+    status: ACTION_STATUS;
+    error: string;
+    id: string;
+    context: ActionContext;
+    constructor();
+    abstract getDescription(): string;
+    getJSON(): {
+        id: string;
+        description: string;
+        context: ActionContext;
+        status: ACTION_STATUS;
+        error: string;
+    };
+    protected abstract executeAction(): Promise<any>;
+    protected abstract resetAction(): void;
+    reset(): void;
+    private getInputValuesFromPage;
+    execute(): Promise<void>;
+    static notifyActionUpdated(action: AbstractAction): Promise<void>;
+}
+declare class Action extends AbstractAction {
+    name: string;
+    stepsFn: (params?: any) => void;
+    steps: Array<AbstractAction>;
+    params: any;
+    index: number;
+    constructor(name: string, steps: (params?: any) => void);
+    getDescription(): string;
+    compileSteps(): void;
+    stepsToJSON(): Object[];
+    getJSON(): {
+        type: string;
+        params: any;
+        steps: Object[];
+        id: string;
+        description: string;
+        context: ActionContext;
+        status: ACTION_STATUS;
+        error: string;
+    };
+    resetAction(): void;
+    continue(): Promise<void>;
+    executeAction(): Promise<void>;
+    setParams(params?: any): void;
+    addStep(action: AbstractAction): void;
+}
+declare abstract class ActionOnElement extends AbstractAction {
+    uiElement: UIElement;
+    element: HTMLElement | null;
+    tries: number;
+    constructor(uiElement: UIElement);
+    getElementName(): string;
+    updateTries(tries: number): void;
+    resetTries(): void;
+    getJSON(): {
+        id: string;
+        element: string;
+        description: string;
+        status: ACTION_STATUS;
+        error: string;
+        context: ActionContext;
+        tries: number;
+    };
+    protected abstract executeActionOnElement(): void;
+    /**
+     *
+     * @param uiElement
+     * @param delay of each try. Defaults to 1 second
+     */
+    static waitForElement(currentAction: ActionOnElement, uiElement: UIElement, delay?: number, maxTries?: number, untilRemoved?: boolean): Promise<HTMLElement | null>;
+    executeAction(): Promise<void>;
+    resetAction(): void;
+}
+declare class ClickAction extends ActionOnElement {
+    constructor(uiElement: UIElement);
+    protected executeActionOnElement(): void | undefined;
+    getDescription(): string;
+    getJSON(): {
+        type: string;
+        id: string;
+        element: string;
+        description: string;
+        status: ACTION_STATUS;
+        error: string;
+        context: ActionContext;
+        tries: number;
+    };
+}
+declare class AssertTextIsAction extends ActionOnElement {
+    text: string;
+    constructor(uiElement: UIElement, text: string);
+    protected executeActionOnElement(): void;
+    getDescription(): string;
+    getJSON(): {
+        type: string;
+        value: string;
+        id: string;
+        element: string;
+        description: string;
+        status: ACTION_STATUS;
+        error: string;
+        context: ActionContext;
+        tries: number;
+    };
+}
+declare class AssertContainsTextAction extends ActionOnElement {
+    text: string;
+    constructor(uiElement: UIElement, text: string);
+    protected executeActionOnElement(): void;
+    getDescription(): string;
+    getJSON(): {
+        type: string;
+        value: string;
+        id: string;
+        element: string;
+        description: string;
+        status: ACTION_STATUS;
+        error: string;
+        context: ActionContext;
+        tries: number;
+    };
+}
+declare class AssertValueIsAction extends ActionOnElement {
+    value: string | boolean | number | Date;
+    constructor(uiElement: UIElement, value: string | boolean | number | Date);
+    protected executeActionOnElement(): void;
+    getDescription(): string;
+    getJSON(): {
+        type: string;
+        value: string | number | boolean | Date;
+        id: string;
+        element: string;
+        description: string;
+        status: ACTION_STATUS;
+        error: string;
+        context: ActionContext;
+        tries: number;
+    };
+}
+declare class AssertExistsAction extends ActionOnElement {
+    constructor(uiElement: UIElement);
+    protected executeActionOnElement(): void;
+    getDescription(): string;
+    getJSON(): {
+        type: string;
+        id: string;
+        element: string;
+        description: string;
+        status: ACTION_STATUS;
+        error: string;
+        context: ActionContext;
+        tries: number;
+    };
+}
+declare class AssertNotExistsAction extends ActionOnElement {
+    constructor(uiElement: UIElement);
+    executeAction(): Promise<void>;
+    protected executeActionOnElement(): void;
+    getDescription(): string;
+    getJSON(): {
+        type: string;
+        id: string;
+        element: string;
+        description: string;
+        status: ACTION_STATUS;
+        error: string;
+        context: ActionContext;
+        tries: number;
+    };
+}
+declare class SelectAction extends ActionOnElement {
+    value: string;
+    constructor(uiElement: UIElement, value: string);
+    protected executeActionOnElement(): void;
+    getDescription(): string;
+    getJSON(): {
+        type: string;
+        value: string;
+        id: string;
+        element: string;
+        description: string;
+        status: ACTION_STATUS;
+        error: string;
+        context: ActionContext;
+        tries: number;
+    };
+}
+declare class TypeAction extends ActionOnElement {
+    value: string;
+    constructor(uiElement: UIElement, value: string);
+    protected executeActionOnElement(): void;
+    getDescription(): string;
+    getJSON(): {
+        type: string;
+        value: string;
+        id: string;
+        element: string;
+        description: string;
+        status: ACTION_STATUS;
+        error: string;
+        context: ActionContext;
+        tries: number;
+    };
+}
+declare class TypePasswordAction extends ActionOnElement {
+    value: string;
+    constructor(uiElement: UIElement, value: string);
+    protected executeActionOnElement(): void;
+    getDescription(): string;
+    getJSON(): {
+        type: string;
+        value: string;
+        id: string;
+        element: string;
+        description: string;
+        status: ACTION_STATUS;
+        error: string;
+        context: ActionContext;
+        tries: number;
+    };
+}
+declare class PressEscKeyAction extends ActionOnElement {
+    constructor(uiElement: UIElement);
+    protected executeActionOnElement(): void;
+    getDescription(): string;
+    getJSON(): {
+        type: string;
+        id: string;
+        element: string;
+        description: string;
+        status: ACTION_STATUS;
+        error: string;
+        context: ActionContext;
+        tries: number;
+    };
+}
+declare class PressDownKeyAction extends ActionOnElement {
+    constructor(uiElement: UIElement);
+    protected executeActionOnElement(): void;
+    getDescription(): string;
+    getJSON(): {
+        type: string;
+        id: string;
+        element: string;
+        description: string;
+        status: ACTION_STATUS;
+        error: string;
+        context: ActionContext;
+        tries: number;
+    };
+}
+declare class PressTabKeyAction extends ActionOnElement {
+    constructor(uiElement: UIElement);
+    protected executeActionOnElement(): void;
+    getDescription(): string;
+    getJSON(): {
+        type: string;
+        id: string;
+        element: string;
+        description: string;
+        status: ACTION_STATUS;
+        error: string;
+        context: ActionContext;
+        tries: number;
+    };
+}
+declare class UploadFileAction extends ActionOnElement {
+    file: File;
+    constructor(uiElement: UIElement, file: File);
+    protected executeActionOnElement(): void;
+    getDescription(): string;
+    getJSON(): {
+        type: string;
+        id: string;
+        element: string;
+        description: string;
+        status: ACTION_STATUS;
+        error: string;
+        context: ActionContext;
+        tries: number;
+    };
+}
+declare class SaveValueAction extends ActionOnElement {
+    memorySlotName: string;
+    constructor(uiElement: UIElement, memorySlotName: string);
+    protected executeActionOnElement(): void;
+    getDescription(): string;
+    getJSON(): {
+        type: string;
+        memorySlotName: string;
+        id: string;
+        element: string;
+        description: string;
+        status: ACTION_STATUS;
+        error: string;
+        context: ActionContext;
+        tries: number;
+    };
+}
+declare class WaitAction extends AbstractAction {
+    miliseconds: number;
+    constructor(miliseconds: number);
+    getDescription(): string;
+    getJSON(): {
+        type: string;
+        id: string;
+        description: string;
+        context: ActionContext;
+        status: ACTION_STATUS;
+        error: string;
+    };
+    executeAction(): Promise<void>;
+    resetAction(): void;
+}
+declare class WaitUntilElementRemovedAction extends AbstractAction {
+    uiElement: UIElement;
+    tries: number;
+    constructor(uiElement: UIElement);
+    updateTries(tries: number): void;
+    resetAction(): void;
+    getElementName(): string;
+    protected executeAction(): Promise<void>;
+    getDescription(): string;
+    getJSON(): {
+        type: string;
+        id: string;
+        description: string;
+        context: ActionContext;
+        status: ACTION_STATUS;
+        error: string;
+    };
+}
+declare class PauseAction extends AbstractAction {
+    constructor();
+    getDescription(): string;
+    getJSON(): {
+        type: string;
+        id: string;
+        description: string;
+        context: ActionContext;
+        status: ACTION_STATUS;
+        error: string;
+    };
+    executeAction(): Promise<void>;
+    resetAction(): void;
+}
+declare class ManualAction extends AbstractAction {
+    description: string;
+    constructor(description: string);
+    getDescription(): string;
+    getJSON(): {
+        type: string;
+        id: string;
+        description: string;
+        context: ActionContext;
+        status: ACTION_STATUS;
+        error: string;
+    };
+    executeAction(): Promise<unknown>;
+    resetAction(): void;
+}
+declare class ReloadPageAction extends AbstractAction {
+    constructor();
+    getDescription(): string;
+    getJSON(): {
+        type: string;
+        id: string;
+        description: string;
+        context: ActionContext;
+        status: ACTION_STATUS;
+        error: string;
+    };
+    executeAction(): Promise<void>;
+    resetAction(): void;
+}
+export { AbstractAction, Action, ActionOnElement, ClickAction, SelectAction, TypeAction, TypePasswordAction, PressEscKeyAction, PressDownKeyAction, PressTabKeyAction, UploadFileAction, AssertTextIsAction, AssertContainsTextAction, AssertValueIsAction, AssertExistsAction, AssertNotExistsAction, SaveValueAction, WaitAction, WaitUntilElementRemovedAction, PauseAction, ManualAction, ReloadPageAction, ACTION_STATUS, };

package/dist/automation.d.ts

@@ -0,0 +1,116 @@
+import { AbstractAction, ACTION_STATUS } from './actions';
+import { UIUtils } from "./ui-utils";
+import { UIElement } from './ui-element-builder';
+import DateUtils from './date-utils';
+declare const setAutomationLogs: (enabled: boolean) => void;
+declare enum EVENT_NAMES {
+    START = "start",
+    END = "end",
+    ACTION_UPDATE = "action-update",
+    SAVE_VALUE = "save-value",
+    REGISTER_TEST = "register-test",
+    TEST_STARTED = "test-started",
+    TEST_PASSED = "test-passed",
+    TEST_FAILED = "test-failed",
+    TEST_END = "test-end",
+    USER_ACCEPT = "user-accept",
+    USER_REJECT = "user-reject"
+}
+type AutomationEventHandlerType = ((action?: any) => void);
+declare class EventDispatcher {
+    events: Map<EVENT_NAMES, Array<AutomationEventHandlerType>>;
+    constructor();
+    on(eventName: EVENT_NAMES, callback: AutomationEventHandlerType): void;
+    off(eventName: EVENT_NAMES, callback: AutomationEventHandlerType): void;
+    dispatch(eventName: EVENT_NAMES, data?: any): void;
+}
+declare const AutomationEvents: EventDispatcher;
+declare enum TestSpeed {
+    SLOW = 2000,
+    NORMAL = 1000,
+    FAST = 200
+}
+declare enum TestPlayStatus {
+    PLAYING = "Playing",
+    STOPPED = "Stopped",
+    PAUSED = "Paused"
+}
+declare enum RunMode {
+    NORMAL = "Normal",
+    STEPBYSTEP = "Step By Step"
+}
+declare const Test: (id: string, steps: () => void) => void;
+declare const RunTest: (id: string) => void;
+declare const Task: <T>(id: string, steps: (params: T) => void) => (params?: T | undefined) => Promise<void>;
+declare const Click: (uiElement: UIElement) => void;
+declare const Assert: (uiElement: UIElement) => {
+    textIs: (text: string) => void;
+    containsText: (text: string) => void;
+    valueIs: (value: string) => void;
+    exists: () => void;
+    notExists: () => void;
+};
+declare const Select: (value: string) => {
+    in: (uiElement: UIElement) => void;
+};
+declare const Type: (value: string) => {
+    in: (uiElement: UIElement) => void;
+};
+declare const ClearValue: () => {
+    in: (uiElement: UIElement) => void;
+};
+declare const PressEscKey: () => {
+    in: (uiElement: UIElement) => void;
+};
+declare const PressDownKey: () => {
+    in: (uiElement: UIElement) => void;
+};
+declare const PressTabKey: () => {
+    in: (uiElement: UIElement) => void;
+};
+declare const TypePassword: (value: string) => {
+    in: (uiElement: UIElement) => void;
+};
+declare const UploadFile: (file: File) => {
+    in: (uiElement: UIElement) => void;
+};
+declare const SaveValue: (uiElement: UIElement) => {
+    in: (memorySlotName: string) => void;
+};
+declare const Wait: {
+    (miliseconds: number): void;
+    untilElement(uiElement: UIElement): {
+        isRemoved: () => void;
+    };
+};
+declare const Pause: () => void;
+declare const ManualTask: (description: string) => void;
+declare const ReloadPage: () => void;
+declare class Automation {
+    private _document;
+    debug: Boolean;
+    private _uiUtils;
+    speed: TestSpeed;
+    status: TestPlayStatus;
+    runMode: RunMode;
+    currentActionCallback: ((action: AbstractAction) => {}) | undefined;
+    currentAction: AbstractAction | undefined;
+    constructor(window: Window);
+    get document(): Document;
+    get uiUtils(): UIUtils;
+    get isStepByStepMode(): boolean;
+    get isStopped(): boolean;
+    get isPlaying(): boolean;
+    get isPaused(): boolean;
+    pause(): void;
+    continue(): void;
+    next(): void;
+    stop(): void;
+    retryAction(): void;
+    skipAction(): void;
+    saveCurrentAction(callback: (action: AbstractAction) => {}, action: AbstractAction): void;
+    setDebug(value: boolean): void;
+}
+declare let AutomationInstance: Automation;
+declare const Setup: (window: Window, tests?: Array<any>) => Automation;
+export { Setup, AutomationInstance, Test, RunTest, Task, Click, Assert, Select, Type, TypePassword, ClearValue, PressEscKey, PressDownKey, PressTabKey, UploadFile, SaveValue, Wait, Pause, ManualTask, ReloadPage, DateUtils, AutomationEvents, EVENT_NAMES, TestSpeed, ACTION_STATUS, setAutomationLogs, };

package/dist/date-utils.d.ts

@@ -0,0 +1,11 @@
+declare const DateUtils: {
+    formatDate: (date: Date) => string;
+    today: string;
+    tomorrow: string;
+    nextWeek: string;
+    nextMonth: string;
+    yesterday: string;
+    lastWeek: string;
+    lastMonth: string;
+};
+export default DateUtils;