@asdf-overlay/electron 1.2.5 → 2.0.0

package/lib/index.d.ts

@@ -1,4 +1,4 @@
-import type { Overlay } from '@asdf-overlay/core';
+import type { Overlay, SurfaceInfo } from '@asdf-overlay/core';
 /**
  * Describe a window in `Overlay`.
  */
@@ -12,3 +12,20 @@ export type OverlayWindow = {
      */
     id: number;
 };
+/**
+ * Describe a surface in `Overlay`.
+ */
+export type OverlaySurface = {
+    /**
+     * Associated `Overlay` instance.
+     */
+    overlay: Overlay;
+    /**
+     * Surface id.
+     */
+    id: bigint;
+    /**
+     * Surface info.
+     */
+    info: SurfaceInfo;
+};

package/lib/input.d.ts

@@ -1,17 +1,16 @@
 import { type WebContents } from 'electron';
 import type { OverlayWindow } from './index.js';
-import type { CursorInput, KeyboardInput } from '@asdf-overlay/core/input';
+import type { CursorInput, KeyboardInput } from '@asdf-overlay/core';
 /**
  * Connection from a overlay window to a Electron window.
  */
 export declare class ElectronOverlayInput {
     private readonly window;
     private readonly contents;
+    private readonly scaleFactor;
     private readonly cursorInputHandler;
     private readonly keyboardInputHandler;
     private readonly cursorChangedHandler;
-    private readonly displayMetricsChangedHandler;
-    private screenScaleFactor;
     private constructor();
     /**
      * Connect overlay inputs to a Electron `WebContents`.

package/lib/input.js

@@ -1,4 +1,4 @@
-import { screen } from 'electron';
+import {} from 'electron';
 import { mapCssCursor, mapKeycode } from './input/conv.js';
 import { Cursor } from '@asdf-overlay/core';
 /**
@@ -7,60 +7,55 @@ import { Cursor } from '@asdf-overlay/core';
 export class ElectronOverlayInput {
     window;
     contents;
+    scaleFactor;
     cursorInputHandler;
     keyboardInputHandler;
     cursorChangedHandler;
-    displayMetricsChangedHandler;
-    screenScaleFactor;
-    constructor(window, contents) {
+    constructor(window, contents, scaleFactor) {
         this.window = window;
         this.contents = contents;
+        this.scaleFactor = scaleFactor;
         this.window = { ...window };
-        this.screenScaleFactor = screen.getPrimaryDisplay().scaleFactor;
-        screen.addListener('display-metrics-changed', this.displayMetricsChangedHandler = () => {
-            this.screenScaleFactor = screen.getPrimaryDisplay().scaleFactor;
-        });
-        this.window.overlay.event.on('cursor_input', this.cursorInputHandler = (id, input) => {
+        this.window.overlay.event.on('window_cursor_input', this.cursorInputHandler = (id, input) => {
             if (id !== window.id) {
                 return;
             }
             this.sendCursorInput(input);
         });
-        this.window.overlay.event.on('keyboard_input', this.keyboardInputHandler = (id, input) => {
+        this.window.overlay.event.on('window_keyboard_input', this.keyboardInputHandler = (id, input) => {
             if (id !== window.id) {
                 return;
             }
             this.sendKeyboardInput(input);
         });
         this.contents.on('cursor-changed', this.cursorChangedHandler = (_, type) => {
-            void this.window.overlay.setBlockingCursor(this.window.id, mapCssCursor(type));
+            void this.window.overlay.setBlockingCursor(mapCssCursor(type));
         });
     }
     /**
      * Connect overlay inputs to a Electron `WebContents`.
      */
     static connect(window, contents) {
-        return new ElectronOverlayInput({ ...window }, contents);
+        return new ElectronOverlayInput({ ...window }, contents, 1.0 /* todo */);
     }
     /**
      * Disconnect overlay inputs.
      */
     async disconnect() {
-        screen.removeListener('display-metrics-changed', this.displayMetricsChangedHandler);
-        this.window.overlay.event.off('cursor_input', this.cursorInputHandler);
-        this.window.overlay.event.off('keyboard_input', this.keyboardInputHandler);
+        this.window.overlay.event.off('window_cursor_input', this.cursorInputHandler);
+        this.window.overlay.event.off('window_keyboard_input', this.keyboardInputHandler);
         this.contents.off('cursor-changed', this.cursorChangedHandler);
         try {
-            await this.window.overlay.setBlockingCursor(this.window.id, Cursor.Default);
+            await this.window.overlay.setBlockingCursor(Cursor.Default);
         }
         catch {
             //
         }
     }
     clickCounts = [];
-    processCursorAction(input, x, y, globalX, globalY, movementX, movementY) {
+    processCursorAction(input_kind, x, y, globalX, globalY, movementX, movementY) {
         let button;
-        switch (input.action) {
+        switch (input_kind.action) {
             case 'Left': {
                 button = 'left';
                 break;
@@ -82,8 +77,8 @@ export class ElectronOverlayInput {
                 return;
             }
         }
-        if (input.state === 'Pressed') {
-            const clickCount = 1 + ~~input.doubleClick;
+        if (input_kind.state.type === 'Pressed') {
+            const clickCount = input_kind.state.clickCount;
             this.clickCounts.push(clickCount);
             this.contents.sendInputEvent({
                 type: 'mouseDown',
@@ -99,7 +94,7 @@ export class ElectronOverlayInput {
             });
         }
         else {
-            const clickCount = this.clickCounts.pop() ?? 1;
+            const clickCount = this.clickCounts.pop() ?? 0;
             this.contents.sendInputEvent({
                 type: 'mouseUp',
                 button,
@@ -119,13 +114,13 @@ export class ElectronOverlayInput {
         y: 0,
     };
     sendCursorInput(input) {
-        const x = input.clientX / this.screenScaleFactor;
-        const y = input.clientY / this.screenScaleFactor;
-        const globalX = input.windowX / this.screenScaleFactor;
-        const globalY = input.windowY / this.screenScaleFactor;
+        const x = input.x / this.scaleFactor;
+        const y = input.y / this.scaleFactor;
+        const globalX = input.x / this.scaleFactor;
+        const globalY = input.y / this.scaleFactor;
         const movementX = globalX - this.lastWindowCursor.x;
         const movementY = globalY - this.lastWindowCursor.y;
-        switch (input.kind) {
+        switch (input.kind.type) {
             case 'Enter': {
                 this.contents.sendInputEvent({
                     type: 'mouseEnter',
@@ -167,10 +162,10 @@ export class ElectronOverlayInput {
             }
             case 'Scroll': {
                 let scroll;
-                if (input.axis === 'Y') {
+                if (input.kind.axis === 'Y') {
                     scroll = {
                         type: 'mouseWheel',
-                        deltaY: input.delta,
+                        deltaY: input.kind.delta,
                         x,
                         y,
                         globalX,
@@ -183,7 +178,7 @@ export class ElectronOverlayInput {
                 else {
                     scroll = {
                         type: 'mouseWheel',
-                        deltaX: input.delta,
+                        deltaX: input.kind.delta,
                         x,
                         y,
                         globalX,
@@ -197,7 +192,7 @@ export class ElectronOverlayInput {
                 break;
             }
             case 'Action': {
-                this.processCursorAction(input, x, y, globalX, globalY, movementX, movementY);
+                this.processCursorAction(input.kind, x, y, globalX, globalY, movementX, movementY);
                 break;
             }
         }
@@ -256,7 +251,7 @@ export class ElectronOverlayInput {
         }
     }
     sendKeyboardInput(input) {
-        switch (input.kind) {
+        switch (input.type) {
             case 'Key': {
                 const keyCode = mapKeycode(input.key.code);
                 if (!keyCode) {
@@ -286,7 +281,7 @@ export class ElectronOverlayInput {
         }
     }
     processIme(input) {
-        if (input.ime.kind !== 'Commit') {
+        if (input.ime.type !== 'Commit') {
             return;
         }
         for (const ch of input.ime.text) {

package/lib/surface.d.ts

@@ -1,7 +1,6 @@
 import type { WebContents } from 'electron';
-import type { OverlayWindow } from './index.js';
 import EventEmitter from 'node:events';
-import { type GpuLuid } from '@asdf-overlay/core';
+import type { OverlaySurface } from './index.js';
 type Emitter = EventEmitter<{
     /**
      * An error has been occured while copying to overlay surface.
@@ -12,19 +11,19 @@ type Emitter = EventEmitter<{
  * Connection from a Electron offscreen window to a overlay surface.
  */
 export declare class ElectronOverlaySurface {
-    private readonly window;
+    private readonly surface;
     private readonly contents;
     /**
      * Events during paints.
      */
     readonly events: Emitter;
     private handler;
-    private readonly surface;
+    private readonly inner;
     private constructor();
     /**
      * Connect Electron `WebContents` surface to target overlay window.
      */
-    static connect(window: OverlayWindow, luid: GpuLuid, contents: WebContents): ElectronOverlaySurface;
+    static connect(surface: OverlaySurface, contents: WebContents): ElectronOverlaySurface;
     /**
      * Disconnect surface from Electron window and clear overlay surface.
      */

package/lib/surface.js

@@ -1,26 +1,26 @@
 import EventEmitter from 'node:events';
-import { OverlaySurface } from '@asdf-overlay/core';
+import { OverlaySurface as CoreOverlaySurface } from '@asdf-overlay/core';
 /**
  * Connection from a Electron offscreen window to a overlay surface.
  */
 export class ElectronOverlaySurface {
-    window;
+    surface;
     contents;
     /**
      * Events during paints.
      */
     events = new EventEmitter();
     handler;
-    surface;
-    constructor(window, luid, contents) {
-        this.window = window;
+    inner;
+    constructor(surface, contents) {
+        this.surface = surface;
         this.contents = contents;
-        this.surface = OverlaySurface.create(luid);
+        this.inner = new CoreOverlaySurface(surface.info.gpuId);
         this.handler = (e, rect, image) => {
             try {
                 const update = e.texture ? this.paintAccelerated(e.texture) : this.paintSoftware(rect, image);
                 if (update) {
-                    this.window.overlay.updateHandle(this.window.id, update)
+                    this.surface.overlay.updateHandle(this.surface.id, update)
                         .catch((e) => this.events.emit('error', e));
                 }
             }
@@ -34,15 +34,15 @@ export class ElectronOverlaySurface {
     /**
      * Connect Electron `WebContents` surface to target overlay window.
      */
-    static connect(window, luid, contents) {
-        return new ElectronOverlaySurface({ ...window }, luid, contents);
+    static connect(surface, contents) {
+        return new ElectronOverlaySurface({ ...surface }, contents);
     }
     /**
      * Disconnect surface from Electron window and clear overlay surface.
      */
     async disconnect() {
         this.contents.off('paint', this.handler);
-        await this.window.overlay.updateHandle(this.window.id, {});
+        await this.surface.overlay.updateHandle(this.surface.id, { type: 'None' });
     }
     /**
      * Copy overlay texture in gpu accelerated shared texture mode.
@@ -56,7 +56,7 @@ export class ElectronOverlaySurface {
             }
             const rect = info.metadata.captureUpdateRect ?? info.contentRect;
             // update only changed part
-            return this.surface.updateShtex(info.codedSize.width, info.codedSize.height, info.handle.ntHandle, {
+            return this.inner.updateNtShtex(info.codedSize.width, info.codedSize.height, info.handle.ntHandle, {
                 dstX: rect.x,
                 dstY: rect.y,
                 src: rect,
@@ -76,6 +76,6 @@ export class ElectronOverlaySurface {
             return null;
         }
         // TODO:: update only changed part
-        return this.surface.updateBitmap(image.getSize().width, image.toBitmap());
+        return this.inner.updateBitmap(image.getSize().width, image.toBitmap());
     }
 }

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@asdf-overlay/electron",
-  "version": "1.2.5",
+  "version": "2.0.0",
   "description": "Asdf overlay Electron integration",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "type": "module",
-  "author": "storycraft <storycraft@pancake.sh>",
+  "author": "storycraft <me@pancake.sh>",
   "homepage": "https://github.com/storycraft/asdf-overlay#readme",
   "license": "MIT OR Apache-2.0",
   "bugs": {
@@ -29,15 +29,15 @@
     "lib/**/*"
   ],
   "devDependencies": {
-    "@types/node": "^25.6.0",
-    "typescript": "^6.0.3"
+    "@types/node": "^22.13.14",
+    "typescript": "^7.0.2"
   },
   "peerDependencies": {
-    "electron": "^40.1.0",
-    "@asdf-overlay/core": "1.2.5"
+    "electron": "^43.3.0",
+    "@asdf-overlay/core": "2.0.0"
   },
   "scripts": {
-    "build:dist": "tsc",
-    "build": "npm run build:dist"
+    "build:publish": "tsc",
+    "build": "npm run build:publish"
   }
 }