yeow-api 0.2.40 → 0.2.41

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "yeow-api",
-    "version": "0.2.40",
+    "version": "0.2.41",
     "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

@@ -76,3 +76,5 @@ export { createObjective, deleteObjective, getObjectives,
     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> {