frame.simulator 1.0.2 → 1.0.3

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;
+
+  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(
@@ -69,10 +195,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/commandHandler.ts

@@ -8,13 +8,11 @@ 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);
       default:

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,13 @@
 {
   "name": "frame.simulator",
-  "version": "1.0.2",
+  "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"

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) {
@@ -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' });
-  // }
 }