3 thingsssss

- types and errors now exported properly.
- entity apis now allow fetcherror instead of filtering it out
- tests updated to stop failing on entity `.get` calls. (oapi info no longer merged into the returned entity)

src/api/Nations.ts

@@ -1,13 +1,13 @@
 import * as fn from '../utils/functions.js'
 
-import { FetchError } from "../utils/errors.js"
+import { FetchError, NotFoundError } from "../utils/errors.js"
 import { Nation, Town } from '../types.js'
 import { Map } from "../Map.js"
 import { EntityApi } from './EntityApi.js'
 
 //import OfficialAPI from '../OAPI.js'
 
-class Nations implements EntityApi<Nation> {
+class Nations implements EntityApi<Nation | NotFoundError> {
     #map: Map
 
     get map() { return this.#map }
@@ -22,11 +22,11 @@ class Nations implements EntityApi<Nation> {
     //     ...nation
     // } : nation
 
-    readonly get = async (...nationList: string[]): Promise<Nation[] | Nation> => {
+    readonly get = async (...nationList: string[]) => {
         const nations = await this.all()
         if (!nations) throw new FetchError('Error fetching nations! Please try again.')
 
-        const existing = fn.getExisting(nations, nationList, 'name').filter(n => n.name !== "NotFoundError") as Nation[]
+        const existing = fn.getExisting(nations, nationList, 'name')
         return existing.length > 1 ? Promise.all(existing): Promise.resolve(existing[0])
     }
 

src/api/Players.ts

@@ -2,13 +2,13 @@ import striptags from 'striptags'
 
 import * as fn from '../utils/functions.js'
 import * as endpoint from '../utils/endpoint.js'
-import { FetchError } from "../utils/errors.js"
+import { FetchError, NotFoundError } from "../utils/errors.js"
 
 import { Map } from '../Map.js'
 import { OnlinePlayer, Player } from '../types.js'
 import { EntityApi } from './EntityApi.js'
 
-class Players implements EntityApi<Player> {
+class Players implements EntityApi<Player | NotFoundError> {
     #map: Map
 
     get map() { return this.#map }
@@ -21,7 +21,8 @@ class Players implements EntityApi<Player> {
         const players = await this.all()
         if (!players) throw new FetchError('Error fetching players! Please try again.')
 
-        return fn.getExisting(players, playerList, 'name') as Player | Player[]
+        const existing = fn.getExisting(players, playerList, 'name')
+        return existing.length > 1 ? Promise.all(existing) : Promise.resolve(existing[0])
     }
 
     readonly all = async () => {

src/api/Residents.ts

@@ -1,12 +1,12 @@
 import * as fn from '../utils/functions.js'
 //import OfficialAPI from "../OAPI.js"
 
-import { FetchError, InvalidError } from "../utils/errors.js"
+import { FetchError, InvalidError, NotFoundError } from "../utils/errors.js"
 import { Resident, Town } from '../types.js'
 import { Map } from "../Map.js"
 import { EntityApi } from './EntityApi.js'
 
-class Residents implements EntityApi<Resident> {
+class Residents implements EntityApi<Resident | NotFoundError> {
     #map: Map
 
     get map() { return this.#map }
@@ -30,11 +30,11 @@ class Residents implements EntityApi<Resident> {
     //     ...res 
     // } : res
 
-    readonly get = async (...residentList: string[]): Promise<Resident[] | Resident> => {
+    readonly get = async (...residentList: string[]) => {
         const residents = await this.all()
         if (!residents) throw new FetchError('Error fetching residents! Please try again.')
 
-        const existing = fn.getExisting(residents, residentList, 'name').filter(r => r.name != "NotFoundError") as Resident[]
+        const existing = fn.getExisting(residents, residentList, 'name')
         return existing.length > 1 ? Promise.all(existing) : Promise.resolve(existing[0])
     }
 

src/api/Towns.ts

@@ -2,14 +2,14 @@ import striptags from 'striptags'
 
 import * as fn from '../utils/functions.js'
 
-import { FetchError, InvalidError } from "../utils/errors.js"
+import { FetchError, InvalidError, NotFoundError } from "../utils/errors.js"
 import { Nation, Town } from '../types.js'
 import { Map } from "../Map.js"
 import { EntityApi } from './EntityApi.js'
 
 //import OfficialAPI from '../OAPI.js'
 
-class Towns implements EntityApi<Town> {
+class Towns implements EntityApi<Town | NotFoundError> {
     #map: Map
 
     get map() { return this.#map }
@@ -33,11 +33,11 @@ class Towns implements EntityApi<Town> {
     //     ...town
     // } : town
 
-    readonly get = async (...townList: string[]): Promise<Town[] | Town> => {
+    readonly get = async (...townList: string[])=> {
         const towns = await this.all()
         if (!towns) throw new FetchError('Error fetching towns! Please try again.')
 
-        const existing = fn.getExisting(towns, townList, 'name').filter(t => t.name != "NotFoundError") as Town[]
+        const existing = fn.getExisting(towns, townList, 'name')
         return existing.length > 1 ? Promise.all(existing) : Promise.resolve(existing[0])
     }
 

src/main.ts

@@ -1,10 +1,13 @@
-import OfficialAPI from './OAPI.js'
+import * as endpoint from './utils/endpoint.js'
 
-import { MCAPI } from "mojang-lib"
+import { FetchError } from "./utils/errors.js"
 import { Map } from './Map.js'
 
-import * as endpoint from './utils/endpoint.js'
-import * as Errors from "./utils/errors.js"
+import MCAPI from "mojang-lib"
+import OfficialAPI from './OAPI.js'
+
+const Aurora = new Map('aurora')
+const Nova = new Map('nova')
 
 async function fetchServer(name = "play.earthmc.net") {
     const server = await MCAPI.servers.get(name)
@@ -18,29 +21,35 @@ async function fetchServer(name = "play.earthmc.net") {
 
 async function getServerInfo() {
     try {
-        const serverData = await fetchServer(),
-              novaData = await endpoint.playerData("nova"),
-              auroraData = await endpoint.playerData("aurora")
+        const serverData = await fetchServer()
+        const novaData = await endpoint.playerData("nova")
+        const auroraData = await endpoint.playerData("aurora")
 
         const online = serverData.online
         const novaCount = novaData.currentcount ?? 0
         const auroraCount = auroraData.currentcount ?? 0
 
-        const serverInfo = { ...serverData, nova: novaCount, aurora: auroraCount }
-        const queue = online < 1 ? 0 : online - auroraCount - novaCount
+        const serverInfo = { 
+            ...serverData, 
+            nova: novaCount, 
+            aurora: auroraCount 
+        }
 
-        return { queue, ...serverInfo }
+        return { 
+            queue: online < 1 ? 0 : online - auroraCount - novaCount,
+            ...serverInfo 
+        }
     } catch (err: unknown) {
-        throw new Errors.FetchError(`Error fetching server info!\n${err}`)
+        throw new FetchError(`Error fetching server info!\n${err}`)
     }
 }
 
-const Aurora = new Map('aurora')
-const Nova = new Map('nova')
-
 export { formatString } from './utils/functions.js'
+
+export * from "./types.js"
+export * from "./utils/errors.js"
+
 export {
-    Errors,
     MCAPI as MojangLib,
     OfficialAPI, 
     endpoint,

src/utils/functions.ts

@@ -70,12 +70,13 @@ const sqr = (a: Point2D, b: Point2D, range: number) => Math.hypot(
 const average = (nums: Point2D[], key: keyof Point2D) => {
     const sum = nums.map(obj => obj[key]).reduce((a, b) => safeParseInt(a) + safeParseInt(b))
     return safeParseInt(sum) / nums.length
-}
-const getExisting = <T>(a1: T[], a2: string[], key: keyof T) => {
-    const filter = (x: string) => a1.find(e => x?.toLowerCase() == String(e[key])?.toLowerCase()) ?? NotFound(x)
+}    
 
-    // TODO: Ensure this is returning T[] and not a string of names.
-    return a2.flat().map(x => filter(x))
+// TODO: Ensure this is returning T[] and not a string of names.
+const getExisting = <T>(a1: T[], a2: string[], key: keyof T) => {
+    return a2.flat().map(x =>
+        a1.find(e => x?.toLowerCase() == String(e[key])?.toLowerCase()
+    ) ?? NotFound(x))
 }
 
 const hypot = (num: number, args: [input: number, radius: number]) => {

tests/gps.test.ts

@@ -27,9 +27,4 @@ describe('GPS', () => {
         const online = await globalThis.Aurora.GPS.playerIsOnline(op)
         expect(online).toEqual(true)
     })
-
-    it('can throw not found error', async () => { 
-        const player = await globalThis.Aurora.GPS.getPlayer('29394dsaklmsd')
-        expect(player).toBeInstanceOf(NotFoundError)
-    })
 })

tests/nations.test.ts

@@ -30,6 +30,6 @@ describe('Nations', () => {
         expect(novaNation).not.toEqual(auroraNation)
 
         expect(novaNation.stats).toBeUndefined()
-        expect(auroraNation.stats).toBeDefined()
+        //expect(auroraNation.stats).toBeDefined()
     })
 })

tests/residents.test.ts

@@ -20,8 +20,8 @@ describe('Residents', () => {
 
         expect(resident.name).toBe("3meraldK")
         expect(resident.rank).toBe("Mayor")
-        expect(resident.timestamps).toBeDefined()
-        expect(resident.timestamps.registered).toEqual(1652454407381)
+        //expect(resident.timestamps).toBeDefined()
+        //expect(resident.timestamps.registered).toEqual(1652454407381)
     })
 
     it('should return different resident info on Aurora and Nova', async () => {

tests/towns.test.ts

@@ -19,7 +19,7 @@ describe('Towns', () => {
         expectTypeOf(town).not.toEqualTypeOf<Error>()
         assertType<Town[]>(town)
 
-        console.log(town)
+        //console.log(town)
     })
 
     it('can get towns invitable to specified nation', async () => {
@@ -40,9 +40,9 @@ describe('Towns', () => {
         expect(novaTown).not.toEqual(auroraTown)
         expect(novaTown['stats']).toBeUndefined()
 
-        expect(auroraTown.stats).toBeDefined()
         expect(auroraTown.wiki).toBeDefined()
-        expect(auroraTown.founder).toBeDefined()
-        expect(auroraTown.created).toBeDefined()
+        //expect(auroraTown.stats).toBeDefined()
+        //expect(auroraTown.founder).toBeDefined()
+        //expect(auroraTown.created).toBeDefined()
     })
 })