yeow-api 0.2.37 → 0.2.38

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "yeow-api",
-    "version": "0.2.37",
+    "version": "0.2.38",
     "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, post } from './task.js';
+import { call, post, val } from './task.js';
 import { Location, LocationData } from './location.js';
 
 export class Entity {
@@ -16,8 +16,8 @@ export class Entity {
   }
   get world(): string | null { return call<string | null>('entity.getWorld', { uuid: this.uuid }); }
   get location(): Location | null {
-    const r = call<LocationData>('entity.getLocation', { uuid: this.uuid });
-    return r ? Location.from(r) : null;
+    const r = call<any>('entity.getLocation', { uuid: this.uuid });
+    return r ? Location.from(val(r, 'x'), val(r, 'y'), val(r, 'z'), val(r, 'yaw'), val(r, 'pitch'), val(r, 'world')) : null;
   }
   get isGlowing(): boolean { return call<boolean>('entity.isGlowing', { uuid: this.uuid }); }
   set isGlowing(v: boolean) { call('entity.setGlowing', { uuid: this.uuid, value: v }); }

package/src/index.ts

@@ -1,6 +1,6 @@
 /// <reference path="global.d.ts" />
 
-export { call } from './task.js';
+export { call, val } from './task.js';
 export { Location } from './location.js';
 export { Player } from './player.js';
 export { World } from './world.js';

package/src/inventory.ts

@@ -1,4 +1,4 @@
-import { call, post } from './task.js';
+import { call, post, val } from './task.js';
 
 interface ItemData {
   type: string;
@@ -9,10 +9,13 @@ export class Inventory {
   constructor(private readonly uuid: string) {}
 
   getItem(slot: number): Promise<ItemData | null> {
-    return post<ItemData | null>('inventory.getItem', { uuid: this.uuid, slot });
+    return post<any>('inventory.getItem', { uuid: this.uuid, slot }).then((r) =>
+      r ? { type: val(r, 'type'), amount: val(r, 'amount') } : null
+    );
   }
   getItemSync(slot: number): ItemData | null {
-    return call<ItemData | null>('inventory.getItem', { uuid: this.uuid, slot });
+    const r = call<any>('inventory.getItem', { uuid: this.uuid, slot });
+    return r ? { type: val(r, 'type'), amount: val(r, 'amount') } : null;
   }
   setItem(slot: number, itemType: string, amount?: number): Promise<void> {
     return post('inventory.setItem', { uuid: this.uuid, slot, itemType, amount });

package/src/location.ts

@@ -1,3 +1,5 @@
+import { val } from './task.js';
+
 export interface LocationData {
   x: number;
   y: number;
@@ -17,8 +19,13 @@ export class Location {
     public readonly world?: string,
   ) {}
 
-  static from(raw: LocationData): Location {
-    return new Location(raw.x, raw.y, raw.z, raw.yaw ?? 0, raw.pitch ?? 0, raw.world);
+  static from(x: number, y: number, z: number, yaw?: number, pitch?: number, world?: string): Location;
+  static from(raw: LocationData): Location;
+  static from(a: any, b?: any, c?: any, d?: any, e?: any, f?: any): Location {
+    if (typeof a === 'object' && a !== null) {
+      return new Location(val(a, 'x'), val(a, 'y'), val(a, 'z'), val(a, 'yaw') ?? 0, val(a, 'pitch') ?? 0, val(a, 'world'));
+    }
+    return new Location(a, b, c, d ?? 0, e ?? 0, f);
   }
 
   toObject(): LocationData {

package/src/player.ts

@@ -1,24 +1,29 @@
-import { call, post } from './task.js';
+import { call, post, val } from './task.js';
 import { Location, LocationData } from './location.js';
 
-interface PlayerData {
-  uuid: string;
-  name: string;
-}
-
 export class Player {
   static get(identifier: string): Promise<Player | null> {
-    return post<PlayerData>('player.get', { identifier }).then((d) => (d ? new Player(d.uuid, d.name) : null));
+    return post<any>('player.get', { identifier }).then((d: any) => {
+      if (!d) return null;
+      const uuid = val(d, 'uuid');
+      const name = val(d, 'name');
+      return uuid ? new Player(uuid, name) : null;
+    });
   }
   static getSync(identifier: string): Player | null {
-    const d = call<PlayerData>('player.get', { identifier });
-    return d ? new Player(d.uuid, d.name) : null;
+    const d = call<any>('player.get', { identifier });
+    if (!d) return null;
+    return new Player(val(d, 'uuid'), val(d, 'name'));
   }
   static getAll(): Promise<Player[]> {
-    return post<PlayerData[]>('player.getAll', {}).then((list) => list.map((r) => new Player(r.uuid, r.name)));
+    return post<any[]>('player.getAll', {}).then((list) =>
+      (list || []).map((r: any) => new Player(val(r, 'uuid'), val(r, 'name')))
+    );
   }
   static getAllSync(): Player[] {
-    return call<PlayerData[]>('player.getAll', {}).map((r) => new Player(r.uuid, r.name));
+    return (call<any[]>('player.getAll', {}) || []).map((r: any) =>
+      new Player(val(r, 'uuid'), val(r, 'name'))
+    );
   }
 
   constructor(public readonly uuid: string, private _name?: string) {}
@@ -29,8 +34,8 @@ export class Player {
   set gamemode(v: string) { call('player.setGamemode', { uuid: this.uuid, value: v }); }
   get world(): string { return call<string>('player.getWorld', { uuid: this.uuid }); }
   get location(): Location | null {
-    const r = call<LocationData>('player.getLocation', { uuid: this.uuid });
-    return r ? Location.from(r) : null;
+    const r = call<any>('player.getLocation', { uuid: this.uuid });
+    return r ? Location.from(val(r, 'x'), val(r, 'y'), val(r, 'z'), val(r, 'yaw'), val(r, 'pitch'), val(r, 'world')) : null;
   }
   get displayName(): string { return call<string>('player.getDisplayName', { uuid: this.uuid }); }
   set displayName(v: string | null) { call('player.setDisplayName', { uuid: this.uuid, value: v }); }

package/src/task.ts

@@ -6,12 +6,16 @@ export function post<T = unknown>(
   return new Promise((resolve, reject) => {
     const cbId = _registerCallback((result: any) => {
       if (result?.err) {
-        const e = new Error(result.err);
-        if ($dev && typeof _getCurrentCbStack === 'function') {
-          const s = _getCurrentCbStack();
-          if (s) e.stack += '\n    --- cb registered at ---\n' + s;
+        if ($dev) {
+          const e = new Error(result.err);
+          if (typeof _getCurrentCbStack === 'function') {
+            const s = _getCurrentCbStack();
+            if (s) e.stack += '\n    --- cb registered at ---\n' + s;
+          }
+          reject(e);
+        } else {
+          reject(new Error(result.err));
         }
-        reject(e);
       } else resolve(result as T);
     });
     const pld: Record<string, unknown> = { type, params, cb: cbId };
@@ -29,6 +33,14 @@ export function call<T = unknown>(
   if (priority) pld.priority = priority;
   const r = $send('task', pld);
   if (r == null) return undefined as T;
-  if ((r as any)?.err) throw new Error((r as any).err);
+  if ((r as any)?.err) {
+    if ($dev) throw new Error((r as any).err);
+    throw new Error(String((r as any).err));
+  }
   return r as T;
 }
+
+/** Extract value from a buffer result (Map-like with get()) or a plain JSON object. */
+export function val(obj: any, key: string): any {
+  return obj && typeof obj.get === 'function' ? obj.get(key) : obj?.[key];
+}

package/src/world.ts

@@ -1,24 +1,22 @@
-import { call, post } from './task.js';
+import { call, post, val } from './task.js';
 import { Location, LocationData } from './location.js';
 import { Block } from './block.js';
 
-interface WorldData {
-  name: string;
-}
-
 export class World {
   static get(name: string): Promise<World | null> {
-    return post<WorldData>('world.get', { name }).then((d) => (d ? new World(d.name) : null));
+    return post<any>('world.get', { name }).then((d) => (d ? new World(val(d, 'name')) : null));
   }
   static getSync(name: string): World | null {
-    const d = call<WorldData>('world.get', { name });
-    return d ? new World(d.name) : null;
+    const d = call<any>('world.get', { name });
+    return d ? new World(val(d, 'name')) : null;
   }
   static getAll(): Promise<World[]> {
-    return post<WorldData[]>('world.getAll', {}).then((list) => list.map((r) => new World(r.name)));
+    return post<any[]>('world.getAll', {}).then((list) =>
+      (list || []).map((r: any) => new World(val(r, 'name')))
+    );
   }
   static getAllSync(): World[] {
-    return call<WorldData[]>('world.getAll', {}).map((r) => new World(r.name));
+    return (call<any[]>('world.getAll', {}) || []).map((r: any) => new World(val(r, 'name')));
   }
 
   constructor(public readonly name: string) {}
@@ -32,8 +30,8 @@ export class World {
   get difficulty(): string { return call<string>('world.getDifficulty', { world: this.name }); }
   set difficulty(v: string) { call('world.setDifficulty', { world: this.name, value: v }); }
   get spawnLocation(): Location | null {
-    const r = call<LocationData>('world.getSpawnLocation', { world: this.name });
-    return r ? new Location(r.x, r.y, r.z, r.yaw, r.pitch) : null;
+    const r = call<any>('world.getSpawnLocation', { world: this.name });
+    return r ? new Location(val(r, 'x'), val(r, 'y'), val(r, 'z'), val(r, 'yaw'), val(r, 'pitch')) : null;
   }
   set spawnLocation(v: Location) { call('world.setSpawnLocation', { world: this.name, ...v.toObject() }); }
 
@@ -62,12 +60,13 @@ export class World {
     return call<string>('world.getBiome', { world: this.name, x, y, z });
   }
   getBlock(x: number, y: number, z: number): Promise<Block | null> {
-    return post<{ x: number; y: number; z: number; type: string }>('world.getBlock', { world: this.name, x, y, z })
-      .then((r) => (r ? new Block(this.name, r.x, r.y, r.z, r.type) : null));
+    return post<any>('world.getBlock', { world: this.name, x, y, z }).then((r) =>
+      r ? new Block(this.name, val(r, 'x'), val(r, 'y'), val(r, 'z'), val(r, 'type')) : null
+    );
   }
   getBlockSync(x: number, y: number, z: number): Block | null {
-    const r = call<{ x: number; y: number; z: number; type: string }>('world.getBlock', { world: this.name, x, y, z });
-    return r ? new Block(this.name, r.x, r.y, r.z, r.type) : null;
+    const r = call<any>('world.getBlock', { world: this.name, x, y, z });
+    return r ? new Block(this.name, val(r, 'x'), val(r, 'y'), val(r, 'z'), val(r, 'type')) : null;
   }
   setBlock(x: number, y: number, z: number, blockType: string): Promise<void> {
     return post('world.setBlock', { world: this.name, x, y, z, blockType });
@@ -75,18 +74,10 @@ export class World {
   setBlockSync(x: number, y: number, z: number, blockType: string): void {
     call('world.setBlock', { world: this.name, x, y, z, blockType });
   }
-  getEntities(): Promise<string[]> {
-    return post<string[]>('world.getEntities', { world: this.name });
-  }
-  getEntitiesSync(): string[] {
-    return call<string[]>('world.getEntities', { world: this.name });
-  }
-  getPlayers(): Promise<string[]> {
-    return post<string[]>('world.getPlayers', { world: this.name });
-  }
-  getPlayersSync(): string[] {
-    return call<string[]>('world.getPlayers', { world: this.name });
-  }
+  getEntities(): Promise<string[]> { return post<string[]>('world.getEntities', { world: this.name }); }
+  getEntitiesSync(): string[] { return call<string[]>('world.getEntities', { world: this.name }); }
+  getPlayers(): Promise<string[]> { return post<string[]>('world.getPlayers', { world: this.name }); }
+  getPlayersSync(): string[] { return call<string[]>('world.getPlayers', { world: this.name }); }
   getNearbyEntities(x: number, y: number, z: number, radius: number): Promise<string[]> {
     return post<string[]>('world.getNearbyEntities', { world: this.name, x, y, z, radius });
   }