yeow-api 0.2.31 → 0.2.34

package/src/event.ts

@@ -2,397 +2,349 @@ import { call } from './task.js';
 import { Player } from './player.js';
 import { Location } from './location.js';
 
-// ── Event Typed Interfaces ─────────────────────────────────────────
+// ── Event Data Interfaces ──────────────────────────────────────────
 
 export interface PlayerJoinEvent {
-    player: Player;
-    joinMessage: string;
+  player: Player;
+  joinMessage: string;
 }
-
 export interface PlayerQuitEvent {
-    player: Player;
-    quitMessage: string;
+  player: Player;
+  quitMessage: string;
 }
-
 export interface PlayerChatEvent {
-    player: Player;
-    message: string;
-    format: string;
+  player: Player;
+  message: string;
+  format: string;
 }
-
 export interface PlayerMoveEvent {
-    player: Player;
-    from: Location;
-    to: Location;
+  player: Player;
+  from: Location;
+  to: Location;
 }
-
 export interface PlayerInteractEvent {
-    player: Player;
-    action: string;
-    material: string | null;
-    block: { x: number; y: number; z: number; type: string } | null;
+  player: Player;
+  action: string;
+  material: string | null;
+  block: { x: number; y: number; z: number; type: string } | null;
 }
-
 export interface PlayerCommandEvent {
-    player: Player;
-    message: string;
+  player: Player;
+  message: string;
 }
-
 export interface PlayerDeathEvent {
-    player: Player;
-    deathMessage: string;
-    deathType: string;
+  player: Player;
+  deathMessage: string;
+  deathType: string;
 }
-
 export interface PlayerRespawnEvent {
-    player: Player;
-    respawnLocation: Location;
+  player: Player;
+  respawnLocation: Location;
 }
-
 export interface PlayerDropItemEvent {
-    player: Player;
-    itemType: string;
-    amount: number;
+  player: Player;
+  itemType: string;
+  amount: number;
 }
-
 export interface PlayerPickupItemEvent {
-    player: Player;
-    itemType: string;
-    amount: number;
+  player: Player;
+  itemType: string;
+  amount: number;
 }
-
 export interface PlayerBucketFillEvent {
-    player: Player;
-    bucket: string;
+  player: Player;
+  bucket: string;
 }
-
 export interface PlayerBucketEmptyEvent {
-    player: Player;
-    bucket: string;
+  player: Player;
+  bucket: string;
 }
-
 export interface PlayerExpChangeEvent {
-    player: Player;
-    amount: number;
+  player: Player;
+  amount: number;
 }
-
 export interface PlayerLevelChangeEvent {
-    player: Player;
-    oldLevel: number;
-    newLevel: number;
+  player: Player;
+  oldLevel: number;
+  newLevel: number;
 }
-
 export interface PlayerGameModeChangeEvent {
-    player: Player;
-    newGameMode: string;
+  player: Player;
+  newGameMode: string;
 }
-
 export interface FoodLevelChangeEvent {
-    player: Player;
-    oldFoodLevel: number;
-    newFoodLevel: number;
+  player: Player;
+  oldFoodLevel: number;
+  newFoodLevel: number;
 }
-
 export interface EntityDamageEvent {
-    entity: string;
-    damage: number;
-    cause: string;
-    entityType: string;
+  entity: string;
+  damage: number;
+  cause: string;
+  entityType: string;
 }
-
 export interface EntityDeathEvent {
-    entity: string;
-    entityType: string;
-    entityName: string;
+  entity: string;
+  entityType: string;
+  entityName: string;
 }
-
 export interface EntitySpawnEvent {
-    entity: string;
-    entityType: string;
-    x: number;
-    y: number;
-    z: number;
-    world: string;
+  entity: string;
+  entityType: string;
+  x: number;
+  y: number;
+  z: number;
+  world: string;
 }
-
 export interface ProjectileLaunchEvent {
-    entity: string;
-    projectileType: string;
-    shooter?: string;
+  entity: string;
+  projectileType: string;
+  shooter?: string;
 }
-
 export interface BlockBreakEvent {
-    player: Player;
-    block: string;
-    x: number;
-    y: number;
-    z: number;
+  player: Player;
+  block: string;
+  x: number;
+  y: number;
+  z: number;
 }
-
 export interface BlockPlaceEvent {
-    player: Player;
-    block: string;
-    blockAgainst: string;
-    x: number;
-    y: number;
-    z: number;
+  player: Player;
+  block: string;
+  blockAgainst: string;
+  x: number;
+  y: number;
+  z: number;
 }
-
 export interface InventoryOpenEvent {
-    player: Player;
-    inventoryType: string;
-    title: string;
+  player: Player;
+  inventoryType: string;
+  title: string;
 }
-
 export interface InventoryCloseEvent {
-    player: Player;
-    inventoryType: string;
+  player: Player;
+  inventoryType: string;
 }
-
 export interface ServerPingEvent {
-    address: string;
-    numPlayers: number;
-    maxPlayers: number;
-    motd: string;
+  address: string;
+  numPlayers: number;
+  maxPlayers: number;
+  motd: string;
 }
-
 export interface PlayerTeleportEvent {
-    player: Player;
-    from: Location;
-    to: Location;
-    cause: string;
+  player: Player;
+  from: Location;
+  to: Location;
+  cause: string;
 }
-
 export interface PlayerItemConsumeEvent {
-    player: Player;
-    itemType: string;
+  player: Player;
+  itemType: string;
 }
-
 export interface EntityExplodeEvent {
-    entity: string;
-    entityType: string;
-    x: number;
-    y: number;
-    z: number;
-    blockCount: number;
+  entity: string;
+  entityType: string;
+  x: number;
+  y: number;
+  z: number;
+  blockCount: number;
 }
-
 export interface EntityRegainHealthEvent {
-    entity: string;
-    amount: number;
-    reason: string;
+  entity: string;
+  amount: number;
+  reason: string;
 }
-
 export interface EntityTargetEvent {
-    entity: string;
-    target: string | null;
+  entity: string;
+  target: string | null;
 }
-
 export interface ProjectileHitEvent {
-    entity: string;
-    projectileType: string;
-    hitEntity: string | null;
-    hitBlock: { x: number; y: number; z: number; type: string } | null;
+  entity: string;
+  projectileType: string;
+  hitEntity: string | null;
+  hitBlock: { x: number; y: number; z: number; type: string } | null;
 }
-
 export interface BlockFadeEvent {
-    block: string;
-    x: number;
-    y: number;
-    z: number;
+  block: string;
+  x: number;
+  y: number;
+  z: number;
 }
-
 export interface BlockGrowEvent {
-    block: string;
-    x: number;
-    y: number;
-    z: number;
+  block: string;
+  x: number;
+  y: number;
+  z: number;
 }
-
 export interface BlockSpreadEvent {
-    block: string;
-    x: number;
-    y: number;
-    z: number;
+  block: string;
+  x: number;
+  y: number;
+  z: number;
 }
-
 export interface BlockExplodeEvent {
-    block: string;
-    x: number;
-    y: number;
-    z: number;
+  block: string;
+  x: number;
+  y: number;
+  z: number;
 }
-
 export interface ServerCommandEvent {
-    command: string;
-    sender: string;
+  command: string;
+  sender: string;
 }
 
-// ── Event Type Mapping ─────────────────────────────────────────────
-
 type EventMap = {
-    playerJoin: PlayerJoinEvent;
-    playerQuit: PlayerQuitEvent;
-    playerChat: PlayerChatEvent;
-    playerMove: PlayerMoveEvent;
-    playerInteract: PlayerInteractEvent;
-    playerCommand: PlayerCommandEvent;
-    playerDeath: PlayerDeathEvent;
-    playerRespawn: PlayerRespawnEvent;
-    playerDropItem: PlayerDropItemEvent;
-    playerPickupItem: PlayerPickupItemEvent;
-    playerBucketFill: PlayerBucketFillEvent;
-    playerBucketEmpty: PlayerBucketEmptyEvent;
-    playerExpChange: PlayerExpChangeEvent;
-    playerLevelChange: PlayerLevelChangeEvent;
-    playerGameModeChange: PlayerGameModeChangeEvent;
-    foodLevelChange: FoodLevelChangeEvent;
-    entityDamage: EntityDamageEvent;
-    entityDeath: EntityDeathEvent;
-    entitySpawn: EntitySpawnEvent;
-    projectileLaunch: ProjectileLaunchEvent;
-    blockBreak: BlockBreakEvent;
-    blockPlace: BlockPlaceEvent;
-    blockFade: BlockFadeEvent;
-    blockGrow: BlockGrowEvent;
-    blockSpread: BlockSpreadEvent;
-    blockExplode: BlockExplodeEvent;
-    inventoryOpen: InventoryOpenEvent;
-    inventoryClose: InventoryCloseEvent;
-    serverPing: ServerPingEvent;
-    serverCommand: ServerCommandEvent;
-    playerTeleport: PlayerTeleportEvent;
-    playerItemConsume: PlayerItemConsumeEvent;
-    entityExplode: EntityExplodeEvent;
-    entityRegainHealth: EntityRegainHealthEvent;
-    entityTarget: EntityTargetEvent;
-    projectileHit: ProjectileHitEvent;
+  playerJoin: PlayerJoinEvent;
+  playerQuit: PlayerQuitEvent;
+  playerChat: PlayerChatEvent;
+  playerMove: PlayerMoveEvent;
+  playerInteract: PlayerInteractEvent;
+  playerCommand: PlayerCommandEvent;
+  playerDeath: PlayerDeathEvent;
+  playerRespawn: PlayerRespawnEvent;
+  playerDropItem: PlayerDropItemEvent;
+  playerPickupItem: PlayerPickupItemEvent;
+  playerBucketFill: PlayerBucketFillEvent;
+  playerBucketEmpty: PlayerBucketEmptyEvent;
+  playerExpChange: PlayerExpChangeEvent;
+  playerLevelChange: PlayerLevelChangeEvent;
+  playerGameModeChange: PlayerGameModeChangeEvent;
+  foodLevelChange: FoodLevelChangeEvent;
+  entityDamage: EntityDamageEvent;
+  entityDeath: EntityDeathEvent;
+  entitySpawn: EntitySpawnEvent;
+  entityExplode: EntityExplodeEvent;
+  entityRegainHealth: EntityRegainHealthEvent;
+  entityTarget: EntityTargetEvent;
+  projectileLaunch: ProjectileLaunchEvent;
+  projectileHit: ProjectileHitEvent;
+  blockBreak: BlockBreakEvent;
+  blockPlace: BlockPlaceEvent;
+  blockFade: BlockFadeEvent;
+  blockGrow: BlockGrowEvent;
+  blockSpread: BlockSpreadEvent;
+  blockExplode: BlockExplodeEvent;
+  inventoryOpen: InventoryOpenEvent;
+  inventoryClose: InventoryCloseEvent;
+  serverPing: ServerPingEvent;
+  serverCommand: ServerCommandEvent;
+  playerTeleport: PlayerTeleportEvent;
+  playerItemConsume: PlayerItemConsumeEvent;
 };
 
-// ── Event Data Adapter ──────────────────────────────────────────────
-
-function _loc(raw: any): Location | null {
-    if (!raw) return null;
-    return new Location(raw.x, raw.y, raw.z, raw.yaw ?? 0, raw.pitch ?? 0, raw.world);
-}
-
-function adaptEvent(type: string, data: any): any {
-    if (!data) return data;
-    const wrap: any = {};
-    for (const key of Object.keys(data)) {
-        if (key.startsWith('_')) continue;
-        wrap[key] = data[key];
-    }
-    switch (type) {
-        case 'playerJoin': case 'playerQuit': case 'playerChat': case 'playerMove':
-        case 'playerInteract': case 'playerCommand': case 'playerDeath': case 'playerRespawn':
-        case 'playerTeleport': case 'playerItemConsume':
-        case 'playerDropItem': case 'playerPickupItem': case 'playerBucketFill': case 'playerBucketEmpty':
-        case 'playerExpChange': case 'playerLevelChange': case 'playerGameModeChange': case 'foodLevelChange':
-        case 'blockBreak': case 'blockPlace': case 'inventoryOpen': case 'inventoryClose':
-            if (data.player) wrap.player = Player.get(data.player);
-            break;
-    }
-    if (data.from) wrap.from = _loc(data.from);
-    if (data.to) wrap.to = _loc(data.to);
-    if (data.respawnLocation) wrap.respawnLocation = _loc(data.respawnLocation);
-    return wrap;
-}
-
-// ── EventOn/EventOff ───────────────────────────────────────────────
+type RawEvent = Record<string, unknown> & { _cancellable?: boolean };
+
+function loc(raw: Record<string, unknown> | null): Location | null {
+  if (!raw) return null;
+  return new Location(
+    raw.x as number, raw.y as number, raw.z as number,
+    (raw.yaw as number) ?? 0, (raw.pitch as number) ?? 0, raw.world as string,
+  );
+}
+
+function adaptEvent<K extends keyof EventMap>(type: K, data: RawEvent): EventMap[K] {
+  const wrap: Record<string, unknown> = {};
+  for (const key of Object.keys(data)) {
+    if (key.startsWith('_')) continue;
+    wrap[key] = data[key];
+  }
+  const hasPlayer = [
+    'playerJoin', 'playerQuit', 'playerChat', 'playerMove',
+    'playerInteract', 'playerCommand', 'playerDeath', 'playerRespawn',
+    'playerTeleport', 'playerItemConsume',
+    'playerDropItem', 'playerPickupItem', 'playerBucketFill',
+    'playerBucketEmpty', 'playerExpChange', 'playerLevelChange',
+    'playerGameModeChange', 'foodLevelChange', 'blockBreak',
+    'blockPlace', 'inventoryOpen', 'inventoryClose',
+  ] as K[];
+  if (hasPlayer.includes(type) && data.player) {
+    wrap.player = Player.get(data.player as string);
+  }
+  if (data.from) wrap.from = loc(data.from as Record<string, unknown>);
+  if (data.to) wrap.to = loc(data.to as Record<string, unknown>);
+  if (data.respawnLocation) wrap.respawnLocation = loc(data.respawnLocation as Record<string, unknown>);
+  return wrap as unknown as EventMap[K];
+}
+
+// ── Event Subscription ─────────────────────────────────────────────
+
+type EventHandler<K extends keyof EventMap> = (e: EventMap[K]) => void;
+type ManualHandler<K extends keyof EventMap> = (
+  e: EventMap[K],
+  complete: (result?: Record<string, unknown>) => void,
+) => void;
 
 export function eventOn<K extends keyof EventMap>(
-    eventType: K,
-    handler: ((e: EventMap[K]) => void) | ((e: EventMap[K], release: (result?: any) => void) => void),
-    options?: { manualRelease?: boolean }
+  eventType: K,
+  handler: EventHandler<K>,
+): () => void;
+export function eventOn<K extends keyof EventMap>(
+  eventType: K,
+  options: { manualRelease: true },
+  handler: ManualHandler<K>,
+): () => void;
+export function eventOn<K extends keyof EventMap>(
+  eventType: K,
+  handlerOrOptions: EventHandler<K> | { manualRelease?: boolean },
+  handlerOrUndef?: ManualHandler<K>,
 ): () => void {
-    const wrapper = (data: any, release?: Function) => {
-        if (options?.manualRelease) {
-            (handler as any)(data as EventMap[K], release);
-        } else {
-            (handler as any)(data as EventMap[K]);
-        }
-    };
-    (wrapper as any)._raw = handler;
-    (wrapper as any)._manualRelease = !!options?.manualRelease;
-
-    if (!(globalThis as any).__yeowEventHandlers) (globalThis as any).__yeowEventHandlers = {};
-    if (!(globalThis as any).__yeowEventHandlers[eventType]) {
-        (globalThis as any).__yeowEventHandlers[eventType] = [];
-        call('event.subscribe', {
-            pluginName: (globalThis as any).__plugin?.name || 'unknown',
-            eventType,
-        });
-    }
-    (globalThis as any).__yeowEventHandlers[eventType].push(wrapper);
-    return () => eventOff(eventType, handler);
-}
+  const manualRelease = typeof handlerOrOptions === 'object' && handlerOrOptions?.manualRelease === true;
+  const handler = manualRelease ? handlerOrUndef! : (handlerOrOptions as EventHandler<K>);
+  const pluginName = __plugin?.name || 'unknown';
 
-export function eventOff(eventType: string, handler: Function): void {
-    const handlers = (globalThis as any).__yeowEventHandlers?.[eventType];
-    if (!handlers) return;
-    const idx = handlers.findIndex((h: any) => h._raw === handler || h === handler);
-    if (idx !== -1) handlers.splice(idx, 1);
-    if (handlers.length === 0) {
-        delete (globalThis as any).__yeowEventHandlers[eventType];
-        call('event.unsubscribe', {
-            pluginName: (globalThis as any).__plugin?.name || 'unknown',
-            eventType,
-        });
-    }
-}
-
-// ── _onEvent dispatcher (called from init.js) ──────────────────────
-
-(globalThis as any)._onEvent = (eventType: string, data: any, release: Function): void => {
-    const handlers = (globalThis as any).__yeowEventHandlers?.[eventType];
-    if (!handlers?.length) { release({}); return; }
-
-    const cancellable = data?._cancellable;
+  const cbId = _registerCallback((data: RawEvent) => {
     const wrapped = adaptEvent(eventType, data);
-    const localMods: Record<string, any> = {};
+    const cancellable = data?._cancellable;
+    const localMods: { cancelled?: boolean } = {};
 
     if (cancellable) {
-        Object.defineProperty(wrapped, 'cancelled', {
-            get: () => localMods.cancelled || false,
-            set: (v: boolean) => { localMods.cancelled = v; },
-            enumerable: true,
+      Object.defineProperty(wrapped, 'cancelled', {
+        get: () => localMods.cancelled || false,
+        set: (v: boolean) => { localMods.cancelled = v; },
+        enumerable: true,
+      });
+    }
+
+    if (manualRelease) {
+      const complete = (result?: Record<string, unknown>) => {
+        $send('task', {
+          type: 'event.complete',
+          params: { callbackId: cbId, mods: result },
+          cb: '',
         });
+      };
+      (handler as ManualHandler<typeof eventType>)(wrapped, complete);
+      return;
     }
 
-    const finish = () => {
-        if (cancellable && localMods.cancelled) release({ cancelled: true });
-        else release({});
-    };
+    const result = (handler as EventHandler<typeof eventType>)(wrapped);
+    const mods = { cancelled: localMods.cancelled || false };
+    $send('task', { type: 'event.complete', params: { callbackId: cbId, mods }, cb: '' });
+  }, { persistent: true });
 
-    for (const wrapper of handlers) {
-        try {
-            if ((wrapper as any)._manualRelease) {
-                wrapper(wrapped, release);
-                return;
-            }
-            const result = wrapper(wrapped);
-            if (result && typeof result.then === 'function') {
-                // Async handler — release immediately with sync mods only.
-                // Awaiting async operations in event handlers requires manualRelease: true.
-                finish();
-                return;
-            }
-        } catch (e: any) {
-            const errInfo: any = {
-                message: e?.message || String(e),
-                stack: e?.stack || '',
-                fileName: e?.fileName || 'main.js',
-                lineNumber: e?.lineNumber || 0,
-                columnNumber: e?.columnNumber || 0,
-            };
-            if (!errInfo.fileName || errInfo.fileName === 'main.js' || !errInfo.lineNumber) {
-                const m = e?.stack?.match(/at\s+(?:\S+\s+)?\(?([^\s(]+):(\d+):(\d+)\)?/);
-                if (m) { errInfo.fileName = m[1]; errInfo.lineNumber = parseInt(m[2]); errInfo.columnNumber = parseInt(m[3]); }
-            }
-            (globalThis as any).$send('reportError', errInfo);
-        }
-    }
+  if (!__yeowEventHandlers) (globalThis as any).__yeowEventHandlers = {};
+  const handlers = __yeowEventHandlers!;
+  if (!handlers[eventType]) handlers[eventType] = [];
+  handlers[eventType].push({ cbId, handler, manualRelease });
 
-    finish();
-};
+  call('event.subscribe', { pluginName, eventType, callbackId: String(cbId) });
+  return () => eventOff(eventType, handler);
+}
+
+export function eventOff(eventType: string, handler: Function): void {
+  if (!__yeowEventHandlers) return;
+  const entries = __yeowEventHandlers[eventType];
+  if (!entries) return;
+  const idx = entries.findIndex((e) => e.handler === handler);
+  if (idx !== -1) {
+    const removed = entries.splice(idx, 1)[0];
+    if (removed.cbId) _unregisterCallback(removed.cbId);
+  }
+  if (entries.length === 0) {
+    delete __yeowEventHandlers![eventType];
+    call('event.unsubscribe', {
+      pluginName: __plugin?.name || 'unknown',
+      eventType,
+    });
+  }
+}