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

package/src/main/api/morality.ts

@@ -1,31 +1,49 @@
+import { Alignment } from './alignment'
+
 export const MORALITY = ['hero', 'vigilante', 'villain', 'rogue', 'resistance', 'loyalist'] as const
-export type Morality = typeof MORALITY[number]
-export type MoralityExtended = Morality
+export const MORALITY_EXTENDED = [
+  ...MORALITY,
   /**
    * Any of the Primal Earth moralities - Hero, Vigilante, Villain, Rogue.
    */
-  | 'primal'
+  'primal',
   /**
    * Either of the Praetorian Earth moralities - Resistance or Loyalist.
    */
-  | 'praetorian'
+  'praetorian',
   /**
    * The moralities that roll up to the Hero {@link Alignment} - Hero and Vigilante.
    */
-  | 'heroic'
+  'heroic',
   /**
    * The moralities that roll up to the Villain {@link Alignment} - Villain and Rogue.
    */
-  | 'villainous'
+  'villainous',
   /**
    * Moralities with access to Paragon City - Hero, Vigilante and Rogue.
    */
-  | 'paragon-city-access'
+  'paragon-city-access',
   /**
    * Moralities with access to the Rogue Isles - Villain, Rogue and Vigilante.
    */
-  | 'rogue-isles-access'
+  'rogue-isles-access',
   /**
    * All the moralities.
    */
-  | 'all'
+  'all',
+] as const
+export type Morality = typeof MORALITY[number]
+export type MoralityExtended = typeof MORALITY_EXTENDED[number]
+
+/**
+ * Maps a morality to the underlying alignment
+ */
+export const MoralityMap: Record<Morality | Alignment, Alignment> = {
+  hero: 'hero',
+  vigilante: 'hero',
+  villain: 'villain',
+  rogue: 'villain',
+  loyalist: 'praetorian',
+  resistance: 'praetorian',
+  praetorian: 'praetorian',
+}

package/src/main/api/set-title-data.ts

@@ -0,0 +1,4 @@
+/**
+ * The id, or a pair of ids [primal, praetorian] that are used with the /settitle command to set a badge
+ */
+export type SetTitleData = [number, number?]

package/src/main/api/variant-context.ts

@@ -0,0 +1,11 @@
+import { Sex } from './sex'
+import { Morality } from './morality'
+import { Alignment } from './alignment'
+
+/**
+ * For badges, aspects like the name, icon, or badge text can vary depending on context, such as the alignment or sex of the character.
+ */
+export interface VariantContext {
+  readonly morality?: Morality | Alignment
+  readonly sex?: Sex
+}

package/src/main/api/{alternate-data.ts → variant-data.ts}

@@ -2,16 +2,16 @@ import { Sex } from './sex'
 import { Alignment } from './alignment'
 
 /**
- * Some badge values differ based on the alignment or sex of the character.
+ * Some badge values differ based on the alignment or sex of a character.
  */
-export interface AlternateData<V> {
+export interface VariantData<V> {
   /**
-   * The character alignment this alternate applies to.
+   * The character alignment this variant applies to.
    */
   readonly alignment?: Alignment
 
   /**
-   * The character sex this alternate applies to.
+   * The character sex this variant applies to.
    */
   readonly sex?: Sex
 

package/src/main/api/zone-data.ts

@@ -1,4 +1,8 @@
 import { Link } from './link'
+import { MoralityExtended } from './morality'
+import { ZoneType } from './zone-type'
+import { MarkdownString } from './markdown-string'
+import { LevelRangeData } from './level-range-data'
 
 export interface ZoneData {
   /**
@@ -13,6 +17,26 @@ export interface ZoneData {
    */
   readonly name: string
 
+  /**
+   * The type of zone.
+   */
+  readonly type: ZoneType
+
+  /**
+   * The character moralities that this zone is accessible by.
+   */
+  readonly morality?: MoralityExtended | MoralityExtended[]
+
+  /**
+   * The level range this zone is recommended for.
+   */
+  readonly levelRange?: LevelRangeData
+
+  /**
+   * Freeform notes or tips about the zone.
+   */
+  readonly notes?: MarkdownString
+
   /**
    * List of external links. Wiki, forums, etc.
    */

package/src/main/api/zone-type.ts

@@ -0,0 +1,59 @@
+export const ZONE_TYPE = [
+  /**
+   * The standard zone type, even if not technically occurring in the 'City' proper.
+   */
+  'city',
+  /**
+   * An Ouroboros flashback to a zone as it was in a previous era.
+   */
+  'echo',
+  /**
+   * Tutorial zon, usually inaccessible after leaving.
+   */
+  'tutorial',
+  /**
+   * Trial zones, like the Abandoned Sewers trial.
+   */
+  'trial',
+  /**
+   * Hazard zones like the Hollows.
+   */
+  'hazard',
+  /**
+   * Mayhem mission zones.
+   */
+  'mayhem',
+  /**
+   * Safeguard mission zones.
+   */
+  'safeguard',
+  /**
+   * Exists inside a mission not covered by the other types.
+   */
+  'mission',
+  /**
+   * Incarnate trial zones.
+   */
+  'incarnate',
+  /**
+   * Cooprative zones where Heroes and Villains can team up for PvE content.
+   */
+  'co-op',
+  /**
+   * PvP zones like Bloody Bay.
+   */
+  'pvp',
+  /**
+   * Located in an arena PvP map.
+   */
+  'arena',
+  /**
+   * A building, usually contained within another zone, like the AE buildings.
+   */
+  'building',
+  /**
+   * Stuff like the (Phone only) zone.
+   */
+  'other',
+] as const
+export type ZoneType = typeof ZONE_TYPE[number]

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

@@ -1,35 +1,31 @@
 type KeysOfType<T, V> = { [P in keyof T]: T[P] extends V ? P : never }[keyof T]
 
 export class AbstractIndex<T> {
-  readonly #keyField: KeysOfType<T, string>
   protected _values: T[] = []
   protected _hashTable: Record<string, T> = {}
 
-  constructor(keyField: KeysOfType<T, string>) {
-    this.#keyField = keyField
-  }
-
-  /**
-   * Return all indexed values
-   */
-  get values(): T[] {
-    return this._values
-  }
-
   /**
-   * Load the given list of values into the index, replacing any existing data.
-   * @param values List of values.
+   * Create a new index.
+   * @param keyField The field of the values that will act as the key.
+   * @param values Values to index.
    */
-  load(values: T[] | undefined): void {
+  constructor(keyField: KeysOfType<T, string>, values: T[] | undefined) {
     this._values = values ?? []
     this._hashTable = {}
     for (const value of this.values) {
-      const key = value[this.#keyField] as string
+      const key = value[keyField] as string
       if (this._hashTable[key] !== undefined) throw new Error(`Duplicate key [${key}]`)
       this._hashTable[key] = value
     }
   }
 
+  /**
+   * Return all indexed values
+   */
+  get values(): T[] {
+    return this._values
+  }
+
   /**
    * Get a value from the index
    * @param key Key string

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

@@ -1,57 +1,83 @@
-import { Badge, compareByDefaultName, compareByZoneKey } from './badge'
+import { Badge, compareByName, compareByReleaseDate, compareByZoneKey } from './badge'
 import { BadgeSearchOptions } from './badge-search-options'
 import { Paged } from './paged'
 import { AbstractIndex } from './abstract-index'
 
 export class BadgeIndex extends AbstractIndex<Badge> {
-  constructor() {
-    super('key')
+  constructor(values: Badge[] | undefined) {
+    super('key', values)
   }
 
   search(options?: BadgeSearchOptions): Paged<Badge> {
-    const filtered = (options?.query || options?.filter)
+    const matched = (options?.query || options?.filter)
       ? this._values.filter(badge => this.#satisfiesQueryPredicate(badge, options?.query) && this.#satisfiesFilterPredicate(badge, options?.filter))
       : this._values
 
-    const totalPages = options?.pageSize ? Math.ceil(filtered.length / (options?.pageSize)) : 1
-    const page = Math.max(1, Math.min(totalPages, options?.page ?? 1))
-    const paged = options?.pageSize ? filtered.slice((page - 1) * options.pageSize, page * options?.pageSize) : filtered
+    const sorted = this.#sort(matched, options)
 
-    const sorted = this.#sort(paged, options?.sort)
+    const totalPages = options?.pageSize ? Math.ceil(matched.length / (options?.pageSize)) : 1
+    const pageNumber = Math.max(1, Math.min(totalPages, options?.page ?? 1))
+    const items = options?.pageSize ? sorted.slice((pageNumber - 1) * options.pageSize, pageNumber * options?.pageSize) : sorted
 
     return {
-      items: sorted,
-      page: page,
+      items: items,
+      pageIndex: pageNumber - 1,
+      pageNumber: pageNumber,
       pageSize: options?.pageSize,
-      totalItems: filtered.length,
-      totalPages: totalPages,
+      matchedItemCount: matched.length,
+      totalItemCount: this._values.length,
+      totalPageCount: totalPages,
     }
   }
 
   #satisfiesQueryPredicate(badge: Badge, query?: BadgeSearchOptions['query']): boolean {
     const queryString = query?.str?.toLowerCase() ?? ''
-    return !!(((query?.on?.name ?? true) && badge.name.canonical.some(x => x.value.toLowerCase().includes(queryString)))
-      || (query?.on?.badgeText && badge.badgeText.canonical.some(x => x.value.toLowerCase().includes(queryString)))
-      || (query?.on?.acquisition && badge.acquisition?.toLowerCase().includes(queryString))
-      || (query?.on?.effect && badge.effect?.toLowerCase().includes(queryString))
-      || (query?.on?.notes && badge.notes?.toLowerCase().includes(queryString))
-      || (query?.on?.setTitle && (badge.setTitleId?.some(x => x?.toString().includes(queryString)))))
+    const fields = query?.fields ? new Set(query?.fields) : new Set(['name']) // Default to name if not provided
+    if (fields.size === 0) return true
+
+    return !!((fields.has('name') && badge.name.canonical.some(x => x.value.toLowerCase().includes(queryString)))
+      || (fields.has('badge-text') && badge.badgeText.canonical.some(x => x.value.toLowerCase().includes(queryString)))
+      || (fields.has('acquisition') && badge.acquisition?.toLowerCase().includes(queryString))
+      || (fields.has('effect') && badge.effect?.toLowerCase().includes(queryString))
+      || (fields.has('notes') && badge.notes?.toLowerCase().includes(queryString))
+      || (fields.has('set-title-id') && (badge.setTitleId?.primal.toString() === queryString))
+      || (fields.has('set-title-id') && (badge.setTitleId?.praetorian?.toString() === queryString))
+    )
   }
 
   #satisfiesFilterPredicate(badge: Badge, filter?: BadgeSearchOptions['filter']): boolean {
     return (!filter?.type || badge.type === filter.type)
       && (!filter?.zoneKey || badge.zoneKey === filter.zoneKey)
       && (!filter?.morality || badge.morality.has(filter.morality))
+      && (!filter?.predicate || filter.predicate(badge))
   }
 
-  #sort(badges: Badge[], sort?: BadgeSearchOptions['sort']): Badge[] {
-    if (!sort) return badges
-    const ascending = sort.dir !== 'desc'
-
-    if (sort.by === 'badge-name') return badges.sort((a, b) => ascending ? compareByDefaultName(a, b) : compareByDefaultName(b, a))
-
-    if (sort.by === 'zone-key') return badges.sort((a, b) => ascending ? compareByZoneKey(a, b) : compareByZoneKey(b, a))
-
-    return sort.dir === 'desc' ? badges.reverse() : badges
+  #sort(badges: Badge[], options?: BadgeSearchOptions): Badge[] {
+    switch (options?.sort) {
+      case 'name.asc': {
+        return badges.toSorted((a, b) => compareByName(a, b, options.context))
+      }
+      case 'name.desc': {
+        return badges.toSorted((a, b) => compareByName(b, a, options.context))
+      }
+      case 'zone-key.asc': {
+        return badges.toSorted(compareByZoneKey)
+      }
+      case 'zone-key.desc': {
+        return badges.toSorted((a, b) => compareByZoneKey(b, a))
+      }
+      case 'release-date.asc': {
+        return badges.toSorted(compareByReleaseDate)
+      }
+      case 'release-date.desc': {
+        return badges.toSorted((a, b) => compareByReleaseDate(b, a))
+      }
+      case 'canonical.desc': {
+        return badges.toReversed()
+      }
+      default: {
+        return [...badges]
+      }
+    }
   }
 }

package/src/main/db/badge-requirement.ts

@@ -5,7 +5,7 @@ import { Key } from './key'
 import { MarkdownString } from '../api/markdown-string'
 import { Link } from '../api/link'
 import { Location } from './location'
-import { coalesceToArray } from '../util'
+import { coalesceToArray } from '../util/coalesce-to-array'
 
 export class BadgeRequirement {
   /**

package/src/main/db/badge-search-options.ts

@@ -1,5 +1,10 @@
 import { BadgeType } from '../api/badge-type'
-import { MoralityExtended } from '../api/morality'
+import { Morality } from '../api/morality'
+import { Badge } from './badge'
+import { VariantContext } from '../api/variant-context'
+
+export type BadgeQueryableField = 'name' | 'badge-text' | 'acquisition' | 'notes' | 'effect' | 'set-title-id'
+export type BadgeSort = `${'canonical' | 'name' | 'zone-key' | 'release-date'}.${'asc' | 'desc'}`
 
 export interface BadgeSearchOptions {
 
@@ -10,14 +15,7 @@ export interface BadgeSearchOptions {
    */
   query?: {
     str?: string
-    on?: {
-      name?: boolean
-      badgeText?: boolean
-      acquisition?: boolean
-      notes?: boolean
-      effect?: boolean
-      setTitle?: boolean
-    }
+    fields?: BadgeQueryableField[]
   }
 
   /**
@@ -26,18 +24,21 @@ export interface BadgeSearchOptions {
   filter?: {
     type?: BadgeType
     zoneKey?: string
-    morality?: MoralityExtended
+    morality?: Morality
+    predicate?: (badge: Badge) => boolean
   }
 
+  /**
+   * Adjust search results based on a given variant context (morality or sex of a character).
+   */
+  context?: VariantContext
+
   /**
    * Sort results.
    *
    * Badges are assumed to be in canonical order in the content bundle, and should match the in-game display order.
    */
-  sort?: {
-    by?: 'canonical' | 'badge-name' | 'zone-key'
-    dir?: 'asc' | 'desc'
-  }
+  sort?: BadgeSort
 
   /**
    * The page (1-based)

package/src/main/db/badge.ts

@@ -3,13 +3,17 @@ import { Link } from '../api/link'
 import { BadgeData } from '../api/badge-data'
 import { BadgeRequirement } from './badge-requirement'
 import { Key } from './key'
-import { Alternates } from './alternates'
+import { Variants } from './variants'
 import { MarkdownString } from '../api/markdown-string'
-import { coalesceToArray } from '../util'
 import { MoralityList } from './morality-list'
+import { AbstractIndex } from './abstract-index'
+import { toDate } from '../util/to-date'
+import { coalesceToArray } from '../util/coalesce-to-array'
+import { SetTitleIds } from './set-title-ids'
+import { VariantContext } from '../api/variant-context'
 
 export class Badge {
-  readonly #requirementsIndex: Record<string, BadgeRequirement> = {}
+  readonly #requirementsIndex: AbstractIndex<BadgeRequirement>
   readonly #zoneKeys = new Set<string>()
 
   /**
@@ -27,7 +31,12 @@ export class Badge {
    *
    * May vary by character sex or alignment.
    */
-  readonly name: Alternates<string>
+  readonly name: Variants<string>
+
+  /**
+   * The date that the badge was added to the game.
+   */
+  readonly releaseDate: Date
 
   /**
    * The character moralities that this badge is available to.
@@ -37,7 +46,7 @@ export class Badge {
   /**
    * The badge text as it appears in-game. May vary by character sex or alignment.
    */
-  readonly badgeText: Alternates<MarkdownString>
+  readonly badgeText: Variants<MarkdownString>
 
   /**
    * Short description of how to acquire the badge. Detailed instructions will be in the notes field.
@@ -49,7 +58,7 @@ export class Badge {
    *
    * May vary by character sex or alignment.
    */
-  readonly icon: Alternates<string>
+  readonly icon: Variants<string>
 
   /**
    * Freeform notes or tips about the badge.
@@ -65,18 +74,13 @@ export class Badge {
    * The id used with the in-game `/settitle` command to apply the badge.
    * The first value is the id for primal characters and the (optional) second number is the id for praetorian characters.
    */
-  readonly setTitleId?: [number, number?]
+  readonly setTitleId?: SetTitleIds
 
   /**
    * A description of the effect the badge will have, such as a buff or granting a temporary power.
    */
   readonly effect?: MarkdownString
 
-  /**
-   * Represents the requirements for badges with multiple fulfillment steps, such as visiting monuments for history badges, completing missions, or collecting other badges.
-   */
-  readonly requirements?: BadgeRequirement[]
-
   /**
    * Some badges are not included in the badge total count... such as Flames of Prometheus, which can be removed by redeeming it for a Notice of the Well.
    */
@@ -85,32 +89,36 @@ export class Badge {
   constructor(badgeData: BadgeData) {
     this.key = new Key(badgeData.key).value
     this.type = badgeData.type
-    this.name = new Alternates(badgeData.name)
+    this.name = new Variants(badgeData.name)
+    this.releaseDate = toDate(badgeData.releaseDate)
     this.morality = new MoralityList(coalesceToArray(badgeData.morality))
-    this.badgeText = new Alternates(badgeData.badgeText ?? [])
+    this.badgeText = new Variants(badgeData.badgeText ?? [])
     this.acquisition = badgeData.acquisition
-    this.icon = new Alternates(badgeData.icon ?? [])
+    this.icon = new Variants(badgeData.icon ?? [])
     this.notes = badgeData.notes
     this.links = badgeData.links ?? []
     this.effect = badgeData.effect
-    this.setTitleId = badgeData.setTitleId
+    this.setTitleId = badgeData.setTitleId ? new SetTitleIds(badgeData.setTitleId) : undefined
     this.ignoreInTotals = badgeData.ignoreInTotals ?? false
 
-    this.requirements = badgeData.requirements?.map((requirementData) => {
-      if (this.#requirementsIndex[requirementData.key]) throw new Error(`Duplicate badge requirement key [${badgeData.key}:${requirementData.key}]`)
-      const requirement = new BadgeRequirement(requirementData)
-      this.#requirementsIndex[requirement.key] = requirement
+    this.#requirementsIndex = new AbstractIndex<BadgeRequirement>('key', badgeData.requirements?.map(x => new BadgeRequirement(x)))
+
+    for (const requirement of this.#requirementsIndex.values) {
       if (requirement.location) for (const location of requirement.location) {
         if (location.zoneKey) this.#zoneKeys.add(location.zoneKey)
       }
-      return requirement
-    })
+    }
   }
 
-  getRequirement(key: string): BadgeRequirement {
-    const result = this.#requirementsIndex[key]
-    if (result === undefined) throw new Error(`Unknown badge requirement key [${key}]`)
-    return result
+  /**
+   * Represents the requirements for badges with multiple fulfillment steps, such as visiting monuments for history badges, completing missions, or collecting other badges.
+   */
+  get requirements(): BadgeRequirement[] {
+    return this.#requirementsIndex.values
+  }
+
+  getRequirement(key: string): BadgeRequirement | undefined {
+    return this.#requirementsIndex.get(key)
   }
 
   /**
@@ -128,9 +136,9 @@ export class Badge {
   }
 }
 
-export function compareByDefaultName(a?: Badge, b?: Badge): number {
-  const aName = a?.name.default?.value
-  const bName = b?.name.default?.value
+export function compareByName(a?: Badge, b?: Badge, context?: VariantContext): number {
+  const aName = a?.name?.getValue(context)
+  const bName = b?.name?.getValue(context)
   if (!aName && !bName) return 0
   if (!aName) return 1
   if (!bName) return -1
@@ -145,3 +153,12 @@ export function compareByZoneKey(a?: Badge, b?: Badge): number {
   if (!bZone) return -1
   return aZone.localeCompare(bZone)
 }
+
+export function compareByReleaseDate(a?: Badge, b?: Badge): number {
+  const aReleaseDate = a?.releaseDate?.getTime()
+  const bReleaseDate = b?.releaseDate?.getTime()
+  if (aReleaseDate === bReleaseDate) return 0
+  if (!aReleaseDate) return 1
+  if (!bReleaseDate) return -1
+  return aReleaseDate < bReleaseDate ? -1 : 1
+}

package/src/main/db/bundle-header.ts

@@ -1,12 +1,23 @@
 import { Link } from '../api/link'
 import { MarkdownString } from '../api/markdown-string'
 import { BundleHeaderData } from '../api/bundle-header-data'
+import { toDate } from '../util/to-date'
 
 export class BundleHeader {
   /**
-   * Name of the content bundle.
+   * Name of the fork this bundle contains data for.
    */
-  readonly name?: string
+  readonly name: string
+
+  /**
+   * Version number for this data package.
+   */
+  readonly version: string
+
+  /**
+   * The time this bundle was last updated.
+   */
+  readonly lastUpdateTime: Date
 
   /**
    * Description of the fork.
@@ -28,17 +39,14 @@ export class BundleHeader {
    */
   readonly links?: Link[]
 
-  /**
-   * The current version of the data package.
-   */
-  readonly version?: string
-
-  constructor(data: BundleHeaderData | undefined) {
-    this.name = data?.name
+  constructor(data: BundleHeaderData) {
+    if (!data) throw new Error('Missing header data')
+    this.name = data.name
+    this.version = data.version
+    this.lastUpdateTime = toDate(data.lastUpdateTime)
     this.description = data?.description
     this.repositoryUrl = data?.repositoryUrl
     this.changelogUrl = data?.changelogUrl
     this.links = data?.links ?? []
-    this.version = data?.version
   }
 }