frame.simulator 1.0.1 → 1.0.3

package/batch.ts

@@ -0,0 +1,218 @@
+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 {
+  private filename: string;
+
+  constructor(filename: string) {
+    const batchFilePath = path.join(process.cwd(), filename);
+    this.filename = batchFilePath;
+
+    // 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(
+    command: string,
+    data?: TUserAction,
+  ): Promise<string> {
+    let status = 'blocked';
+    try {
+      const response = await fetch(`http://localhost:${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: string,
+    retries: number = 5,
+    delay: number = 1000,
+  ): Promise<void> {
+    const sleep = (ms: number) =>
+      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.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: 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,
+      x,
+      y,
+    });
+    // Small delay to ensure element is fully ready
+    await new Promise((resolve) => setTimeout(resolve, 300));
+  }
+}

package/command.ts

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

package/commandHandler.ts

@@ -1,6 +1,6 @@
 import { Command } from './command';
 import { Simulator } from './simulator';
-import { TUserAction, TClick, TClickOnCanvas, TScaleFrame } from './types';
+import { TUserAction, TClick, TClickOnCanvas, TInput } from './types';
 
 export function useCommandHandler() {
   const handleCommand = async (command: string, data: TUserAction) => {
@@ -8,11 +8,13 @@ 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.simulateInput(data as TInput);
+      case Command.SimulateCheck:
+        return simulator.simulateUserCheck(data as TClick);
       default:
         console.warn('Unknown command:', command);
         console.log(`SimulateUserAction command received with data:`, data);

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,17 +1,20 @@
 {
   "name": "frame.simulator",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "A simulator for testing form interactions in a controlled environment.",
   "main": "index.js",
   "license": "MIT",
   "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"
   },
   "devDependencies": {
+    "@types/cors": "^2.8.19",
+    "@types/express": "^5.0.6",
     "@types/node": "^25.3.0",
     "cors": "^2.8.5",
     "express": "^5.2.1",

package/simulator.ts

@@ -1,5 +1,5 @@
 import { green, red, reset } from 'frame.constants';
-import { TClick, TClickOnCanvas, TScaleFrame } from './types';
+import { TClick, TClickOnCanvas, TInput } from './types';
 
 export class Simulator {
   constructor() {
@@ -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) {
@@ -77,7 +77,8 @@ export class Simulator {
     }
   }
 
-  simulateUserInput(testId: string, value: string) {
+  simulateInput(data: TInput) {
+    const { testId, value } = data;
     const element = this.findHTMLElement(testId, HTMLDivElement, 'input');
 
     if (element) {
@@ -94,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' });
-  }
 }

package/types.ts

@@ -2,6 +2,11 @@ export type TClick = {
   testId: string;
 };
 
+export type TInput = {
+  testId: string;
+  value: string;
+};
+
 export type TClickOnCanvas = {
   x: number;
   y: number;
@@ -12,4 +17,4 @@ export type TScaleFrame = {
   height: number;
 };
 
-export type TUserAction = TClickOnCanvas | TScaleFrame | TClick;
+export type TUserAction = TClickOnCanvas | TScaleFrame | TClick | TInput;