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

package/src/main/index.ts

@@ -0,0 +1,41 @@
+// API
+export * from './api/alignment'
+export * from './api/alternate-data'
+export * from './api/archetype-data'
+export * from './api/badge-data'
+export * from './api/badge-requirement-data'
+export * from './api/badge-requirement-type'
+export * from './api/badge-type'
+export * from './api/bundle-data'
+export * from './api/bundle-header-data'
+export * from './api/contact-data'
+export * from './api/enhancement-category'
+export * from './api/link'
+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/zone-data'
+
+// DB
+export * from './db/alignment-list'
+export * from './db/alternates'
+export * from './db/archetype'
+export * from './db/badge'
+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/contact'
+export * from './db/key'
+export * from './db/location'
+export * from './db/mission'
+export * from './db/morality-list'
+export * from './db/paged'
+export * from './db/zone'
+
+// ROOT
+export * from './util'

package/src/main/util.ts

@@ -0,0 +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'
+
+/**
+ * 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 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 `contact://${key}`
+}
+
+/**
+ * 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 contactLink(target: string | Contact | ContactData): string {
+  const key = typeof target === 'string' ? target : target.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

@@ -0,0 +1,65 @@
+import { Alignment, ALIGNMENT, compareAlignment } from '../../main'
+
+describe('ALIGNMENT', () => {
+  test('should be an array', () => {
+    expect(Array.isArray(ALIGNMENT)).toBeTruthy()
+  })
+
+  test('should not be empty', () => {
+    expect(ALIGNMENT).not.toHaveLength(0)
+  })
+
+  test('should contain only strings', () => {
+    for (const entry of ALIGNMENT) {
+      expect(typeof entry).toBe('string')
+    }
+  })
+
+  test('should contain all known alignments', () => {
+    const expected = ['hero', 'villain', 'praetorian']
+    for (const category of expected) {
+      expect(ALIGNMENT).toContain(category)
+    }
+  })
+})
+
+describe('Alignment', () => {
+  test('should be a usable type', () => {
+    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/archetype-data.fixture.ts

@@ -0,0 +1,8 @@
+import { defineFixture } from 'efate'
+import { ArchetypeData } from '../../main'
+
+export const archetypeDataFixture = defineFixture<ArchetypeData>((t) => {
+  t.key.as(index => `archetype-${index}`)
+  t.name.as(index => `Archetype ${index}`)
+  t.description?.asLoremIpsum()
+})

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

@@ -0,0 +1,8 @@
+import { defineFixture } from 'efate'
+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}` }])
+})

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

@@ -0,0 +1,15 @@
+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: 'praetorian', value: 'My Badge for Praetorians' }],
+  morality: ['hero', 'praetorian'],
+}
+
+describe('BadgeData', () => {
+  test('should be a usable interface', () => {
+    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

@@ -0,0 +1,35 @@
+import { BADGE_TYPE, BadgeType } from '../../main'
+
+describe('BADGE_TYPE', () => {
+  test('should be an array', () => {
+    expect(Array.isArray(BADGE_TYPE)).toBeTruthy()
+  })
+
+  test('should not be empty', () => {
+    expect(BADGE_TYPE).not.toHaveLength(0)
+  })
+
+  test('should contain only strings', () => {
+    for (const entry of BADGE_TYPE) {
+      expect(typeof entry).toBe('string')
+    }
+  })
+
+  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', 'architect-entertainment',
+    ]
+    for (const category of expected) {
+      expect(BADGE_TYPE).toContain(category)
+    }
+  })
+})
+
+describe('BadgeType', () => {
+  test('should be a usable type', () => {
+    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

@@ -0,0 +1,35 @@
+import { ENHANCEMENT_CATEGORY, EnhancementCategory } from '../../main'
+
+describe('ENHANCEMENT_CATEGORY', () => {
+  test('should be an array', () => {
+    expect(Array.isArray(ENHANCEMENT_CATEGORY)).toBeTruthy()
+  })
+
+  test('should not be empty', () => {
+    expect(ENHANCEMENT_CATEGORY).not.toHaveLength(0)
+  })
+
+  test('should contain only strings', () => {
+    for (const entry of ENHANCEMENT_CATEGORY) {
+      expect(typeof entry).toBe('string')
+    }
+  })
+
+  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',
+    ]
+    for (const category of expected) {
+      expect(ENHANCEMENT_CATEGORY).toContain(category)
+    }
+  })
+})
+
+describe('EnhancementCategory', () => {
+  test('should be a usable type', () => {
+    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

@@ -0,0 +1,63 @@
+import { compareSex, Sex, SEX } from '../../main'
+
+describe('SEX', () => {
+  test('should be an array', () => {
+    expect(Array.isArray(SEX)).toBeTruthy()
+  })
+
+  test('should not be empty', () => {
+    expect(SEX).not.toHaveLength(0)
+  })
+
+  test('should contain only strings', () => {
+    for (const entry of SEX) {
+      expect(typeof entry).toBe('string')
+    }
+  })
+
+  test('should contain all known sexes', () => {
+    const expected = ['M', 'F']
+    for (const category of expected) {
+      expect(SEX).toContain(category)
+    }
+  })
+})
+
+describe('Sex', () => {
+  test('should be a usable type', () => {
+    const field: Sex = 'M'
+    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()
+    })
+  })
+})