yeow-api 0.2.31 → 0.2.33

package/package.json

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

package/src/assets.ts

@@ -1,41 +1,48 @@
-function _sendAssets(payload) {
-    const r = $send('assets', payload);
-    if (!r) return undefined;
-    if (r.err) throw new Error(r.err);
-    return r;
+function _sendAssets(payload: Record<string, unknown>): unknown {
+  const r = $send('assets', payload);
+  if (r == null) return undefined;
+  if ((r as any)?.err) throw new Error((r as any).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 read(path: string): Promise<string> {
+  return new Promise((resolve, reject) => {
+    try {
+      const r = _sendAssets({ t: 'read', p: { path } }) as { data: string };
+      resolve(r.data);
+    } catch (e) { reject(e); }
+  });
 }
-export function readSync(path) {
-    return _sendAssets({ t: 'read', p: { path } }).data;
+export function readSync(path: string): string {
+  return (_sendAssets({ t: 'read', p: { path } }) as { data: string }).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 readBase64(path: string): Promise<string> {
+  return new Promise((resolve, reject) => {
+    try {
+      const r = _sendAssets({ t: 'readBase64', p: { path } }) as { data: string };
+      resolve(r.data);
+    } catch (e) { reject(e); }
+  });
 }
-export function readBase64Sync(path) {
-    return _sendAssets({ t: 'readBase64', p: { path } }).data;
+export function readBase64Sync(path: string): string {
+  return (_sendAssets({ t: 'readBase64', p: { path } }) as { data: string }).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 extract(path: string, dest?: string): Promise<string> {
+  return new Promise((resolve, reject) => {
+    try {
+      const p: Record<string, unknown> = { path };
+      if (dest) p.dest = dest;
+      const r = _sendAssets({ t: 'extract', p }) as { path: string };
+      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 function extractSync(path: string, dest?: string): string {
+  const p: Record<string, unknown> = { path };
+  if (dest) p.dest = dest;
+  return (_sendAssets({ t: 'extract', p }) as { path: string }).path;
 }
 
 export const assets = { read, readSync, readBase64, readBase64Sync, extract, extractSync };

package/src/block.ts

@@ -2,16 +2,18 @@ import { call } from './task.js';
 import { Location } from './location.js';
 
 export class Block {
-    constructor(
-        public readonly world: string,
-        public readonly x: number,
-        public readonly y: number,
-        public readonly z: number,
-        public readonly type: string
-    ) {}
+  constructor(
+    public readonly world: string,
+    public readonly x: number,
+    public readonly y: number,
+    public readonly z: number,
+    public readonly type: string,
+  ) {}
 
-    get location(): Location { return new Location(this.x, this.y, this.z, undefined, undefined, this.world); }
-    isSolid(): boolean { return call('block.isSolid', { world: this.world, x: this.x, y: this.y, z: this.z }) as boolean; }
-    isLiquid(): boolean { return call('block.isLiquid', { world: this.world, x: this.x, y: this.y, z: this.z }) as boolean; }
-    isEmpty(): boolean { return call('block.isEmpty', { world: this.world, x: this.x, y: this.y, z: this.z }) as boolean; }
+  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 }); }
 }

package/src/command.ts

@@ -1,85 +1,104 @@
 import { call } from './task.js';
 
 export interface CommandSender {
-    readonly name: string;
-    readonly uuid: string;
-    readonly isPlayer: boolean;
-    sendMessage(msg: string): void;
+  readonly name: string;
+  readonly uuid: string;
+  readonly isPlayer: boolean;
+  sendMessage(msg: string): void;
 }
 
 export interface CommandPayload {
-    readonly sender: CommandSender;
-    readonly args: string[];
-    readonly label: string;
+  readonly sender: CommandSender;
+  readonly args: string[];
+  readonly label: string;
 }
 
-type CompleterFn = (sender: CommandSender, args: string[]) => string[];
+type CompleterFn = (sender: CommandSender, args: string[]) => string[] | Promise<string[]>;
 export interface ManualCompleter {
-    manualRelease: true;
-    handler: (sender: CommandSender, args: string[], release: (result: string[]) => void) => void;
+  manualRelease: true;
+  handler: (sender: CommandSender, args: string[], complete: (result: string[]) => void) => void;
 }
 
 export interface CommandOptions {
-    description?: string;
-    usage?: string;
-    permission?: string;
-    aliases?: string[];
-    executor: (payload: CommandPayload) => void;
-    completer?: CompleterFn | ManualCompleter;
+  description?: string;
+  usage?: string;
+  permission?: string;
+  aliases?: string[];
+  executor: (payload: CommandPayload) => void;
+  completer?: CompleterFn | ManualCompleter;
 }
 
 export function registerCommand(name: string, options: CommandOptions): boolean {
-    const executor = options.executor;
-    const completer = options.completer;
-    const pluginName = (globalThis as any).__plugin?.name || 'unknown';
+  const executor = options.executor;
+  const completer = options.completer;
+  const pluginName = __plugin?.name || 'unknown';
 
-    const cbId = (globalThis as any)._registerCallback((payload: CommandPayload) => {
-        const sender = payload.sender;
-        if (sender?.uuid && sender.isPlayer) {
-            (sender as any).sendMessage = (msg: string) => {
-                call('player.sendMessage', { uuid: sender.uuid, message: msg });
-            };
-        }
-        executor(payload);
-    }, { persistent: true });
+  const cbId = _registerCallback((payload: CommandPayload) => {
+    const sender = payload.sender;
+    if (sender?.uuid && sender.isPlayer) {
+      (sender as any).sendMessage = (msg: string) => {
+        call('player.sendMessage', { uuid: sender.uuid, message: msg });
+      };
+    }
+    executor(payload);
+  }, { persistent: true });
+
+  let compCbId = '';
+  if (completer) {
+    let manualRelease = false;
+    let completerFn: Function;
+    if (typeof completer === 'object' && (completer as any).manualRelease) {
+      manualRelease = true;
+      completerFn = (completer as any).handler;
+    } else {
+      completerFn = completer as CompleterFn;
+    }
 
-    let compCbId = '';
-    if (completer) {
-        let manualRelease = false;
-        let completerFn: Function;
-        if (typeof completer === 'object' && (completer as any).manualRelease) {
-            manualRelease = true;
-            completerFn = (completer as any).handler;
+    compCbId = _registerCallback((data: any) => {
+      try {
+        if (manualRelease) {
+          const complete = (result: string[]) => {
+            $send('task', {
+              type: 'command.tabComplete',
+              params: { callbackId: compCbId, completions: result },
+              cb: '',
+            });
+          };
+          completerFn(data.sender, data.args, complete);
         } else {
-            completerFn = completer as CompleterFn;
+          const result = completerFn(data.sender, data.args);
+          if (result && typeof result.then === 'function') {
+            $send('task', {
+              type: 'command.tabComplete',
+              params: { callbackId: compCbId, completions: [] },
+              cb: '',
+            });
+          } else {
+            $send('task', {
+              type: 'command.tabComplete',
+              params: { callbackId: compCbId, completions: result || [] },
+              cb: '',
+            });
+          }
         }
+      } catch (_e) {
+        $send('task', {
+          type: 'command.tabComplete',
+          params: { callbackId: compCbId, completions: [] },
+          cb: '',
+        });
+      }
+    }, { persistent: true });
+  }
 
-        compCbId = (globalThis as any)._registerCallback((data: any, release: Function) => {
-            try {
-                if (manualRelease) {
-                    completerFn(data.sender, data.args, release);
-                } else {
-                    const result = completerFn(data.sender, data.args);
-                    if (result && typeof result.then === 'function') {
-                        release([]);  // async → release immediate, use ManualCompleter for async
-                    } else {
-                        release(result || []);
-                    }
-                }
-            } catch (e) {
-                release([]);
-            }
-        }, { persistent: true });
-    }
-
-    return call('command.register', {
-        pluginName,
-        commandName: name,
-        callbackId: String(cbId),
-        completerCbId: compCbId,
-        description: options.description,
-        usage: options.usage,
-        permission: options.permission,
-        aliases: options.aliases,
-    }) as boolean;
+  return call<boolean>('command.register', {
+    pluginName,
+    commandName: name,
+    callbackId: String(cbId),
+    completerCbId: compCbId,
+    description: options.description,
+    usage: options.usage,
+    permission: options.permission,
+    aliases: options.aliases,
+  });
 }

package/src/entity.ts

@@ -1,36 +1,39 @@
 import { call, post } from './task.js';
-import { Location } from './location.js';
+import { Location, LocationData } from './location.js';
 
 export class Entity {
-    constructor(public readonly uuid: string) {}
+  constructor(public readonly uuid: string) {}
 
-    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 { 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 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; }
-    set isGlowing(v: boolean) { call('entity.setGlowing', { uuid: this.uuid, value: v }); }
-    get isInvulnerable(): boolean { return call('entity.isInvulnerable', { uuid: this.uuid }) as boolean; }
-    set isInvulnerable(v: boolean) { call('entity.setInvulnerable', { uuid: this.uuid, value: v }); }
-    get isSilent(): boolean { return call('entity.isSilent', { uuid: this.uuid }) as boolean; }
-    set isSilent(v: boolean) { call('entity.setSilent', { uuid: this.uuid, value: v }); }
-    get hasGravity(): boolean { return call('entity.hasGravity', { uuid: this.uuid }) as boolean; }
-    set hasGravity(v: boolean) { call('entity.setGravity', { uuid: this.uuid, value: v }); }
-    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; }
+  get type(): string { return call<string>('entity.getType', { uuid: this.uuid }); }
+  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 }); }
+  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;
+  }
+  get isGlowing(): boolean { return call<boolean>('entity.isGlowing', { uuid: this.uuid }); }
+  set isGlowing(v: boolean) { call('entity.setGlowing', { uuid: this.uuid, value: v }); }
+  get isInvulnerable(): boolean { return call<boolean>('entity.isInvulnerable', { uuid: this.uuid }); }
+  set isInvulnerable(v: boolean) { call('entity.setInvulnerable', { uuid: this.uuid, value: v }); }
+  get isSilent(): boolean { return call<boolean>('entity.isSilent', { uuid: this.uuid }); }
+  set isSilent(v: boolean) { call('entity.setSilent', { uuid: this.uuid, value: v }); }
+  get hasGravity(): boolean { return call<boolean>('entity.hasGravity', { uuid: this.uuid }); }
+  set hasGravity(v: boolean) { call('entity.setGravity', { uuid: this.uuid, value: v }); }
+  get passengers(): string[] { return call<string[]>('entity.getPassengers', { uuid: this.uuid }); }
+  get vehicle(): string | null { return call<string | null>('entity.getVehicle', { uuid: this.uuid }); }
 
-    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 post('entity.teleport', { uuid: this.uuid, ...loc.toObject() }) as Promise<void>; }
-    teleportSync(loc: Location): void { call('entity.teleport', { uuid: this.uuid, ...loc.toObject() }); }
+  remove(): Promise<void> { return post('entity.remove', { uuid: this.uuid }); }
+  removeSync(): void { call('entity.remove', { uuid: this.uuid }); }
+  teleport(loc: Location): Promise<void> { return post('entity.teleport', { uuid: this.uuid, ...loc.toObject() }); }
+  teleportSync(loc: Location): void { call('entity.teleport', { uuid: this.uuid, ...loc.toObject() }); }
 }
 
 export class LivingEntity extends Entity {
-    get health(): number { return call('entity.getHealth', { uuid: this.uuid }) as number; }
-    set health(v: number) { call('entity.setHealth', { uuid: this.uuid, value: v }); }
-    get maxHealth(): number { return call('entity.getMaxHealth', { uuid: this.uuid }) as number; }
-    get isDead(): boolean { return call('entity.isDead', { uuid: this.uuid }) as boolean; }
+  get health(): number { return call<number>('entity.getHealth', { uuid: this.uuid }); }
+  set health(v: number) { call('entity.setHealth', { uuid: this.uuid, value: v }); }
+  get maxHealth(): number { return call<number>('entity.getMaxHealth', { uuid: this.uuid }); }
+  get isDead(): boolean { return call<boolean>('entity.isDead', { uuid: this.uuid }); }
 }