frame.simulator 1.0.3 → 1.0.5

package/batch.ts

@@ -3,14 +3,14 @@ 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;
+  port: number;
 
-  constructor(filename: string) {
+  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)) {
@@ -140,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) {

package/command.ts

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

package/commandHandler.ts

@@ -14,12 +14,12 @@ export function useCommandHandler() {
       case Command.SimulateInput:
         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,182 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { Command } from './command';
+export 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.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.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.SimulateClickOnCanvas, {
+            testId,
+            x,
+            y,
+        });
+        // Small delay to ensure element is fully ready
+        await new Promise((resolve) => setTimeout(resolve, 300));
+    }
+}

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,7 @@
+export var Command;
+(function (Command) {
+    Command["SimulateClick"] = "SimulateClick";
+    Command["SimulateClickOnCanvas"] = "SimulateClickOnCanvas";
+    Command["SimulateInput"] = "SimulateInput";
+    Command["SimulateCheck"] = "SimulateCheck";
+})(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,22 @@
+import { Command } from './command';
+import { Simulator } from './simulator';
+export function useCommandHandler() {
+    const handleCommand = async (command, data) => {
+        const simulator = new Simulator();
+        switch (command) {
+            case Command.SimulateClick:
+                return simulator.simulateClick(data);
+            case Command.SimulateClickOnCanvas:
+                return simulator.simulateClickOnCanvas(data);
+            case Command.SimulateInput:
+                return simulator.simulateInput(data);
+            case 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/frame-simulator.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const c=require("frame.constants");class o{constructor(){console.log("Simulator initialized")}findHTMLElement(n,i,t){t&&console.log(`${c.green}Simulating ${t} on element with testId: ${n}${c.reset}`);const e=document.querySelector(`[data-testid="${n}"]`);return e?e instanceof i||console.error(`Element found but not a ${i.name} for ${t} simulation: ${n}`):console.error(`Element not found for ${t} simulation: ${n}`),e}simulateClickOnCanvas(n){const{x:i,y:t}=n,e=this.findHTMLElement("canvas.draw",HTMLCanvasElement,"click");if(e){const s=e.getBoundingClientRect(),l=new MouseEvent("click",{clientX:s.left+s.width/2+i,clientY:s.top+s.height/2-t,bubbles:!0});l.isBatch=!0,l.batchX=i,l.batchY=t,e.dispatchEvent(l)}}simulateClick(n){const{testId:i}=n,t=this.findHTMLElement(i,HTMLButtonElement,"click");if(t){const e=new MouseEvent("click",{bubbles:!0});e.isBatch=!0,t.click()}}simulateCheck(n){const{testId:i}=n,t=this.findHTMLElement(i,HTMLInputElement,"check");if(t){const e=new MouseEvent("click",{bubbles:!0});e.isBatch=!0,t.dispatchEvent(e)}}simulateInput(n){const{testId:i,value:t}=n,e=this.findHTMLElement(i,HTMLDivElement,"input");if(e){if(e instanceof HTMLInputElement)return e.value=t.toString(),e.dispatchEvent(new Event("input",{bubbles:!0})),{status:"ok"};if(e instanceof HTMLDivElement){const s=e.firstChild;s instanceof HTMLInputElement&&(s.value=t||"",s.dispatchEvent(new Event("input",{bubbles:!0})))}}}}exports.Simulator=o;

package/dist/frame-simulator.js

@@ -0,0 +1,60 @@
+import { green as c, reset as o } from "frame.constants";
+class r {
+  constructor() {
+    console.log("Simulator initialized");
+  }
+  findHTMLElement(n, i, t) {
+    t && console.log(
+      `${c}Simulating ${t} on element with testId: ${n}${o}`
+    );
+    const e = document.querySelector(`[data-testid="${n}"]`);
+    return e ? e instanceof i || console.error(
+      `Element found but not a ${i.name} for ${t} simulation: ${n}`
+    ) : console.error(`Element not found for ${t} simulation: ${n}`), e;
+  }
+  simulateClickOnCanvas(n) {
+    const { x: i, y: t } = n, e = this.findHTMLElement(
+      "canvas.draw",
+      HTMLCanvasElement,
+      "click"
+    );
+    if (e) {
+      const s = e.getBoundingClientRect(), l = new MouseEvent("click", {
+        clientX: s.left + s.width / 2 + i,
+        // Convert canvas-relative to screen coordinates
+        clientY: s.top + s.height / 2 - t,
+        // Convert canvas-relative to screen coordinates (flip Y)
+        bubbles: !0
+      });
+      l.isBatch = !0, l.batchX = i, l.batchY = t, e.dispatchEvent(l);
+    }
+  }
+  simulateClick(n) {
+    const { testId: i } = n, t = this.findHTMLElement(i, HTMLButtonElement, "click");
+    if (t) {
+      const e = new MouseEvent("click", { bubbles: !0 });
+      e.isBatch = !0, t.click();
+    }
+  }
+  simulateCheck(n) {
+    const { testId: i } = n, t = this.findHTMLElement(i, HTMLInputElement, "check");
+    if (t) {
+      const e = new MouseEvent("click", { bubbles: !0 });
+      e.isBatch = !0, t.dispatchEvent(e);
+    }
+  }
+  simulateInput(n) {
+    const { testId: i, value: t } = n, e = this.findHTMLElement(i, HTMLDivElement, "input");
+    if (e) {
+      if (e instanceof HTMLInputElement)
+        return e.value = t.toString(), e.dispatchEvent(new Event("input", { bubbles: !0 })), { status: "ok" };
+      if (e instanceof HTMLDivElement) {
+        const s = e.firstChild;
+        s instanceof HTMLInputElement && (s.value = t || "", s.dispatchEvent(new Event("input", { bubbles: !0 })));
+      }
+    }
+  }
+}
+export {
+  r as Simulator
+};

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,4 @@
+export { Simulator } from './simulator';
+export { Command } from './command';
+export { useCommandHandler } from './commandHandler';
+export { Batch } from './batch';

package/dist/main.d.ts

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

package/dist/main.js

@@ -0,0 +1,66 @@
+import { Batch } from './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(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,81 @@
+import { green, reset } from 'frame.constants';
+export class Simulator {
+    constructor() {
+        console.log('Simulator initialized');
+    }
+    findHTMLElement(testId, elementType, type) {
+        if (type) {
+            console.log(`${green}Simulating ${type} on element with testId: ${testId}${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 }));
+                }
+            }
+        }
+    }
+}

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","../vite.config.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 @@
+export {};

package/dist/vite.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vite").UserConfig;
+export default _default;

package/dist/vite.config.js

@@ -0,0 +1,21 @@
+import { defineConfig } from 'vite';
+import tsconfigPaths from 'vite-tsconfig-paths';
+export default defineConfig({
+    plugins: [tsconfigPaths()],
+    build: {
+        lib: {
+            entry: './simulator.ts',
+            name: 'FrameSimulator',
+            fileName: 'frame-simulator',
+            formats: ['es', 'cjs'],
+        },
+        rollupOptions: {
+            external: ['frame.constants'],
+            output: {
+                globals: {
+                    'frame.constants': 'frameConstants',
+                },
+            },
+        },
+    },
+});

package/package.json

@@ -1,9 +1,17 @@
 {
   "name": "frame.simulator",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "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",
@@ -19,6 +27,8 @@
     "cors": "^2.8.5",
     "express": "^5.2.1",
     "frame.constants": "^1.0.5",
-    "tsx": "^4.21.0"
+    "tsx": "^4.21.0",
+    "vite": "^7.3.1",
+    "vite-tsconfig-paths": "^6.1.1"
   }
 }

package/simulator.ts

@@ -1,4 +1,4 @@
-import { green, red, reset } from 'frame.constants';
+import { green, reset } from 'frame.constants';
 import { TClick, TClickOnCanvas, TInput } from './types';
 
 export class Simulator {
@@ -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) {

package/tsconfig.json

@@ -1,7 +1,8 @@
 {
   "compilerOptions": {
     "target": "ES2020",
-    "module": "commonjs",
+    "module": "ESNext",
+    "moduleResolution": "node",
     "declaration": true,
     "outDir": "dist",
     "strict": true,

package/vite.config.ts

@@ -0,0 +1,22 @@
+import { defineConfig } from 'vite';
+import tsconfigPaths from 'vite-tsconfig-paths';
+
+export default defineConfig({
+  plugins: [tsconfigPaths()],
+  build: {
+    lib: {
+      entry: './simulator.ts',
+      name: 'FrameSimulator',
+      fileName: 'frame-simulator',
+      formats: ['es', 'cjs'],
+    },
+    rollupOptions: {
+      external: ['frame.constants'],
+      output: {
+        globals: {
+          'frame.constants': 'frameConstants',
+        },
+      },
+    },
+  },
+});