yeow-api 0.2.34 → 0.2.36

package/package.json

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

package/src/block.ts

@@ -1,4 +1,4 @@
-import { call } from './task.js';
+import { call, post } from './task.js';
 import { Location } from './location.js';
 
 export class Block {
@@ -13,7 +13,10 @@ export class Block {
   get location(): Location {
     return new Location(this.x, this.y, this.z, undefined, undefined, this.world);
   }
-  isSolid(): boolean { return call<boolean>('block.isSolid', { world: this.world, x: this.x, y: this.y, z: this.z }); }
-  isLiquid(): boolean { return call<boolean>('block.isLiquid', { world: this.world, x: this.x, y: this.y, z: this.z }); }
-  isEmpty(): boolean { return call<boolean>('block.isEmpty', { world: this.world, x: this.x, y: this.y, z: this.z }); }
+  isSolid(): Promise<boolean> { return post<boolean>('block.isSolid', { world: this.world, x: this.x, y: this.y, z: this.z }); }
+  isSolidSync(): boolean { return call<boolean>('block.isSolid', { world: this.world, x: this.x, y: this.y, z: this.z }); }
+  isLiquid(): Promise<boolean> { return post<boolean>('block.isLiquid', { world: this.world, x: this.x, y: this.y, z: this.z }); }
+  isLiquidSync(): boolean { return call<boolean>('block.isLiquid', { world: this.world, x: this.x, y: this.y, z: this.z }); }
+  isEmpty(): Promise<boolean> { return post<boolean>('block.isEmpty', { world: this.world, x: this.x, y: this.y, z: this.z }); }
+  isEmptySync(): boolean { return call<boolean>('block.isEmpty', { world: this.world, x: this.x, y: this.y, z: this.z }); }
 }

package/src/entity.ts

@@ -8,7 +8,12 @@ export class Entity {
   get name(): string { return call<string>('entity.getName', { uuid: this.uuid }); }
   get customName(): string | null { return call<string | null>('entity.getCustomName', { uuid: this.uuid }); }
   set customName(v: string | null) { call('entity.setCustomName', { uuid: this.uuid, value: v }); }
-  setCustomNameVisible(v: boolean): Promise<void> { return post('entity.setCustomNameVisible', { uuid: this.uuid, value: v }); }
+  setCustomNameVisible(v: boolean): Promise<void> {
+    return post('entity.setCustomNameVisible', { uuid: this.uuid, value: v });
+  }
+  setCustomNameVisibleSync(v: boolean): void {
+    call('entity.setCustomNameVisible', { uuid: this.uuid, value: v });
+  }
   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 });

package/src/event.ts

@@ -258,7 +258,7 @@ function adaptEvent<K extends keyof EventMap>(type: K, data: RawEvent): EventMap
     'blockPlace', 'inventoryOpen', 'inventoryClose',
   ] as K[];
   if (hasPlayer.includes(type) && data.player) {
-    wrap.player = Player.get(data.player as string);
+    wrap.player = Player.getSync(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>);
@@ -322,26 +322,26 @@ export function eventOn<K extends keyof EventMap>(
     $send('task', { type: 'event.complete', params: { callbackId: cbId, mods }, cb: '' });
   }, { persistent: true });
 
-  if (!__yeowEventHandlers) (globalThis as any).__yeowEventHandlers = {};
-  const handlers = __yeowEventHandlers!;
-  if (!handlers[eventType]) handlers[eventType] = [];
-  handlers[eventType].push({ cbId, handler, manualRelease });
+  const gh = globalThis as any;
+  if (!gh.__yeowEventHandlers) gh.__yeowEventHandlers = {};
+  if (!gh.__yeowEventHandlers[eventType]) gh.__yeowEventHandlers[eventType] = [];
+  gh.__yeowEventHandlers[eventType].push({ cbId, handler, manualRelease });
 
   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];
+  const gh = globalThis as any;
+  const entries = gh.__yeowEventHandlers?.[eventType];
   if (!entries) return;
-  const idx = entries.findIndex((e) => e.handler === handler);
+  const idx = entries.findIndex((e: any) => 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];
+    delete gh.__yeowEventHandlers[eventType];
     call('event.unsubscribe', {
       pluginName: __plugin?.name || 'unknown',
       eventType,

package/src/fs.ts

@@ -49,6 +49,14 @@ export function writeFileBase64Sync(path: string, data: string): void {
   _sendFs({ t: 'writeBase64', p: { path, data } });
 }
 
+export function exists(path: string): Promise<boolean> {
+  return new Promise((resolve, reject) => {
+    try {
+      const r = _sendFs({ t: 'exists', p: { path } });
+      resolve(r === true || String(r) === 'true');
+    } catch (e) { reject(e); }
+  });
+}
 export function existsSync(path: string): boolean {
   const r = _sendFs({ t: 'exists', p: { path } });
   return r === true || String(r) === 'true';
@@ -62,6 +70,10 @@ export function deleteFile(path: string): Promise<boolean> {
     } catch (e) { reject(e); }
   });
 }
+export function deleteFileSync(path: string): boolean {
+  const r = _sendFs({ t: 'delete', p: { path } });
+  return r === true || String(r) === 'true';
+}
 
 export function mkdir(path: string): Promise<void> {
   return new Promise((resolve, reject) => {
@@ -69,6 +81,9 @@ export function mkdir(path: string): Promise<void> {
     catch (e) { reject(e); }
   });
 }
+export function mkdirSync(path: string): void {
+  _sendFs({ t: 'mkdir', p: { path } });
+}
 
 export function list(path: string): Promise<string[]> {
   return new Promise((resolve, reject) => {
@@ -78,9 +93,12 @@ export function list(path: string): Promise<string[]> {
     } catch (e) { reject(e); }
   });
 }
+export function listSync(path: string): string[] {
+  return _sendFs({ t: 'list', p: { path } }) as string[];
+}
 
 export const fs = {
   readFile, readFileSync, readFileBase64, readFileBase64Sync,
   writeFile, writeFileSync, writeFileBase64, writeFileBase64Sync,
-  existsSync, deleteFile, mkdir, list,
+  exists, existsSync, deleteFile, deleteFileSync, mkdir, mkdirSync, list, listSync,
 };

package/src/index.ts

@@ -24,9 +24,20 @@ export type {
     ServerPingEvent, ServerCommandEvent,
 } from './event.js';
 export { onInit, onLoad, onUnload } from './lifecycle.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 {
+    broadcast, broadcastSync, dispatchCommand, dispatchCommandSync,
+    setMotd, setMotdSync, setIcon, setIconSync,
+    getMotd, getMotdSync, getVersion, getVersionSync,
+} from './server.js';
+export {
+    fs,
+    readFile, readFileSync, readFileBase64, readFileBase64Sync,
+    writeFile, writeFileSync, writeFileBase64, writeFileBase64Sync,
+    exists, existsSync, deleteFile, deleteFileSync, mkdir, mkdirSync, list, listSync,
+} 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 { path } from './path.js';
 export { listen, respond, close, request, requestSync } from './http.js';
 export { logError } from './log-error.js';

package/src/inventory.ts

@@ -8,7 +8,10 @@ interface ItemData {
 export class Inventory {
   constructor(private readonly uuid: string) {}
 
-  getItem(slot: number): ItemData | null {
+  getItem(slot: number): Promise<ItemData | null> {
+    return post<ItemData | null>('inventory.getItem', { uuid: this.uuid, slot });
+  }
+  getItemSync(slot: number): ItemData | null {
     return call<ItemData | null>('inventory.getItem', { uuid: this.uuid, slot });
   }
   setItem(slot: number, itemType: string, amount?: number): Promise<void> {

package/src/player.ts

@@ -7,11 +7,17 @@ interface PlayerData {
 }
 
 export class Player {
-  static get(identifier: string): Player | null {
+  static get(identifier: string): Promise<Player | null> {
+    return post<PlayerData>('player.get', { identifier }).then((d) => (d ? new Player(d.uuid, d.name) : null));
+  }
+  static getSync(identifier: string): Player | null {
     const d = call<PlayerData>('player.get', { identifier });
     return d ? new Player(d.uuid, d.name) : null;
   }
-  static getAll(): Player[] {
+  static getAll(): Promise<Player[]> {
+    return post<PlayerData[]>('player.getAll', {}).then((list) => list.map((r) => new Player(r.uuid, r.name)));
+  }
+  static getAllSync(): Player[] {
     return call<PlayerData[]>('player.getAll', {}).map((r) => new Player(r.uuid, r.name));
   }
 
@@ -49,7 +55,12 @@ export class Player {
   }
   giveExp(amount: number): Promise<void> { return post('player.giveExp', { uuid: this.uuid, amount }); }
   giveExpSync(amount: number): void { call('player.giveExp', { uuid: this.uuid, amount }); }
-  hasPermission(node: string): boolean { return call<boolean>('player.hasPermission', { uuid: this.uuid, permission: node }); }
+  hasPermission(node: string): Promise<boolean> {
+    return post<boolean>('player.hasPermission', { uuid: this.uuid, permission: node });
+  }
+  hasPermissionSync(node: string): boolean {
+    return call<boolean>('player.hasPermission', { uuid: this.uuid, permission: node });
+  }
   teleport(loc: Location): Promise<void> { return post('player.teleport', { uuid: this.uuid, ...loc.toObject() }); }
   teleportSync(loc: Location): void { call('player.teleport', { uuid: this.uuid, ...loc.toObject() }); }
 }

package/src/server.ts

@@ -8,5 +8,7 @@ export function setMotd(motd: string): Promise<void> { return post('server.setMo
 export function setMotdSync(motd: string): void { call('server.setMotd', { motd }); }
 export function setIcon(base64: string): Promise<void> { return post('server.setIcon', { icon: base64 }); }
 export function setIconSync(base64: string): void { call('server.setIcon', { icon: base64 }); }
-export function getMotd(): string { return call<string>('server.getMotd', {}); }
-export function getVersion(): string { return call<string>('server.getVersion', {}); }
+export function getMotd(): Promise<string> { return post<string>('server.getMotd', {}); }
+export function getMotdSync(): string { return call<string>('server.getMotd', {}); }
+export function getVersion(): Promise<string> { return post<string>('server.getVersion', {}); }
+export function getVersionSync(): string { return call<string>('server.getVersion', {}); }

package/src/world.ts

@@ -7,11 +7,17 @@ interface WorldData {
 }
 
 export class World {
-  static get(name: string): World | null {
+  static get(name: string): Promise<World | null> {
+    return post<WorldData>('world.get', { name }).then((d) => (d ? new World(d.name) : null));
+  }
+  static getSync(name: string): World | null {
     const d = call<WorldData>('world.get', { name });
     return d ? new World(d.name) : null;
   }
-  static getAll(): World[] {
+  static getAll(): Promise<World[]> {
+    return post<WorldData[]>('world.getAll', {}).then((list) => list.map((r) => new World(r.name)));
+  }
+  static getAllSync(): World[] {
     return call<WorldData[]>('world.getAll', {}).map((r) => new World(r.name));
   }
 
@@ -31,12 +37,35 @@ export class World {
   }
   set spawnLocation(v: Location) { call('world.setSpawnLocation', { world: this.name, ...v.toObject() }); }
 
-  getHighestBlockY(x: number, z: number): number { return call<number>('world.getHighestBlockY', { world: this.name, x, z }); }
-  getGameRule(rule: string): string | null { return call<string | null>('world.getGameRule', { world: this.name, rule }); }
-  setGameRule(rule: string, value: string): Promise<boolean> { return post('world.setGameRule', { world: this.name, rule, value }); }
-  setGameRuleSync(rule: string, value: string): boolean { return call<boolean>('world.setGameRule', { world: this.name, rule, value }); }
-  getBiome(x: number, y: number, z: number): string { return call<string>('world.getBiome', { world: this.name, x, y, z }); }
-  getBlock(x: number, y: number, z: number): Block | null {
+  getHighestBlockY(x: number, z: number): Promise<number> {
+    return post<number>('world.getHighestBlockY', { world: this.name, x, z });
+  }
+  getHighestBlockYSync(x: number, z: number): number {
+    return call<number>('world.getHighestBlockY', { world: this.name, x, z });
+  }
+  getGameRule(rule: string): Promise<string | null> {
+    return post<string | null>('world.getGameRule', { world: this.name, rule });
+  }
+  getGameRuleSync(rule: string): string | null {
+    return call<string | null>('world.getGameRule', { world: this.name, rule });
+  }
+  setGameRule(rule: string, value: string): Promise<boolean> {
+    return post('world.setGameRule', { world: this.name, rule, value });
+  }
+  setGameRuleSync(rule: string, value: string): boolean {
+    return call<boolean>('world.setGameRule', { world: this.name, rule, value });
+  }
+  getBiome(x: number, y: number, z: number): Promise<string> {
+    return post<string>('world.getBiome', { world: this.name, x, y, z });
+  }
+  getBiomeSync(x: number, y: number, z: number): string {
+    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));
+  }
+  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;
   }
@@ -46,9 +75,22 @@ export class World {
   setBlockSync(x: number, y: number, z: number, blockType: string): void {
     call('world.setBlock', { world: this.name, x, y, z, blockType });
   }
-  getEntities(): string[] { return call<string[]>('world.getEntities', { world: this.name }); }
-  getPlayers(): string[] { return call<string[]>('world.getPlayers', { world: this.name }); }
-  getNearbyEntities(x: number, y: number, z: number, radius: number): string[] {
+  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 });
+  }
+  getNearbyEntitiesSync(x: number, y: number, z: number, radius: number): string[] {
     return call<string[]>('world.getNearbyEntities', { world: this.name, x, y, z, radius });
   }
   dropItem(x: number, y: number, z: number, itemType: string, amount?: number): Promise<void> {