usecomputer 0.0.2 → 0.0.4

package/dist/cli.js

@@ -1,11 +1,17 @@
 // usecomputer CLI entrypoint and command wiring for desktop automation actions.
 import { goke } from 'goke';
+import pc from 'picocolors';
 import { z } from 'zod';
 import dedent from 'string-dedent';
 import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import pathModule from 'node:path';
 import url from 'node:url';
 import { createBridge } from './bridge.js';
+import { getRegionFromCoordMap, mapPointFromCoordMap, mapPointToCoordMap, parseCoordMapOrThrow, } from './coord-map.js';
 import { parseDirection, parseModifiers, parsePoint, parseRegion } from './command-parsers.js';
+import { drawDebugPointOnImage } from './debug-point-image.js';
+import { renderAlignedTable } from './terminal-table.js';
 const require = createRequire(import.meta.url);
 const packageJson = require('../package.json');
 function printJson(value) {
@@ -14,6 +20,38 @@ function printJson(value) {
 function printLine(value) {
     process.stdout.write(`${value}\n`);
 }
+function readTextFromStdin() {
+    return fs.readFileSync(0, 'utf8');
+}
+function parsePositiveInteger({ value, option, }) {
+    if (typeof value !== 'number') {
+        return undefined;
+    }
+    if (!Number.isFinite(value) || value <= 0) {
+        throw new Error(`Option ${option} must be a positive number`);
+    }
+    return Math.round(value);
+}
+function splitIntoChunks({ text, chunkSize, }) {
+    if (!chunkSize || text.length <= chunkSize) {
+        return [text];
+    }
+    const chunkCount = Math.ceil(text.length / chunkSize);
+    return Array.from({ length: chunkCount }, (_, index) => {
+        const start = index * chunkSize;
+        const end = start + chunkSize;
+        return text.slice(start, end);
+    }).filter((chunk) => {
+        return chunk.length > 0;
+    });
+}
+function sleep({ ms, }) {
+    return new Promise((resolve) => {
+        setTimeout(() => {
+            resolve();
+        }, ms);
+    });
+}
 function parsePointOrThrow(input) {
     const parsed = parsePoint(input);
     if (parsed instanceof Error) {
@@ -21,6 +59,21 @@ function parsePointOrThrow(input) {
     }
     return parsed;
 }
+function resolveOutputPath({ path }) {
+    if (!path) {
+        return undefined;
+    }
+    return path.startsWith('/')
+        ? path
+        : `${process.cwd()}/${path}`;
+}
+function ensureParentDirectory({ filePath }) {
+    if (!filePath) {
+        return;
+    }
+    const parentDirectory = pathModule.dirname(filePath);
+    fs.mkdirSync(parentDirectory, { recursive: true });
+}
 function resolvePointInput({ x, y, target, command, }) {
     if (typeof x === 'number' || typeof y === 'number') {
         if (typeof x !== 'number' || typeof y !== 'number') {
@@ -39,8 +92,88 @@ function parseButton(input) {
     }
     return 'left';
 }
+function printDesktopList({ displays }) {
+    const rows = displays.map((display) => {
+        return {
+            desktop: `#${display.index}`,
+            primary: display.isPrimary ? pc.green('yes') : 'no',
+            size: `${display.width}x${display.height}`,
+            position: `${display.x},${display.y}`,
+            id: String(display.id),
+            scale: String(display.scale),
+            name: display.name,
+        };
+    });
+    const lines = renderAlignedTable({
+        rows,
+        columns: [
+            { header: pc.bold('desktop'), value: (row) => { return row.desktop; } },
+            { header: pc.bold('primary'), value: (row) => { return row.primary; } },
+            { header: pc.bold('size'), value: (row) => { return row.size; }, align: 'right' },
+            { header: pc.bold('position'), value: (row) => { return row.position; }, align: 'right' },
+            { header: pc.bold('id'), value: (row) => { return row.id; }, align: 'right' },
+            { header: pc.bold('scale'), value: (row) => { return row.scale; }, align: 'right' },
+            { header: pc.bold('name'), value: (row) => { return row.name; } },
+        ],
+    });
+    lines.forEach((line) => {
+        printLine(line);
+    });
+}
+function mapWindowsByDesktopIndex({ windows, }) {
+    return windows.reduce((acc, window) => {
+        const list = acc.get(window.desktopIndex) ?? [];
+        list.push(window);
+        acc.set(window.desktopIndex, list);
+        return acc;
+    }, new Map());
+}
+function printDesktopListWithWindows({ displays, windows, }) {
+    const windowsByDesktop = mapWindowsByDesktopIndex({ windows });
+    printDesktopList({ displays });
+    displays.forEach((display) => {
+        printLine('');
+        printLine(pc.bold(pc.cyan(`desktop #${display.index} windows`)));
+        const desktopWindows = windowsByDesktop.get(display.index) ?? [];
+        if (desktopWindows.length === 0) {
+            printLine(pc.dim('none'));
+            return;
+        }
+        const lines = renderAlignedTable({
+            rows: desktopWindows,
+            columns: [
+                { header: pc.bold('id'), value: (row) => { return String(row.id); }, align: 'right' },
+                { header: pc.bold('app'), value: (row) => { return row.ownerName; } },
+                { header: pc.bold('pid'), value: (row) => { return String(row.ownerPid); }, align: 'right' },
+                { header: pc.bold('size'), value: (row) => { return `${row.width}x${row.height}`; }, align: 'right' },
+                { header: pc.bold('position'), value: (row) => { return `${row.x},${row.y}`; }, align: 'right' },
+                { header: pc.bold('title'), value: (row) => { return row.title; } },
+            ],
+        });
+        lines.forEach((line) => {
+            printLine(line);
+        });
+    });
+}
+function printWindowList({ windows }) {
+    const lines = renderAlignedTable({
+        rows: windows,
+        columns: [
+            { header: pc.bold('id'), value: (row) => { return String(row.id); }, align: 'right' },
+            { header: pc.bold('desktop'), value: (row) => { return `#${row.desktopIndex}`; }, align: 'right' },
+            { header: pc.bold('app'), value: (row) => { return row.ownerName; } },
+            { header: pc.bold('pid'), value: (row) => { return String(row.ownerPid); }, align: 'right' },
+            { header: pc.bold('size'), value: (row) => { return `${row.width}x${row.height}`; }, align: 'right' },
+            { header: pc.bold('position'), value: (row) => { return `${row.x},${row.y}`; }, align: 'right' },
+            { header: pc.bold('title'), value: (row) => { return row.title; } },
+        ],
+    });
+    lines.forEach((line) => {
+        printLine(line);
+    });
+}
 function notImplemented({ command }) {
-    throw new Error(`Command \"${command}\" is not implemented yet`);
+    throw new Error(`TODO not implemented: ${command}`);
 }
 export function createCli({ bridge = createBridge() } = {}) {
     const cli = goke('usecomputer');
@@ -51,18 +184,28 @@ export function createCli({ bridge = createBridge() } = {}) {
         This command uses a native Zig backend over macOS APIs.
       `)
         .option('-r, --region [region]', z.string().describe('Capture region as x,y,width,height'))
-        .option('--display [display]', z.number().describe('Display index for multi-monitor setups'))
+        .option('--display [display]', z.number().describe('Display index for multi-monitor setups (0-based: first display is index 0)'))
+        .option('--window [window]', z.number().describe('Capture a specific window by window id'))
         .option('--annotate', 'Annotate screenshot with labels')
         .option('--json', 'Output as JSON')
         .action(async (path, options) => {
+        const outputPath = resolveOutputPath({ path });
+        ensureParentDirectory({ filePath: outputPath });
         const region = options.region ? parseRegion(options.region) : undefined;
         if (region instanceof Error) {
             throw region;
         }
+        if (typeof options.window === 'number' && region) {
+            throw new Error('Cannot use --window and --region together');
+        }
+        if (typeof options.window === 'number' && typeof options.display === 'number') {
+            throw new Error('Cannot use --window and --display together');
+        }
         const result = await bridge.screenshot({
-            path,
+            path: outputPath,
             region,
             display: options.display,
+            window: options.window,
             annotate: options.annotate,
         });
         if (options.json) {
@@ -70,14 +213,27 @@ export function createCli({ bridge = createBridge() } = {}) {
             return;
         }
         printLine(result.path);
+        printLine(result.hint);
+        printLine(`desktop-index=${String(result.desktopIndex)}`);
     });
     cli
-        .command('click [target]', 'Click at coordinates')
-        .option('-x [x]', z.number().describe('X coordinate'))
-        .option('-y [y]', z.number().describe('Y coordinate'))
+        .command('click [target]', dedent `
+        Click at coordinates.
+
+        When you are clicking from a screenshot, use the exact pixel coordinates
+        of the target in that screenshot image and always pass the exact
+        --coord-map value printed by usecomputer screenshot. The coord map
+        scales screenshot-space pixels back into the real captured desktop or
+        window rectangle before sending the native click.
+      `)
+        .option('-x [x]', z.number().describe('X coordinate. When using --coord-map, this must be the exact pixel from the screenshot image'))
+        .option('-y [y]', z.number().describe('Y coordinate. When using --coord-map, this must be the exact pixel from the screenshot image'))
         .option('--button [button]', z.enum(['left', 'right', 'middle']).default('left').describe('Mouse button'))
         .option('--count [count]', z.number().default(1).describe('Number of clicks'))
         .option('--modifiers [modifiers]', z.string().describe('Modifiers as ctrl,shift,alt,meta'))
+        .option('--coord-map [coordMap]', z.string().describe('Map exact screenshot-space pixels back into the real captured desktop or window rectangle'))
+        .example('# Click the exact pixel you saw in a screenshot')
+        .example('usecomputer click -x 155 -y 446 --coord-map "0,0,1720,1440,1568,1313"')
         .action(async (target, options) => {
         const point = resolvePointInput({
             x: options.x,
@@ -85,23 +241,144 @@ export function createCli({ bridge = createBridge() } = {}) {
             target,
             command: 'click',
         });
+        const coordMap = parseCoordMapOrThrow(options.coordMap);
         await bridge.click({
-            point,
+            point: mapPointFromCoordMap({ point, coordMap }),
             button: options.button,
             count: options.count,
             modifiers: parseModifiers(options.modifiers),
         });
     });
     cli
-        .command('type <text>', 'Type text in the focused element')
-        .option('--delay [delay]', z.number().describe('Delay in milliseconds between keystrokes'))
+        .command('debug-point [target]', dedent `
+        Capture a screenshot and draw a red marker where a click would land.
+
+        Pass the same --coord-map you plan to use for click. This validates
+        screenshot-space coordinates before you send a real click. When
+        --coord-map is present, debug-point captures that same region so the
+        overlay matches the screenshot you are targeting.
+      `)
+        .option('-x [x]', z.number().describe('X coordinate'))
+        .option('-y [y]', z.number().describe('Y coordinate'))
+        .option('--coord-map [coordMap]', z.string().describe('Map input coordinates from screenshot space'))
+        .option('--output [path]', z.string().describe('Write the annotated screenshot to this path'))
+        .option('--json', 'Output as JSON')
+        .example('# Validate the same coordinates you plan to click')
+        .example('usecomputer debug-point -x 210 -y 560 --coord-map "0,0,1720,1440,1568,1313"')
+        .action(async (target, options) => {
+        const point = resolvePointInput({
+            x: options.x,
+            y: options.y,
+            target,
+            command: 'debug-point',
+        });
+        const inputCoordMap = parseCoordMapOrThrow(options.coordMap);
+        const desktopPoint = mapPointFromCoordMap({ point, coordMap: inputCoordMap });
+        const outputPath = resolveOutputPath({ path: options.output ?? './tmp/debug-point.png' });
+        ensureParentDirectory({ filePath: outputPath });
+        const screenshotRegion = getRegionFromCoordMap({ coordMap: inputCoordMap });
+        const screenshot = await bridge.screenshot({
+            path: outputPath,
+            region: screenshotRegion,
+        });
+        const screenshotCoordMap = parseCoordMapOrThrow(screenshot.coordMap);
+        const screenshotPoint = mapPointToCoordMap({ point: desktopPoint, coordMap: screenshotCoordMap });
+        await drawDebugPointOnImage({
+            imagePath: screenshot.path,
+            point: screenshotPoint,
+            imageWidth: screenshot.imageWidth,
+            imageHeight: screenshot.imageHeight,
+        });
+        if (options.json) {
+            printJson({
+                path: screenshot.path,
+                inputPoint: point,
+                desktopPoint,
+                screenshotPoint,
+                inputCoordMap: options.coordMap ?? null,
+                screenshotCoordMap: screenshot.coordMap,
+                hint: screenshot.hint,
+            });
+            return;
+        }
+        printLine(screenshot.path);
+        printLine(`input-point=${point.x},${point.y}`);
+        printLine(`desktop-point=${desktopPoint.x},${desktopPoint.y}`);
+        printLine(`screenshot-point=${screenshotPoint.x},${screenshotPoint.y}`);
+        printLine(screenshot.hint);
+    });
+    cli
+        .command('type [text]', dedent `
+        Type text in the currently focused input.
+
+        Supports direct text arguments or --stdin for long/multiline content.
+        For very long text, use --chunk-size to split input into multiple native
+        type calls so shells and apps are less likely to drop input.
+      `)
+        .option('--stdin', 'Read text from stdin instead of [text] argument')
+        .option('--delay [delay]', z.number().describe('Delay in milliseconds between typed characters'))
+        .option('--chunk-size [size]', z.number().describe('Split text into fixed-size chunks before typing'))
+        .option('--chunk-delay [delay]', z.number().describe('Delay in milliseconds between chunks'))
+        .option('--max-length [length]', z.number().describe('Fail when input text exceeds this maximum length'))
+        .example('# Type a short string')
+        .example('usecomputer type "hello"')
+        .example('# Type multiline text from a file')
+        .example('cat ./notes.txt | usecomputer type --stdin --chunk-size 4000 --chunk-delay 15')
         .action(async (text, options) => {
-        await bridge.typeText({ text, delayMs: options.delay });
+        const fromStdin = Boolean(options.stdin);
+        if (fromStdin && text) {
+            throw new Error('Use either [text] or --stdin, not both');
+        }
+        if (!fromStdin && !text) {
+            throw new Error('Command "type" requires [text] or --stdin');
+        }
+        const sourceText = fromStdin ? readTextFromStdin() : text ?? '';
+        const chunkSize = parsePositiveInteger({
+            value: options.chunkSize,
+            option: '--chunk-size',
+        });
+        const maxLength = parsePositiveInteger({
+            value: options.maxLength,
+            option: '--max-length',
+        });
+        const chunkDelay = parsePositiveInteger({
+            value: options.chunkDelay,
+            option: '--chunk-delay',
+        });
+        if (typeof maxLength === 'number' && sourceText.length > maxLength) {
+            throw new Error(`Input text length ${String(sourceText.length)} exceeds --max-length ${String(maxLength)}`);
+        }
+        const chunks = splitIntoChunks({
+            text: sourceText,
+            chunkSize,
+        });
+        await chunks.reduce(async (previousChunk, chunk, index) => {
+            await previousChunk;
+            await bridge.typeText({
+                text: chunk,
+                delayMs: options.delay,
+            });
+            if (typeof chunkDelay === 'number' && index < chunks.length - 1) {
+                await sleep({ ms: chunkDelay });
+            }
+        }, Promise.resolve());
     });
     cli
-        .command('press <key>', 'Press a key or key combo')
+        .command('press <key>', dedent `
+        Press a key or key combo in the focused app.
+
+        Key combos use plus syntax such as cmd+s or ctrl+shift+p.
+        Platform behavior: cmd maps to Command on macOS, Win/Super on
+        Windows/Linux. For cross-platform app shortcuts, prefer ctrl+... .
+      `)
         .option('--count [count]', z.number().default(1).describe('How many times to press'))
         .option('--delay [delay]', z.number().describe('Delay between presses in milliseconds'))
+        .example('# Save in the current app on macOS')
+        .example('usecomputer press "cmd+s"')
+        .example('# Portable save shortcut across most apps')
+        .example('usecomputer press "ctrl+s"')
+        .example('# Open command palette in many editors')
+        .example('usecomputer press "cmd+shift+p"')
         .action(async (key, options) => {
         await bridge.press({ key, count: options.count, delayMs: options.delay });
     });
@@ -128,10 +405,12 @@ export function createCli({ bridge = createBridge() } = {}) {
         .command('drag <from> <to>', 'Drag from one coordinate to another')
         .option('--duration [duration]', z.number().describe('Duration in milliseconds'))
         .option('--button [button]', z.enum(['left', 'right', 'middle']).default('left').describe('Mouse button'))
+        .option('--coord-map [coordMap]', z.string().describe('Map input coordinates from screenshot space'))
         .action(async (from, to, options) => {
+        const coordMap = parseCoordMapOrThrow(options.coordMap);
         await bridge.drag({
-            from: parsePointOrThrow(from),
-            to: parsePointOrThrow(to),
+            from: mapPointFromCoordMap({ point: parsePointOrThrow(from), coordMap }),
+            to: mapPointFromCoordMap({ point: parsePointOrThrow(to), coordMap }),
             durationMs: options.duration,
             button: options.button,
         });
@@ -140,6 +419,7 @@ export function createCli({ bridge = createBridge() } = {}) {
         .command('hover [target]', 'Move mouse cursor to coordinates without clicking')
         .option('-x [x]', z.number().describe('X coordinate'))
         .option('-y [y]', z.number().describe('Y coordinate'))
+        .option('--coord-map [coordMap]', z.string().describe('Map input coordinates from screenshot space'))
         .action(async (target, options) => {
         const point = resolvePointInput({
             x: options.x,
@@ -147,12 +427,14 @@ export function createCli({ bridge = createBridge() } = {}) {
             target,
             command: 'hover',
         });
-        await bridge.hover(point);
+        const coordMap = parseCoordMapOrThrow(options.coordMap);
+        await bridge.hover(mapPointFromCoordMap({ point, coordMap }));
     });
     cli
-        .command('mouse move [x] [y]', 'Move mouse cursor to absolute coordinates')
+        .command('mouse move [x] [y]', 'Move mouse cursor to absolute coordinates (optional before click; click can target coordinates directly)')
         .option('-x [x]', z.number().describe('X coordinate'))
         .option('-y [y]', z.number().describe('Y coordinate'))
+        .option('--coord-map [coordMap]', z.string().describe('Map input coordinates from screenshot space'))
         .action(async (x, y, options) => {
         const point = resolvePointInput({
             x: options.x,
@@ -160,7 +442,8 @@ export function createCli({ bridge = createBridge() } = {}) {
             target: x && y ? `${x},${y}` : undefined,
             command: 'mouse move',
         });
-        await bridge.mouseMove(point);
+        const coordMap = parseCoordMapOrThrow(options.coordMap);
+        await bridge.mouseMove(mapPointFromCoordMap({ point, coordMap }));
     });
     cli
         .command('mouse down', 'Press and hold mouse button')
@@ -194,10 +477,28 @@ export function createCli({ bridge = createBridge() } = {}) {
             printJson(displays);
             return;
         }
-        displays.forEach((display) => {
-            const primary = display.isPrimary ? ' (primary)' : '';
-            printLine(`#${display.id} ${display.name}${primary} ${display.width}x${display.height} @ (${display.x},${display.y}) scale=${display.scale}`);
-        });
+        printDesktopList({ displays });
+    });
+    cli
+        .command('desktop list', 'List desktops as display indexes and sizes (#0 is the primary display)')
+        .option('--windows', 'Include available windows grouped by desktop index')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        const displays = await bridge.displayList();
+        const windows = options.windows ? await bridge.windowList() : [];
+        if (options.json) {
+            if (options.windows) {
+                printJson({ displays, windows });
+                return;
+            }
+            printJson(displays);
+            return;
+        }
+        if (options.windows) {
+            printDesktopListWithWindows({ displays, windows });
+            return;
+        }
+        printDesktopList({ displays });
     });
     cli
         .command('clipboard get', 'Print clipboard text')
@@ -228,8 +529,13 @@ export function createCli({ bridge = createBridge() } = {}) {
     cli.command('get focused').action(() => {
         notImplemented({ command: 'get focused' });
     });
-    cli.command('window list').action(() => {
-        notImplemented({ command: 'window list' });
+    cli.command('window list').option('--json', 'Output as JSON').action(async (options) => {
+        const windows = await bridge.windowList();
+        if (options.json) {
+            printJson(windows);
+            return;
+        }
+        printWindowList({ windows });
     });
     cli.command('window focus <target>').action(() => {
         notImplemented({ command: 'window focus' });

package/dist/coord-map.d.ts

@@ -0,0 +1,14 @@
+import type { CoordMap, Point, Region } from './types.js';
+export declare function parseCoordMapOrThrow(input?: string): CoordMap | undefined;
+export declare function mapPointFromCoordMap({ point, coordMap, }: {
+    point: Point;
+    coordMap?: CoordMap;
+}): Point;
+export declare function mapPointToCoordMap({ point, coordMap, }: {
+    point: Point;
+    coordMap?: CoordMap;
+}): Point;
+export declare function getRegionFromCoordMap({ coordMap, }: {
+    coordMap?: CoordMap;
+}): Region | undefined;
+//# sourceMappingURL=coord-map.d.ts.map

package/dist/coord-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coord-map.d.ts","sourceRoot":"","sources":["../src/coord-map.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAEzD,wBAAgB,oBAAoB,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,CA2BzE;AAED,wBAAgB,oBAAoB,CAAC,EACnC,KAAK,EACL,QAAQ,GACT,EAAE;IACD,KAAK,EAAE,KAAK,CAAA;IACZ,QAAQ,CAAC,EAAE,QAAQ,CAAA;CACpB,GAAG,KAAK,CAoBR;AAED,wBAAgB,kBAAkB,CAAC,EACjC,KAAK,EACL,QAAQ,GACT,EAAE;IACD,KAAK,EAAE,KAAK,CAAA;IACZ,QAAQ,CAAC,EAAE,QAAQ,CAAA;CACpB,GAAG,KAAK,CAoBR;AAED,wBAAgB,qBAAqB,CAAC,EACpC,QAAQ,GACT,EAAE;IACD,QAAQ,CAAC,EAAE,QAAQ,CAAA;CACpB,GAAG,MAAM,GAAG,SAAS,CAWrB"}

package/dist/coord-map.js

@@ -0,0 +1,75 @@
+// Shared coord-map helpers for converting screenshot-space pixels to desktop coordinates.
+export function parseCoordMapOrThrow(input) {
+    if (!input) {
+        return undefined;
+    }
+    const values = input.split(',').map((value) => {
+        return Number(value.trim());
+    });
+    if (values.length !== 6 || values.some((value) => {
+        return !Number.isFinite(value);
+    })) {
+        throw new Error('Option --coord-map must be x,y,width,height,imageWidth,imageHeight');
+    }
+    const [captureX, captureY, captureWidth, captureHeight, imageWidth, imageHeight] = values;
+    if (captureWidth <= 0 || captureHeight <= 0 || imageWidth <= 0 || imageHeight <= 0) {
+        throw new Error('Option --coord-map must have positive width and height values');
+    }
+    return {
+        captureX,
+        captureY,
+        captureWidth,
+        captureHeight,
+        imageWidth,
+        imageHeight,
+    };
+}
+export function mapPointFromCoordMap({ point, coordMap, }) {
+    if (!coordMap) {
+        return point;
+    }
+    const imageWidthSpan = Math.max(coordMap.imageWidth - 1, 1);
+    const imageHeightSpan = Math.max(coordMap.imageHeight - 1, 1);
+    const captureWidthSpan = Math.max(coordMap.captureWidth - 1, 0);
+    const captureHeightSpan = Math.max(coordMap.captureHeight - 1, 0);
+    const maxCaptureX = coordMap.captureX + captureWidthSpan;
+    const maxCaptureY = coordMap.captureY + captureHeightSpan;
+    const mappedX = coordMap.captureX + (point.x / imageWidthSpan) * captureWidthSpan;
+    const mappedY = coordMap.captureY + (point.y / imageHeightSpan) * captureHeightSpan;
+    const clampedX = Math.max(coordMap.captureX, Math.min(maxCaptureX, mappedX));
+    const clampedY = Math.max(coordMap.captureY, Math.min(maxCaptureY, mappedY));
+    return {
+        x: Math.round(clampedX),
+        y: Math.round(clampedY),
+    };
+}
+export function mapPointToCoordMap({ point, coordMap, }) {
+    if (!coordMap) {
+        return point;
+    }
+    const captureWidthSpan = Math.max(coordMap.captureWidth - 1, 1);
+    const captureHeightSpan = Math.max(coordMap.captureHeight - 1, 1);
+    const imageWidthSpan = Math.max(coordMap.imageWidth - 1, 0);
+    const imageHeightSpan = Math.max(coordMap.imageHeight - 1, 0);
+    const relativeX = (point.x - coordMap.captureX) / captureWidthSpan;
+    const relativeY = (point.y - coordMap.captureY) / captureHeightSpan;
+    const mappedX = relativeX * imageWidthSpan;
+    const mappedY = relativeY * imageHeightSpan;
+    const clampedX = Math.max(0, Math.min(imageWidthSpan, mappedX));
+    const clampedY = Math.max(0, Math.min(imageHeightSpan, mappedY));
+    return {
+        x: Math.round(clampedX),
+        y: Math.round(clampedY),
+    };
+}
+export function getRegionFromCoordMap({ coordMap, }) {
+    if (!coordMap) {
+        return undefined;
+    }
+    return {
+        x: coordMap.captureX,
+        y: coordMap.captureY,
+        width: coordMap.captureWidth,
+        height: coordMap.captureHeight,
+    };
+}

package/dist/coord-map.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=coord-map.test.d.ts.map

package/dist/coord-map.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coord-map.test.d.ts","sourceRoot":"","sources":["../src/coord-map.test.ts"],"names":[],"mappings":""}