coh-content-db 2.0.0-rc.5 → 2.0.0-rc.6

package/src/test/db/badge.test.ts

@@ -1,6 +1,6 @@
 import { Badge } from '../../main'
 import { badgeDataFixture } from '../api/badge-data.fixture'
-import { badgePartialDataFixture } from '../api/badge-partial-data.fixture'
+import { badgeRequirementDataFixture } from '../api/badge-requirement-data.fixture'
 
 describe(Badge.name, () => {
   describe('Constructor', () => {
@@ -9,33 +9,208 @@ describe(Badge.name, () => {
     })
   })
 
-  describe('partials', () => {
-    test(`should throw an error on duplicate key`, () => {
+  describe('key', () => {
+    test('should be set from the data', () => {
+      const badge = new Badge(badgeDataFixture.create({ key: 'badge123' }))
+      expect(badge.key).toEqual('badge123')
+    })
+  })
+
+  describe('type', () => {
+    test('should be set from the data', () => {
+      const badge = new Badge(badgeDataFixture.create({ type: 'ACHIEVEMENT' }))
+      expect(badge.type).toEqual('ACHIEVEMENT')
+    })
+  })
+
+  describe('name', () => {
+    test('should be set from the data', () => {
+      const badge = new Badge(badgeDataFixture.create({ name: [{ value: 'foo' }] }))
+      expect(badge.name.default).toEqual({ value: 'foo' })
+    })
+  })
+
+  describe('alignment', () => {
+    test('should be set from the data', () => {
+      const badge = new Badge(badgeDataFixture.create({ alignment: ['H', 'V'] }))
+      expect(badge.alignment.hero).toBeTruthy()
+      expect(badge.alignment.villain).toBeTruthy()
+      expect(badge.alignment.praetorian).toBeFalsy()
+    })
+  })
+
+  describe('badgeText', () => {
+    test('should be set from the data', () => {
+      const badge = new Badge(badgeDataFixture.create({ badgeText: [{ value: 'foo' }] }))
+      expect(badge.badgeText.default).toEqual({ value: 'foo' })
+    })
+
+    test('should be optional', () => {
+      const badge = new Badge(badgeDataFixture.omit('badgeText').create())
+      expect(badge.badgeText.default).toBeUndefined()
+    })
+  })
+
+  describe('acquisition', () => {
+    test('should be set from the data', () => {
+      const badge = new Badge(badgeDataFixture.create({ acquisition: 'Quest Reward' }))
+      expect(badge.acquisition).toEqual('Quest Reward')
+    })
+
+    test('should be optional', () => {
+      const badge = new Badge(badgeDataFixture.omit('acquisition').create())
+      expect(badge.acquisition).toBeUndefined()
+    })
+  })
+
+  describe('icon', () => {
+    test('should be set from the data', () => {
+      const badge = new Badge(badgeDataFixture.create({ icon: [{ value: 'foo' }] }))
+      expect(badge.icon.default).toEqual({ value: 'foo' })
+    })
+
+    test('should be optional', () => {
+      const badge = new Badge(badgeDataFixture.omit('icon').create())
+      expect(badge.icon.default).toBeUndefined()
+    })
+  })
+
+  describe('notes', () => {
+    test('should be set from the data', () => {
+      const badge = new Badge(badgeDataFixture.create({ notes: 'foo' }))
+      expect(badge.notes).toEqual('foo')
+    })
+
+    test('should be optional', () => {
+      const badge = new Badge(badgeDataFixture.omit('notes').create())
+      expect(badge.notes).toBeUndefined()
+    })
+  })
+
+  describe('links', () => {
+    test('should be set from the data', () => {
+      const badge = new Badge(badgeDataFixture.create({ links: [{ title: 'foo', href: 'bar' }] }))
+      expect(badge.links).toStrictEqual([{ title: 'foo', href: 'bar' }])
+    })
+
+    test('should be optional', () => {
+      const badge = new Badge(badgeDataFixture.omit('links').create())
+      expect(badge.links).toHaveLength(0)
+    })
+  })
+
+  describe('zoneKey', () => {
+    test('should be set from the data', () => {
+      const badge = new Badge(badgeDataFixture.create({ zoneKey: 'foo' }))
+      expect(badge.zoneKey).toEqual('foo')
+    })
+
+    test('should be optional', () => {
+      const badge = new Badge(badgeDataFixture.omit('zoneKey').create())
+      expect(badge.zoneKey).toBeUndefined()
+    })
+  })
+
+  describe('loc', () => {
+    test('should be set from the data', () => {
+      const badge = new Badge(badgeDataFixture.create({ loc: [1, 2, 3] }))
+      expect(badge.loc).toStrictEqual([1, 2, 3])
+    })
+
+    test('should be optional', () => {
+      const badge = new Badge(badgeDataFixture.omit('loc').create())
+      expect(badge.loc).toBeUndefined()
+    })
+  })
+
+  describe('effect', () => {
+    test('should be set from the data', () => {
+      const badge = new Badge(badgeDataFixture.create({ effect: 'foo' }))
+      expect(badge.effect).toEqual('foo')
+    })
+
+    test('should be optional', () => {
+      const badge = new Badge(badgeDataFixture.omit('effect').create())
+      expect(badge.effect).toBeUndefined()
+    })
+  })
+
+  describe('vidiotMapKey', () => {
+    test('should be set from the data', () => {
+      const badge = new Badge(badgeDataFixture.create({ vidiotMapKey: 'foo' }))
+      expect(badge.vidiotMapKey).toEqual('foo')
+    })
+
+    test('should be optional', () => {
+      const badge = new Badge(badgeDataFixture.omit('vidiotMapKey').create())
+      expect(badge.vidiotMapKey).toBeUndefined()
+    })
+  })
+
+  describe('setTitle', () => {
+    test('should be set from the data', () => {
+      const badge = new Badge(badgeDataFixture.create({ setTitle: { id: 123, praetorianId: 456 } }))
+      expect(badge.setTitle).toStrictEqual({ id: 123, praetorianId: 456 })
+    })
+
+    test('should be optional', () => {
+      const badge = new Badge(badgeDataFixture.omit('setTitle').create())
+      expect(badge.setTitle).toBeUndefined()
+    })
+  })
+
+  describe('ignoreInTotals', () => {
+    test('should be set from the data', () => {
+      const badge = new Badge(badgeDataFixture.create({ ignoreInTotals: true }))
+      expect(badge.ignoreInTotals).toEqual(true)
+    })
+
+    test('should default to false', () => {
+      const badge = new Badge(badgeDataFixture.omit('ignoreInTotals').create())
+      expect(badge.ignoreInTotals).toEqual(false)
+    })
+  })
+
+  describe('requirements', () => {
+    test(`should throw an error on duplicate key in same group`, () => {
+      const data = badgeDataFixture.create({
+        key: 'badge',
+        requirements: [[
+          badgeRequirementDataFixture.create({ key: 'foo' }),
+          badgeRequirementDataFixture.create({ key: 'foo' }),
+        ]],
+      })
+      expect(() => new Badge(data)).toThrow('Duplicate badge requirement key [badge:foo] in group [1]')
+    })
+
+    test(`should not throw an error on duplicate key in different group`, () => {
       const data = badgeDataFixture.create({
-        partials: [
-          badgePartialDataFixture.create({ key: 'foo' }),
-          badgePartialDataFixture.create({ key: 'foo' }),
-        ],
+        key: 'badge',
+        requirements: [[
+          badgeRequirementDataFixture.create({ key: 'foo' }),
+        ], [
+          badgeRequirementDataFixture.create({ key: 'foo' }),
+        ]],
       })
-      expect(() => new Badge(data)).toThrow('Duplicate badge partial key [foo]')
+      new Badge(data)
     })
   })
 
-  describe('getBadgePartial', () => {
-    test(`should retrieve partial from the index`, () => {
+  describe('getRequirement', () => {
+    test(`should retrieve requirement from the index`, () => {
       const data = badgeDataFixture.create({
-        partials: [badgePartialDataFixture.create({ key: 'foo' })],
+        requirements: [[badgeRequirementDataFixture.create({ key: 'foo' })]],
       })
 
-      expect(new Badge(data).getPartial('foo')).not.toBeUndefined()
+      expect(new Badge(data).getRequirement('foo')).not.toBeUndefined()
     })
 
-    test(`should throw error for unknown partial`, () => {
+    test(`should throw error for unknown requirement`, () => {
       const data = badgeDataFixture.create({
-        partials: [],
+        requirements: [],
       })
 
-      expect(() => new Badge(data).getPartial('foo')).toThrow('Unknown badge partial key [foo]')
+      expect(() => new Badge(data).getRequirement('foo')).toThrow('Unknown badge requirement key [foo]')
     })
   })
 })

package/src/test/db/coh-content-database.test.ts

@@ -2,7 +2,8 @@ import { CohContentDatabase } from '../../main'
 import { contentBundleFixture } from '../api/content-bundle.fixture'
 import { archetypeDataFixture } from '../api/archetype-data.fixture'
 import { badgeDataFixture } from '../api/badge-data.fixture'
-import { gameMapDataFixture } from '../api/game-map-data.fixture'
+import { zoneDataFixture } from '../api/zone-data.fixture'
+import { contactDataFixture } from '../api/contact-data.fixture'
 
 describe(CohContentDatabase.name, () => {
   test('should load a basic bundle', () => {
@@ -32,7 +33,7 @@ describe(CohContentDatabase.name, () => {
           archetypeDataFixture.create({ key: 'foo' }),
         ],
       })
-      expect(() => new CohContentDatabase(data)).toThrow('Duplicate archetype key [foo]')
+      expect(() => new CohContentDatabase(data)).toThrow(`Duplicate archetype key 'foo'`)
     })
 
     test(`should accept an undefined field`, () => {
@@ -68,22 +69,41 @@ describe(CohContentDatabase.name, () => {
     })
   })
 
-  describe('maps', () => {
-    test(`should throw an error on duplicate map`, () => {
+  describe('zones', () => {
+    test(`should throw an error on duplicate zone`, () => {
       const data = contentBundleFixture.create({
-        maps: [
-          gameMapDataFixture.create({ key: 'foo' }),
-          gameMapDataFixture.create({ key: 'foo' }),
+        zones: [
+          zoneDataFixture.create({ key: 'foo' }),
+          zoneDataFixture.create({ key: 'foo' }),
         ],
       })
-      expect(() => new CohContentDatabase(data)).toThrow('Duplicate map key [foo]')
+      expect(() => new CohContentDatabase(data)).toThrow(`Duplicate zone key 'foo'`)
     })
 
     test(`should accept an undefined field`, () => {
       const data = contentBundleFixture
-        .omit('maps')
+        .omit('zones')
         .create()
-      expect(() => new CohContentDatabase(data).maps).toHaveLength(0)
+      expect(() => new CohContentDatabase(data).zones).toHaveLength(0)
+    })
+  })
+
+  describe('contacts', () => {
+    test(`should throw an error on duplicate contact`, () => {
+      const data = contentBundleFixture.create({
+        contacts: [
+          contactDataFixture.create({ key: 'foo' }),
+          contactDataFixture.create({ key: 'foo' }),
+        ],
+      })
+      expect(() => new CohContentDatabase(data)).toThrow(`Duplicate contact key 'foo'`)
+    })
+
+    test(`should accept an undefined field`, () => {
+      const data = contentBundleFixture
+        .omit('contacts')
+        .create()
+      expect(() => new CohContentDatabase(data).contacts).toHaveLength(0)
     })
   })
 
@@ -101,25 +121,79 @@ describe(CohContentDatabase.name, () => {
         archetypes: [],
       })
 
-      expect(() => new CohContentDatabase(data).getArchetype('foo')).toThrow('Unknown archetype key [foo]')
+      expect(() => new CohContentDatabase(data).getArchetype('foo')).toThrow(`Unknown archetype key 'foo'`)
     })
   })
 
-  describe('getMap', () => {
-    test(`should retrieve map from the index`, () => {
+  describe('getZone', () => {
+    test(`should retrieve zone from the index`, () => {
       const data = contentBundleFixture.create({
-        maps: [gameMapDataFixture.create({ key: 'foo' })],
+        zones: [zoneDataFixture.create({ key: 'foo' })],
       })
 
-      expect(new CohContentDatabase(data).getMap('foo')).not.toBeUndefined()
+      expect(new CohContentDatabase(data).getZone('foo')).not.toBeUndefined()
     })
 
-    test(`should throw error for unknown map`, () => {
+    test(`should throw error for unknown zone`, () => {
       const data = contentBundleFixture.create({
-        maps: [],
+        zones: [],
       })
 
-      expect(() => new CohContentDatabase(data).getMap('foo')).toThrow('Unknown map key [foo]')
+      expect(() => new CohContentDatabase(data).getZone('foo')).toThrow(`Unknown zone key 'foo'`)
+    })
+  })
+
+  describe('zoneExists', () => {
+    test(`should return true for a zone that exists`, () => {
+      const data = contentBundleFixture.create({
+        zones: [zoneDataFixture.create({ key: 'foo' })],
+      })
+
+      expect(new CohContentDatabase(data).zoneExists('foo')).toBeTruthy()
+    })
+
+    test(`should return false for a zone that does not exist`, () => {
+      const data = contentBundleFixture.create({
+        zones: [],
+      })
+
+      expect(new CohContentDatabase(data).zoneExists('foo')).toBeFalsy()
+    })
+  })
+
+  describe('getContact', () => {
+    test(`should retrieve contact from the index`, () => {
+      const data = contentBundleFixture.create({
+        contacts: [contactDataFixture.create({ key: 'foo' })],
+      })
+
+      expect(new CohContentDatabase(data).getContact('foo')).not.toBeUndefined()
+    })
+
+    test(`should throw error for unknown contact`, () => {
+      const data = contentBundleFixture.create({
+        contacts: [],
+      })
+
+      expect(() => new CohContentDatabase(data).getContact('foo')).toThrow(`Unknown contact key 'foo'`)
+    })
+  })
+
+  describe('contactExists', () => {
+    test(`should return true for a contact that exists`, () => {
+      const data = contentBundleFixture.create({
+        contacts: [contactDataFixture.create({ key: 'foo' })],
+      })
+
+      expect(new CohContentDatabase(data).contactExists('foo')).toBeTruthy()
+    })
+
+    test(`should return false for a contact that does not exist`, () => {
+      const data = contentBundleFixture.create({
+        contacts: [],
+      })
+
+      expect(new CohContentDatabase(data).contactExists('foo')).toBeFalsy()
     })
   })
 
@@ -141,6 +215,24 @@ describe(CohContentDatabase.name, () => {
     })
   })
 
+  describe('badgeExists', () => {
+    test(`should return true for a badge that exists`, () => {
+      const data = contentBundleFixture.create({
+        badges: [badgeDataFixture.create({ key: 'foo' })],
+      })
+
+      expect(new CohContentDatabase(data).badgeExists('foo')).toBeTruthy()
+    })
+
+    test(`should return false for a badge that does not exist`, () => {
+      const data = contentBundleFixture.create({
+        badges: [],
+      })
+
+      expect(new CohContentDatabase(data).badgeExists('foo')).toBeFalsy()
+    })
+  })
+
   describe('searchBadges', () => {
     test(`should search the badge list`, () => {
       const data = contentBundleFixture.create({

package/src/test/db/contact.test.ts

@@ -0,0 +1,96 @@
+import { Contact } from '../../main'
+import { contactDataFixture } from '../api/contact-data.fixture'
+
+describe(Contact.name, () => {
+  describe('Constructor', () => {
+    test(`should accept the test fixture`, () => {
+      new Contact(contactDataFixture.create())
+    })
+  })
+
+  describe('key', () => {
+    test(`should should be set from the data`, () => {
+      const contact = new Contact(contactDataFixture.create({ key: 'foo' }))
+      expect(contact.key).toEqual('foo')
+    })
+  })
+
+  describe('name', () => {
+    test(`should should be set from the data`, () => {
+      const contact = new Contact(contactDataFixture.create({ name: 'foo' }))
+      expect(contact.name).toEqual('foo')
+    })
+  })
+
+  describe('title', () => {
+    test(`should should be set from the data`, () => {
+      const contact = new Contact(contactDataFixture.create({ title: 'foo' }))
+      expect(contact.title).toEqual('foo')
+    })
+
+    test(`should should be optional`, () => {
+      const contact = new Contact(contactDataFixture.omit('title').create())
+      expect(contact.title).toBeUndefined()
+    })
+  })
+
+  describe('zoneKey', () => {
+    test(`should should be set from the data`, () => {
+      const contact = new Contact(contactDataFixture.create({ zoneKey: 'foo' }))
+      expect(contact.zoneKey).toEqual('foo')
+    })
+
+    test(`should should be optional`, () => {
+      const contact = new Contact(contactDataFixture.omit('zoneKey').create())
+      expect(contact.zoneKey).toBeUndefined()
+    })
+  })
+
+  describe('loc', () => {
+    test(`should should be set from the data`, () => {
+      const contact = new Contact(contactDataFixture.create({ loc: [1, 2, 3] }))
+      expect(contact.loc).toStrictEqual([1, 2, 3])
+    })
+
+    test(`should should be optional`, () => {
+      const contact = new Contact(contactDataFixture.omit('loc').create())
+      expect(contact.loc).toBeUndefined()
+    })
+  })
+
+  describe('levelRange', () => {
+    test(`should should be set from the data`, () => {
+      const contact = new Contact(contactDataFixture.create({ levelRange: [1, 2] }))
+      expect(contact.levelRange).toStrictEqual([1, 2])
+    })
+
+    test(`should should be optional`, () => {
+      const contact = new Contact(contactDataFixture.omit('levelRange').create())
+      expect(contact.levelRange).toBeUndefined()
+    })
+  })
+
+  describe('notes', () => {
+    test(`should should be set from the data`, () => {
+      const contact = new Contact(contactDataFixture.create({ notes: 'foo' }))
+      expect(contact.notes).toEqual('foo')
+    })
+
+    test(`should should be optional`, () => {
+      const contact = new Contact(contactDataFixture.omit('notes').create())
+      expect(contact.notes).toBeUndefined()
+    })
+  })
+
+  describe('links', () => {
+    test(`should should be set from the data`, () => {
+      const contact = new Contact(contactDataFixture.create({ links: [{ title: 'foo', href: 'bar' }] }))
+      expect(contact.links).toStrictEqual([{ title: 'foo', href: 'bar' }])
+    })
+
+    test(`should should be optional`, () => {
+      const contact = new Contact(contactDataFixture.omit('links').create())
+      expect(contact.links).toHaveLength(0)
+    })
+  })
+})

package/src/test/db/zone.test.ts

@@ -0,0 +1,36 @@
+import { Zone } from '../../main'
+import { zoneDataFixture } from '../api/zone-data.fixture'
+
+describe(Zone.name, () => {
+  describe('Constructor', () => {
+    test(`should accept the test fixture`, () => {
+      new Zone(zoneDataFixture.create())
+    })
+  })
+
+  describe('key', () => {
+    test(`should should be set from the data`, () => {
+      const zone = new Zone(zoneDataFixture.create({ key: 'foo' }))
+      expect(zone.key).toEqual('foo')
+    })
+  })
+
+  describe('name', () => {
+    test(`should should be set from the data`, () => {
+      const zone = new Zone(zoneDataFixture.create({ name: 'foo' }))
+      expect(zone.name).toEqual('foo')
+    })
+  })
+
+  describe('links', () => {
+    test(`should should be set from the data`, () => {
+      const zone = new Zone(zoneDataFixture.create({ links: [{ title: 'foo', href: 'bar' }] }))
+      expect(zone.links).toStrictEqual([{ title: 'foo', href: 'bar' }])
+    })
+
+    test(`should should be optional`, () => {
+      const zone = new Zone(zoneDataFixture.omit('links').create())
+      expect(zone.links).toHaveLength(0)
+    })
+  })
+})

package/src/test/index.test.ts

@@ -7,6 +7,8 @@ test('should export the changelog', () => {
 test('should export badge reference utils', () => {
   expect(index).toHaveProperty('badgeUri')
   expect(index).toHaveProperty('badgeLink')
-  expect(index).toHaveProperty('mapUri')
-  expect(index).toHaveProperty('mapLink')
+  expect(index).toHaveProperty('contactUri')
+  expect(index).toHaveProperty('contactLink')
+  expect(index).toHaveProperty('zoneUri')
+  expect(index).toHaveProperty('zoneLink')
 })

package/src/test/util.test.ts

@@ -1,6 +1,7 @@
-import { Badge, badgeLink, badgeUri, GameMap, mapLink, mapUri } from '../main'
+import { Badge, badgeLink, badgeUri, Contact, contactLink, contactUri, Zone, zoneLink, zoneUri } from '../main'
 import { badgeDataFixture } from './api/badge-data.fixture'
-import { gameMapDataFixture } from './api/game-map-data.fixture'
+import { zoneDataFixture } from './api/zone-data.fixture'
+import { contactDataFixture } from './api/contact-data.fixture'
 
 describe(badgeUri.name, () => {
   test('should return the expected pattern', () => {
@@ -38,38 +39,74 @@ describe(badgeLink.name, () => {
   })
 })
 
-describe(mapUri.name, () => {
+describe(contactUri.name, () => {
   test('should return the expected pattern', () => {
-    expect(mapUri('foo')).toBe('map://foo')
-    expect(mapUri('bar')).toBe('map://bar')
-    expect(mapUri('foo-bar')).toBe('map://foo-bar')
+    expect(contactUri('foo')).toBe('contact://foo')
+    expect(contactUri('bar')).toBe('contact://bar')
+    expect(contactUri('foo-bar')).toBe('contact://foo-bar')
   })
 
-  test('should accept a GameMap object', () => {
-    const map = new GameMap(gameMapDataFixture.create({ key: 'foo' }))
-    expect(mapUri(map)).toBe('map://foo')
+  test('should accept a Contact object', () => {
+    const contact = new Contact(contactDataFixture.create({ key: 'foo' }))
+    expect(contactUri(contact)).toBe('contact://foo')
   })
 
-  test('should accept a GameMapData object', () => {
-    const map = gameMapDataFixture.create({ key: 'foo' })
-    expect(mapUri(map)).toBe('map://foo')
+  test('should accept a ContactData object', () => {
+    const contact = contactDataFixture.create({ key: 'foo' })
+    expect(contactUri(contact)).toBe('contact://foo')
   })
 })
 
-describe(mapLink.name, () => {
+describe(contactLink.name, () => {
   test('should return the expected pattern', () => {
-    expect(mapLink('foo')).toBe('[foo](map://foo)')
-    expect(mapLink('bar')).toBe('[bar](map://bar)')
-    expect(mapLink('foo-bar')).toBe('[foo-bar](map://foo-bar)')
+    expect(contactLink('foo')).toBe('[foo](contact://foo)')
+    expect(contactLink('bar')).toBe('[bar](contact://bar)')
+    expect(contactLink('foo-bar')).toBe('[foo-bar](contact://foo-bar)')
   })
 
-  test('should accept a GameMap object', () => {
-    const map = new GameMap(gameMapDataFixture.create({ key: 'foo' }))
-    expect(mapLink(map)).toBe('[foo](map://foo)')
+  test('should accept a Contact object', () => {
+    const contact = new Contact(contactDataFixture.create({ key: 'foo' }))
+    expect(contactLink(contact)).toBe('[foo](contact://foo)')
   })
 
-  test('should accept a GameMapData object', () => {
-    const map = gameMapDataFixture.create({ key: 'foo' })
-    expect(mapLink(map)).toBe('[foo](map://foo)')
+  test('should accept a ContactData object', () => {
+    const contact = contactDataFixture.create({ key: 'foo' })
+    expect(contactLink(contact)).toBe('[foo](contact://foo)')
+  })
+})
+
+describe(zoneUri.name, () => {
+  test('should return the expected pattern', () => {
+    expect(zoneUri('foo')).toBe('zone://foo')
+    expect(zoneUri('bar')).toBe('zone://bar')
+    expect(zoneUri('foo-bar')).toBe('zone://foo-bar')
+  })
+
+  test('should accept a Zone object', () => {
+    const zone = new Zone(zoneDataFixture.create({ key: 'foo' }))
+    expect(zoneUri(zone)).toBe('zone://foo')
+  })
+
+  test('should accept a ZoneData object', () => {
+    const zone = zoneDataFixture.create({ key: 'foo' })
+    expect(zoneUri(zone)).toBe('zone://foo')
+  })
+})
+
+describe(zoneLink.name, () => {
+  test('should return the expected pattern', () => {
+    expect(zoneLink('foo')).toBe('[foo](zone://foo)')
+    expect(zoneLink('bar')).toBe('[bar](zone://bar)')
+    expect(zoneLink('foo-bar')).toBe('[foo-bar](zone://foo-bar)')
+  })
+
+  test('should accept a Zone object', () => {
+    const zone = new Zone(zoneDataFixture.create({ key: 'foo' }))
+    expect(zoneLink(zone)).toBe('[foo](zone://foo)')
+  })
+
+  test('should accept a ZoneData object', () => {
+    const zone = zoneDataFixture.create({ key: 'foo' })
+    expect(zoneLink(zone)).toBe('[foo](zone://foo)')
   })
 })

package/src/main/api/badge-partial-type.ts

@@ -1,8 +0,0 @@
-export const BADGE_PARTIAL_TYPE = [
-  'PLAQUE',
-  'BADGE',
-  'INVENTION',
-  'INVENTION_PLUS_ONE', // Some invention badges require you to build x of two different invention levels, 'plus one of either level'.
-] as const
-
-export type BadgePartialType = typeof BADGE_PARTIAL_TYPE[number]