frame.simulator 1.0.2 → 1.0.4

package/batch.ts

@@ -1,11 +1,137 @@
+import * as fs from 'fs';
+import * as path from 'path';
 import { Command } from './command';
 import { TUserAction } from './types';
 
-const PORT: number = parseInt(process.env.PORT || '3010', 10);
-
 export class Batch {
-  constructor() {
-    // Initialize any necessary properties here
+  private filename: string;
+  port: number;
+
+  constructor(filename: string, port: number = 3010) {
+    const batchFilePath = path.join(process.cwd(), filename);
+    this.filename = batchFilePath;
+    this.port = port;
+
+    // Check if batch.json exists
+    if (!fs.existsSync(batchFilePath)) {
+      console.error(
+        'Error: batch.json file not found in the current directory',
+      );
+      process.exit(1);
+    }
+  }
+
+  async run(
+    handleCommand: (batch: Batch, item: any, index: number) => Promise<void>,
+  ) {
+    try {
+      // Read the batch.json file
+      const fileContent = fs.readFileSync(this.filename, 'utf-8');
+
+      // Parse the JSON content
+      let batchData;
+      try {
+        batchData = JSON.parse(fileContent);
+      } catch (parseError) {
+        console.error('Error: Invalid JSON in batch.json file');
+        console.error(parseError);
+        process.exit(1);
+      }
+      console.log('Processing batch.json...');
+      console.log('='.repeat(50));
+
+      // Check if batchData is an array or object
+      if (Array.isArray(batchData)) {
+        // If it's an array of objects, process each object sequentially
+        for (let index = 0; index < batchData.length; index++) {
+          // console.log(`Processing item ${index + 1}/${batchData.length}...`);
+          const item = batchData[index];
+          if (typeof item === 'object' && item !== null) {
+            // Print all keys in the object
+            await handleCommand(this, item, index + 1);
+          } else {
+            console.log(`  Not an object: ${item}`);
+          }
+          console.log('');
+        }
+      } else if (typeof batchData === 'object' && batchData !== null) {
+        // If it's a single object, print its keys
+        console.log('Root object keys:');
+        const keys = Object.keys(batchData);
+        keys.forEach((key) => {
+          console.log(`  Key: ${key}`);
+        });
+
+        // If any values are also objects, print their keys too
+        keys.forEach((key) => {
+          const value = batchData[key];
+          if (
+            typeof value === 'object' &&
+            value !== null &&
+            !Array.isArray(value)
+          ) {
+            console.log(`\nKeys in "${key}" object:`);
+            Object.keys(value).forEach((subKey) => {
+              console.log(`  Key: ${subKey}`);
+            });
+          }
+        });
+      } else {
+        console.log(
+          'Error: batch.json should contain an object or array of objects',
+        );
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error('Error processing batch.json:');
+      console.error(error);
+      process.exit(1);
+    }
+  }
+
+  async handleDrawFrame(item: any, index: number) {
+    const coordinates = item.payload.coordinates;
+    console.log(`  Command[${index}]: MainDrawFrame`);
+    await this.selectButtonSafe('FDOptions.button.draw-frame');
+
+    const coords: { x: number; y: number }[] = coordinates.points;
+    for (const point of coords) {
+      console.log(`      Drawing point: (${point.x}, ${point.y})`);
+      // Small delay between points to simulate drawing
+      // await new Promise(resolve => setTimeout(resolve, 500));
+      await this.sampleClickCanvasDrawAt('canvas.draw', point.x, point.y); // Example click to trigger drawing (replace with actual coordinates if needed)
+    }
+    await this.selectButtonSafe('Finish.button.start-transformation'); // Example button click after drawing (replace with actual testId if needed)
+  }
+
+  async handleScaleFrame(item: any, index: number) {
+    const length = item.payload.length;
+    const height = item.payload.height;
+    console.log(`  Command[${index}]: MainScaleFrame`);
+    console.log(
+      `      Simulating scale frame with length: ${length}, height: ${height}`,
+    );
+    await this.selectInput('ScaleInput.input.length', length.toString());
+    await this.selectInput('ScaleInput.input.height', height.toString());
+    await this.selectButtonSafe('ShowOptions.cbx.scaledBox');
+    await this.selectButtonSafe('ScaleForm.button.apply');
+    await this.selectButtonSafe('ShowOptions.cbx.points');
+  }
+
+  async handleDefineTrademark(item: any, index: number) {
+    const name = item.payload.name;
+    console.log(`  Command[${index}]: MainDefineTrademark`);
+    console.log(`      Simulating trademark definition with name: ${name}`);
+    await this.selectInput('TrademarkInput.input.name', name);
+    await this.selectButtonSafe('TrademarkForm.button.apply');
+  }
+
+  async selectButtonSafe(testId: string): Promise<void> {
+    // Small delay to ensure element is fully ready
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    // Now click the button
+    await this.selectButton(testId);
   }
 
   private async sendRequest(
@@ -14,16 +140,19 @@ export class Batch {
   ): Promise<string> {
     let status = 'blocked';
     try {
-      const response = await fetch(`http://localhost:${PORT}/send-command`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
+      const response = await fetch(
+        `http://localhost:${this.port}/send-command`,
+        {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({
+            command,
+            data,
+          }),
         },
-        body: JSON.stringify({
-          command,
-          data,
-        }),
-      });
+      );
       // console.log(`response: ${JSON.stringify(response, null)}`);
       // console.log(`response.status: ${response.status}`);
       if (response.status === 200) {
@@ -69,10 +198,20 @@ export class Batch {
     }
   }
 
-  async sampleClickCanvasDrawAt(x: number, y: number) {
+  async selectInput(testId: string, value: string): Promise<void> {
+    const status = await this.sendRequest(Command.SimulateInput, {
+      testId,
+      value,
+    });
+    if (status !== 'ok') {
+      console.log('Failed to send input simulation command');
+    }
+  }
+
+  async sampleClickCanvasDrawAt(testId: string, x: number, y: number) {
     console.log(`sampleClickCanvasDrawAt(${x}, ${y})`);
     await this.sendRequest(Command.SimulateClickOnCanvas, {
-      testId: 'canvas.draw',
+      testId,
       x,
       y,
     });

package/command.ts

@@ -2,5 +2,5 @@ export enum Command {
   SimulateClick = 'SimulateClick',
   SimulateClickOnCanvas = 'SimulateClickOnCanvas',
   SimulateInput = 'SimulateInput',
-  SimulateCheck = 'SimulateUserCheck',
+  SimulateCheck = 'SimulateCheck',
 }

package/commandHandler.ts

@@ -8,20 +8,18 @@ export function useCommandHandler() {
 
     switch (command) {
       case Command.SimulateClick:
-        return simulator.simulateUserClick(data as TClick);
+        return simulator.simulateClick(data as TClick);
       case Command.SimulateClickOnCanvas:
         return simulator.simulateClickOnCanvas(data as TClickOnCanvas);
-      // case Command.MainScaleFrame:
-      //   return simulator.simulateScaleFrame(data as TScaleFrame);
       case Command.SimulateInput:
-        return simulator.simulateUserInput(data as TInput);
+        return simulator.simulateInput(data as TInput);
       case Command.SimulateCheck:
-        return simulator.simulateUserCheck(data as TClick);
+        return simulator.simulateCheck(data as TClick);
       default:
         console.warn('Unknown command:', command);
-        console.log(`SimulateUserAction command received with data:`, data);
+        console.log(`useCommandHandler: command received with data:`, data);
         throw new Error(
-          'SimulateUserAction command should be handled by simulateUserAction function directly',
+          'command should be handled by useCommandHandler function',
         );
     }
   };

package/dist/batch.d.ts

@@ -0,0 +1,14 @@
+export declare class Batch {
+    private filename;
+    port: number;
+    constructor(filename: string, port?: number);
+    run(handleCommand: (batch: Batch, item: any, index: number) => Promise<void>): Promise<void>;
+    handleDrawFrame(item: any, index: number): Promise<void>;
+    handleScaleFrame(item: any, index: number): Promise<void>;
+    handleDefineTrademark(item: any, index: number): Promise<void>;
+    selectButtonSafe(testId: string): Promise<void>;
+    private sendRequest;
+    selectButton(testId: string, retries?: number, delay?: number): Promise<void>;
+    selectInput(testId: string, value: string): Promise<void>;
+    sampleClickCanvasDrawAt(testId: string, x: number, y: number): Promise<void>;
+}

package/dist/batch.js

@@ -0,0 +1,209 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Batch = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const command_1 = require("./command");
+class Batch {
+    constructor(filename, port = 3010) {
+        const batchFilePath = path.join(process.cwd(), filename);
+        this.filename = batchFilePath;
+        this.port = port;
+        // Check if batch.json exists
+        if (!fs.existsSync(batchFilePath)) {
+            console.error('Error: batch.json file not found in the current directory');
+            process.exit(1);
+        }
+    }
+    async run(handleCommand) {
+        try {
+            // Read the batch.json file
+            const fileContent = fs.readFileSync(this.filename, 'utf-8');
+            // Parse the JSON content
+            let batchData;
+            try {
+                batchData = JSON.parse(fileContent);
+            }
+            catch (parseError) {
+                console.error('Error: Invalid JSON in batch.json file');
+                console.error(parseError);
+                process.exit(1);
+            }
+            console.log('Processing batch.json...');
+            console.log('='.repeat(50));
+            // Check if batchData is an array or object
+            if (Array.isArray(batchData)) {
+                // If it's an array of objects, process each object sequentially
+                for (let index = 0; index < batchData.length; index++) {
+                    // console.log(`Processing item ${index + 1}/${batchData.length}...`);
+                    const item = batchData[index];
+                    if (typeof item === 'object' && item !== null) {
+                        // Print all keys in the object
+                        await handleCommand(this, item, index + 1);
+                    }
+                    else {
+                        console.log(`  Not an object: ${item}`);
+                    }
+                    console.log('');
+                }
+            }
+            else if (typeof batchData === 'object' && batchData !== null) {
+                // If it's a single object, print its keys
+                console.log('Root object keys:');
+                const keys = Object.keys(batchData);
+                keys.forEach((key) => {
+                    console.log(`  Key: ${key}`);
+                });
+                // If any values are also objects, print their keys too
+                keys.forEach((key) => {
+                    const value = batchData[key];
+                    if (typeof value === 'object' &&
+                        value !== null &&
+                        !Array.isArray(value)) {
+                        console.log(`\nKeys in "${key}" object:`);
+                        Object.keys(value).forEach((subKey) => {
+                            console.log(`  Key: ${subKey}`);
+                        });
+                    }
+                });
+            }
+            else {
+                console.log('Error: batch.json should contain an object or array of objects');
+                process.exit(1);
+            }
+        }
+        catch (error) {
+            console.error('Error processing batch.json:');
+            console.error(error);
+            process.exit(1);
+        }
+    }
+    async handleDrawFrame(item, index) {
+        const coordinates = item.payload.coordinates;
+        console.log(`  Command[${index}]: MainDrawFrame`);
+        await this.selectButtonSafe('FDOptions.button.draw-frame');
+        const coords = coordinates.points;
+        for (const point of coords) {
+            console.log(`      Drawing point: (${point.x}, ${point.y})`);
+            // Small delay between points to simulate drawing
+            // await new Promise(resolve => setTimeout(resolve, 500));
+            await this.sampleClickCanvasDrawAt('canvas.draw', point.x, point.y); // Example click to trigger drawing (replace with actual coordinates if needed)
+        }
+        await this.selectButtonSafe('Finish.button.start-transformation'); // Example button click after drawing (replace with actual testId if needed)
+    }
+    async handleScaleFrame(item, index) {
+        const length = item.payload.length;
+        const height = item.payload.height;
+        console.log(`  Command[${index}]: MainScaleFrame`);
+        console.log(`      Simulating scale frame with length: ${length}, height: ${height}`);
+        await this.selectInput('ScaleInput.input.length', length.toString());
+        await this.selectInput('ScaleInput.input.height', height.toString());
+        await this.selectButtonSafe('ShowOptions.cbx.scaledBox');
+        await this.selectButtonSafe('ScaleForm.button.apply');
+        await this.selectButtonSafe('ShowOptions.cbx.points');
+    }
+    async handleDefineTrademark(item, index) {
+        const name = item.payload.name;
+        console.log(`  Command[${index}]: MainDefineTrademark`);
+        console.log(`      Simulating trademark definition with name: ${name}`);
+        await this.selectInput('TrademarkInput.input.name', name);
+        await this.selectButtonSafe('TrademarkForm.button.apply');
+    }
+    async selectButtonSafe(testId) {
+        // Small delay to ensure element is fully ready
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        // Now click the button
+        await this.selectButton(testId);
+    }
+    async sendRequest(command, data) {
+        let status = 'blocked';
+        try {
+            const response = await fetch(`http://localhost:${this.port}/send-command`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    command,
+                    data,
+                }),
+            });
+            // console.log(`response: ${JSON.stringify(response, null)}`);
+            // console.log(`response.status: ${response.status}`);
+            if (response.status === 200) {
+                status = 'ok';
+            }
+            return status;
+        }
+        catch (error) {
+            console.log(`error.status: ${status}`);
+            console.error('Error:', error);
+        }
+        console.log(`return status: ${status}`);
+        return status;
+    }
+    async selectButton(testId, retries = 5, delay = 1000) {
+        const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+        for (let attempt = 1; attempt <= retries; attempt++) {
+            try {
+                if (attempt >= 1) {
+                    console.log(`Attempt ${attempt}/${retries} to click button: ${testId}`);
+                }
+                const status = await this.sendRequest(command_1.Command.SimulateClick, {
+                    testId,
+                });
+                if (status !== 'ok') {
+                    console.log('Failed to send button simulation command');
+                }
+                await sleep(delay);
+                return; // Success, exit the retry loop
+            }
+            catch (error) {
+                console.error('Error in main:', error);
+            }
+        }
+    }
+    async selectInput(testId, value) {
+        const status = await this.sendRequest(command_1.Command.SimulateInput, {
+            testId,
+            value,
+        });
+        if (status !== 'ok') {
+            console.log('Failed to send input simulation command');
+        }
+    }
+    async sampleClickCanvasDrawAt(testId, x, y) {
+        console.log(`sampleClickCanvasDrawAt(${x}, ${y})`);
+        await this.sendRequest(command_1.Command.SimulateClickOnCanvas, {
+            testId,
+            x,
+            y,
+        });
+        // Small delay to ensure element is fully ready
+        await new Promise((resolve) => setTimeout(resolve, 300));
+    }
+}
+exports.Batch = Batch;

package/dist/command-server.d.ts

@@ -0,0 +1,3 @@
+import express from 'express';
+declare const app: express.Application;
+export default app;

package/dist/command.d.ts

@@ -0,0 +1,6 @@
+export declare enum Command {
+    SimulateClick = "SimulateClick",
+    SimulateClickOnCanvas = "SimulateClickOnCanvas",
+    SimulateInput = "SimulateInput",
+    SimulateCheck = "SimulateCheck"
+}

package/dist/command.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Command = void 0;
+var Command;
+(function (Command) {
+    Command["SimulateClick"] = "SimulateClick";
+    Command["SimulateClickOnCanvas"] = "SimulateClickOnCanvas";
+    Command["SimulateInput"] = "SimulateInput";
+    Command["SimulateCheck"] = "SimulateCheck";
+})(Command || (exports.Command = Command = {}));

package/dist/commandHandler.d.ts

@@ -0,0 +1,6 @@
+import { TUserAction } from './types';
+export declare function useCommandHandler(): {
+    handleCommand: (command: string, data: TUserAction) => Promise<void | {
+        status: string;
+    }>;
+};

package/dist/commandHandler.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useCommandHandler = useCommandHandler;
+const command_1 = require("./command");
+const simulator_1 = require("./simulator");
+function useCommandHandler() {
+    const handleCommand = async (command, data) => {
+        const simulator = new simulator_1.Simulator();
+        switch (command) {
+            case command_1.Command.SimulateClick:
+                return simulator.simulateClick(data);
+            case command_1.Command.SimulateClickOnCanvas:
+                return simulator.simulateClickOnCanvas(data);
+            case command_1.Command.SimulateInput:
+                return simulator.simulateInput(data);
+            case command_1.Command.SimulateCheck:
+                return simulator.simulateCheck(data);
+            default:
+                console.warn('Unknown command:', command);
+                console.log(`useCommandHandler: command received with data:`, data);
+                throw new Error('command should be handled by useCommandHandler function');
+        }
+    };
+    return { handleCommand };
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { Simulator } from './simulator';
+export { TClick, TClickOnCanvas, TScaleFrame, TUserAction } from './types';
+export { Command } from './command';
+export { useCommandHandler } from './commandHandler';
+export { Batch } from './batch';

package/dist/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Batch = exports.useCommandHandler = exports.Command = exports.Simulator = void 0;
+var simulator_1 = require("./simulator");
+Object.defineProperty(exports, "Simulator", { enumerable: true, get: function () { return simulator_1.Simulator; } });
+var command_1 = require("./command");
+Object.defineProperty(exports, "Command", { enumerable: true, get: function () { return command_1.Command; } });
+var commandHandler_1 = require("./commandHandler");
+Object.defineProperty(exports, "useCommandHandler", { enumerable: true, get: function () { return commandHandler_1.useCommandHandler; } });
+var batch_1 = require("./batch");
+Object.defineProperty(exports, "Batch", { enumerable: true, get: function () { return batch_1.Batch; } });

package/dist/main.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/main.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const batch_1 = require("./batch");
+async function handleDrawFrame(batch, item, index) {
+    const coordinates = item.payload.coordinates;
+    console.log(`  Command[${index}]: MainDrawFrame`);
+    await batch.selectButtonSafe('FDOptions.button.draw-frame');
+    const coords = coordinates.points;
+    for (const point of coords) {
+        console.log(`      Drawing point: (${point.x}, ${point.y})`);
+        // Small delay between points to simulate drawing
+        // await new Promise(resolve => setTimeout(resolve, 500));
+        await batch.sampleClickCanvasDrawAt('canvas.draw', point.x, point.y); // Example click to trigger drawing (replace with actual coordinates if needed)
+    }
+    await batch.selectButtonSafe('Finish.button.start-transformation'); // Example button click after drawing (replace with actual testId if needed)
+}
+async function handleScaleFrame(batch, item, index) {
+    const length = item.payload.length;
+    const height = item.payload.height;
+    console.log(`  Command[${index}]: MainScaleFrame`);
+    console.log(`      Simulating scale frame with length: ${length}, height: ${height}`);
+    await batch.selectInput('ScaleInput.input.length', length.toString());
+    await batch.selectInput('ScaleInput.input.height', height.toString());
+    await batch.selectButtonSafe('ShowOptions.cbx.scaledBox');
+    await batch.selectButtonSafe('ScaleForm.button.apply');
+    await batch.selectButtonSafe('ShowOptions.cbx.points');
+}
+async function handleDefineTrademark(batch, item, index) {
+    const name = item.payload.name;
+    console.log(`  Command[${index}]: MainDefineTrademark`);
+    console.log(`      Simulating trademark definition with name: ${name}`);
+    await batch.selectInput('TrademarkInput.input.name', name);
+    await batch.selectButtonSafe('TrademarkForm.button.apply');
+}
+async function handleCommand(batch, item, index) {
+    // console.log(JSON.stringify(item, null, 2));
+    if (item.command) {
+        switch (item.command) {
+            case 'main-draw-frame':
+                await handleDrawFrame(batch, item, index);
+                break;
+            case 'main-scale-frame':
+                await handleScaleFrame(batch, item, index);
+                break;
+            case 'main-define-trademark':
+                await handleDefineTrademark(batch, item, index);
+                break;
+            default:
+                throw new Error(`Unknown command: ${item.command}`);
+        }
+    }
+    else {
+        console.log('No command found in this item.');
+    }
+}
+async function main(batchFile) {
+    try {
+        const batch = new batch_1.Batch(batchFile);
+        await batch.run(handleCommand);
+    }
+    catch (error) {
+        console.error('Error in main:', error);
+    }
+}
+// Accept batch file path as command-line argument
+const batchFileArg = process.argv[2] || 'batch.json';
+console.log(`Starting batch processing with file: ${batchFileArg}`);
+main(batchFileArg);

package/dist/simulator.d.ts

@@ -0,0 +1,11 @@
+import { TClick, TClickOnCanvas, TInput } from './types';
+export declare class Simulator {
+    constructor();
+    findHTMLElement(testId: string, elementType: typeof HTMLElement, type?: string): HTMLElement | null;
+    simulateClickOnCanvas(data: TClickOnCanvas): void;
+    simulateClick(data: TClick): void;
+    simulateCheck(data: TClick): void;
+    simulateInput(data: TInput): {
+        status: string;
+    } | undefined;
+}

package/dist/simulator.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Simulator = void 0;
+const frame_constants_1 = require("frame.constants");
+class Simulator {
+    constructor() {
+        console.log('Simulator initialized');
+    }
+    findHTMLElement(testId, elementType, type) {
+        if (type) {
+            console.log(`${frame_constants_1.green}Simulating ${type} on element with testId: ${testId}${frame_constants_1.reset}`);
+        }
+        const element = document.querySelector(`[data-testid="${testId}"]`);
+        if (element) {
+            if (element instanceof elementType) {
+            }
+            else {
+                console.error(`Element found but not a ${elementType.name} for ${type} simulation: ${testId}`);
+            }
+        }
+        else {
+            console.error(`Element not found for ${type} simulation: ${testId}`);
+        }
+        return element;
+    }
+    simulateClickOnCanvas(data) {
+        const { x, y } = data;
+        const canvas = this.findHTMLElement('canvas.draw', HTMLCanvasElement, 'click');
+        if (canvas) {
+            const rect = canvas.getBoundingClientRect();
+            const event = new MouseEvent('click', {
+                clientX: rect.left + rect.width / 2 + x, // Convert canvas-relative to screen coordinates
+                clientY: rect.top + rect.height / 2 - y, // Convert canvas-relative to screen coordinates (flip Y)
+                bubbles: true,
+            });
+            // Set batch properties
+            // @ts-ignore - Add custom properties for batch identification
+            event.isBatch = true;
+            // @ts-ignore - Store original canvas-relative coordinates
+            event.batchX = x;
+            // @ts-ignore - Store original canvas-relative coordinates
+            event.batchY = y;
+            canvas.dispatchEvent(event);
+        }
+    }
+    simulateClick(data) {
+        const { testId } = data;
+        const element = this.findHTMLElement(testId, HTMLButtonElement, 'click');
+        if (element) {
+            const event = new MouseEvent('click', { bubbles: true });
+            // @ts-ignore - Add custom property to identify this as a batch click
+            event.isBatch = true;
+            element.click();
+        }
+    }
+    simulateCheck(data) {
+        const { testId } = data;
+        const element = this.findHTMLElement(testId, HTMLInputElement, 'check');
+        if (element) {
+            const event = new MouseEvent('click', { bubbles: true });
+            // @ts-ignore - Add custom property to identify this as a batch click
+            event.isBatch = true;
+            element.dispatchEvent(event);
+        }
+    }
+    simulateInput(data) {
+        const { testId, value } = data;
+        const element = this.findHTMLElement(testId, HTMLDivElement, 'input');
+        if (element) {
+            if (element instanceof HTMLInputElement) {
+                element.value = value.toString();
+                element.dispatchEvent(new Event('input', { bubbles: true }));
+                return { status: 'ok' };
+            }
+            else if (element instanceof HTMLDivElement) {
+                const childElement = element.firstChild;
+                if (childElement instanceof HTMLInputElement) {
+                    childElement.value = value || '';
+                    childElement.dispatchEvent(new Event('input', { bubbles: true }));
+                }
+            }
+        }
+    }
+}
+exports.Simulator = Simulator;

package/dist/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../batch.ts","../command-server.ts","../command.ts","../commandhandler.ts","../index.ts","../main.ts","../simulator.ts","../types.ts"],"version":"5.6.3"}

package/dist/types.d.ts

@@ -0,0 +1,16 @@
+export type TClick = {
+    testId: string;
+};
+export type TInput = {
+    testId: string;
+    value: string;
+};
+export type TClickOnCanvas = {
+    x: number;
+    y: number;
+};
+export type TScaleFrame = {
+    length: number;
+    height: number;
+};
+export type TUserAction = TClickOnCanvas | TScaleFrame | TClick | TInput;

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/draw.json

@@ -0,0 +1,25 @@
+[
+  {
+    "command": "main-draw-frame",
+    "payload": {
+      "coordinates": {
+        "points": [
+          { "x": 200, "y": 100 },
+          { "x": -100, "y": 100 },
+          { "x": -60, "y": 0 },
+          { "x": -100, "y": -100 },
+          { "x": 200, "y": -100 }
+        ],
+        "universeCenter": { "x": 300, "y": 200 }
+      }
+    }
+  },
+  {
+    "command": "main-scale-frame",
+    "payload": { "length": 500, "height": 250 }
+  },
+  {
+    "command": "main-define-trademark",
+    "payload": { "x": -95, "y": 62 }
+  }
+]

package/index.ts

@@ -2,3 +2,4 @@ export { Simulator } from './simulator';
 export { TClick, TClickOnCanvas, TScaleFrame, TUserAction } from './types';
 export { Command } from './command';
 export { useCommandHandler } from './commandHandler';
+export { Batch } from './batch';

package/main.ts

@@ -0,0 +1,73 @@
+import { Batch } from './batch';
+
+async function handleDrawFrame(batch: Batch, item: any, index: number) {
+  const coordinates = item.payload.coordinates;
+  console.log(`  Command[${index}]: MainDrawFrame`);
+  await batch.selectButtonSafe('FDOptions.button.draw-frame');
+
+  const coords: { x: number; y: number }[] = coordinates.points;
+  for (const point of coords) {
+    console.log(`      Drawing point: (${point.x}, ${point.y})`);
+    // Small delay between points to simulate drawing
+    // await new Promise(resolve => setTimeout(resolve, 500));
+    await batch.sampleClickCanvasDrawAt('canvas.draw', point.x, point.y); // Example click to trigger drawing (replace with actual coordinates if needed)
+  }
+  await batch.selectButtonSafe('Finish.button.start-transformation'); // Example button click after drawing (replace with actual testId if needed)
+}
+
+async function handleScaleFrame(batch: Batch, item: any, index: number) {
+  const length = item.payload.length;
+  const height = item.payload.height;
+  console.log(`  Command[${index}]: MainScaleFrame`);
+  console.log(
+    `      Simulating scale frame with length: ${length}, height: ${height}`,
+  );
+  await batch.selectInput('ScaleInput.input.length', length.toString());
+  await batch.selectInput('ScaleInput.input.height', height.toString());
+  await batch.selectButtonSafe('ShowOptions.cbx.scaledBox');
+  await batch.selectButtonSafe('ScaleForm.button.apply');
+  await batch.selectButtonSafe('ShowOptions.cbx.points');
+}
+
+async function handleDefineTrademark(batch: Batch, item: any, index: number) {
+  const name = item.payload.name;
+  console.log(`  Command[${index}]: MainDefineTrademark`);
+  console.log(`      Simulating trademark definition with name: ${name}`);
+  await batch.selectInput('TrademarkInput.input.name', name);
+  await batch.selectButtonSafe('TrademarkForm.button.apply');
+}
+
+async function handleCommand(batch: Batch, item: any, index: number) {
+  // console.log(JSON.stringify(item, null, 2));
+  if (item.command) {
+    switch (item.command) {
+      case 'main-draw-frame':
+        await handleDrawFrame(batch, item, index);
+        break;
+      case 'main-scale-frame':
+        await handleScaleFrame(batch, item, index);
+        break;
+      case 'main-define-trademark':
+        await handleDefineTrademark(batch, item, index);
+        break;
+      default:
+        throw new Error(`Unknown command: ${item.command}`);
+    }
+  } else {
+    console.log('No command found in this item.');
+  }
+}
+
+async function main(batchFile: string) {
+  try {
+    const batch = new Batch(batchFile);
+    await batch.run(handleCommand);
+  } catch (error) {
+    console.error('Error in main:', error);
+  }
+}
+
+// Accept batch file path as command-line argument
+const batchFileArg = process.argv[2] || 'batch.json';
+console.log(`Starting batch processing with file: ${batchFileArg}`);
+main(batchFileArg);

package/package.json

@@ -1,12 +1,21 @@
 {
   "name": "frame.simulator",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "A simulator for testing form interactions in a controlled environment.",
-  "main": "index.js",
   "license": "MIT",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.d.ts"
+    }
+  },
   "scripts": {
     "build": "tsc -b",
-    "command-server": "tsx command-server.ts"
+    "command-server": "tsx command-server.ts",
+    "draw": "tsx main.ts draw.json"
   },
   "peerDependencies": {
     "frame.constants": "^1.0.5"

package/simulator.ts

@@ -55,7 +55,7 @@ export class Simulator {
     }
   }
 
-  simulateUserClick(data: TClick) {
+  simulateClick(data: TClick) {
     const { testId } = data;
     const element = this.findHTMLElement(testId, HTMLButtonElement, 'click');
     if (element) {
@@ -66,7 +66,7 @@ export class Simulator {
     }
   }
 
-  simulateUserCheck(data: TClick) {
+  simulateCheck(data: TClick) {
     const { testId } = data;
     const element = this.findHTMLElement(testId, HTMLInputElement, 'check');
     if (element) {
@@ -77,7 +77,7 @@ export class Simulator {
     }
   }
 
-  simulateUserInput(data: TInput) {
+  simulateInput(data: TInput) {
     const { testId, value } = data;
     const element = this.findHTMLElement(testId, HTMLDivElement, 'input');
 
@@ -95,16 +95,4 @@ export class Simulator {
       }
     }
   }
-
-  // simulateScaleFrame(scaleValues: TScaleFrame) {
-  //   const { length, height } = scaleValues;
-  //   console.log(
-  //     `${red}Simulating scale frame with length: ${length}, height: ${height}${reset}`,
-  //   );
-  //   this.simulateUserInput('ScaleInput.input.length', length.toString());
-  //   this.simulateUserInput('ScaleInput.input.height', height.toString());
-  //   this.simulateUserCheck({ testId: 'ShowOptions.cbx.scaledBox' });
-  //   this.simulateUserClick({ testId: 'ScaleForm.button.apply' });
-  //   this.simulateUserCheck({ testId: 'ShowOptions.cbx.points' });
-  // }
 }