yeow-api 0.2.7 → 0.2.9

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "yeow-api",
-    "version": "0.2.7",
-    "description": "Yeow API �?TypeScript OOP wrappers over the task protocol",
+    "version": "0.2.9",
+    "description": "Yeow API �?TypeScript OOP wrappers over the task protocol",
     "type": "module",
     "main": "./src/index.ts",
     "types": "./src/index.ts",
@@ -9,5 +9,4 @@
         "src/"
     ],
     "license": "MIT"
-}
-
+}

package/src/assets.ts

@@ -0,0 +1,42 @@
+function _sendAssets(payload) {
+    const raw = $send('assets', JSON.stringify(payload));
+    if (!raw) return undefined;
+    const r = JSON.parse(raw);
+    if (r.err) throw new Error(r.err);
+    return r;
+}
+
+export function read(path) {
+    return new Promise((resolve, reject) => {
+        try { const r = _sendAssets({ t: 'read', p: { path } }); resolve(r.data); } catch(e) { reject(e); }
+    });
+}
+export function readSync(path) {
+    return _sendAssets({ t: 'read', p: { path } }).data;
+}
+
+export function readBase64(path) {
+    return new Promise((resolve, reject) => {
+        try { const r = _sendAssets({ t: 'readBase64', p: { path } }); resolve(r.data); } catch(e) { reject(e); }
+    });
+}
+export function readBase64Sync(path) {
+    return _sendAssets({ t: 'readBase64', p: { path } }).data;
+}
+
+export function extract(path, dest) {
+    return new Promise((resolve, reject) => {
+        try {
+            const p = { path };
+            if (dest) p.dest = dest;
+            const r = _sendAssets({ t: 'extract', p }); resolve(r.path);
+        } catch(e) { reject(e); }
+    });
+}
+export function extractSync(path, dest) {
+    const p = { path };
+    if (dest) p.dest = dest;
+    return _sendAssets({ t: 'extract', p }).path;
+}
+
+export const assets = { read, readSync, readBase64, readBase64Sync, extract, extractSync };

package/src/event.ts

@@ -1,11 +1,226 @@
 import { call } from './task.js';
+import { Player } from './player.js';
+import { Location } from './location.js';
+
+// ── Event Typed Interfaces ─────────────────────────────────────────
+
+export interface PlayerJoinEvent {
+    player: Player;
+    joinMessage: string;
+}
+
+export interface PlayerQuitEvent {
+    player: Player;
+    quitMessage: string;
+}
+
+export interface PlayerChatEvent {
+    player: Player;
+    message: string;
+    format: string;
+}
+
+export interface PlayerMoveEvent {
+    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;
+}
+
+export interface PlayerCommandEvent {
+    player: Player;
+    message: string;
+}
+
+export interface PlayerDeathEvent {
+    player: Player;
+    deathMessage: string;
+    deathType: string;
+}
+
+export interface PlayerRespawnEvent {
+    player: Player;
+    respawnLocation: Location;
+}
+
+export interface PlayerDropItemEvent {
+    player: Player;
+    itemType: string;
+    amount: number;
+}
+
+export interface PlayerPickupItemEvent {
+    player: Player;
+    itemType: string;
+    amount: number;
+}
+
+export interface PlayerBucketFillEvent {
+    player: Player;
+    bucket: string;
+}
+
+export interface PlayerBucketEmptyEvent {
+    player: Player;
+    bucket: string;
+}
+
+export interface PlayerExpChangeEvent {
+    player: Player;
+    amount: number;
+}
+
+export interface PlayerLevelChangeEvent {
+    player: Player;
+    oldLevel: number;
+    newLevel: number;
+}
+
+export interface PlayerGameModeChangeEvent {
+    player: Player;
+    newGameMode: string;
+}
+
+export interface FoodLevelChangeEvent {
+    player: Player;
+    oldFoodLevel: number;
+    newFoodLevel: number;
+}
+
+export interface EntityDamageEvent {
+    entity: string;
+    damage: number;
+    cause: string;
+    entityType: string;
+}
+
+export interface EntityDeathEvent {
+    entity: string;
+    entityType: string;
+    entityName: string;
+}
+
+export interface EntitySpawnEvent {
+    entity: string;
+    entityType: string;
+    x: number;
+    y: number;
+    z: number;
+    world: string;
+}
+
+export interface ProjectileLaunchEvent {
+    entity: string;
+    projectileType: string;
+    shooter?: string;
+}
+
+export interface BlockBreakEvent {
+    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;
+}
+
+export interface InventoryOpenEvent {
+    player: Player;
+    inventoryType: string;
+    title: string;
+}
+
+export interface InventoryCloseEvent {
+    player: Player;
+    inventoryType: string;
+}
+
+export interface ServerPingEvent {
+    address: string;
+    numPlayers: number;
+    maxPlayers: number;
+    motd: 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;
+    inventoryOpen: InventoryOpenEvent;
+    inventoryClose: InventoryCloseEvent;
+    serverPing: ServerPingEvent;
+};
+
+// ── 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 '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 ───────────────────────────────────────────────
+
+export function eventOn<K extends keyof EventMap>(eventType: K, handler: (e: EventMap[K]) => void): () => void {
+    const wrapper = (data: any) => handler(adaptEvent(eventType, data) as EventMap[K]);
+    (wrapper as any)._raw = handler;
 
-export function eventOn(eventType: string, handler: (e: any) => void): () => void {
-    // eventOn registers a handler on the JS side.
-    // The _onEvent function in init.js dispatches SYNC_CALLBACK messages to handlers.
-    // For now, event handlers are set up via a global registry.
-    // This is a simplified version — full sync callback event system requires
-    // the PluginThread to call _onEvent which processes handlers.
     if (!(globalThis as any).__yeowEventHandlers) (globalThis as any).__yeowEventHandlers = {};
     if (!(globalThis as any).__yeowEventHandlers[eventType]) {
         (globalThis as any).__yeowEventHandlers[eventType] = [];
@@ -14,14 +229,14 @@ export function eventOn(eventType: string, handler: (e: any) => void): () => voi
             eventType,
         });
     }
-    (globalThis as any).__yeowEventHandlers[eventType].push(handler);
+    (globalThis as any).__yeowEventHandlers[eventType].push(wrapper);
     return () => eventOff(eventType, handler);
 }
 
-export function eventOff(eventType: string, handler: (e: any) => void): void {
+export function eventOff(eventType: string, handler: Function): void {
     const handlers = (globalThis as any).__yeowEventHandlers?.[eventType];
     if (!handlers) return;
-    const idx = handlers.indexOf(handler);
+    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];
@@ -32,31 +247,31 @@ export function eventOff(eventType: string, handler: (e: any) => void): void {
     }
 }
 
-// Install _onEvent handler called by init.js for SYNC_CALLBACK events
-(globalThis as any)._onEvent = (eventType: string, snapshot: any): any => {
+// ── _onEvent dispatcher (called from init.js) ──────────────────────
+
+(globalThis as any)._onEvent = (eventType: string, data: any): any => {
     const handlers = (globalThis as any).__yeowEventHandlers?.[eventType];
     if (!handlers?.length) return {};
 
-    const cancellable = snapshot?._cancellable;
+    const cancellable = data?._cancellable;
     const mods: Record<string, any> = {};
 
+    const wrapped = adaptEvent(eventType, data);
+
+    const localMods: Record<string, any> = {};
+    if (cancellable) {
+        Object.defineProperty(wrapped, 'cancelled', {
+            get: () => localMods.cancelled || false,
+            set: (v: boolean) => { localMods.cancelled = v; },
+            enumerable: true,
+        });
+    }
+
     for (const handler of handlers) {
         try {
-            const proxy: any = {};
-            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: () => localMods.cancelled || false,
-                    set: (v: boolean) => { localMods.cancelled = v; },
-                    enumerable: true,
-                });
-            }
-            handler(proxy);
-            if (cancellable && localMods.cancelled) mods.cancelled = true;
+            handler(wrapped);
         } catch (e: any) { console.error('event:', e?.message || e); }
     }
+    if (cancellable && localMods.cancelled) mods.cancelled = true;
     return mods;
 };

package/src/fs.ts

@@ -1,33 +1,70 @@
-import { call } from './task.js';
+function _sendFs(payload) {
+    const raw = $send('fs', JSON.stringify(payload));
+    if (!raw) return undefined;
+    const r = JSON.parse(raw);
+    if (r.err) throw new Error(r.err);
+    return r;
+}
 
-/**
- * Async file system operations. Paths are resolved relative to the server root.
- * All sync variants have the `Sync` suffix.
- */
+export function readFile(path) {
+    return new Promise((resolve, reject) => {
+        try { const r = _sendFs({ t: 'readFile', p: { path } }); resolve(r.data); } catch(e) { reject(e); }
+    });
+}
+export function readFileSync(path) {
+    return _sendFs({ t: 'readFile', p: { path } }).data;
+}
 
-export function readFile(path: string): Promise<string> {
-    return call('fs.readFile', { path }) as Promise<string>;
+export function readFileBase64(path) {
+    return new Promise((resolve, reject) => {
+        try { const r = _sendFs({ t: 'readBase64', p: { path } }); resolve(r.data); } catch(e) { reject(e); }
+    });
+}
+export function readFileBase64Sync(path) {
+    return _sendFs({ t: 'readBase64', p: { path } }).data;
 }
 
-export function readFileSync(path: string): string {
-    return call('fs.readFile', { path }) as string;
+export function writeFile(path, data) {
+    return new Promise((resolve, reject) => {
+        try { _sendFs({ t: 'writeFile', p: { path, data } }); resolve(); } catch(e) { reject(e); }
+    });
+}
+export function writeFileSync(path, data) {
+    _sendFs({ t: 'writeFile', p: { path, data } });
 }
 
-export function writeFile(path: string, data: string): Promise<void> {
-    return call('fs.writeFile', { path, data }) as Promise<void>;
+export function writeFileBase64(path, data) {
+    return new Promise((resolve, reject) => {
+        try { _sendFs({ t: 'writeBase64', p: { path, data } }); resolve(); } catch(e) { reject(e); }
+    });
+}
+export function writeFileBase64Sync(path, data) {
+    _sendFs({ t: 'writeBase64', p: { path, data } });
 }
 
-export function writeFileSync(path: string, data: string): void {
-    call('fs.writeFile', { path, data });
+export function existsSync(path) {
+    const r = _sendFs({ t: 'exists', p: { path } });
+    return r === true || String(r) === 'true';
 }
 
-export function existsSync(path: string): boolean {
-    return call('fs.exists', { path }) as boolean;
+export function deleteFile(path) {
+    return new Promise((resolve, reject) => {
+        try { const r = _sendFs({ t: 'delete', p: { path } }); resolve(r === true || String(r) === 'true'); } catch(e) { reject(e); }
+    });
+}
+export function mkdir(path) {
+    return new Promise((resolve, reject) => {
+        try { _sendFs({ t: 'mkdir', p: { path } }); resolve(); } catch(e) { reject(e); }
+    });
+}
+export function list(path) {
+    return new Promise((resolve, reject) => {
+        try { const r = _sendFs({ t: 'list', p: { path } }); resolve(r); } catch(e) { reject(e); }
+    });
 }
 
 export const fs = {
-    readFile, readFileSync,
-    writeFile, writeFileSync,
-    existsSync,
-    // ... more to come
+    readFile, readFileSync, readFileBase64, readFileBase64Sync,
+    writeFile, writeFileSync, writeFileBase64, writeFileBase64Sync,
+    existsSync, deleteFile, mkdir, list,
 };

package/src/http.ts

@@ -1,69 +1,63 @@
-import { call, post } from './task.js';
-
-const _servers: Set<string> = new Set();
+const _servers = new Set();
+
+function _sendHttp(payload) {
+    const raw = $send('http', JSON.stringify(payload));
+    if (!raw) return undefined;
+    const r = JSON.parse(raw);
+    if (r.err) throw new Error(r.err);
+    return r;
+}
 
-/**
- * Start an HTTP server on a random available port.
- * The callback receives: { connId, serverId, method, path, query, headers, body }
- * Response is sent via http.respond(task: { serverId, connId, status?, headers?, body? })
- */
-export function listen(
-    callback: (req: HttpRequest) => void,
-    port?: number
-): Promise<{ serverId: string; port: number }> {
+export function listen(callback, port) {
     return new Promise((resolve, reject) => {
-        const cbId = (globalThis as any)._registerCallback((payload: HttpRequest) => {
+        const cbId = _registerCallback((payload) => {
             callback(payload);
         }, { persistent: true });
 
-        const result = call('http.listen', {
-            pluginName: (globalThis as any).__plugin?.name || 'unknown',
-            callbackId: String(cbId),
-            port: port || 0,
-        }) as { serverId: string; port: number };
-
-        _servers.add(result.serverId);
-        resolve(result);
+        try {
+            const result = _sendHttp({ t: 'listen', p: {
+                pluginName: __plugin?.name || 'unknown',
+                callbackId: String(cbId),
+                port: port || 0,
+            }});
+            _servers.add(result.serverId);
+            resolve(result);
+        } catch(e) { reject(e); }
     });
 }
 
-/**
- * Send an HTTP response to a pending connection.
- */
-export function respond(serverId: string, connId: string, options: {
-    status?: number; headers?: Record<string, string>; body?: string;
-}): Promise<void> {
-    return call('http.respond', {
-        serverId,
-        connId,
-        status: options.status || 200,
-        headers: options.headers || {},
-        body: options.body || '',
-    }) as Promise<void>;
+export function respond(serverId, connId, opts = {}) {
+    return new Promise((resolve, reject) => {
+        try {
+            _sendHttp({ t: 'respond', p: { serverId, connId, ...opts }});
+            resolve();
+        } catch(e) { reject(e); }
+    });
 }
 
-/**
- * Stop an HTTP server and release its port.
- */
-export function close(serverId: string): Promise<void> {
+export function close(serverId) {
     _servers.delete(serverId);
-    return call('http.close', { serverId }) as Promise<void>;
+    return new Promise((resolve, reject) => {
+        try { _sendHttp({ t: 'close', p: { serverId }}); resolve(); } catch(e) { reject(e); }
+    });
 }
 
-/** Auto-close all servers when the plugin is disabled. */
-(globalThis as any)._registerCallback(() => {
+_registerCallback(() => {
     for (const id of _servers) {
-        try { call('http.close', { serverId: id }); } catch {}
+        try { _sendHttp({ t: 'close', p: { serverId: id }}); } catch {}
     }
     _servers.clear();
 }, { persistent: true });
 
-export interface HttpRequest {
-    connId: string;
-    serverId: string;
-    method: string;
-    path: string;
-    query: string;
-    headers: Record<string, string>;
-    body: string;
+export function request(url, opts = {}) {
+    return new Promise((resolve, reject) => {
+        try {
+            const result = _sendHttp({ t: 'request', p: { url, ...opts }});
+            resolve(result);
+        } catch(e) { reject(e); }
+    });
+}
+
+export function requestSync(url, opts = {}) {
+    return _sendHttp({ t: 'request', p: { url, ...opts }});
 }

package/src/index.ts

@@ -4,4 +4,18 @@ export { Player } from './player.js';
 export { registerCommand } from './command.js';
 export type { CommandOptions, CommandPayload, CommandSender } from './command.js';
 export { eventOn, eventOff } from './event.js';
+export type {
+    PlayerJoinEvent, PlayerQuitEvent, PlayerChatEvent, PlayerMoveEvent,
+    PlayerInteractEvent, PlayerCommandEvent, PlayerDeathEvent, PlayerRespawnEvent,
+    PlayerDropItemEvent, PlayerPickupItemEvent, PlayerBucketFillEvent, PlayerBucketEmptyEvent,
+    PlayerExpChangeEvent, PlayerLevelChangeEvent, PlayerGameModeChangeEvent, FoodLevelChangeEvent,
+    EntityDamageEvent, EntityDeathEvent, EntitySpawnEvent, ProjectileLaunchEvent,
+    BlockBreakEvent, BlockPlaceEvent,
+    InventoryOpenEvent, InventoryCloseEvent,
+    ServerPingEvent,
+} from './event.js';
+export { onInit, onLoad } from './lifecycle.js';
 export { broadcast, getMotd, getVersion } from './server.js';
+export { fs, readFile, readFileSync, readFileBase64, readFileBase64Sync, writeFile, writeFileSync, writeFileBase64, writeFileBase64Sync, existsSync, deleteFile, mkdir, list } from './fs.js';
+export { assets, read as assetsRead, readSync as assetsReadSync, readBase64 as assetsReadBase64, readBase64Sync as assetsReadBase64Sync, extract as assetsExtract, extractSync as assetsExtractSync } from './assets.js';
+export { listen, respond, close, request, requestSync } from './http.js';

package/src/lifecycle.ts

@@ -0,0 +1,8 @@
+const _initCbs: (() => void)[] = [];
+const _loadCbs: (() => void)[] = [];
+
+export function onInit(cb: () => void): void { _initCbs.push(cb); }
+export function onLoad(cb: () => void): void { _loadCbs.push(cb); }
+
+(globalThis as any).__yeowInitCbs = _initCbs;
+(globalThis as any).__yeowLoadCbs = _loadCbs;

package/src/task.ts

@@ -1,15 +1,19 @@
-export function post(type: string, params: Record<string, unknown> = {}): Promise<unknown> {
+export function post(type: string, params: Record<string, unknown> = {}, priority?: string): Promise<unknown> {
     return new Promise((resolve, reject) => {
         const cbId = (globalThis as any)._registerCallback((result: any) => {
             if (result?.err) reject(new Error(result.err));
             else resolve(result);
         });
-        (globalThis as any).$send('game', JSON.stringify({ t: type, p: params, cb: cbId }));
+        const pld: Record<string, unknown> = { t: type, p: params, cb: cbId };
+        if (priority) pld._priority = priority;
+        (globalThis as any).$send('game', JSON.stringify(pld));
     });
 }
 
-export function call(type: string, params: Record<string, unknown> = {}): unknown {
-    const raw = (globalThis as any).$send('game', JSON.stringify({ t: type, p: params }));
+export function call(type: string, params: Record<string, unknown> = {}, priority?: string): unknown {
+    const pld: Record<string, unknown> = { t: type, p: params };
+    if (priority) pld._priority = priority;
+    const raw = (globalThis as any).$send('game', JSON.stringify(pld));
     if (!raw) return undefined;
     const r = JSON.parse(raw as string);
     if (r.err) throw new Error(r.err);