@asdf-overlay/core 0.9.0

package/lib/addon.d.ts

@@ -0,0 +1,16 @@
+import { OverlayEventEmitter } from './index.js';
+import { CopyRect, Cursor, PercentLength } from './types.js';
+export type Addon = {
+    attach(dllDir: string, pid: number, timeout?: number): Promise<number>;
+    overlaySetPosition(id: number, winId: number, x: PercentLength, y: PercentLength): Promise<void>;
+    overlaySetAnchor(id: number, winId: number, x: PercentLength, y: PercentLength): Promise<void>;
+    overlaySetMargin(id: number, winId: number, top: PercentLength, right: PercentLength, bottom: PercentLength, left: PercentLength): Promise<void>;
+    overlayListenInput(id: number, winId: number, cursor: boolean, keyboard: boolean): Promise<void>;
+    overlayBlockInput(id: number, winId: number, block: boolean): Promise<void>;
+    overlaySetBlockingCursor(id: number, winId: number, cursor?: Cursor): Promise<void>;
+    overlayUpdateBitmap(id: number, winId: number, width: number, data: Buffer): Promise<void>;
+    overlayUpdateShtex(id: number, winId: number, width: number, height: number, handle: Buffer, rect?: CopyRect): Promise<void>;
+    overlayClearSurface(id: number, winId: number): Promise<void>;
+    overlayCallNextEvent(id: number, emitter: OverlayEventEmitter, emit: OverlayEventEmitter['emit']): Promise<boolean>;
+    overlayDestroy(id: number): void;
+};

package/lib/addon.js

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

package/lib/index.d.ts

@@ -0,0 +1,102 @@
+import { EventEmitter } from 'node:events';
+import { CursorInput, KeyboardInput } from './input.js';
+import { PercentLength, CopyRect, Cursor } from './types.js';
+export * from './types.js';
+export * from './util.js';
+declare const idSym: unique symbol;
+export type OverlayEventEmitter = EventEmitter<{
+    added: [id: number, width: number, height: number];
+    resized: [id: number, width: number, height: number];
+    cursor_input: [id: number, input: CursorInput];
+    keyboard_input: [id: number, input: KeyboardInput];
+    input_blocking_ended: [id: number];
+    destroyed: [id: number];
+    error: [err: unknown];
+    disconnected: [];
+}>;
+export declare class Overlay {
+    readonly event: OverlayEventEmitter;
+    readonly [idSym]: number;
+    private constructor();
+    /**
+     * Update overlay position relative to window
+     * @param id target window id
+     * @param x x position
+     * @param y y position
+     */
+    setPosition(id: number, x: PercentLength, y: PercentLength): Promise<void>;
+    /**
+     * Update overlay anchor
+     * @param id target window id
+     * @param x x anchor
+     * @param y y anchor
+     */
+    setAnchor(id: number, x: PercentLength, y: PercentLength): Promise<void>;
+    /**
+     * Update overlay margin
+     * @param id target window id
+     * @param top top margin
+     * @param right right margin
+     * @param bottom bottom margin
+     * @param left left margin
+     */
+    setMargin(id: number, top: PercentLength, right: PercentLength, bottom: PercentLength, left: PercentLength): Promise<void>;
+    /**
+     * Listen to window input without blocking
+     * @param id target window id
+     * @param cursor listen cursor input or not
+     * @param keyboard listen keyboard input or not
+     */
+    listenInput(id: number, cursor: boolean, keyboard: boolean): Promise<void>;
+    /**
+     * Block window input and listen them
+     * @param id target window id
+     * @param block set true to block input, false to release
+     */
+    blockInput(id: number, block: boolean): Promise<void>;
+    /**
+     * Set cursor while in input blocking mode
+     * @param id target window id
+     * @param cursor cursor to set. Do not supply this value to hide cursor.
+     */
+    setBlockingCursor(id: number, cursor?: Cursor): Promise<void>;
+    /**
+     * Update overlay using bitmap buffer. The size of overlay is `width x (data.byteLength / 4 / width)`
+     * @param id target window id
+     * @param width width of the bitmap
+     * @param data bgra formatted bitmap
+     */
+    updateBitmap(id: number, width: number, data: Buffer): Promise<void>;
+    /**
+     * Update overlay using D3D11 shared texture.
+     * @param id target window id
+     * @param width width of the surface
+     * @param height height of the surface
+     * @param handle NT Handle of shared D3D11 Texture
+     * @param rect Area to update
+     */
+    updateShtex(id: number, width: number, height: number, handle: Buffer, rect?: CopyRect): Promise<void>;
+    /**
+     * Clear overlay
+     * @param id target window id
+     */
+    clearSurface(id: number): Promise<void>;
+    /**
+     * Destroy overlay
+     */
+    destroy(): void;
+    /**
+     * Attach overlay to target process
+     *
+     * Name must be unique or it will fail if there is a connection with same name
+     * @param dllDir path to dlls
+     * @param pid target process pid
+     * @param timeout Timeout for injection, in milliseconds. Will wait indefinitely if not provided.
+     * @returns new {@link Overlay} object
+     */
+    static attach(dllDir: string, pid: number, timeout?: number): Promise<Overlay>;
+}
+/**
+ * Default dll directory path
+ */
+export declare function defaultDllDir(): string;

package/lib/index.js

@@ -0,0 +1,162 @@
+import path from 'node:path';
+import { arch } from 'node:process';
+import { fileURLToPath } from 'node:url';
+import { EventEmitter } from 'node:events';
+export * from './types.js';
+export * from './util.js';
+const addon = loadAddon();
+function loadAddon() {
+    const nodeModule = { exports: {} };
+    let name;
+    switch (arch) {
+        case 'arm64': {
+            name = '../addon-aarch64.node';
+            break;
+        }
+        case 'x64': {
+            name = '../addon-x64.node';
+            break;
+        }
+        default: throw new Error(`Unsupported arch: ${arch}`);
+    }
+    process.dlopen(nodeModule, path.resolve(path.dirname(fileURLToPath(new URL(import.meta.url))), name));
+    return nodeModule.exports;
+}
+const idSym = Symbol('id');
+export class Overlay {
+    event = new EventEmitter();
+    [idSym];
+    constructor(id) {
+        this[idSym] = id;
+        void (async () => {
+            // wait until next tick so no events are lost
+            await new Promise((resolve) => {
+                process.nextTick(resolve);
+            });
+            try {
+                for (;;) {
+                    const hasNext = await addon.overlayCallNextEvent(id, this.event, (name, ...args) => this.event.emit(name, ...args));
+                    if (!hasNext)
+                        break;
+                }
+            }
+            catch (err) {
+                if (this.event.listenerCount('error') != 0) {
+                    this.event.emit('error', err);
+                }
+                else {
+                    throw err;
+                }
+            }
+            finally {
+                this.destroy();
+            }
+        })();
+    }
+    /**
+     * Update overlay position relative to window
+     * @param id target window id
+     * @param x x position
+     * @param y y position
+     */
+    async setPosition(id, x, y) {
+        await addon.overlaySetPosition(this[idSym], id, x, y);
+    }
+    /**
+     * Update overlay anchor
+     * @param id target window id
+     * @param x x anchor
+     * @param y y anchor
+     */
+    async setAnchor(id, x, y) {
+        await addon.overlaySetAnchor(this[idSym], id, x, y);
+    }
+    /**
+     * Update overlay margin
+     * @param id target window id
+     * @param top top margin
+     * @param right right margin
+     * @param bottom bottom margin
+     * @param left left margin
+     */
+    async setMargin(id, top, right, bottom, left) {
+        await addon.overlaySetMargin(this[idSym], id, top, right, bottom, left);
+    }
+    /**
+     * Listen to window input without blocking
+     * @param id target window id
+     * @param cursor listen cursor input or not
+     * @param keyboard listen keyboard input or not
+     */
+    async listenInput(id, cursor, keyboard) {
+        await addon.overlayListenInput(this[idSym], id, cursor, keyboard);
+    }
+    /**
+     * Block window input and listen them
+     * @param id target window id
+     * @param block set true to block input, false to release
+     */
+    async blockInput(id, block) {
+        await addon.overlayBlockInput(this[idSym], id, block);
+    }
+    /**
+     * Set cursor while in input blocking mode
+     * @param id target window id
+     * @param cursor cursor to set. Do not supply this value to hide cursor.
+     */
+    async setBlockingCursor(id, cursor) {
+        await addon.overlaySetBlockingCursor(this[idSym], id, cursor);
+    }
+    /**
+     * Update overlay using bitmap buffer. The size of overlay is `width x (data.byteLength / 4 / width)`
+     * @param id target window id
+     * @param width width of the bitmap
+     * @param data bgra formatted bitmap
+     */
+    async updateBitmap(id, width, data) {
+        await addon.overlayUpdateBitmap(this[idSym], id, width, data);
+    }
+    /**
+     * Update overlay using D3D11 shared texture.
+     * @param id target window id
+     * @param width width of the surface
+     * @param height height of the surface
+     * @param handle NT Handle of shared D3D11 Texture
+     * @param rect Area to update
+     */
+    async updateShtex(id, width, height, handle, rect) {
+        await addon.overlayUpdateShtex(this[idSym], id, width, height, handle, rect);
+    }
+    /**
+     * Clear overlay
+     * @param id target window id
+     */
+    async clearSurface(id) {
+        await addon.overlayClearSurface(this[idSym], id);
+    }
+    /**
+     * Destroy overlay
+     */
+    destroy() {
+        addon.overlayDestroy(this[idSym]);
+        this.event.emit('disconnected');
+    }
+    /**
+     * Attach overlay to target process
+     *
+     * Name must be unique or it will fail if there is a connection with same name
+     * @param dllDir path to dlls
+     * @param pid target process pid
+     * @param timeout Timeout for injection, in milliseconds. Will wait indefinitely if not provided.
+     * @returns new {@link Overlay} object
+     */
+    static async attach(dllDir, pid, timeout) {
+        return new Overlay(await addon.attach(dllDir, pid, timeout));
+    }
+}
+/**
+ * Default dll directory path
+ */
+export function defaultDllDir() {
+    return path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../');
+}

package/lib/input.d.ts

@@ -0,0 +1,82 @@
+import { Key } from './index.js';
+export type CursorInput = {
+    clientX: number;
+    clientY: number;
+    windowX: number;
+    windowY: number;
+} & ({
+    kind: 'Enter';
+} | {
+    kind: 'Leave';
+} | {
+    kind: 'Action';
+    state: InputState;
+    doubleClick: boolean;
+    action: CursorAction;
+} | {
+    kind: 'Move';
+} | {
+    kind: 'Scroll';
+    axis: ScrollAxis;
+    /**
+     * Scroll tick delta
+     */
+    delta: number;
+});
+export type KeyboardInput = {
+    kind: 'Key';
+    key: Key;
+    /**
+     * Key input state
+     */
+    state: InputState;
+} | {
+    kind: 'Char';
+    ch: string;
+} | {
+    kind: 'Ime';
+    ime: Ime;
+};
+export type Ime = {
+    kind: 'Enabled';
+    lang: string;
+    conversion: ImeConversion;
+} | {
+    kind: 'Changed';
+    /** ETF language tag(BCP 47) */
+    lang: string;
+} | {
+    kind: 'ChangedConversion';
+    conversion: ImeConversion;
+} | {
+    kind: 'CandidateChanged';
+    list: ImeCandidateList;
+} | {
+    kind: 'CandidateClosed';
+} | {
+    kind: 'Compose';
+    text: string;
+    caret: number;
+} | {
+    kind: 'Commit';
+    text: string;
+} | {
+    kind: 'Disabled';
+};
+export type ImeCandidateList = {
+    pageStartIndex: number;
+    pageSize: number;
+    selectedIndex: number;
+    candidates: string[];
+};
+export declare const enum ImeConversion {
+    None = 0,
+    Native = 1,
+    Fullshape = 2,
+    NoConversion = 4,
+    HanjaConvert = 8,
+    Katakana = 16
+}
+export type InputState = 'Pressed' | 'Released';
+export type CursorAction = 'Left' | 'Right' | 'Middle' | 'Back' | 'Forward';
+export type ScrollAxis = 'X' | 'Y';

package/lib/input.js

@@ -0,0 +1,9 @@
+export var ImeConversion;
+(function (ImeConversion) {
+    ImeConversion[ImeConversion["None"] = 0] = "None";
+    ImeConversion[ImeConversion["Native"] = 1] = "Native";
+    ImeConversion[ImeConversion["Fullshape"] = 2] = "Fullshape";
+    ImeConversion[ImeConversion["NoConversion"] = 4] = "NoConversion";
+    ImeConversion[ImeConversion["HanjaConvert"] = 8] = "HanjaConvert";
+    ImeConversion[ImeConversion["Katakana"] = 16] = "Katakana";
+})(ImeConversion || (ImeConversion = {}));

package/lib/types.d.ts

@@ -0,0 +1,66 @@
+export type PercentLength = {
+    ty: 'percent' | 'length';
+    value: number;
+};
+export type CopyRect = {
+    dstX: number;
+    dstY: number;
+    src: Rect;
+};
+export type Rect = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export type Key = {
+    /**
+     * Windows virtual key code
+     */
+    code: number;
+    /**
+     * Extended flag
+     */
+    extended: boolean;
+};
+export declare enum Cursor {
+    Default = 0,
+    Help = 1,
+    Pointer = 2,
+    Progress = 3,
+    Wait = 4,
+    Cell = 5,
+    Crosshair = 6,
+    Text = 7,
+    VerticalText = 8,
+    Alias = 9,
+    Copy = 10,
+    Move = 11,
+    NotAllowed = 12,
+    Grab = 13,
+    Grabbing = 14,
+    ColResize = 15,
+    RowResize = 16,
+    EastWestResize = 17,
+    NorthSouthResize = 18,
+    NorthEastSouthWestResize = 19,
+    NorthWestSouthEastResize = 20,
+    ZoomIn = 21,
+    ZoomOut = 22,
+    UpArrow = 23,
+    Pin = 24,
+    Person = 25,
+    Pen = 26,
+    Cd = 27,
+    PanMiddle = 28,
+    PanMiddleHorizontal = 29,
+    PanMiddleVertical = 30,
+    PanEast = 31,
+    PanNorth = 32,
+    PanNorthEast = 33,
+    PanNorthWest = 34,
+    PanSouth = 35,
+    PanSouthEast = 36,
+    PanSouthWest = 37,
+    PanWest = 38
+}

package/lib/types.js

@@ -0,0 +1,45 @@
+export var Cursor;
+(function (Cursor) {
+    Cursor[Cursor["Default"] = 0] = "Default";
+    Cursor[Cursor["Help"] = 1] = "Help";
+    Cursor[Cursor["Pointer"] = 2] = "Pointer";
+    Cursor[Cursor["Progress"] = 3] = "Progress";
+    Cursor[Cursor["Wait"] = 4] = "Wait";
+    Cursor[Cursor["Cell"] = 5] = "Cell";
+    Cursor[Cursor["Crosshair"] = 6] = "Crosshair";
+    Cursor[Cursor["Text"] = 7] = "Text";
+    Cursor[Cursor["VerticalText"] = 8] = "VerticalText";
+    Cursor[Cursor["Alias"] = 9] = "Alias";
+    Cursor[Cursor["Copy"] = 10] = "Copy";
+    Cursor[Cursor["Move"] = 11] = "Move";
+    Cursor[Cursor["NotAllowed"] = 12] = "NotAllowed";
+    Cursor[Cursor["Grab"] = 13] = "Grab";
+    Cursor[Cursor["Grabbing"] = 14] = "Grabbing";
+    Cursor[Cursor["ColResize"] = 15] = "ColResize";
+    Cursor[Cursor["RowResize"] = 16] = "RowResize";
+    Cursor[Cursor["EastWestResize"] = 17] = "EastWestResize";
+    Cursor[Cursor["NorthSouthResize"] = 18] = "NorthSouthResize";
+    Cursor[Cursor["NorthEastSouthWestResize"] = 19] = "NorthEastSouthWestResize";
+    Cursor[Cursor["NorthWestSouthEastResize"] = 20] = "NorthWestSouthEastResize";
+    Cursor[Cursor["ZoomIn"] = 21] = "ZoomIn";
+    Cursor[Cursor["ZoomOut"] = 22] = "ZoomOut";
+    // Windows additional cursors
+    Cursor[Cursor["UpArrow"] = 23] = "UpArrow";
+    Cursor[Cursor["Pin"] = 24] = "Pin";
+    Cursor[Cursor["Person"] = 25] = "Person";
+    Cursor[Cursor["Pen"] = 26] = "Pen";
+    Cursor[Cursor["Cd"] = 27] = "Cd";
+    // panning
+    Cursor[Cursor["PanMiddle"] = 28] = "PanMiddle";
+    Cursor[Cursor["PanMiddleHorizontal"] = 29] = "PanMiddleHorizontal";
+    Cursor[Cursor["PanMiddleVertical"] = 30] = "PanMiddleVertical";
+    Cursor[Cursor["PanEast"] = 31] = "PanEast";
+    Cursor[Cursor["PanNorth"] = 32] = "PanNorth";
+    Cursor[Cursor["PanNorthEast"] = 33] = "PanNorthEast";
+    Cursor[Cursor["PanNorthWest"] = 34] = "PanNorthWest";
+    Cursor[Cursor["PanSouth"] = 35] = "PanSouth";
+    Cursor[Cursor["PanSouthEast"] = 36] = "PanSouthEast";
+    Cursor[Cursor["PanSouthWest"] = 37] = "PanSouthWest";
+    Cursor[Cursor["PanWest"] = 38] = "PanWest";
+})(Cursor || (Cursor = {}));
+;

package/lib/util.d.ts

@@ -0,0 +1,4 @@
+import { Key, PercentLength } from './index.js';
+export declare function percent(value: number): PercentLength;
+export declare function length(value: number): PercentLength;
+export declare function key(code: number, extended?: boolean): Key;

package/lib/util.js

@@ -0,0 +1,18 @@
+export function percent(value) {
+    return {
+        ty: 'percent',
+        value,
+    };
+}
+export function length(value) {
+    return {
+        ty: 'length',
+        value,
+    };
+}
+export function key(code, extended = false) {
+    return {
+        code,
+        extended,
+    };
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@asdf-overlay/core",
+  "version": "0.9.0",
+  "description": "Asdf overlay core Node addon",
+  "main": "./lib/index.js",
+  "type": "module",
+  "author": "storycraft <storycraft@pancake.sh>",
+  "homepage": "https://github.com/storycraft/asdf-overlay#readme",
+  "license": "MIT OR Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/storycraft/asdf-overlay/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/storycraft/asdf-overlay"
+  },
+  "os": [
+    "win32"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ],
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./*": {
+      "types": "./lib/*.d.ts",
+      "default": "./lib/*.js"
+    }
+  },
+  "types": "./lib/index.d.ts",
+  "files": [
+    "lib/**/*",
+    "addon-x64.node",
+    "addon-aarch64.node",
+    "asdf_overlay-x64.dll",
+    "asdf_overlay-x86.dll",
+    "asdf_overlay-aarch64.dll"
+  ],
+  "devDependencies": {
+    "@types/node": "^24.1.0",
+    "typescript": "^5.8.3"
+  },
+  "scripts": {
+    "build-dll": "cargo xtask build-dll --",
+    "cargo-build": "cargo xtask build-node --",
+    "build:debug": "npm run cargo-build && npm run build-dll && tsc",
+    "build:dist": "tsc",
+    "build": "npm run cargo-build -- --release && npm run build-dll -- --release && npm run build:dist"
+  }
+}