yeow-api 0.1.4 → 0.1.8

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "yeow-api",
-    "version": "0.1.4",
+    "version": "0.1.8",
     "description": "Yeow API �?TypeScript OOP wrappers over the task protocol",
     "type": "module",
     "main": "./src/index.ts",

package/src/event.ts

@@ -1,11 +1,6 @@
 import { call } from './task.js';
 
-/**
- * Event subscription with cancellation support.
- * Sync handlers: e.cancelled = true takes effect immediately (sync task intercepted by EventBridge).
- * Async handlers: e.cancelled is @deprecated (no effect after await).
- */
-const _handlers: Record<string, Array<{ h: Function; async: boolean }>> = {};
+const _handlers: Record<string, Array<{ h: Function }>> = {};
 
 function _process(internalType: string, snapshot: Record<string, unknown>): Record<string, unknown> {
     const entries = _handlers[internalType];
@@ -20,31 +15,29 @@ function _process(internalType: string, snapshot: Record<string, unknown>): Reco
             for (const key of Object.keys(snapshot)) {
                 if (!key.startsWith('_')) proxy[key] = snapshot[key];
             }
+            const localMods: Record<string, any> = {};
             if (cancellable) {
                 Object.defineProperty(proxy, 'cancelled', {
-                    get: () => call('event.isCancelled', {}),
-                    set: (v: boolean) => { call('event.setCancelled', { cancelled: v }); },
+                    get: () => localMods.cancelled || false,
+                    set: (v: boolean) => { localMods.cancelled = v; },
                     enumerable: true,
                 });
             }
             entry.h(proxy);
-        } catch (e: any) { console.error(`event handler error: ${e?.message || e}`); }
+            if (cancellable && localMods.cancelled) {
+                mods.cancelled = true;
+            }
+        } catch (e: any) { console.error(`event: ${e?.message || e}`); }
     }
     return mods;
 }
 
-// Install the global event handler that init.js calls
-(globalThis as any)._onEvent = (msg: any) => {
-    const eventType = msg.ev;
-    _process(eventType, msg.sn);
-    // Notify Java that event processing is done
-    if (typeof (globalThis as any)._eventComplete === 'function') {
-        (globalThis as any)._eventComplete(eventType);
-    }
+// SYNC_CALLBACK handler — receives snapshot, returns modifications
+(globalThis as any)._onEvent = (eventType: string, snapshot: any): any => {
+    return _process(eventType, snapshot);
 };
 
 export function eventOn(eventType: string, handler: (e: any) => void): () => void {
-    const async = handler.constructor.name === 'AsyncFunction';
     if (!_handlers[eventType]) {
         _handlers[eventType] = [];
         call('event.subscribe', {
@@ -52,8 +45,7 @@ export function eventOn(eventType: string, handler: (e: any) => void): () => voi
             eventType,
         });
     }
-    const entry = { h: handler, async };
-    _handlers[eventType].push(entry);
+    _handlers[eventType].push({ h: handler });
     return () => eventOff(eventType, handler);
 }