coh-content-db 2.0.0-rc.1 → 2.0.0-rc.10

package/src/main/db/morality-list.ts

@@ -0,0 +1,99 @@
+import { MORALITY, Morality, MoralityExtended } from '../api/morality'
+
+export class MoralityList {
+  readonly #items: Set<Morality>
+
+  readonly hero: boolean
+  readonly vigilante: boolean
+  readonly villain: boolean
+  readonly rogue: boolean
+  readonly resistance: boolean
+  readonly loyalist: boolean
+
+  readonly primal: boolean
+  readonly praetorian: boolean
+  readonly heroic: boolean
+  readonly villainous: boolean
+  readonly paragonCityAccess: boolean
+  readonly rogueIslesAccess: boolean
+
+  readonly all: boolean
+
+  constructor(items?: MoralityExtended[]) {
+    const set = new Set(items ?? [...MORALITY])
+    this.hero = set.has('hero') || set.has('primal') || set.has('heroic') || set.has('paragon-city-access') || set.has('all')
+    this.vigilante = set.has('vigilante') || set.has('primal') || set.has('heroic') || set.has('paragon-city-access') || set.has('rogue-isles-access') || set.has('all')
+    this.villain = set.has('villain') || set.has('primal') || set.has('villainous') || set.has('rogue-isles-access') || set.has('all')
+    this.rogue = set.has('rogue') || set.has('primal') || set.has('villainous') || set.has('paragon-city-access') || set.has('rogue-isles-access') || set.has('all')
+    this.resistance = set.has('resistance') || set.has('praetorian') || set.has('all')
+    this.loyalist = set.has('loyalist') || set.has('praetorian') || set.has('all')
+
+    this.primal = this.hero && this.vigilante && this.villain && this.rogue
+    this.praetorian = this.loyalist && this.resistance
+    this.heroic = this.hero && this.vigilante
+    this.villainous = this.villain && this.rogue
+    this.paragonCityAccess = this.heroic && this.rogue
+    this.rogueIslesAccess = this.villainous && this.vigilante
+
+    this.all = this.primal && this.praetorian
+
+    this.#items = new Set()
+    if (this.hero) this.#items.add('hero')
+    if (this.vigilante) this.#items.add('vigilante')
+    if (this.villain) this.#items.add('villain')
+    if (this.rogue) this.#items.add('rogue')
+    if (this.resistance) this.#items.add('resistance')
+    if (this.loyalist) this.#items.add('loyalist')
+  }
+
+  get items(): Morality[] {
+    return [...this.#items]
+  }
+
+  has(morality?: MoralityExtended): boolean {
+    switch (morality) {
+      case 'hero': {
+        return this.hero
+      }
+      case 'vigilante': {
+        return this.vigilante
+      }
+      case 'villain': {
+        return this.villain
+      }
+      case 'rogue': {
+        return this.rogue
+      }
+      case 'resistance': {
+        return this.resistance
+      }
+      case 'loyalist': {
+        return this.loyalist
+      }
+      case 'primal' : {
+        return this.primal
+      }
+      case 'praetorian': {
+        return this.praetorian
+      }
+      case 'heroic': {
+        return this.hero
+      }
+      case 'paragon-city-access': {
+        return this.paragonCityAccess
+      }
+      case 'rogue-isles-access': {
+        return this.rogueIslesAccess
+      }
+      case 'villainous': {
+        return this.villainous
+      }
+      case 'all': {
+        return this.all
+      }
+      default: {
+        return false
+      }
+    }
+  }
+}

package/src/main/db/paged.ts

@@ -0,0 +1,7 @@
+export interface Paged<T> {
+  items: T[]
+  page: number
+  pageSize?: number
+  totalItems: number
+  totalPages: number
+}

package/src/main/db/zone.ts

@@ -0,0 +1,28 @@
+import { Link } from '../api/link'
+import { ZoneData } from '../api/zone-data'
+import { Key } from './key'
+
+export class Zone {
+  /**
+   * Unique key used to reference this zone.
+   *
+   * Keys must be unique and can only contain lowercase letters, numbers and hyphens (`-`).
+   */
+  readonly key: string
+
+  /**
+   * The name of the zone as it appears in-game.
+   */
+  readonly name: string
+
+  /**
+   * List of external links. Wiki, forums, etc.
+   */
+  readonly links: Link[]
+
+  constructor(data: ZoneData) {
+    this.key = new Key(data.key).value
+    this.name = data.name
+    this.links = data.links ?? []
+  }
+}

package/src/main/index.ts

@@ -3,31 +3,39 @@ export * from './api/alignment'
 export * from './api/alternate-data'
 export * from './api/archetype-data'
 export * from './api/badge-data'
-export * from './api/badge-partial-data'
-export * from './api/badge-partial-type'
+export * from './api/badge-requirement-data'
+export * from './api/badge-requirement-type'
 export * from './api/badge-type'
-export * from './api/change'
+export * from './api/bundle-data'
+export * from './api/bundle-header-data'
+export * from './api/contact-data'
 export * from './api/enhancement-category'
-export * from './api/game-map-data'
 export * from './api/link'
-export * from './api/plaque-type'
-export * from './api/server-group-data'
+export * from './api/location-data'
+export * from './api/markdown-string'
+export * from './api/mission-data'
+export * from './api/mission-type'
+export * from './api/morality'
 export * from './api/sex'
-export * from './api/vidiot-map-data'
-export * from './api/vidiot-map-point-of-interest-data'
+export * from './api/zone-data'
 
 // DB
+export * from './db/alignment-list'
+export * from './db/alternates'
 export * from './db/archetype'
 export * from './db/badge'
-export * from './db/badge-partial'
+export * from './db/badge-index'
+export * from './db/badge-requirement'
+export * from './db/badge-search-options'
+export * from './db/bundle-header'
 export * from './db/coh-content-database'
-export * from './db/game-map'
+export * from './db/contact'
 export * from './db/key'
-export * from './db/server-group'
-export * from './db/vidiot-map'
-export * from './db/vidiot-map-point-of-interest'
+export * from './db/location'
+export * from './db/mission'
+export * from './db/morality-list'
+export * from './db/paged'
+export * from './db/zone'
 
 // ROOT
-export { CHANGELOG } from './changelog'
-
 export * from './util'

package/src/main/util.ts

@@ -1,17 +1,118 @@
+import { BadgeData } from './api/badge-data'
+import { Badge } from './db/badge'
+import { ZoneData } from './api/zone-data'
+import { Zone } from './db/zone'
+import { Contact } from './db/contact'
+import { ContactData } from './api/contact-data'
+import { Mission } from './db/mission'
+import { MissionData } from './api/mission-data'
+
 /**
- * Create a reference string that can be used in most text strings to display a link to the given badge.
+ * Returns the URI of the given badge that can be used in {@link MarkdownString} fields.
+ *
+ * URI format: `badge://<key>`
+ *
  * @param target The badge or badge key to target.
  */
-export function createBadgeReference(target: string | { key: string }): string {
+export function badgeUri(target: string | Badge | BadgeData): string {
+  const key = typeof target === 'string' ? target : target.key
+  return `badge://${key}`
+}
+
+/**
+ * Returns a {@link MarkdownString} link to the given badge.
+ *
+ * Link format: `[<key>](badge://<key>)`
+ *
+ * @param target The {@link Badge} or badge key to target.
+ */
+export function badgeLink(target: string | Badge | BadgeData): string {
+  const key = typeof target === 'string' ? target : target.key
+  return `[${key}](${badgeUri(target)})`
+}
+
+/**
+ * Returns the URI of the given contact that can be used in {@link MarkdownString} fields.
+ *
+ * URI format: `contact://<key>`
+ *
+ * @param target The {@link Contact} or contact key to target.
+ */
+export function contactUri(target: string | Contact | ContactData): string {
   const key = typeof target === 'string' ? target : target.key
-  return `[badge:${key}]`
+  return `contact://${key}`
 }
 
 /**
- * Create a reference string that can be used in most text strings to display a link to the given map.
- * @param target The {@link GameMap} or map key to target.
+ * Returns a {@link MarkdownString} link to the given contact.
+ *
+ * Link format: `[<key>](contact://<key>)`
+ *
+ * @param target The {@link Contact} or contact key to target.
  */
-export function createMapReference(target: string | { key: string }): string {
+export function contactLink(target: string | Contact | ContactData): string {
   const key = typeof target === 'string' ? target : target.key
-  return `[map:${key}]`
+  return `[${key}](${contactUri(target)})`
+}
+
+/**
+ * Returns the URI of the given mission that can be used in {@link MarkdownString} fields.
+ *
+ * URI format: `mission://<key>`
+ *
+ * @param target The {@link Mission} or mission key to target.
+ */
+export function missionUri(target: string | Mission | MissionData): string {
+  const key = typeof target === 'string' ? target : target.key
+  return `mission://${key}`
+}
+
+/**
+ * Returns a {@link MarkdownString} link to the given mission.
+ *
+ * Link format: `[<key>](mission://<key>)`
+ *
+ * @param target The {@link Mission} or mission key to target.
+ */
+export function missionLink(target: string | Mission | MissionData): string {
+  const key = typeof target === 'string' ? target : target.key
+  return `[${key}](${missionUri(target)})`
+}
+
+/**
+ * Returns the URI of the given zone that can be used in {@link MarkdownString} fields.
+ *
+ * URI format: `zone://<key>`
+ *
+ * @param target The {@link Zone} or zone key to target.
+ */
+export function zoneUri(target: string | Zone | ZoneData): string {
+  const key = typeof target === 'string' ? target : target.key
+  return `zone://${key}`
+}
+
+/**
+ * Returns a {@link MarkdownString} link to the given zone.
+ *
+ * Link format: `[<key>](zone://<key>)`
+ *
+ * @param target The {@link Zone} or zone key to target.
+ */
+export function zoneLink(target: string | Zone | ZoneData): string {
+  const key = typeof target === 'string' ? target : target.key
+  return `[${key}](${zoneUri(target)})`
+}
+
+/**
+ * For fields that accept either an array of values or a single value, coalesces the value to an array.
+ *
+ * Arrays are returned as-is.
+ * Single values are returned as a single-value array.
+ * Undefined values are returned as undefined.
+ *
+ * @param value The value to coalesce.
+ */
+export function coalesceToArray<T>(value?: T | T[]): T[] | undefined {
+  if (!value) return undefined
+  return Array.isArray(value) ? value as T[] : [value]
 }

package/src/test/api/alignment.test.ts

@@ -1,4 +1,4 @@
-import { Alignment, ALIGNMENT } from '../../main'
+import { Alignment, ALIGNMENT, compareAlignment } from '../../main'
 
 describe('ALIGNMENT', () => {
   test('should be an array', () => {
@@ -16,7 +16,7 @@ describe('ALIGNMENT', () => {
   })
 
   test('should contain all known alignments', () => {
-    const expected = ['H', 'V', 'P']
+    const expected = ['hero', 'villain', 'praetorian']
     for (const category of expected) {
       expect(ALIGNMENT).toContain(category)
     }
@@ -25,7 +25,41 @@ describe('ALIGNMENT', () => {
 
 describe('Alignment', () => {
   test('should be a usable type', () => {
-    const field: Alignment = 'H'
-    expect(field).toBe('H')
+    const field: Alignment = 'hero'
+    expect(field).toBe('hero')
+  })
+})
+
+describe('compareAlignment', () => {
+  test('should return <0 if first argument comes first', () => {
+    expect(compareAlignment('hero', 'villain')).toBeLessThan(0)
+    expect(compareAlignment('hero', 'praetorian')).toBeLessThan(0)
+  })
+
+  test('should return >0 if second argument comes first', () => {
+    expect(compareAlignment('villain', 'hero')).toBeGreaterThan(0)
+    expect(compareAlignment('praetorian', 'hero')).toBeGreaterThan(0)
+  })
+
+  test('should return 0 if arguments match', () => {
+    expect(compareAlignment('hero', 'hero')).toBe(0)
+  })
+
+  test('should return 0 if both arguments are undefined', () => {
+    expect(compareAlignment()).toBe(0)
+  })
+
+  test('should work as a compare function', () => {
+    const unsorted: (Alignment | undefined)[] = [undefined, 'hero', 'villain', 'praetorian', undefined, 'villain', 'praetorian']
+    const sorted = unsorted.sort(compareAlignment)
+
+    expect(sorted).toStrictEqual(['hero', 'villain', 'villain', 'praetorian', 'praetorian', undefined, undefined])
+  })
+
+  test('should sort against undefined', () => {
+    const unsorted: (Alignment | undefined)[] = [undefined, 'hero']
+    const sorted = unsorted.sort(compareAlignment)
+
+    expect(sorted).toStrictEqual(['hero', undefined])
   })
 })

package/src/test/api/badge-data.fixture.ts

@@ -1,22 +1,8 @@
 import { defineFixture } from 'efate'
-import { ALIGNMENT, BADGE_TYPE, BadgeData } from '../../main'
-import { badgePartialDataFixture } from './badge-partial-data.fixture'
+import { BADGE_TYPE, BadgeData } from '../../main'
 
 export const badgeDataFixture = defineFixture<BadgeData>((t) => {
   t.key.as(index => `badge-${index}`)
   t.type.pickFrom([...BADGE_TYPE])
   t.name.as(index => [{ value: `Badge ${index}` }])
-  t.alignment.pickFrom([...ALIGNMENT])
-  t.badgeText?.as(index => [{ value: `This is badge ${index}` }])
-  t.acquisition?.asLoremIpsum()
-  t.icon?.asArray([{ value: 'https://nouri.org' }])
-  t.notes?.asLoremIpsum()
-  t.links?.asArray([{ href: 'https://nouri.org' }])
-  t.mapKey?.asString()
-  t.loc?.asArray()
-  t.vidiotMapKey?.asString()
-  t.setTitle?.asArray({ length: 2 })
-  t.effect?.asString()
-  t.partials?.arrayOfFixture({ fixture: badgePartialDataFixture })
-  t.ignoreInTotals?.asBoolean()
 })

package/src/test/api/badge-data.test.ts

@@ -3,13 +3,13 @@ import { BadgeData } from '../../main'
 // If you change this test, update the example in the README as well
 export const TEST_BADGE: BadgeData = {
   key: 'test-badge',
-  type: 'ACHIEVEMENT',
-  name: [{ value: 'Test Badge' }, { alignment: 'P', value: 'My Badge for Praetorians' }],
-  alignment: ['H', 'V', 'P'],
+  type: 'achievement',
+  name: [{ value: 'Test Badge' }, { alignment: 'praetorian', value: 'My Badge for Praetorians' }],
+  morality: ['hero', 'praetorian'],
 }
 
 describe('BadgeData', () => {
   test('should be a usable interface', () => {
-    expect(TEST_BADGE).not.toBeNull()
+    expect(TEST_BADGE).not.toBeUndefined()
   })
 })

package/src/test/api/badge-requirement-data.fixture.ts

@@ -0,0 +1,7 @@
+import { defineFixture } from 'efate'
+import { BADGE_REQUIREMENT_TYPE, BadgeRequirementData } from '../../main'
+
+export const badgeRequirementDataFixture = defineFixture<BadgeRequirementData>((t) => {
+  t.key.as(index => `badge-requirement-${index}`)
+  t.type.pickFrom([...BADGE_REQUIREMENT_TYPE])
+})

package/src/test/api/badge-requirement-type.test.ts

@@ -0,0 +1,31 @@
+import { BADGE_REQUIREMENT_TYPE, BadgeRequirementType } from '../../main'
+
+describe('BADGE_REQUIREMENT_TYPE', () => {
+  test('should be an array', () => {
+    expect(Array.isArray(BADGE_REQUIREMENT_TYPE)).toBeTruthy()
+  })
+
+  test('should not be empty', () => {
+    expect(BADGE_REQUIREMENT_TYPE).not.toHaveLength(0)
+  })
+
+  test('should contain only strings', () => {
+    for (const entry of BADGE_REQUIREMENT_TYPE) {
+      expect(typeof entry).toBe('string')
+    }
+  })
+
+  test('should contain all known badge requirement types', () => {
+    const expected = ['badge', 'invention', 'invention-plus-one', 'location', 'monument', 'mission', 'task']
+    for (const category of expected) {
+      expect(BADGE_REQUIREMENT_TYPE).toContain(category)
+    }
+  })
+})
+
+describe('BadgeRequirementType', () => {
+  test('should be a usable type', () => {
+    const field: BadgeRequirementType = 'monument'
+    expect(field).toBe('monument')
+  })
+})

package/src/test/api/badge-type.test.ts

@@ -17,9 +17,9 @@ describe('BADGE_TYPE', () => {
 
   test('should contain all known basic badge types', () => {
     const expected = [
-      'EXPLORATION', 'HISTORY', 'ACCOMPLISHMENT', 'ACHIEVEMENT', 'ACCOLADE',
-      'GLADIATOR', 'VETERAN', 'PVP', 'INVENTION', 'DEFEAT',
-      'EVENT', 'OUROBOROS', 'CONSIGNMENT', 'DAY_JOB', 'AE',
+      'exploration', 'history', 'accomplishment', 'achievement', 'accolade',
+      'gladiator', 'veteran', 'pvp', 'invention', 'defeat',
+      'event', 'ouroboros', 'consignment', 'day-job', 'architect-entertainment',
     ]
     for (const category of expected) {
       expect(BADGE_TYPE).toContain(category)
@@ -29,7 +29,7 @@ describe('BADGE_TYPE', () => {
 
 describe('BadgeType', () => {
   test('should be a usable type', () => {
-    const field: BadgeType = 'EXPLORATION'
-    expect(field).toBe('EXPLORATION')
+    const field: BadgeType = 'exploration'
+    expect(field).toBe('exploration')
   })
 })

package/src/test/api/bundle-data.fixture.ts

@@ -0,0 +1,6 @@
+import { defineFixture } from 'efate'
+import { BundleData } from '../../main'
+
+export const bundleDataFixture = defineFixture<BundleData>(() => {
+  // no mandatory fields
+})

package/src/test/api/bundle-header-data.fixture.ts

@@ -0,0 +1,6 @@
+import { defineFixture } from 'efate'
+import { BundleHeaderData } from '../../main'
+
+export const bundleHeaderDataFixture = defineFixture<BundleHeaderData>(() => {
+  // no mandatory fields
+})

package/src/test/api/contact-data.fixture.ts

@@ -0,0 +1,7 @@
+import { defineFixture } from 'efate'
+import { ContactData } from '../../main'
+
+export const contactDataFixture = defineFixture<ContactData>((t) => {
+  t.key.as(index => `contact-${index}`)
+  t.name.as(index => [{ value: `Contact ${index}` }])
+})

package/src/test/api/enhancement-category.test.ts

@@ -17,9 +17,9 @@ describe('ENHANCEMENT_CATEGORY', () => {
 
   test('should contain all known default enhancement categories', () => {
     const expected = [
-      'DEFENSE_DEBUFF', 'TO_HIT_DEBUFF', 'TAUNT', 'CONFUSE', 'HEALING', 'DEFENSE_BUFF', 'RESIST_DAMAGE', 'INTANGIBILITY', 'SLEEP', 'SLOW', 'HOLD', 'STUN', 'IMMOBILIZE',
-      'FEAR', 'ENDURANCE_MODIFICATION', 'ENDURANCE_REDUCTION', 'RECHARGE_REDUCTION', 'INTERRUPT_DURATION', 'ACCURACY', 'TO_HIT_BUFF', 'DAMAGE', 'KNOCKBACK', 'RUN_SPEED',
-      'JUMP', 'FLY_SPEED', 'RANGE',
+      'defense-debuff', 'to-hit-debuff', 'taunt', 'confuse', 'healing', 'defense-buff', 'resist-damage', 'intangibility', 'sleep', 'slow', 'hold', 'stun', 'immobilize',
+      'fear', 'endurance-modification', 'endurance-reduction', 'recharge-reduction', 'interrupt-duration', 'accuracy', 'to-hit-buff', 'damage', 'knockback', 'run-speed',
+      'jump', 'fly-speed', 'range',
     ]
     for (const category of expected) {
       expect(ENHANCEMENT_CATEGORY).toContain(category)
@@ -29,7 +29,7 @@ describe('ENHANCEMENT_CATEGORY', () => {
 
 describe('EnhancementCategory', () => {
   test('should be a usable type', () => {
-    const field: EnhancementCategory = 'RUN_SPEED'
-    expect(field).toBe('RUN_SPEED')
+    const field: EnhancementCategory = 'run-speed'
+    expect(field).toBe('run-speed')
   })
 })

package/src/test/api/mission-data.fixture.ts

@@ -0,0 +1,12 @@
+import { defineFixture } from 'efate'
+import { MISSION_TYPE, MissionData, MissionFlashbackData } from '../../main'
+
+export const missionDataFixture = defineFixture<MissionData>((t) => {
+  t.key.as(index => `mission-${index}`)
+  t.name.as(index => `Mission ${index}`)
+  t.type.pickFrom([...MISSION_TYPE])
+})
+
+export const missionFlashbackDataFixture = defineFixture<MissionFlashbackData>((t) => {
+  t.id.as(index => `${index}.${index}`)
+})

package/src/test/api/sex.test.ts

@@ -1,4 +1,4 @@
-import { Sex, SEX } from '../../main'
+import { compareSex, Sex, SEX } from '../../main'
 
 describe('SEX', () => {
   test('should be an array', () => {
@@ -29,3 +29,35 @@ describe('Sex', () => {
     expect(field).toBe('M')
   })
 })
+
+describe('compareSex', () => {
+  test('should return <0 if first argument comes first', () => {
+    expect(compareSex('M', 'F')).toBeLessThan(0)
+  })
+
+  test('should return >0 if second argument comes first', () => {
+    expect(compareSex('F', 'M')).toBeGreaterThan(0)
+  })
+
+  test('should return 0 if arguments match', () => {
+    expect(compareSex('F', 'F')).toBe(0)
+  })
+
+  test('should return 0 if both arguments are undefined', () => {
+    expect(compareSex()).toBe(0)
+  })
+
+  test('should work as a compare function', () => {
+    const unsorted: (Sex | undefined)[] = [undefined, 'M', 'F', 'M', undefined, 'F', 'M']
+    const sorted = unsorted.sort(compareSex)
+
+    expect(sorted).toStrictEqual(['M', 'M', 'M', 'F', 'F', undefined, undefined])
+  })
+
+  test('should sort against undefined', () => {
+    const unsorted: (Sex | undefined)[] = [undefined, 'M']
+    const sorted = unsorted.sort(compareSex)
+
+    expect(sorted).toStrictEqual(['M', undefined])
+  })
+})

package/src/test/api/zone-data.fixture.ts

@@ -0,0 +1,8 @@
+import { ZoneData } from '../../main'
+import { defineFixture } from 'efate'
+
+export const zoneDataFixture = defineFixture<ZoneData>((t) => {
+  t.key.as(index => `zone-${index}`)
+  t.name.as(index => `Zone ${index}`)
+  t.links?.as(() => [{ title: 'foo', href: 'https://nouri.org' }])
+})

package/src/test/db/abstract-index.test.ts

@@ -0,0 +1,55 @@
+import { AbstractIndex } from '../../main/db/abstract-index'
+
+interface TestObject {
+  key: string
+  otherValue: number
+}
+
+describe(AbstractIndex.name, () => {
+  describe('Constructor', () => {
+    test(`should accept the key field`, () => {
+      new AbstractIndex<TestObject>('key', [])
+    })
+
+    test(`should throw an error on duplicate key`, () => {
+      expect(() => new AbstractIndex<TestObject>('key', [
+        { key: '1', otherValue: 1 },
+        { key: '1', otherValue: 1 },
+      ])).toThrow('Duplicate key [1]')
+    })
+  })
+
+  describe('value', () => {
+    test(`should return the original values`, () => {
+      const values = [
+        { key: '1', otherValue: 1 },
+        { key: '2', otherValue: 2 },
+      ]
+      const index = new AbstractIndex<TestObject>('key', values)
+      expect(index.values).toStrictEqual(values)
+    })
+  })
+
+  describe('get', () => {
+    test(`should return the indexed value on match`, () => {
+      const index = new AbstractIndex<TestObject>('key', [
+        { key: '1', otherValue: 1 },
+        { key: '2', otherValue: 2 },
+      ])
+
+      expect(index.get('2')).toStrictEqual({ key: '2', otherValue: 2 })
+    })
+
+    test(`should return undefined on no match`, () => {
+      const index = new AbstractIndex<TestObject>('key', [])
+
+      expect(index.get('2')).toBeUndefined()
+    })
+
+    test(`should return undefined on undefined key`, () => {
+      const index = new AbstractIndex<TestObject>('key', [])
+      const key = undefined
+      expect(index.get(key)).toBeUndefined()
+    })
+  })
+})