You are the best software engineer in the world. Please convert the following Python…
- User
You are the best software engineer in the world. Please convert the following Python code into Node.js TypeScript. Feel free to use sharp library. Make sure it is high performance. NOTE: When writing strings, please write a quote that is used for programming.
import numpy as np import json import time import threading import keyboard import sys from mss import mss as mss_module from PIL import Image HORIZONTAL_LEN, VERTICAL_LEN = [1920, 1080] SCAN_RADIUS = 3 CENTER_CROP_AREA = ( int(HORIZONTAL_LEN / 2 - SCAN_RADIUS), int(VERTICAL_LEN / 2 - SCAN_RADIUS), int(HORIZONTAL_LEN / 2 + SCAN_RADIUS), int(VERTICAL_LEN / 2 + SCAN_RADIUS), ) def quit_app(): try: sys.exit() except: raise SystemExit class App: def __init__(self): self.scrcpy = mss_module() self.is_active = False self.is_toggle = True self.exit_app = False self.thread_lock = threading.Lock() self.wasd_pressed = False self.last_wasd_release_time = time.time() with open('config.json') as json_file: data = json.load(json_file) try: self.hotkey = int(data["triggerhotkey"], 16) self.always_enabled = data["alwaysenabled"] self.trigger_delay = data["triggerdelay"] self.base_delay = data["basedelay"] self.tolerance = data["colortolerance"] self.firekey = data["firekey"] self.R, self.G, self.B = (250, 100, 250) except: quit_app() print("Started!") def wait(self): time.sleep(0.1) with self.thread_lock: self.is_toggle = True def scan(self): # if self.wasd_pressed: # return img = np.array(self.scrcpy.grab(CENTER_CROP_AREA)) pmap = np.array(img) px = pmap.reshape(-1, 4) color_mask = ( (px[:, 0] > self.R - self.tolerance) & (px[:, 0] < self.R + self.tolerance) & (px[:, 1] > self.G - self.tolerance) & (px[:, 1] < self.G + self.tolerance) & (px[:, 2] > self.B - self.tolerance) & (px[:, 2] < self.B + self.tolerance) ) matching_pixels = px[color_mask] if self.is_active and len(matching_pixels) > 0: delay_percentage = self.trigger_delay / 100.0 actual_delay = self.base_delay + self.base_delay * delay_percentage time.sleep(actual_delay) keyboard.press(self.firekey) time.sleep(0.12) keyboard.release(self.firekey) time.sleep(0.4) def on_toggle(self): if keyboard.is_pressed("f10"): # Save image im = np.array(self.scrcpy.grab(CENTER_CROP_AREA)) im = Image.fromarray(im).convert('RGB') im.save("screenshot.jpg") with self.thread_lock: if self.is_toggle: self.is_active = not self.is_active print(self.is_active) self.is_toggle = False threading.Thread(target=self.wait).start() if keyboard.is_pressed("ctrl+shift+x"): self.exit_app = True quit_app() def check_mv(self): if keyboard.is_pressed('w') or keyboard.is_pressed('a') or keyboard.is_pressed('s') or keyboard.is_pressed('d'): self.wasd_pressed = True else: if self.wasd_pressed: self.last_wasd_release_time = time.time() self.wasd_pressed = False def letsgo(self): while not self.exit_app: # self.check_wasd() if self.always_enabled == True: self.on_toggle() self.scan() if self.is_active else time.sleep(0.1) if __name__ == "__main__": try: App().letsgo() except KeyboardInterrupt: print("Quit!") quit_app() - Assistant
Below is a conversion of the provided Python code into Node.js TypeScript code using the
sharplibrary for image processing androbotjsfor simulating keyboard events instead of Python'skeyboardlibrary (since we don't have a direct equivalent in the Node.js ecosystem). Please note that functionality related to screenshots might differ depend on the available screen capture methods in your environment. Theiohooklibrary might be used for global keyboard hooks, similar tokeyboardin Python.import sharp from 'sharp'; import fs from 'fs'; import robotjs from 'robotjs'; import { hook, start } from 'iohook'; // ioHook is a global keyboard and mouse listener import { Rectangle } from 'electron'; // Assuming this module is used within an electron context const HORIZONTAL_LEN = 1920; const VERTICAL_LEN = 1080; const SCAN_RADIUS = 3; const CENTER_CROP_AREA: Rectangle = { x: HORIZONTAL_LEN / 2 - SCAN_RADIUS, y: VERTICAL_LEN / 2 - SCAN_RADIUS, width: SCAN_RADIUS * 2, height: SCAN_RADIUS * 2, }; async function quitApp() { process.exit(); } class App { private scrcpy: any; // Needs an appropriate screen capture lib private isActive: boolean; private isToggle: boolean; private exitApp: boolean; private threadLock: boolean; private wasdPressed: boolean; private lastWasdReleaseTime: number; private config: any; private hotkey: number; private alwaysEnabled: boolean; private triggerDelay: number; private baseDelay: number; private tolerance: number; private fireKey: string; private R: number; private G: number; private B: number; constructor() { this.isActive = false; this.isToggle = true; this.exitApp = false; this.threadLock = false; this.wasdPressed = false; this.lastWasdReleaseTime = Date.now(); try { const data = JSON.parse(fs.readFileSync('config.json', { encoding: 'utf8' })); this.hotkey = parseInt(data['triggerhotkey'], 16); this.alwaysEnabled = data['alwaysenabled']; this.triggerDelay = data['triggerdelay']; this.baseDelay = data['basedelay']; this.tolerance = data['colortolerance']; this.fireKey = data['firekey']; this.R = 250; this.G = 100; this.B = 250; } catch { quitApp(); } console.log('Started!'); } private wait(): void { setTimeout(() => { this.threadLock = true; }, 100); } private async scan(): Promise<void> { if (this.isActive) { const imageBuffer = await this.scrcpy.capture(CENTER_CROP_AREA.x, CENTER_CROP_AREA.y, CENTER_CROP_AREA.width, CENTER_CROP_AREA.height); const image = sharp(imageBuffer); const { data } = await image.raw().ensureAlpha().toBuffer({ resolveWithObject: true }); const pixels = Buffer.from(data).toJSON().data; // Construct color mask (placeholder, exact implementation depends on the available image capture library) let matchingPixels = []; for (let i = 0; i < pixels.length; i += 4) { const R = pixels[i]; const G = pixels[i + 1]; const B = pixels[i + 2]; if ( R > this.R - this.tolerance && R < this.R + this.tolerance && G > this.G - this.tolerance && G < this.G + this.tolerance && B > this.B - this.tolerance && B < this.B + this.tolerance ) { matchingPixels.push([R, G, B]); } } if (matchingPixels.length > 0) { const delayPercentage = this.triggerDelay / 100; const actualDelay = this.baseDelay + this.baseDelay * delayPercentage; setTimeout(() => { robotjs.keyTap(this.fireKey); }, actualDelay); } } } // ioHook-based implementation for simultaneous keystroke detection private setupIoHook(): void { hook((event) => { if (event.keycode === this.hotkey) { this.isActive = !this.isActive; console.log(this.isActive); this.wait(); } // ...Handle other keys... }); start(); } private checkMv(): void { // (Not implemented; Node.js does not have built-in keyboard state checking) } public async letsgo(): Promise<void> { while (!this.exitApp) { if (this.alwaysEnabled) { this.setupIoHook(); } await this.scan(); this.isActive ? await this.scan() : await new Promise((resolve) => setTimeout(resolve, 100)); } } } (async () => { try { const app = new App(); await app.letsgo(); } catch (error) { console.error(error); quitApp(); } })();Please note the following key changes and considerations:
- Since Node.js is asynchronous by nature, the
scanandletsgomethods are now asynchronous and return Promises. - We're using the
sharplibrary for processing images (but note that this library doesn't capture screen images; you'll have to find a Node.js module that captures a portion of the screen, possibly from within the Electron context). iohookis used for global keyboard event handling and the code assumes some keycodes for demonstration purposes (and the keycodes may differ depending on the library or platform).- Node.js does not have a native method to check if a key is pressed, so keyboard monitoring must be handled differently; usually with libraries such as
iohookorrobotjs. - The buffer manipulation part is changed to match Node.js Buffer usage.
This is a starting template and will require further adjustment to integrate with a proper screen-capture module, proper key code mapping for
iohook, adjustment of the pixel processing section, and other Node.js specifics that might apply to your environment. - Since Node.js is asynchronous by nature, the
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.