yeow-api 0.2.40 → 0.2.42

package/package.json

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

package/src/assets.ts

@@ -5,39 +5,37 @@ function _sendAssets(payload: Record<string, unknown>): unknown {
   return r;
 }
 
-export function read(path: string): Promise<string> {
+function _sendAssetsAsync(payload: Record<string, unknown>): Promise<unknown> {
   return new Promise((resolve, reject) => {
-    try {
-      const r = _sendAssets({ t: 'read', p: { path } }) as { data: string };
-      resolve(r.data);
-    } catch (e) { reject(e); }
+    const cbId = _registerCallback((result: unknown) => {
+      if ((result as any)?.err) reject(new Error((result as any).err));
+      else resolve(result);
+    });
+    $send('assets', { ...payload, cb: cbId });
   });
 }
+
+export async function read(path: string): Promise<string> {
+  const r = await _sendAssetsAsync({ t: 'read', p: { path } }) as { data: string };
+  return r.data;
+}
 export function readSync(path: string): string {
   return (_sendAssets({ t: 'read', p: { path } }) as { data: string }).data;
 }
 
-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 async function readBase64(path: string): Promise<string> {
+  const r = await _sendAssetsAsync({ t: 'readBase64', p: { path } }) as { data: string };
+  return r.data;
 }
 export function readBase64Sync(path: string): string {
   return (_sendAssets({ t: 'readBase64', p: { path } }) as { data: string }).data;
 }
 
-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 async function extract(path: string, dest?: string): Promise<string> {
+  const p: Record<string, unknown> = { path };
+  if (dest) p.dest = dest;
+  const r = await _sendAssetsAsync({ t: 'extract', p }) as { path: string };
+  return r.path;
 }
 export function extractSync(path: string, dest?: string): string {
   const p: Record<string, unknown> = { path };

package/src/fs.ts

@@ -5,116 +5,89 @@ function _sendFs(payload: Record<string, unknown>): unknown {
   return r;
 }
 
-export function readFile(path: string): Promise<string> {
+function _sendFsAsync(payload: Record<string, unknown>): Promise<unknown> {
   return new Promise((resolve, reject) => {
-    try {
-      const r = _sendFs({ t: 'readFile', p: { path } }) as { data: string };
-      resolve(r.data);
-    } catch (e) { reject(e); }
+    const cbId = _registerCallback((result: unknown) => {
+      if ((result as any)?.err) reject(new Error((result as any).err));
+      else resolve(result);
+    });
+    $send('fs', { ...payload, cb: cbId });
   });
 }
+
+export async function readFile(path: string): Promise<string> {
+  const r = await _sendFsAsync({ t: 'readFile', p: { path } }) as { data: string };
+  return r.data;
+}
 export function readFileSync(path: string): string {
   return (_sendFs({ t: 'readFile', p: { path } }) as { data: string }).data;
 }
 
-export function readFileBase64(path: string): Promise<string> {
-  return new Promise((resolve, reject) => {
-    try {
-      const r = _sendFs({ t: 'readBase64', p: { path } }) as { data: string };
-      resolve(r.data);
-    } catch (e) { reject(e); }
-  });
+export async function readFileBase64(path: string): Promise<string> {
+  const r = await _sendFsAsync({ t: 'readBase64', p: { path } }) as { data: string };
+  return r.data;
 }
 export function readFileBase64Sync(path: string): string {
   return (_sendFs({ t: 'readBase64', p: { path } }) as { data: string }).data;
 }
 
-export function writeFile(path: string, data: string): Promise<void> {
-  return new Promise((resolve, reject) => {
-    try { _sendFs({ t: 'writeFile', p: { path, data } }); resolve(); }
-    catch (e) { reject(e); }
-  });
+export async function writeFile(path: string, data: string): Promise<void> {
+  await _sendFsAsync({ t: 'writeFile', p: { path, data } });
 }
 export function writeFileSync(path: string, data: string): void {
   _sendFs({ t: 'writeFile', p: { path, data } });
 }
 
-export function writeFileBase64(path: string, data: string): Promise<void> {
-  return new Promise((resolve, reject) => {
-    try { _sendFs({ t: 'writeBase64', p: { path, data } }); resolve(); }
-    catch (e) { reject(e); }
-  });
+export async function writeFileBase64(path: string, data: string): Promise<void> {
+  await _sendFsAsync({ t: 'writeBase64', p: { path, data } });
 }
 export function writeFileBase64Sync(path: string, data: string): void {
   _sendFs({ t: 'writeBase64', p: { path, data } });
 }
 
-export function appendFile(path: string, data: string): Promise<void> {
-  return new Promise((resolve, reject) => {
-    try { _sendFs({ t: 'appendFile', p: { path, data } }); resolve(); }
-    catch (e) { reject(e); }
-  });
+export async function appendFile(path: string, data: string): Promise<void> {
+  await _sendFsAsync({ t: 'appendFile', p: { path, data } });
 }
 export function appendFileSync(path: string, data: string): void {
   _sendFs({ t: 'appendFile', 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 async function exists(path: string): Promise<boolean> {
+  const r = await _sendFsAsync({ t: 'exists', p: { path } });
+  return r === true || String(r) === 'true';
 }
 export function existsSync(path: string): boolean {
   const r = _sendFs({ t: 'exists', p: { path } });
   return r === true || String(r) === 'true';
 }
 
-export function isDirectory(path: string): Promise<boolean> {
-  return new Promise((resolve, reject) => {
-    try {
-      const r = _sendFs({ t: 'isDirectory', p: { path } });
-      resolve(r === true || String(r) === 'true');
-    } catch (e) { reject(e); }
-  });
+export async function isDirectory(path: string): Promise<boolean> {
+  const r = await _sendFsAsync({ t: 'isDirectory', p: { path } });
+  return r === true || String(r) === 'true';
 }
 export function isDirectorySync(path: string): boolean {
   const r = _sendFs({ t: 'isDirectory', p: { path } });
   return r === true || String(r) === 'true';
 }
 
-export function deleteFile(path: string): Promise<boolean> {
-  return new Promise((resolve, reject) => {
-    try {
-      const r = _sendFs({ t: 'delete', p: { path } });
-      resolve(r === true || String(r) === 'true');
-    } catch (e) { reject(e); }
-  });
+export async function deleteFile(path: string): Promise<boolean> {
+  const r = await _sendFsAsync({ t: 'delete', p: { path } });
+  return r === true || String(r) === 'true';
 }
 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) => {
-    try { _sendFs({ t: 'mkdir', p: { path } }); resolve(); }
-    catch (e) { reject(e); }
-  });
+export async function mkdir(path: string): Promise<void> {
+  await _sendFsAsync({ t: 'mkdir', p: { path } });
 }
 export function mkdirSync(path: string): void {
   _sendFs({ t: 'mkdir', p: { path } });
 }
 
-export function list(path: string): Promise<string[]> {
-  return new Promise((resolve, reject) => {
-    try {
-      const r = _sendFs({ t: 'list', p: { path } });
-      resolve(r as string[]);
-    } catch (e) { reject(e); }
-  });
+export async function list(path: string): Promise<string[]> {
+  return await _sendFsAsync({ t: 'list', p: { path } }) as string[];
 }
 export function listSync(path: string): string[] {
   return _sendFs({ t: 'list', p: { path } }) as string[];

package/src/index.ts

@@ -69,10 +69,13 @@ export { add as addRecipe, remove as removeRecipe, getForItem as getRecipesForIt
 export type {
     ObjectiveInfo, TeamInfo,
 } from './scoreboard.js';
-export { createObjective, deleteObjective, getObjectives,
+export { createBoard as createScoreboard, deleteBoard as deleteScoreboard,
+    createObjective, deleteObjective, getObjectives,
     setObjectiveDisplay, getScore, setScore, resetScore,
     createTeam, deleteTeam, getTeam, getTeams,
     setTeamDisplayName, setTeamPrefix, setTeamSuffix, setTeamColor,
     setTeamFriendlyFire, setTeamSeeInvisible, setTeamOption,
     teamAddEntry, teamRemoveEntry, teamGetEntries,
     setPlayerBoard } from './scoreboard.js';
+export { getMaterials, getBlocks, getItems } from './material.js';
+export type { MaterialInfo } from './material.js';

package/src/material.ts

@@ -0,0 +1,19 @@
+import { post } from './task.js';
+
+export interface MaterialInfo {
+  key: string;
+  isBlock: boolean;
+  isItem: boolean;
+}
+
+export function getMaterials(): Promise<MaterialInfo[]> {
+  return post<MaterialInfo[]>('server.getMaterials', {});
+}
+
+export function getBlocks(): Promise<string[]> {
+  return post<string[]>('server.getBlocks', {});
+}
+
+export function getItems(): Promise<string[]> {
+  return post<string[]>('server.getItems', {});
+}

package/src/recipe.ts

@@ -54,7 +54,7 @@ interface CampfireRecipe {
 }
 
 export function add(recipe: RecipeDefinition): Promise<boolean> {
-  return post<boolean>('recipe.add', recipe as Record<string, unknown>);
+  return post<boolean>('recipe.add', recipe as unknown as Record<string, unknown>);
 }
 
 export function remove(key: string): Promise<void> {

package/src/scoreboard.ts

@@ -22,94 +22,108 @@ export interface TeamInfo {
   };
 }
 
+function boardParam(board?: string): Record<string, unknown> {
+  return board ? { board } : {};
+}
+
+// ── Board ──
+
+export function createBoard(id: string): Promise<string> {
+  return post<string>('scoreboard.createBoard', { id });
+}
+
+export function deleteBoard(id: string): Promise<void> {
+  return post('scoreboard.deleteBoard', { id });
+}
+
 // ── Objectives ──
 
-export function createObjective(name: string, criteria: string, displayName: string): Promise<ObjectiveInfo> {
-  return post<ObjectiveInfo>('scoreboard.createObjective', { name, criteria, displayName });
+export function createObjective(name: string, criteria: string, displayName: string, board?: string): Promise<ObjectiveInfo> {
+  return post<ObjectiveInfo>('scoreboard.createObjective', { name, criteria, displayName, ...boardParam(board) });
 }
 
-export function deleteObjective(name: string): Promise<void> {
-  return post('scoreboard.deleteObjective', { name });
+export function deleteObjective(name: string, board?: string): Promise<void> {
+  return post('scoreboard.deleteObjective', { name, ...boardParam(board) });
 }
 
-export function getObjectives(): Promise<ObjectiveInfo[]> {
-  return post<ObjectiveInfo[]>('scoreboard.getObjectives', {});
+export function getObjectives(board?: string): Promise<ObjectiveInfo[]> {
+  return post<ObjectiveInfo[]>('scoreboard.getObjectives', { ...boardParam(board) });
 }
 
-export function setObjectiveDisplay(name: string, slot: string | null): Promise<boolean> {
-  return post<boolean>('scoreboard.setObjectiveDisplay', { name, slot });
+export function setObjectiveDisplay(name: string, slot: string | null, board?: string): Promise<boolean> {
+  return post<boolean>('scoreboard.setObjectiveDisplay', { name, slot, ...boardParam(board) });
 }
 
-export function getScore(objective: string, entry: string): Promise<number | null> {
-  return post<number | null>('scoreboard.getScore', { objective, entry });
+export function getScore(objective: string, entry: string, board?: string): Promise<number | null> {
+  return post<number | null>('scoreboard.getScore', { objective, entry, ...boardParam(board) });
 }
 
-export function setScore(objective: string, entry: string, value: number): Promise<void> {
-  return post('scoreboard.setScore', { objective, entry, value });
+export function setScore(objective: string, entry: string, value: number, board?: string): Promise<void> {
+  return post('scoreboard.setScore', { objective, entry, value, ...boardParam(board) });
 }
 
-export function resetScore(objective: string, entry: string): Promise<void> {
-  return post('scoreboard.resetScore', { objective, entry });
+export function resetScore(objective: string, entry: string, board?: string): Promise<void> {
+  return post('scoreboard.resetScore', { objective, entry, ...boardParam(board) });
 }
 
 // ── Teams ──
 
-export function createTeam(name: string): Promise<void> {
-  return post('scoreboard.createTeam', { name });
+export function createTeam(name: string, board?: string): Promise<void> {
+  return post('scoreboard.createTeam', { name, ...boardParam(board) });
 }
 
-export function deleteTeam(name: string): Promise<void> {
-  return post('scoreboard.deleteTeam', { name });
+export function deleteTeam(name: string, board?: string): Promise<void> {
+  return post('scoreboard.deleteTeam', { name, ...boardParam(board) });
 }
 
-export function getTeam(name: string): Promise<TeamInfo | null> {
-  return post<TeamInfo | null>('scoreboard.getTeam', { name });
+export function getTeam(name: string, board?: string): Promise<TeamInfo | null> {
+  return post<TeamInfo | null>('scoreboard.getTeam', { name, ...boardParam(board) });
 }
 
-export function getTeams(): Promise<TeamInfo[]> {
-  return post<TeamInfo[]>('scoreboard.getTeams', {});
+export function getTeams(board?: string): Promise<TeamInfo[]> {
+  return post<TeamInfo[]>('scoreboard.getTeams', { ...boardParam(board) });
 }
 
-export function setTeamDisplayName(name: string, displayName: string): Promise<void> {
-  return post('scoreboard.setTeamDisplayName', { name, displayName });
+export function setTeamDisplayName(name: string, displayName: string, board?: string): Promise<void> {
+  return post('scoreboard.setTeamDisplayName', { name, displayName, ...boardParam(board) });
 }
 
-export function setTeamPrefix(name: string, prefix: string): Promise<void> {
-  return post('scoreboard.setTeamPrefix', { name, prefix });
+export function setTeamPrefix(name: string, prefix: string, board?: string): Promise<void> {
+  return post('scoreboard.setTeamPrefix', { name, prefix, ...boardParam(board) });
 }
 
-export function setTeamSuffix(name: string, suffix: string): Promise<void> {
-  return post('scoreboard.setTeamSuffix', { name, suffix });
+export function setTeamSuffix(name: string, suffix: string, board?: string): Promise<void> {
+  return post('scoreboard.setTeamSuffix', { name, suffix, ...boardParam(board) });
 }
 
-export function setTeamColor(name: string, color: string): Promise<void> {
-  return post('scoreboard.setTeamColor', { name, color });
+export function setTeamColor(name: string, color: string, board?: string): Promise<void> {
+  return post('scoreboard.setTeamColor', { name, color, ...boardParam(board) });
 }
 
-export function setTeamFriendlyFire(name: string, allow: boolean): Promise<void> {
-  return post('scoreboard.setTeamFriendlyFire', { name, allow });
+export function setTeamFriendlyFire(name: string, allow: boolean, board?: string): Promise<void> {
+  return post('scoreboard.setTeamFriendlyFire', { name, allow, ...boardParam(board) });
 }
 
-export function setTeamSeeInvisible(name: string, canSee: boolean): Promise<void> {
-  return post('scoreboard.setTeamSeeInvisible', { name, canSee });
+export function setTeamSeeInvisible(name: string, canSee: boolean, board?: string): Promise<void> {
+  return post('scoreboard.setTeamSeeInvisible', { name, canSee, ...boardParam(board) });
 }
 
-export function setTeamOption(name: string, option: string, value: string): Promise<void> {
-  return post('scoreboard.setTeamOption', { name, option, value });
+export function setTeamOption(name: string, option: string, value: string, board?: string): Promise<void> {
+  return post('scoreboard.setTeamOption', { name, option, value, ...boardParam(board) });
 }
 
-export function teamAddEntry(name: string, entry: string): Promise<void> {
-  return post('scoreboard.teamAddEntry', { name, entry });
+export function teamAddEntry(name: string, entry: string, board?: string): Promise<void> {
+  return post('scoreboard.teamAddEntry', { name, entry, ...boardParam(board) });
 }
 
-export function teamRemoveEntry(name: string, entry: string): Promise<void> {
-  return post('scoreboard.teamRemoveEntry', { name, entry });
+export function teamRemoveEntry(name: string, entry: string, board?: string): Promise<void> {
+  return post('scoreboard.teamRemoveEntry', { name, entry, ...boardParam(board) });
 }
 
-export function teamGetEntries(name: string): Promise<string[]> {
-  return post<string[]>('scoreboard.teamGetEntries', { name });
+export function teamGetEntries(name: string, board?: string): Promise<string[]> {
+  return post<string[]>('scoreboard.teamGetEntries', { name, ...boardParam(board) });
 }
 
-export function setPlayerBoard(uuid: string): Promise<void> {
-  return post('scoreboard.setPlayerBoard', { uuid });
+export function setPlayerBoard(uuid: string, board?: string): Promise<void> {
+  return post('scoreboard.setPlayerBoard', { uuid, ...boardParam(board) });
 }