yeow-api 0.1.6 → 0.2.0

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "yeow-api",
-    "version": "0.1.6",
-    "description": "Yeow API �?TypeScript OOP wrappers over the task protocol",
+    "version": "0.2.0",
+    "description": "Yeow API �?TypeScript OOP wrappers over the task protocol",
     "type": "module",
     "main": "./src/index.ts",
     "types": "./src/index.ts",
@@ -9,4 +9,4 @@
         "src/"
     ],
     "license": "MIT"
-}
+}

package/src/command.ts

@@ -1,25 +1,15 @@
 import { call } from './task.js';
 
 export interface CommandSender {
-    /** Sender display name. */
     readonly name: string;
-    /** Player UUID, or "CONSOLE" for console senders. */
     readonly uuid: string;
-    /** Whether this sender is a player. */
     readonly isPlayer: boolean;
-    /**
-     * Send a message back to the sender. Injected by the API at callback time.
-     * MiniMessage format is supported.
-     */
     sendMessage(msg: string): void;
 }
 
 export interface CommandPayload {
-    /** The command sender. Use `Player.get(sender.uuid)` to access full Player properties. */
     readonly sender: CommandSender;
-    /** Space-delimited command arguments. */
     readonly args: string[];
-    /** The alias used to invoke the command. */
     readonly label: string;
 }
 
@@ -35,7 +25,7 @@ export function registerCommand(name: string, options: CommandOptions): boolean
     const executor = options.executor;
     const pluginName = (globalThis as any).__plugin?.name || 'unknown';
 
-    const cbId = (globalThis as any)._registerCallback((payload: CommandPayload) => {
+    const cbId = (globalThis as any)._regCb((payload: CommandPayload) => {
         const sender = payload.sender;
         if (sender?.uuid && sender.isPlayer) {
             (sender as any).sendMessage = (msg: string) => {

package/src/event.ts

@@ -1,78 +1,62 @@
 import { call } from './task.js';
 
-/**
- * Event subscription with cancellation support.
- * Sync handlers: e.cancelled = true takes effect immediately (sync task intercepted by EventBridge).
- * Async handlers: e.cancelled is @deprecated (no effect after await).
- */
-const _handlers: Record<string, Array<{ h: Function; async: boolean }>> = {};
-
-function _process(internalType: string, snapshot: Record<string, unknown>): Record<string, unknown> {
-    const entries = _handlers[internalType];
-    if (!entries?.length) return {};
-
-    const cancellable = snapshot._cancellable;
-    const mods: Record<string, unknown> = {};
-
-    for (const entry of entries) {
-        try {
-            const proxy: any = {};
-            for (const key of Object.keys(snapshot)) {
-                if (!key.startsWith('_')) proxy[key] = snapshot[key];
-            }
-            if (cancellable) {
-                Object.defineProperty(proxy, 'cancelled', {
-                    get: () => call('event.isCancelled', {}),
-                    set: (v: boolean) => { call('event.setCancelled', { cancelled: v }); },
-                    enumerable: true,
-                });
-            }
-            entry.h(proxy);
-        } catch (e: any) { console.error(`event handler error: ${e?.message || e}`); }
-    }
-    return mods;
-}
-
-// Install the global event handler that init.js calls
-(globalThis as any)._onEvent = (msg: any) => {
-    const eventType = msg.ev;
-    _process(eventType, msg.sn);
-    // Notify Java that event processing is done
-    if (typeof (globalThis as any)._eventComplete === 'function') {
-        (globalThis as any)._eventComplete(eventType);
-    }
-};
-
 export function eventOn(eventType: string, handler: (e: any) => void): () => void {
-    const async = handler.constructor.name === 'AsyncFunction';
-    if (!_handlers[eventType]) {
-        _handlers[eventType] = [];
+    // eventOn registers a handler on the JS side.
+    // The _onEvent function in init.js dispatches SYNC_CALLBACK messages to handlers.
+    // For now, event handlers are set up via a global registry.
+    // This is a simplified version — full sync callback event system requires
+    // the PluginThread to call _onEvent which processes handlers.
+    if (!(globalThis as any).__yeowEventHandlers) (globalThis as any).__yeowEventHandlers = {};
+    if (!(globalThis as any).__yeowEventHandlers[eventType]) {
+        (globalThis as any).__yeowEventHandlers[eventType] = [];
         call('event.subscribe', {
             pluginName: (globalThis as any).__plugin?.name || 'unknown',
             eventType,
         });
     }
-    const entry = { h: handler, async };
-    _handlers[eventType].push(entry);
+    (globalThis as any).__yeowEventHandlers[eventType].push(handler);
     return () => eventOff(eventType, handler);
 }
 
-export function eventOnce(eventType: string, handler: (e: any) => void): () => void {
-    const wrapper = (e: any) => { eventOff(eventType, wrapper); handler(e); };
-    return eventOn(eventType, wrapper);
-}
-
-export function eventOff(eventType: string, handler: (e: any) => void) {
-    const entries = _handlers[eventType];
-    if (!entries) return;
-    for (let i = 0; i < entries.length; i++) {
-        if (entries[i].h === handler) { entries.splice(i, 1); break; }
-    }
-    if (entries.length === 0) {
-        delete _handlers[eventType];
+export function eventOff(eventType: string, handler: (e: any) => void): void {
+    const handlers = (globalThis as any).__yeowEventHandlers?.[eventType];
+    if (!handlers) return;
+    const idx = handlers.indexOf(handler);
+    if (idx !== -1) handlers.splice(idx, 1);
+    if (handlers.length === 0) {
+        delete (globalThis as any).__yeowEventHandlers[eventType];
         call('event.unsubscribe', {
             pluginName: (globalThis as any).__plugin?.name || 'unknown',
             eventType,
         });
     }
 }
+
+// Install _onEvent handler called by init.js for SYNC_CALLBACK events
+(globalThis as any)._onEvent = (eventType: string, snapshot: any): any => {
+    const handlers = (globalThis as any).__yeowEventHandlers?.[eventType];
+    if (!handlers?.length) return {};
+
+    const cancellable = snapshot?._cancellable;
+    const mods: Record<string, any> = {};
+
+    for (const handler of handlers) {
+        try {
+            const proxy: any = {};
+            for (const key of Object.keys(snapshot || {})) {
+                if (!key.startsWith('_')) proxy[key] = snapshot[key];
+            }
+            const localMods: Record<string, any> = {};
+            if (cancellable) {
+                Object.defineProperty(proxy, 'cancelled', {
+                    get: () => localMods.cancelled || false,
+                    set: (v: boolean) => { localMods.cancelled = v; },
+                    enumerable: true,
+                });
+            }
+            handler(proxy);
+            if (cancellable && localMods.cancelled) mods.cancelled = true;
+        } catch (e: any) { console.error('event:', e?.message || e); }
+    }
+    return mods;
+};

package/src/index.ts

@@ -1,15 +1,7 @@
-export { call, post } from './task.js';
+export { call } from './task.js';
 export { Location } from './location.js';
-export { Entity, LivingEntity } from './entity.js';
 export { Player } from './player.js';
-export { World } from './world.js';
-export { Block } from './block.js';
-export { Inventory } from './inventory.js';
-export { fs, readFileSync, writeFileSync, existsSync } from './fs.js';
-export { path, join, basename, dirname, extname } from './path.js';
 export { registerCommand } from './command.js';
-export type { CommandOptions, CommandPayload } from './command.js';
-export { eventOn, eventOnce, eventOff } from './event.js';
-export { listen, respond, close } from './http.js';
-export type { HttpRequest } from './http.js';
-export { broadcast, broadcastSync, dispatchCommand, dispatchCommandSync, getMotd, getMaxPlayers, getVersion } from './server.js';
+export type { CommandOptions, CommandPayload, CommandSender } from './command.js';
+export { eventOn, eventOff } from './event.js';
+export { broadcast, getMotd, getVersion } from './server.js';

package/src/location.ts

@@ -2,23 +2,13 @@ import { call } from './task.js';
 
 export class Location {
     constructor(
-        public readonly x: number,
-        public readonly y: number,
-        public readonly z: number,
-        public readonly yaw: number = 0,
-        public readonly pitch: number = 0,
+        public readonly x: number, public readonly y: number, public readonly z: number,
+        public readonly yaw: number = 0, public readonly pitch: number = 0,
         public readonly world?: string
     ) {}
-
     static from(raw: Record<string, unknown>): Location {
-        return new Location(
-            raw.x as number, raw.y as number, raw.z as number,
-            (raw.yaw as number) ?? 0, (raw.pitch as number) ?? 0,
-            raw.world as string | undefined
-        );
-    }
-
-    toObject(): Record<string, unknown> {
-        return { x: this.x, y: this.y, z: this.z, yaw: this.yaw, pitch: this.pitch, world: this.world };
+        return new Location(raw.x as number, raw.y as number, raw.z as number,
+            (raw.yaw as number) ?? 0, (raw.pitch as number) ?? 0, raw.world as string | undefined);
     }
+    toObject(): Record<string, unknown> { return { x: this.x, y: this.y, z: this.z, yaw: this.yaw, pitch: this.pitch, world: this.world }; }
 }

package/src/player.ts

@@ -1,65 +1,22 @@
 import { call } from './task.js';
 import { Location } from './location.js';
-import { LivingEntity } from './entity.js';
-import { Inventory } from './inventory.js';
 
-export class Player extends LivingEntity {
-    static get(identifier: string): Player | null { const d = call('player.get',{identifier}) as any; return d?new Player(d.uuid,d.name):null; }
-    static getAll(): Player[] { return (call('player.getAll',{}) as any[]).map((r:any)=>new Player(r.uuid,r.name)); }
-
-    constructor(uuid: string, private _name?: string) { super(uuid); }
-    get name(): string { return this._name ?? ''; }
-    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 displayName(): string { return call('player.getDisplayName',{uuid:this.uuid}) as string; }
-    set displayName(v: string) { call('player.setDisplayName',{uuid:this.uuid,value:v}); }
-    get playerListName(): string { return call('player.getPlayerListName',{uuid:this.uuid}) as string; }
-    set playerListName(v: string) { call('player.setPlayerListName',{uuid:this.uuid,value:v}); }
-    get foodLevel(): number { return call('player.getFoodLevel',{uuid:this.uuid}) as number; }
-    set foodLevel(v: number) { call('player.setFoodLevel',{uuid:this.uuid,value:v}); }
-    get saturation(): number { return call('player.getSaturation',{uuid:this.uuid}) as number; }
-    set saturation(v: number) { call('player.setSaturation',{uuid:this.uuid,value:v}); }
-    get exp(): number { return call('player.getExp',{uuid:this.uuid}) as number; }
-    set exp(v: number) { call('player.setExp',{uuid:this.uuid,value:v}); }
-    get level(): number { return call('player.getLevel',{uuid:this.uuid}) as number; }
-    set level(v: number) { call('player.setLevel',{uuid:this.uuid,value:v}); }
-    get totalExperience(): number { return call('player.getTotalExperience',{uuid:this.uuid}) as number; }
-    giveExp(v: number): Promise<void> { return call('player.giveExp',{uuid:this.uuid,value:v}) as Promise<void>; }
-    giveExpSync(v: number): void { call('player.giveExp',{uuid:this.uuid,value:v}); }
-    get isOp(): boolean { return call('player.isOp',{uuid:this.uuid}) as boolean; }
-    get allowFlight(): boolean { return call('player.getAllowFlight',{uuid:this.uuid}) as boolean; }
-    set allowFlight(v: boolean) { call('player.setAllowFlight',{uuid:this.uuid,value:v}); }
-    get isFlying(): boolean { return call('player.isFlying',{uuid:this.uuid}) as boolean; }
-    set isFlying(v: boolean) { call('player.setFlying',{uuid:this.uuid,value:v}); }
-    get walkSpeed(): number { return call('player.getWalkSpeed',{uuid:this.uuid}) as number; }
-    set walkSpeed(v: number) { call('player.setWalkSpeed',{uuid:this.uuid,value:v}); }
-    get flySpeed(): number { return call('player.getFlySpeed',{uuid:this.uuid}) as number; }
-    set flySpeed(v: number) { call('player.setFlySpeed',{uuid:this.uuid,value:v}); }
-    hasPermission(node: string): boolean { return call('player.hasPermission',{uuid:this.uuid,node}) as boolean; }
-    get compassTarget(): Location | null { const r=call('player.getCompassTarget',{uuid:this.uuid}) as any; return r?Location.from(r):null; }
-    set compassTarget(loc: Location) { call('player.setCompassTarget',{uuid:this.uuid,...loc.toObject()}); }
-    get bedSpawnLocation(): Location | null { const r=call('player.getBedSpawnLocation',{uuid:this.uuid}) as any; return r?Location.from(r):null; }
-    setBedSpawnLocation(loc: Location): Promise<void> { return call('player.setBedSpawnLocation',{uuid:this.uuid,...loc.toObject()}) as Promise<void>; }
-    setBedSpawnLocationSync(loc: Location): void { call('player.setBedSpawnLocation',{uuid:this.uuid,...loc.toObject()}); }
-
-    sendMessage(msg: string): Promise<void> { return call('player.sendMessage',{uuid:this.uuid,message:msg}) as Promise<void>; }
-    sendMessageSync(msg: string): void { call('player.sendMessage',{uuid:this.uuid,message:msg}); }
-    sendTitle(title: string, subtitle?: string, fadeIn?: number, stay?: number, fadeOut?: number): Promise<void> {
-        return call('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});
+export class Player {
+    static get(identifier: string): Player | null {
+        const d = call('player.get', { identifier }) as any;
+        return d ? new Player(d.uuid, d.name) : null;
     }
-    playSound(sound: string, volume?: number, pitch?: number): Promise<void> {
-        return call('player.playSound',{uuid:this.uuid,sound,volume,pitch}) as Promise<void>;
+    static getAll(): Player[] {
+        return (call('player.getAll', {}) as any[]).map((r: any) => new Player(r.uuid, r.name));
     }
-    playSoundSync(sound: string, volume?: number, pitch?: number): void {
-        call('player.playSound',{uuid:this.uuid,sound,volume,pitch});
-    }
-    kick(reason?: string): Promise<void> { return call('player.kick',{uuid:this.uuid,reason}) as Promise<void>; }
-    kickSync(reason?: string): void { call('player.kick',{uuid:this.uuid,reason}); }
 
-    private _inv: Inventory | null = null;
-    get inventory(): Inventory { return this._inv ?? (this._inv = new Inventory(this.uuid)); }
+    constructor(public readonly uuid: string, private _name?: string) {}
+
+    get name(): string { return this._name ?? ''; }
+    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 }); }
+
+    sendMessage(msg: string): void { call('player.sendMessage', { uuid: this.uuid, message: msg }); }
+    kick(reason?: string): void { call('player.kick', { uuid: this.uuid, reason }); }
 }

package/src/server.ts

@@ -1,29 +1,5 @@
 import { call } from './task.js';
 
-export function broadcast(msg: string): Promise<void> {
-    return call('server.broadcast', { message: msg }) as Promise<void>;
-}
-
-export function broadcastSync(msg: string): void {
-    call('server.broadcast', { message: msg });
-}
-
-export function getMotd(): string {
-    return call('server.getMotd', {}) as string;
-}
-
-export function getVersion(): string {
-    return call('server.getVersion', {}) as string;
-}
-
-export function getMaxPlayers(): number {
-    return call('server.getMaxPlayers', {}) as number;
-}
-
-export function dispatchCommand(cmd: string): Promise<void> {
-    return call('server.dispatchCommand', { command: cmd }) as Promise<void>;
-}
-
-export function dispatchCommandSync(cmd: string): void {
-    call('server.dispatchCommand', { command: cmd });
-}
+export function broadcast(msg: string): void { call('server.broadcast', { message: msg }); }
+export function getMotd(): string { return call('server.getMotd', {}) as string; }
+export function getVersion(): string { return call('server.getVersion', {}) as string; }

package/src/task.ts

@@ -1,19 +1,17 @@
-export function call(type: string, params?: Record<string, unknown>): unknown {
-    const json = typeof params === 'object' && params !== null ? JSON.stringify(params) : '{}';
-    const raw = (globalThis as any).$submitSync(type, json);
-    if (typeof raw !== 'string') return undefined;
-    const result = JSON.parse(raw);
-    if (result && result.err) throw new Error(result.err);
-    return result;
-}
-
-export function post(type: string, params?: Record<string, unknown>): Promise<unknown> {
+export function post(type: string, params: Record<string, unknown> = {}): Promise<unknown> {
     return new Promise((resolve, reject) => {
-        const json = typeof params === 'object' && params !== null ? JSON.stringify(params) : '{}';
-        const cbId = (globalThis as any)._registerCallback((result: any) => {
+        const cbId = (globalThis as any)._regCb((result: any) => {
             if (result?.err) reject(new Error(result.err));
             else resolve(result);
         });
-        (globalThis as any).$submitAsync(type, json, cbId);
+        (globalThis as any).$send('game', JSON.stringify({ t: type, p: params, cb: cbId }));
     });
 }
+
+export function call(type: string, params: Record<string, unknown> = {}): unknown {
+    const raw = (globalThis as any).$send('game', JSON.stringify({ t: type, p: params }));
+    if (!raw) return undefined;
+    const r = JSON.parse(raw as string);
+    if (r.err) throw new Error(r.err);
+    return r;
+}