coh-content-db 2.0.0-rc.9 → 2.0.0

package/src/test/db/{alternates.test.ts → variants.test.ts}

@@ -1,9 +1,9 @@
-import { Alternates } from '../../main'
+import { Variants } from '../../main'
 
-describe(Alternates.name, () => {
+describe(Variants.name, () => {
   describe('Constructor', () => {
-    test('should accept a list of alternate values', () => {
-      new Alternates([
+    test('should accept a list of variant values', () => {
+      new Variants([
         { value: 'Default' },
         { sex: 'M', value: 'Male' },
         { alignment: 'hero', value: 'Hero' },
@@ -13,17 +13,17 @@ describe(Alternates.name, () => {
     })
 
     test('should accept a single value', () => {
-      expect(new Alternates('foo').default?.value).toBe('foo')
+      expect(new Variants('foo').default?.value).toBe('foo')
     })
   })
 
   describe('getValue', () => {
     test('should return undefined if there are no values', () => {
-      expect(new Alternates([]).getValue()).toBeUndefined()
+      expect(new Variants([]).getValue()).toBeUndefined()
     })
 
     test('should return the least-specific value when no classifiers are provided', () => {
-      expect(new Alternates([
+      expect(new Variants([
         { value: 'Default' },
         { sex: 'M', value: 'Male' },
         { alignment: 'hero', value: 'Hero' },
@@ -33,7 +33,7 @@ describe(Alternates.name, () => {
     })
 
     test('should return the least-specific value when no classifiers are provided, regardless of insert order', () => {
-      expect(new Alternates([
+      expect(new Variants([
         { alignment: 'villain', sex: 'M', value: 'Male Villain' },
         { alignment: 'hero', value: 'Hero' },
         { value: 'Default' },
@@ -43,27 +43,27 @@ describe(Alternates.name, () => {
     })
 
     test('should return the most specific match', () => {
-      expect(new Alternates([
+      expect(new Variants([
         { value: 'Default' },
         { sex: 'M', value: 'Male' },
         { alignment: 'hero', value: 'Hero' },
         { alignment: 'villain', sex: 'M', value: 'Male Villain' },
         { alignment: 'praetorian', sex: 'F', value: 'Praetorian Female' },
-      ]).getValue('villain', 'M')).toBe('Male Villain')
+      ]).getValue({ morality: 'villain', sex: 'M' })).toBe('Male Villain')
     })
 
     test('should return the most specific match, regardless of insert order', () => {
-      expect(new Alternates([
+      expect(new Variants([
         { alignment: 'praetorian', sex: 'F', value: 'Praetorian Female' },
         { sex: 'M', value: 'Male' },
         { alignment: 'hero', value: 'Hero' },
         { alignment: 'villain', sex: 'M', value: 'Male Villain' },
         { value: 'Default' },
-      ]).getValue('villain', 'M')).toBe('Male Villain')
+      ]).getValue({ morality: 'villain', sex: 'M' })).toBe('Male Villain')
     })
 
     test('should return the lowest canonical value if there is no default', () => {
-      expect(new Alternates([
+      expect(new Variants([
         { alignment: 'hero', value: 'Hero' },
         { sex: 'M', value: 'Male' },
         { alignment: 'praetorian', sex: 'F', value: 'Praetorian Female' },
@@ -72,22 +72,22 @@ describe(Alternates.name, () => {
     })
 
     test('should return the lowest canonical value if a specific is requested that does not exist', () => {
-      expect(new Alternates([
+      expect(new Variants([
         { alignment: 'hero', value: 'Hero' },
         { alignment: 'villain', value: 'Villain' },
         { alignment: 'villain', sex: 'M', value: 'Male Villain' },
         { alignment: 'praetorian', sex: 'F', value: 'Praetorian Female' },
-      ]).getValue(undefined, 'F')).toBe('Hero')
+      ]).getValue({ sex: 'F' })).toBe('Hero')
     })
   })
 
   describe('default', () => {
     test('should return undefined if there are no values', () => {
-      expect(new Alternates([]).default).toBeUndefined()
+      expect(new Variants([]).default).toBeUndefined()
     })
 
     test('should return the lowest priority value', () => {
-      expect(new Alternates([
+      expect(new Variants([
         { value: 'Default' },
         { sex: 'M', value: 'Male' },
         { alignment: 'hero', value: 'Hero' },
@@ -95,7 +95,7 @@ describe(Alternates.name, () => {
         { alignment: 'praetorian', sex: 'F', value: 'Praetorian Female' },
       ]).default?.value).toBe('Default')
 
-      expect(new Alternates([
+      expect(new Variants([
         { alignment: 'villain', sex: 'M', value: 'Male Villain' },
         { alignment: 'praetorian', sex: 'F', value: 'Praetorian Female' },
         { sex: 'M', value: 'Male' },
@@ -103,7 +103,7 @@ describe(Alternates.name, () => {
         { alignment: 'hero', value: 'Hero' },
       ]).default?.value).toBe('Default')
 
-      expect(new Alternates([
+      expect(new Variants([
         { alignment: 'villain', sex: 'M', value: 'Male Villain' },
         { alignment: 'praetorian', sex: 'F', value: 'Praetorian Female' },
         { sex: 'M', value: 'Male' },
@@ -114,11 +114,11 @@ describe(Alternates.name, () => {
 
   describe('canonical', () => {
     test('should be empty if there are no values', () => {
-      expect(new Alternates([]).canonical).toHaveLength(0)
+      expect(new Variants([]).canonical).toHaveLength(0)
     })
 
     test('should return values sorted in canonical order', () => {
-      const result = new Alternates([
+      const result = new Variants([
         { alignment: 'hero', sex: 'F', value: 'Female Hero' },
         { alignment: 'praetorian', value: 'Praetorian' },
         { sex: 'F', value: 'Female' },
@@ -150,7 +150,7 @@ describe(Alternates.name, () => {
     })
 
     test('should sort unspecified values by alpha', () => {
-      expect(new Alternates([
+      expect(new Variants([
         { value: 'A' },
         { value: 'C' },
         { value: 'B' },
@@ -162,7 +162,7 @@ describe(Alternates.name, () => {
     })
 
     test('should sort identical values by value alpha', () => {
-      expect(new Alternates([
+      expect(new Variants([
         { alignment: 'villain', value: 'B' },
         { sex: 'M', value: 'D' },
         { alignment: 'villain', value: 'A' },
@@ -178,7 +178,7 @@ describe(Alternates.name, () => {
 
   describe('toString', () => {
     test('should create a string separated by the separator', () => {
-      expect(new Alternates([
+      expect(new Variants([
         { sex: 'M', value: 'A' },
         { sex: 'F', value: 'B' },
         { alignment: 'hero', value: 'C' },

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

@@ -22,6 +22,51 @@ describe(Zone.name, () => {
     })
   })
 
+  describe('type', () => {
+    test(`should be set from the data`, () => {
+      const zone = new Zone(zoneDataFixture.create({ type: 'city' }))
+      expect(zone.type).toEqual('city')
+    })
+  })
+
+  describe('morality', () => {
+    test(`should be set from the data`, () => {
+      const zone = new Zone(zoneDataFixture.create({ morality: ['hero'] }))
+      expect(zone.morality?.hero).toBeTruthy()
+      expect(zone.morality?.vigilante).toBeFalsy()
+    })
+
+    test(`should be optional`, () => {
+      const zone = new Zone(zoneDataFixture.omit('morality').create())
+      expect(zone.morality?.all).toBeTruthy()
+    })
+  })
+
+  describe('levelRange', () => {
+    test(`should be set from the data`, () => {
+      const zone = new Zone(zoneDataFixture.create({ levelRange: [10] }))
+      expect(zone.levelRange?.min).toEqual(10)
+      expect(zone.levelRange?.max).toBeUndefined()
+    })
+
+    test(`should be optional`, () => {
+      const zone = new Zone(zoneDataFixture.omit('levelRange').create())
+      expect(zone.levelRange).toBeUndefined()
+    })
+  })
+
+  describe('notes', () => {
+    test(`should be set from the data`, () => {
+      const zone = new Zone(zoneDataFixture.create({ notes: 'foo' }))
+      expect(zone.notes).toEqual('foo')
+    })
+
+    test(`should be optional`, () => {
+      const zone = new Zone(zoneDataFixture.omit('notes').create())
+      expect(zone.notes).toBeUndefined()
+    })
+  })
+
   describe('links', () => {
     test(`should be set from the data`, () => {
       const zone = new Zone(zoneDataFixture.create({ links: [{ title: 'foo', href: 'bar' }] }))

package/src/test/integration.test.ts

@@ -4,13 +4,13 @@ import { TEST_BADGE } from './api/badge-data.test'
 /**
  * If you change this test, update the example in the README as well
  */
-export const TEST_BUNDLE: BundleData = {
-  header: { name: 'My Content Bundle' },
+export const MyBundle: BundleData = {
+  header: { name: 'My Content Bundle', version: '1.0.0', lastUpdateTime: '2025-04-21T00:00:00Z' },
   badges: [TEST_BADGE],
 }
 
 describe('BundleData', () => {
   test('should be a usable interface', () => {
-    expect(TEST_BUNDLE).not.toBeUndefined()
+    expect(MyBundle).not.toBeUndefined()
   })
 })

package/src/test/util/coalese-to-array.test.ts

@@ -0,0 +1,17 @@
+import { coalesceToArray } from '../../main/util/coalesce-to-array'
+
+describe(coalesceToArray.name, () => {
+  test('should return an array unmodified', () => {
+    expect(coalesceToArray(['a', 'b'])).toStrictEqual(['a', 'b'])
+    expect(coalesceToArray([1, 2])).toStrictEqual([1, 2])
+  })
+
+  test('should return a single value as a single-value array', () => {
+    expect(coalesceToArray('a')).toStrictEqual(['a'])
+    expect(coalesceToArray(1)).toStrictEqual([1])
+  })
+
+  test('should return undefined value as undefined', () => {
+    expect(coalesceToArray()).toBeUndefined()
+  })
+})

package/src/test/{util.test.ts → util/links.test.ts}

@@ -1,8 +1,8 @@
-import { Badge, badgeLink, badgeUri, coalesceToArray, Contact, contactLink, contactUri, Mission, missionLink, missionUri, Zone, zoneLink, zoneUri } from '../main'
-import { badgeDataFixture } from './api/badge-data.fixture'
-import { zoneDataFixture } from './api/zone-data.fixture'
-import { contactDataFixture } from './api/contact-data.fixture'
-import { missionDataFixture } from './api/mission-data.fixture'
+import { Badge, badgeLink, badgeUri, Contact, contactLink, contactUri, Mission, missionLink, missionUri, Zone, zoneLink, zoneUri } from '../../main'
+import { badgeDataFixture } from '../api/badge-data.fixture'
+import { zoneDataFixture } from '../api/zone-data.fixture'
+import { contactDataFixture } from '../api/contact-data.fixture'
+import { missionDataFixture } from '../api/mission-data.fixture'
 
 describe(badgeUri.name, () => {
   test('should return the expected pattern', () => {
@@ -147,19 +147,3 @@ describe(zoneLink.name, () => {
     expect(zoneLink(zone)).toBe('[foo](zone://foo)')
   })
 })
-
-describe(coalesceToArray.name, () => {
-  test('should return an array unmodified', () => {
-    expect(coalesceToArray(['a', 'b'])).toStrictEqual(['a', 'b'])
-    expect(coalesceToArray([1, 2])).toStrictEqual([1, 2])
-  })
-
-  test('should return a single value as a single-value array', () => {
-    expect(coalesceToArray('a')).toStrictEqual(['a'])
-    expect(coalesceToArray(1)).toStrictEqual([1])
-  })
-
-  test('should return undefined value as undefined', () => {
-    expect(coalesceToArray()).toBeUndefined()
-  })
-})

package/src/test/util/to-date.test.ts

@@ -0,0 +1,15 @@
+import { toDate } from '../../main/util/to-date'
+
+describe(toDate.name, () => {
+  test('should return a valid date', () => {
+    expect(toDate('2025-02-01')).toStrictEqual(new Date('2025-02-01'))
+  })
+
+  test('should return a valid time', () => {
+    expect(toDate('2025-04-21T02:57:52.402Z')).toStrictEqual(new Date('2025-04-21T02:57:52.402Z'))
+  })
+
+  test('should throw on invalid ISO string', () => {
+    expect(() => toDate('foo')).toThrow('Invalid date')
+  })
+})

package/src/main/db/alternates.ts

@@ -1,67 +0,0 @@
-import { AlternateData } from '../api/alternate-data'
-import { compareSex, Sex } from '../api/sex'
-import { Alignment, compareAlignment } from '../api/alignment'
-
-export class Alternates<T> {
-  readonly #sortedValues: AlternateData<T>[] = []
-
-  /**
-   * Create an alternate set from either a list of categorized values, or a single value when there are no alternates.
-   * @param value List of alternates, or a single value.
-   */
-  constructor(value: AlternateData<T>[] | T) {
-    if (Array.isArray(value)) {
-      this.#sortedValues = value.sort()
-      this.#sortedValues.sort((a, b) => this.#compareAlternates(a, b))
-    } else {
-      this.#sortedValues = [{ value }]
-    }
-  }
-
-  getValue(alignment?: Alignment, sex?: Sex): T | undefined {
-    for (let index = this.#sortedValues.length; index--;) {
-      const entry = this.#sortedValues[index]
-      if ((entry.alignment === undefined || entry.alignment === alignment)
-        && (entry.sex === undefined || entry.sex === sex)
-      ) return entry.value
-    }
-
-    return this.default?.value
-  }
-
-  /**
-   * Get the default value for this list of alternates, the value with the highest priority and lowest specificity.
-   */
-  get default(): AlternateData<T> | undefined {
-    return this.#sortedValues[0]
-  }
-
-  /**
-   * Get the list of alternates sorted in canonical order (alignment then sex, low to high specificity).
-   */
-  get canonical(): AlternateData<T>[] {
-    return this.#sortedValues
-  }
-
-  /**
-   * Create a joined string from the alternate values in canonical order.
-   * @param separator Separator to use. Default is ' / '
-   */
-  toString(separator: string): string {
-    return this.canonical.map(x => x.value).join(separator)
-  }
-
-  #compareAlternates(a: AlternateData<T>, b: AlternateData<T>): number {
-    const aSpecificity = (a.alignment ? 2 : 0) + (a.sex ? 1 : 0)
-    const bSpecificity = (b.alignment ? 2 : 0) + (b.sex ? 1 : 0)
-    if (aSpecificity !== bSpecificity) return aSpecificity - bSpecificity // Order first by least-specific
-
-    const alignmentComparison = compareAlignment(a.alignment, b.alignment) // Next by alignment
-    if (alignmentComparison !== 0) return alignmentComparison
-
-    const sexComparison = compareSex(a.sex, b.sex) // Last by sex
-    if (sexComparison !== 0) return sexComparison
-
-    return String(a.value).localeCompare(String(b.value))
-  }
-}