yeow-api 0.2.36 → 0.2.38

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "yeow-api",
-    "version": "0.2.36",
+    "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/http.ts

@@ -16,39 +16,28 @@ function _sendHttp(payload: Record<string, unknown>): HttpResult {
 
 const _servers = new Set<string>();
 
-export function listen(callback: (req: Record<string, unknown>) => void, port?: number): Promise<HttpResult> {
-  return new Promise((resolve, reject) => {
-    const cbId = _registerCallback((payload: unknown) => {
-      callback(payload as Record<string, unknown>);
-    }, { persistent: true });
-    try {
-      const result = _sendHttp({
-        t: 'listen', p: {
-          pluginName: __plugin?.name || 'unknown',
-          callbackId: String(cbId),
-          port: port || 0,
-        },
-      });
-      if (result.serverId) _servers.add(result.serverId);
-      resolve(result);
-    } catch (e) { reject(e); }
+export function listen(callback: (req: Record<string, unknown>) => void, port?: number): HttpResult {
+  const cbId = _registerCallback((payload: unknown) => {
+    callback(payload as Record<string, unknown>);
+  }, { persistent: true });
+  const result = _sendHttp({
+    t: 'listen', p: {
+      pluginName: __plugin?.name || 'unknown',
+      callbackId: String(cbId),
+      port: port || 0,
+    },
   });
+  if (result.serverId) _servers.add(result.serverId);
+  return result;
 }
 
-export function respond(serverId: string, connId: string, opts: Record<string, unknown> = {}): Promise<void> {
-  return new Promise((resolve, reject) => {
-    try {
-      _sendHttp({ t: 'respond', p: { serverId, connId, ...opts } });
-      resolve();
-    } catch (e) { reject(e); }
-  });
+export function respond(serverId: string, connId: string, opts: Record<string, unknown> = {}): void {
+  _sendHttp({ t: 'respond', p: { serverId, connId, ...opts } });
 }
 
-export function close(serverId: string): Promise<void> {
+export function close(serverId: string): void {
   _servers.delete(serverId);
-  return new Promise((resolve, reject) => {
-    try { _sendHttp({ t: 'close', p: { serverId } }); resolve(); } catch (e) { reject(e); }
-  });
+  _sendHttp({ t: 'close', p: { serverId } });
 }
 
 // Auto-close servers on shutdown
@@ -67,7 +56,3 @@ export function request(url: string, opts: Record<string, unknown> = {}): Promis
     } catch (e) { reject(e); }
   });
 }
-
-export function requestSync(url: string, opts: Record<string, unknown> = {}): HttpResult {
-  return _sendHttp({ t: 'request', p: { url, ...opts } });
-}

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';
@@ -39,5 +39,5 @@ export { assets, read as assetsRead, readSync as assetsReadSync,
     readBase64 as assetsReadBase64, readBase64Sync as assetsReadBase64Sync,
     extract as assetsExtract, extractSync as assetsExtractSync } from './assets.js';
 export { path } from './path.js';
-export { listen, respond, close, request, requestSync } from './http.js';
+export { listen, respond, close, request } from './http.js';
 export { logError } from './log-error.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 });
   }