yeow-api 0.2.11 → 0.2.13

package/package.json

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

package/src/entity.ts

@@ -1,4 +1,4 @@
-import { call } from './task.js';
+import { call, post } from './task.js';
 import { Location } from './location.js';
 
 export class Entity {
@@ -6,9 +6,9 @@ export class Entity {
 
     get type(): string { return call('entity.getType', { uuid: this.uuid }) as string; }
     get name(): string { return call('entity.getName', { uuid: this.uuid }) as string; }
-    get customName(): string | null { return call('entity.getCustomName', { uuid: this.uuid }) as string | null; }
+    get customName(): string | null { const r = call('entity.getCustomName', { uuid: this.uuid }); return r || null; }
     set customName(v: string | null) { call('entity.setCustomName', { uuid: this.uuid, value: v }); }
-    setCustomNameVisible(v: boolean): Promise<void> { return call('entity.setCustomNameVisible', { uuid: this.uuid, value: v }) as Promise<void>; }
+    setCustomNameVisible(v: boolean): Promise<void> { return post('entity.setCustomNameVisible', { uuid: this.uuid, value: v }) as Promise<void>; }
     get world(): string | null { return call('entity.getWorld', { uuid: this.uuid }) as string | null; }
     get location(): Location | null { const r = call('entity.getLocation', { uuid: this.uuid }); return r ? Location.from(r as any) : null; }
     get isGlowing(): boolean { return call('entity.isGlowing', { uuid: this.uuid }) as boolean; }
@@ -22,9 +22,9 @@ export class Entity {
     get passengers(): string[] { return call('entity.getPassengers', { uuid: this.uuid }) as string[]; }
     get vehicle(): string | null { return call('entity.getVehicle', { uuid: this.uuid }) as string | null; }
 
-    remove(): Promise<void> { return call('entity.remove', { uuid: this.uuid }) as Promise<void>; }
+    remove(): Promise<void> { return post('entity.remove', { uuid: this.uuid }) as Promise<void>; }
     removeSync(): void { call('entity.remove', { uuid: this.uuid }); }
-    teleport(loc: Location): Promise<void> { return call('entity.teleport', { uuid: this.uuid, ...loc.toObject() }) as Promise<void>; }
+    teleport(loc: Location): Promise<void> { return post('entity.teleport', { uuid: this.uuid, ...loc.toObject() }) as Promise<void>; }
     teleportSync(loc: Location): void { call('entity.teleport', { uuid: this.uuid, ...loc.toObject() }); }
 }
 

package/src/event.ts

@@ -206,14 +206,7 @@ function adaptEvent(type: string, data: any): any {
         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) {
-                try {
-                    wrap.player = Player.get(data.player);
-                    console.log('[ev] Player.get(' + data.player + ') = ' + (wrap.player ? 'Player' : 'null'));
-                } catch (e: any) {
-                    console.log('[ev] Player.get err: ' + (e?.message || e) + ' stack=' + (e?.stack || ''));
-                }
-            }
+            if (data.player) wrap.player = Player.get(data.player);
             break;
     }
     if (data.from) wrap.from = _loc(data.from);
@@ -225,7 +218,7 @@ function adaptEvent(type: string, data: any): any {
 // ── 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]);
+    const wrapper = (data: any) => handler(data as EventMap[K]);
     (wrapper as any)._raw = handler;
 
     if (!(globalThis as any).__yeowEventHandlers) (globalThis as any).__yeowEventHandlers = {};
@@ -260,38 +253,24 @@ export function eventOff(eventType: string, handler: Function): void {
     const handlers = (globalThis as any).__yeowEventHandlers?.[eventType];
     if (!handlers?.length) return {};
 
-    console.log('[ev] type=' + eventType + ' data=' + JSON.stringify(data).slice(0,200));
-
     const cancellable = data?._cancellable;
     const mods: Record<string, any> = {};
 
-    let wrapped;
-    try {
-        wrapped = adaptEvent(eventType, data);
-    } catch (e: any) {
-        console.log('[ev] adaptEvent err: ' + (e?.message || e) + ' stack=' + (e?.stack || ''));
-        return mods;
-    }
+    const wrapped = adaptEvent(eventType, data);
 
     const localMods: Record<string, any> = {};
     if (cancellable) {
-        try {
-            Object.defineProperty(wrapped, 'cancelled', {
-                get: () => localMods.cancelled || false,
-                set: (v: boolean) => { localMods.cancelled = v; },
-                enumerable: true,
-            });
-        } catch (e: any) {
-            console.log('[ev] defineProperty err: ' + (e?.message || e));
-        }
+        Object.defineProperty(wrapped, 'cancelled', {
+            get: () => localMods.cancelled || false,
+            set: (v: boolean) => { localMods.cancelled = v; },
+            enumerable: true,
+        });
     }
 
     for (const handler of handlers) {
         try {
             handler(wrapped);
-        } catch (e: any) {
-            console.log('[ev] handler err: msg=' + (e?.message || '') + ' name=' + (e?.name || '') + ' stack=' + (e?.stack || '').slice(0,300));
-        }
+        } catch (e: any) { console.error('event:', e?.message || e); }
     }
     if (cancellable && localMods.cancelled) mods.cancelled = true;
     return mods;

package/src/index.ts

@@ -15,7 +15,7 @@ export type {
     ServerPingEvent,
 } from './event.js';
 export { onInit, onLoad } from './lifecycle.js';
-export { broadcast, getMotd, getVersion } from './server.js';
+export { broadcast, broadcastSync, dispatchCommand, dispatchCommandSync, setMotd, setMotdSync, setIcon, setIconSync, 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/inventory.ts

@@ -1,4 +1,4 @@
-import { call } from './task.js';
+import { call, post } from './task.js';
 
 export class Inventory {
     constructor(private readonly uuid: string) {}
@@ -7,25 +7,25 @@ export class Inventory {
         return call('inventory.getItem', { uuid: this.uuid, slot }) as any;
     }
     setItem(slot: number, itemType: string, amount?: number): Promise<void> {
-        return call('inventory.setItem', { uuid: this.uuid, slot, itemType, amount }) as Promise<void>;
+        return post('inventory.setItem', { uuid: this.uuid, slot, itemType, amount }) as Promise<void>;
     }
     setItemSync(slot: number, itemType: string, amount?: number): void {
         call('inventory.setItem', { uuid: this.uuid, slot, itemType, amount });
     }
     addItem(itemType: string, amount?: number): Promise<void> {
-        return call('inventory.addItem', { uuid: this.uuid, itemType, amount }) as Promise<void>;
+        return post('inventory.addItem', { uuid: this.uuid, itemType, amount }) as Promise<void>;
     }
     addItemSync(itemType: string, amount?: number): void {
         call('inventory.addItem', { uuid: this.uuid, itemType, amount });
     }
     removeItem(itemType: string, amount?: number): Promise<void> {
-        return call('inventory.removeItem', { uuid: this.uuid, itemType, amount }) as Promise<void>;
+        return post('inventory.removeItem', { uuid: this.uuid, itemType, amount }) as Promise<void>;
     }
     removeItemSync(itemType: string, amount?: number): void {
         call('inventory.removeItem', { uuid: this.uuid, itemType, amount });
     }
     clear(slot?: number): Promise<void> {
-        return call('inventory.clear', { uuid: this.uuid, slot }) as Promise<void>;
+        return post('inventory.clear', { uuid: this.uuid, slot }) as Promise<void>;
     }
     clearSync(slot?: number): void {
         call('inventory.clear', { uuid: this.uuid, slot });

package/src/player.ts

@@ -1,4 +1,4 @@
-import { call } from './task.js';
+import { call, post } from './task.js';
 import { Location } from './location.js';
 
 export class Player {
@@ -16,7 +16,31 @@ export class Player {
     get ping(): number { return call('player.getPing', { uuid: this.uuid }) as number; }
     get gamemode(): string { return call('player.getGamemode', { uuid: this.uuid }) as string; }
     set gamemode(v: string) { call('player.setGamemode', { uuid: this.uuid, value: v }); }
+    get world(): string { return call('player.getWorld', { uuid: this.uuid }) as string; }
+    get location(): Location | null { const r = call('player.getLocation', { uuid: this.uuid }); return r ? Location.from(r as any) : null; }
+    get displayName(): string { return call('player.getDisplayName', { uuid: this.uuid }) as string; }
+    set displayName(v: string | null) { call('player.setDisplayName', { uuid: this.uuid, value: v }); }
 
-    sendMessage(msg: string): void { call('player.sendMessage', { uuid: this.uuid, message: msg }); }
-    kick(reason?: string): void { call('player.kick', { uuid: this.uuid, reason }); }
+    // Methods (async by default)
+    sendMessage(msg: string): Promise<void> { return post('player.sendMessage', { uuid: this.uuid, message: msg }) as Promise<void>; }
+    sendMessageSync(msg: string): void { call('player.sendMessage', { uuid: this.uuid, message: msg }); }
+    kick(reason?: string): Promise<void> { return post('player.kick', { uuid: this.uuid, reason }) as Promise<void>; }
+    kickSync(reason?: string): void { call('player.kick', { uuid: this.uuid, reason }); }
+    sendTitle(title?: string, subtitle?: string, fadeIn?: number, stay?: number, fadeOut?: number): Promise<void> {
+        return post('player.sendTitle', { uuid: this.uuid, title, subtitle, fadeIn, stay, fadeOut }) as Promise<void>;
+    }
+    sendTitleSync(title?: string, subtitle?: string, fadeIn?: number, stay?: number, fadeOut?: number): void {
+        call('player.sendTitle', { uuid: this.uuid, title, subtitle, fadeIn, stay, fadeOut });
+    }
+    playSound(sound: string, volume?: number, pitch?: number): Promise<void> {
+        return post('player.playSound', { uuid: this.uuid, sound, volume, pitch }) as Promise<void>;
+    }
+    playSoundSync(sound: string, volume?: number, pitch?: number): void {
+        call('player.playSound', { uuid: this.uuid, sound, volume, pitch });
+    }
+    giveExp(amount: number): Promise<void> { return post('player.giveExp', { uuid: this.uuid, amount }) as Promise<void>; }
+    giveExpSync(amount: number): void { call('player.giveExp', { uuid: this.uuid, amount }); }
+    hasPermission(node: string): boolean { return call('player.hasPermission', { uuid: this.uuid, permission: node }) as boolean; }
+    teleport(loc: Location): Promise<void> { return post('player.teleport', { uuid: this.uuid, ...loc.toObject() }) as Promise<void>; }
+    teleportSync(loc: Location): void { call('player.teleport', { uuid: this.uuid, ...loc.toObject() }); }
 }

package/src/server.ts

@@ -1,5 +1,12 @@
-import { call } from './task.js';
+import { call, post } from './task.js';
 
-export function broadcast(msg: string): void { call('server.broadcast', { message: msg }); }
+export function broadcast(msg: string): Promise<void> { return post('server.broadcast', { message: msg }) as Promise<void>; }
+export function broadcastSync(msg: string): void { call('server.broadcast', { message: msg }); }
+export function dispatchCommand(cmd: string): Promise<boolean> { return post('command.dispatch', { command: cmd }) as Promise<boolean>; }
+export function dispatchCommandSync(cmd: string): boolean { return call('command.dispatch', { command: cmd }) as boolean; }
+export function setMotd(motd: string): Promise<void> { return post('server.setMotd', { motd }) as Promise<void>; }
+export function setMotdSync(motd: string): void { call('server.setMotd', { motd }); }
+export function setIcon(base64: string): Promise<void> { return post('server.setIcon', { icon: base64 }) as Promise<void>; }
+export function setIconSync(base64: string): void { call('server.setIcon', { icon: base64 }); }
 export function getMotd(): string { return call('server.getMotd', {}) as string; }
 export function getVersion(): string { return call('server.getVersion', {}) as string; }

package/src/world.ts

@@ -1,4 +1,4 @@
-import { call } from './task.js';
+import { call, post } from './task.js';
 import { Location } from './location.js';
 
 export class World {
@@ -19,15 +19,21 @@ export class World {
     set spawnLocation(v: Location) { call('world.setSpawnLocation', { world: this.name, ...v.toObject() }); }
 
     getGameRule(rule: string): string | null { return call('world.getGameRule', { world: this.name, rule }) as string | null; }
+    setGameRule(rule: string, value: string): Promise<boolean> { return post('world.setGameRule', { world: this.name, rule, value }) as Promise<boolean>; }
     setGameRuleSync(rule: string, value: string): boolean { return call('world.setGameRule', { world: this.name, rule, value }) as boolean; }
     getBiome(x: number, y: number, z: number): string { return call('world.getBiome', { world: this.name, x, y, z }) as string; }
-    getBlock(x: number, y: number, z: number): any { const r = call('world.getBlock', { world: this.name, x, y, z }); return r; }
-    setBlockSync(x: number, y: number, z: number, type: string) { call('world.setBlock', { world: this.name, x, y, z, blockType: type }); }
+    getBlock(x: number, y: number, z: number): any { return call('world.getBlock', { world: this.name, x, y, z }); }
+    setBlock(x: number, y: number, z: number, blockType: string): Promise<void> { return post('world.setBlock', { world: this.name, x, y, z, blockType }) as Promise<void>; }
+    setBlockSync(x: number, y: number, z: number, blockType: string) { call('world.setBlock', { world: this.name, x, y, z, blockType }); }
     getEntities(): string[] { return call('world.getEntities', { world: this.name }) as string[]; }
     getPlayers(): string[] { return call('world.getPlayers', { world: this.name }) as string[]; }
-    getNearbyEntities(x: number, y: number, z: number, r: number): string[] { return call('world.getNearbyEntities', { world: this.name, x, y, z, radius: r }) as string[]; }
-    dropItemSync(x: number, y: number, z: number, type: string, amount?: number) { call('world.dropItem', { world: this.name, x, y, z, itemType: type, amount }); }
+    getNearbyEntities(x: number, y: number, z: number, radius: number): string[] { return call('world.getNearbyEntities', { world: this.name, x, y, z, radius }) as string[]; }
+    dropItem(x: number, y: number, z: number, itemType: string, amount?: number): Promise<void> { return post('world.dropItem', { world: this.name, x, y, z, itemType, amount }) as Promise<void>; }
+    dropItemSync(x: number, y: number, z: number, itemType: string, amount?: number) { call('world.dropItem', { world: this.name, x, y, z, itemType, amount }); }
+    strikeLightning(x: number, y: number, z: number): Promise<void> { return post('world.strikeLightning', { world: this.name, x, y, z }) as Promise<void>; }
     strikeLightningSync(x: number, y: number, z: number) { call('world.strikeLightning', { world: this.name, x, y, z }); }
+    strikeLightningEffect(x: number, y: number, z: number): Promise<void> { return post('world.strikeLightningEffect', { world: this.name, x, y, z }) as Promise<void>; }
     strikeLightningEffectSync(x: number, y: number, z: number) { call('world.strikeLightningEffect', { world: this.name, x, y, z }); }
+    createExplosion(x: number, y: number, z: number, power?: number, fire?: boolean, breaks?: boolean): Promise<void> { return post('world.createExplosion', { world: this.name, x, y, z, power, setFire: fire, breakBlocks: breaks }) as Promise<void>; }
     createExplosionSync(x: number, y: number, z: number, power?: number, fire?: boolean, breaks?: boolean) { call('world.createExplosion', { world: this.name, x, y, z, power, setFire: fire, breakBlocks: breaks }); }
 }