@odg/command 1.13.0 → 1.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@odg/command",
-    "version": "1.13.0",
+    "version": "1.15.0",
     "description": "ODGCommander used to create files based in stubs",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
@@ -41,23 +41,24 @@
     "author": "Dragons Gamers <https://www.linkedin.com/in/victor-alves-odgodinho>",
     "license": "MIT",
     "devDependencies": {
-        "@odg/eslint-config": "^3.4.0",
-        "@odg/tsconfig": "^1.3.0",
+        "@odg/eslint-config": "^3.6.0",
+        "@odg/tsconfig": "^1.4.0",
         "@types/node": ">=24",
-        "@vitest/coverage-istanbul": "^4.1.4",
+        "@vitest/coverage-istanbul": "^4.1.5",
         "concurrently": "^9.2.1",
         "reflect-metadata": "^0.2.2",
         "rimraf": "^6.1.3",
-        "tsc-alias": "^1.8.16",
+        "tsc-alias": "^1.8.17",
         "tsx": "^4.21.0",
         "typescript": "^5.9.3",
-        "vite": "^8.0.8",
-        "vitest": "^4.1.4"
+        "vite": "^8.0.10",
+        "vitest": "^4.1.5"
     },
     "dependencies": {
-        "@odg/chemical-x": "^2.4.0",
-        "@odg/exception": "^1.10.0",
-        "@odg/log": "^1.8.0",
-        "commander": "^14.0.3"
+        "@odg/chemical-x": "^2.6.0",
+        "@odg/exception": "^1.12.0",
+        "@odg/log": "^1.10.0",
+        "commander": "^14.0.3",
+        "ts-morph": "^28.0.0"
     }
 }

package/stubs/handler.stub

@@ -1,11 +1,11 @@
 import {
-    type HandlerInterface,
     type HandlerFunction,
-    HandlerSolution,
-    RetryAction,
+    type HandlerInterface,
+    type HandlerSolutionType,
     ODGDecorators,
+    RetryAction,
 } from "@odg/chemical-x";
-import { type Exception } from "@odg/exception";
+import type { Exception } from "@odg/exception";
 
 import { ConfigName, ContainerName } from "@enums";
 import { BaseHandler } from "@handlers/BaseHandler";
@@ -20,45 +20,23 @@ export class {{ HandlerClassName }} extends BaseHandler implements HandlerInterf
         ]);
     }
 
-    /**
-     * Return timeout for handler
-     *
-     * @returns {Promise<number>}
-     */
     public async getTimeout(): Promise<number> {
         return this.config.get(ConfigName.HANDLER_TIMEOUT);
     }
 
-    /**
-     * Return number attempt to test this handler
-     *
-     * @returns {Promise<number>}
-     */
     public async attempt(): Promise<number> {
         return this.config.get(ConfigName.HANDLER_ATTEMPT);
     }
 
-    /**
-     * Called Always handler attempt error.
-     *
-     * @param {Exception} exception Exception error
-     * @param {number} attempt Current attempt
-     * @returns {Promise<RetryAction>}
-     */
-    public async retrying(exception: Exception, attempt: number): Promise<RetryAction> {
-        await this.log.debug(`Step {{ HandlerClassName }}: Failed Attempt ${attempt}.`);
-        await this.log.warning(exception.message);
+    public override async retrying(exception: Exception, attempt: number): Promise<RetryAction> {
+        await this.logger.debug(`Step {{ HandlerClassName }}: Failed Attempt ${attempt}.`);
+        await this.logger.warning(exception.message);
 
         return RetryAction.Default;
     }
 
-    /**
-     * Handler finish with success after all attempts
-     *
-     * @returns {Promise<void>}
-     */
-    public async success(): Promise<void> {
-        await this.log.debug("Step {{ HandlerClassName }} finish with success.");
+    public override async success(): Promise<void> {
+        await this.logger.debug("Step {{ HandlerClassName }} finish with success.");
     }
 
     /**
@@ -69,7 +47,7 @@ export class {{ HandlerClassName }} extends BaseHandler implements HandlerInterf
      * @returns {Promise<HandlerFunction>}
      */
     public async identifySuccess(): Promise<HandlerFunction> {
-        return this.page.waitForSelector(this.$$s.example.success, { timeout: await this.getTimeout() })
+        return this.page.waitForSelector(this.$$s.{{ HandlerPageSelectorBundle }}.success, { timeout: await this.getTimeout() })
             .then(() => this.successSolution.bind(this));
     }
 
@@ -81,17 +59,17 @@ export class {{ HandlerClassName }} extends BaseHandler implements HandlerInterf
      * @returns {Promise<HandlerFunction>}
      */
     public async identifyError(): Promise<HandlerFunction> {
-        return this.page.waitForSelector(this.$$s.example.example2, { timeout: await this.getTimeout() })
+        return this.page.waitForSelector(this.$$s.{{ HandlerPageSelectorBundle }}.example2, { timeout: await this.getTimeout() })
             .then(() => this.errorSolution.bind(this));
     }
 
     /**
      * Action if example handler
      *
-     * @returns {Promise<HandlerSolution>}
+     * @returns {Promise<HandlerSolutionType>}
      */
-    public async errorSolution(): Promise<HandlerSolution> {
-        return HandlerSolution.Resolve;
+    public async errorSolution(): Promise<HandlerSolutionType> {
+        return RetryAction.Resolve;
     }
 
 }

package/stubs/listener.stub

@@ -0,0 +1,26 @@
+import { ODGDecorators } from "@odg/chemical-x";
+import type { EventListenerInterface } from "@odg/events";
+import type { LoggerInterface } from "@odg/log";
+
+import type { EventBrowserParameters, EventTypes } from "#types/EventsInterface";
+import { ContainerName, EventName } from "@enums";
+import { {{ EventBinding:UCFirst }}Page } from "@pages";
+import { $inject } from "~/ContainerInject";
+
+@ODGDecorators.injectable(ContainerName.{{ ListenerName:UCFirst }}EventListener, "Singleton")
+@ODGDecorators.registerListener(EventName.{{ EventBinding:UCFirst }}Event, ContainerName.{{ ListenerName:UCFirst }}EventListener, {})
+export class {{ ListenerName:UCFirst }}EventListener implements EventListenerInterface<EventTypes, EventName.{{ EventBinding:UCFirst }}Event> {
+
+    public constructor(
+        @$inject(ContainerName.Logger) public readonly logger: LoggerInterface,
+        @$inject(ContainerName.{{ EventBinding:UCFirst }}Page) public readonly {{ EventBinding:LCFirst }}Page: {{ EventBinding:UCFirst }}Page,
+    ) {
+    }
+
+    public async handler({ page }: EventBrowserParameters): Promise<void> {
+        await this.logger.debug("{{ ListenerName:UCFirst }}EventListener is sended");
+
+        await this.{{ EventBinding:LCFirst }}Page.setPage(page).execute();
+    }
+
+}

package/stubs/page.stub

@@ -3,38 +3,20 @@ import { ODGDecorators, type PageInterface } from "@odg/chemical-x";
 import { ConfigName, ContainerName } from "@enums";
 import { BasePage } from "@pages/BasePage";
 import {
-    type {{ PageName:UCFirst }}SelectorType,
     {{ PageName:LCFirst }}Selector,
+    type {{ PageName:UCFirst }}SelectorType,
 } from "@selectors";
 
-/**
- * Generated page {{ PageName:UCFirst }}
- */
 @ODGDecorators.injectable(ContainerName.{{ PageName:UCFirst }}Page)
 @ODGDecorators.attemptableFlow()
 export class {{ PageName:UCFirst }}Page extends BasePage implements PageInterface {
 
-    /**
-     * Selector to {{ PageName:UCFirst }}Page
-     *
-     * @type {{{ PageName:UCFirst }}SelectorType}
-     */
-    public $s: {{ PageName:UCFirst }}SelectorType = {{ PageName:LCFirst }}Selector;
+    public readonly $s: {{ PageName:UCFirst }}SelectorType = {{ PageName:LCFirst }}Selector;
 
-    /**
-     * Execute this step
-     *
-     * @returns {Promise<void>}
-     */
     public async execute(): Promise<void> {
         // Create execution command step here and remove this comment
     }
 
-    /**
-     * Number of attempt this step
-     *
-     * @returns {Promise<number>}
-     */
     public async attempt(): Promise<number> {
         return this.config.get(ConfigName.PAGE_ATTEMPT);
     }

package/stubs/selector.stub

@@ -1,5 +1,7 @@
 export const {{ SelectorName:LCFirst }}Selector = {
+    success: "#success",
     example: "#example",
+    example2: "#example2",
 };
 
 export type {{ SelectorName:UCFirst }}SelectorType = typeof {{ SelectorName:LCFirst }}Selector;

package/stubs/event.stub

@@ -1,26 +0,0 @@
-import { ODGDecorators } from "@odg/chemical-x";
-import { type EventListenerInterface } from "@odg/events";
-import { LoggerInterface } from "@odg/log";
-import { inject } from "inversify";
-
-import { type EventBrowserParameters, type EventTypes } from "#types/EventsInterface";
-import { ContainerName, EventName } from "@enums";
-import { {{ EventName:UCFirst }}Page } from "@pages/{{ EventName:UCFirst }}Page";
-
-@ODGDecorators.injectable(ContainerName.{{ EventName:UCFirst }}EventListener, "Singleton")
-@ODGDecorators.registerListener(EventName.{{ EventName:UCFirst }}Event, ContainerName.{{ EventName:UCFirst }}EventListener, {})
-export class {{ EventName:UCFirst }}EventListener implements EventListenerInterface<EventTypes, EventName.{{ EventName:UCFirst }}Event> {
-
-    public constructor(
-        @inject(ContainerName.Logger) public readonly log: LoggerInterface,
-        @inject(ContainerName.{{ EventName:UCFirst }}Page) public readonly {{ EventName:LCFirst }}Page: {{ EventName:UCFirst }}Page,
-    ) {
-    }
-
-    public async handler({ page }: EventBrowserParameters): Promise<void> {
-        await this.log.debug("{{ EventName:UCFirst }}EventListener is sended");
-
-        await this.{{ EventName:LCFirst }}Page.setPage(page).execute();
-    }
-
-}