coh-content-db 2.0.0-rc.19 → 2.0.0-rc.20

package/src/main/db/variants.ts

@@ -0,0 +1,84 @@
+import { VariantData } from '../api/variant-data'
+import { compareSex } from '../api/sex'
+import { compareAlignment } from '../api/alignment'
+import { VariantContext } from '../api/variant-context'
+import { MoralityMap } from '../api/morality'
+
+export class Variants<T> {
+  readonly #sortedValues: VariantData<T>[] = []
+
+  /**
+   * Create a variant set from either a list of categorized values, or a single value when there are no variants.
+   * @param value List of variants, or a single value.
+   */
+  constructor(value: VariantData<T>[] | T) {
+    if (Array.isArray(value)) {
+      this.#sortedValues = value.toSorted()
+      this.#sortedValues.sort((a, b) => this.#compareVariants(a, b))
+    } else {
+      this.#sortedValues = [{ value }]
+    }
+  }
+
+  /**
+   * Get a variant by context
+   * @param context The context
+   */
+  getVariant(context?: VariantContext): VariantData<T> | undefined {
+    const alignment = context?.morality ? MoralityMap[context.morality] : undefined
+    const sex = context?.sex
+
+    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
+    }
+
+    return this.default
+  }
+
+  /**
+   * Get a value by variant context
+   * @param context The context
+   */
+  getValue(context?: VariantContext): T | undefined {
+    return this.getVariant(context)?.value
+  }
+
+  /**
+   * Get the default value for this list of variants, the value with the highest priority and lowest specificity.
+   */
+  get default(): VariantData<T> | undefined {
+    return this.#sortedValues[0]
+  }
+
+  /**
+   * Get the list of variants sorted in canonical order (alignment then sex, low to high specificity).
+   */
+  get canonical(): VariantData<T>[] {
+    return this.#sortedValues
+  }
+
+  /**
+   * Create a joined string from the variant values in canonical order.
+   * @param separator Separator to use. Default is ' / '
+   */
+  toString(separator: string): string {
+    return this.canonical.map(x => x.value).join(separator)
+  }
+
+  #compareVariants(a: VariantData<T>, b: VariantData<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))
+  }
+}

package/src/main/index.ts

@@ -1,6 +1,5 @@
 // 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'
@@ -20,12 +19,13 @@ export * from './api/mission-type'
 export * from './api/morality'
 export * from './api/set-title-data'
 export * from './api/sex'
+export * from './api/variant-context'
+export * from './api/variant-data'
 export * from './api/zone-data'
 export * from './api/zone-type'
 
 // DB
 export * from './db/alignment-list'
-export * from './db/alternates'
 export * from './db/archetype'
 export * from './db/badge'
 export * from './db/badge-index'
@@ -41,6 +41,7 @@ export * from './db/mission'
 export * from './db/morality-list'
 export * from './db/paged'
 export * from './db/set-title-ids'
+export * from './db/variants'
 export * from './db/zone'
 
 // UTILS

package/src/test/api/morality.test.ts

@@ -0,0 +1,31 @@
+import { MoralityMap } from '../../main'
+
+describe('MoralityMap', () => {
+  test('should map hero to hero', () => {
+    expect(MoralityMap.hero).toEqual('hero')
+  })
+
+  test('should map vigilante to hero', () => {
+    expect(MoralityMap.vigilante).toEqual('hero')
+  })
+
+  test('should map villain to villain', () => {
+    expect(MoralityMap.villain).toEqual('villain')
+  })
+
+  test('should map rogue to villain', () => {
+    expect(MoralityMap.rogue).toEqual('villain')
+  })
+
+  test('should map resistance to praetorian', () => {
+    expect(MoralityMap.resistance).toEqual('praetorian')
+  })
+
+  test('should map loyalist to praetorian', () => {
+    expect(MoralityMap.loyalist).toEqual('praetorian')
+  })
+
+  test('should map praetorian to praetorian', () => {
+    expect(MoralityMap.loyalist).toEqual('praetorian')
+  })
+})

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

@@ -478,6 +478,18 @@ describe(BadgeIndex.name, () => {
         expect(keys).toStrictEqual(['badge-3', 'badge-1', 'badge-2'])
       })
 
+      test(`should sort by badge name, taking variant context into account`, () => {
+        const index = new BadgeIndex([
+          new Badge(badgeDataFixture.create({ key: 'badge-1', name: [{ value: 'A' }, { value: 'C', alignment: 'praetorian', sex: 'F' }] })),
+          new Badge(badgeDataFixture.create({ key: 'badge-2', name: [{ value: 'B' }] })),
+          new Badge(badgeDataFixture.create({ key: 'badge-3', name: [{ value: 'C' }, { value: 'A', alignment: 'praetorian' }] })),
+        ])
+
+        const result = index.search({ sort: 'name.asc', variantContext: { morality: 'resistance', sex: 'F' } })
+        const keys = result.items.map(x => x.key)
+        expect(keys).toStrictEqual(['badge-3', 'badge-2', 'badge-1'])
+      })
+
       test(`should sort by badge name descending`, () => {
         const index = new BadgeIndex([
           new Badge(badgeDataFixture.create({ key: 'badge-1', name: [{ value: 'Abc' }] })),

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

@@ -1,4 +1,4 @@
-import { Badge, compareByDefaultName, compareByReleaseDate, compareByZoneKey } from '../../main'
+import { Badge, compareByName, compareByReleaseDate, compareByZoneKey } from '../../main'
 import { badgeDataFixture } from '../api/badge-data.fixture'
 import { badgeRequirementDataFixture } from '../api/badge-requirement-data.fixture'
 
@@ -299,31 +299,53 @@ describe(Badge.name, () => {
     })
   })
 
-  describe(compareByDefaultName.name, () => {
+  describe(compareByName.name, () => {
     test(`should compare two badges by name`, () => {
       const badgeA = new Badge(badgeDataFixture.create({ name: 'A' }))
       const badgeB = new Badge(badgeDataFixture.create({ name: 'B' }))
-      expect(compareByDefaultName(badgeA, badgeB)).toBeLessThan(0)
-      expect([badgeB, badgeA].toSorted(compareByDefaultName)).toStrictEqual([badgeA, badgeB])
+      expect(compareByName(badgeA, badgeB)).toBeLessThan(0)
+      expect([badgeB, badgeA].toSorted(compareByName)).toStrictEqual([badgeA, badgeB])
     })
 
     test(`should return 0 for equal names`, () => {
       const badgeA = new Badge(badgeDataFixture.create({ name: 'A' }))
       const badgeB = new Badge(badgeDataFixture.create({ name: 'A' }))
-      expect(compareByDefaultName(badgeA, badgeB)).toEqual(0)
+      expect(compareByName(badgeA, badgeB)).toEqual(0)
     })
 
     test(`should compare two undefined values`, () => {
       const badgeA = new Badge(badgeDataFixture.create({ name: [] }))
       const badgeB = new Badge(badgeDataFixture.create({ name: [] }))
-      expect(compareByDefaultName(badgeA, badgeB)).toEqual(0)
+      expect(compareByName(badgeA, badgeB)).toEqual(0)
     })
 
     test(`should sort undefined values last`, () => {
       const badgeA = new Badge(badgeDataFixture.create({ name: 'A' }))
       const badgeB = new Badge(badgeDataFixture.create({ name: [] }))
-      expect([badgeA, badgeB].toSorted(compareByDefaultName)).toStrictEqual([badgeA, badgeB])
-      expect([badgeB, badgeA].toSorted(compareByDefaultName)).toStrictEqual([badgeA, badgeB])
+      expect([badgeA, badgeB].toSorted(compareByName)).toStrictEqual([badgeA, badgeB])
+      expect([badgeB, badgeA].toSorted(compareByName)).toStrictEqual([badgeA, badgeB])
+    })
+
+    test(`should take morality context into account`, () => {
+      const badgeA = new Badge(badgeDataFixture.create({ name: [{ value: 'ZZZ' }, { alignment: 'villain', value: 'AAA' }] }))
+      const badgeB = new Badge(badgeDataFixture.create({ name: 'B' }))
+      expect([badgeA, badgeB].toSorted((a, b) => compareByName(a, b, { morality: 'villain' }))).toStrictEqual([badgeA, badgeB])
+      expect([badgeA, badgeB].toSorted((a, b) => compareByName(a, b, {}))).toStrictEqual([badgeB, badgeA])
+    })
+
+    test(`should take sex context into account`, () => {
+      const badgeA = new Badge(badgeDataFixture.create({ name: [{ value: 'ZZZ' }, { sex: 'F', value: 'AAA' }] }))
+      const badgeB = new Badge(badgeDataFixture.create({ name: 'B' }))
+      expect([badgeA, badgeB].toSorted((a, b) => compareByName(a, b, { sex: 'F' }))).toStrictEqual([badgeA, badgeB])
+      expect([badgeA, badgeB].toSorted((a, b) => compareByName(a, b, {}))).toStrictEqual([badgeB, badgeA])
+    })
+
+    test(`should take full variant context into account`, () => {
+      const badgeA = new Badge(badgeDataFixture.create({ name: [{ value: 'A' }, { sex: 'F', value: 'B' }] }))
+      const badgeB = new Badge(badgeDataFixture.create({ name: [{ value: 'B' }, { alignment: 'praetorian', sex: 'F', value: 'A' }] }))
+      const badgeC = new Badge(badgeDataFixture.create({ name: 'C' }))
+      expect([badgeA, badgeB, badgeC].toSorted((a, b) => compareByName(a, b, { morality: 'resistance', sex: 'F' }))).toStrictEqual([badgeB, badgeA, badgeC])
+      expect([badgeA, badgeB, badgeC].toSorted((a, b) => compareByName(a, b, {}))).toStrictEqual([badgeA, badgeB, badgeC])
     })
   })
 

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/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.toSorted()
-      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))
-  }
-}