index.ts

import fs from "fs"
import path from "path"
import { execSync } from "child_process"
import {
  Locale,
  requiredHeroFields,
  optionalHeroFields,
  saleStatuses,
  userStatuses,
} from "./Locale"
import { placeholderStrings } from "./runtimeUtils"
import type { Hero, RawHeroTree } from "./Locale"

// re-create `Locale.validator.ts` based of current contents of `Locale.ts`
execSync(`yarn create-validator-ts --skipTypeCheck ${__dirname}/Locale.ts`)

// now that we re-created the file we can import the latest version
const validate: (x: unknown) => Locale =
  require("./Locale.validator").validateLocale

class LocaleError extends Error {}

interface HeroSaleState {
  signedOut: Hero
  signedIn: Hero
  vip: Hero
}

export interface ExpandedHeroTree {
  saleClosed: HeroSaleState
  presale: HeroSaleState
  saleOpen: HeroSaleState
  allSold: HeroSaleState
}

export interface DecoratedLocale extends Locale {
  id: string
  hero: ExpandedHeroTree
}

function computeField({
  rawHeroTree,
  saleStatus,
  userStatus,
  required,
}: {
  rawHeroTree: RawHeroTree
  saleStatus: keyof ExpandedHeroTree
  userStatus: keyof HeroSaleState
  required: boolean
}) {
  return (hero: Partial<Hero>, field: keyof Hero) => {
    // @ts-expect-error Type 'string | undefined' is not assignable to type 'Action'
    hero[field] =
      rawHeroTree[saleStatus]?.[userStatus]?.[field] ??
      rawHeroTree[saleStatus]?.[field] ??
      rawHeroTree[field]
    if (required && typeof hero[field] === "undefined") {
      throw new LocaleError(
        `"hero" must include computable "${field}" in each branch; please include at least one of:\n` +
          `  • "hero.${field}"\n` +
          `  • "hero.${saleStatus}.${field}"\n` +
          `  • "hero.${saleStatus}.${userStatus}.${field}"\n` +
          `(if set in more than one of these, a more specific setting overrides a more general)`
      )
    }
    // warn if it looks like there might be an unknown placeholder string
    // ('action' field values are validated as part of the schema, so we can skip them here)
    const allCapsSubStrings =
      field !== "action" && hero[field]?.matchAll(/\b[A-Z_]+\b/g)
    Array.from(allCapsSubStrings || []).forEach(([possiblePlaceholder]) => {
      // TODO: update above regex to only match strings with underscores in them to avoid `.match('_')`
      if (
        possiblePlaceholder.match("_") &&
        !placeholderStrings.includes(possiblePlaceholder)
      ) {
        console.warn(
          `"hero" field "${field}" contains what looks like a placeholder string "${possiblePlaceholder}", ` +
            `but no substitution is available for this string. Did you mean to include one of the following?\n\n` +
            `  • ${placeholderStrings.join("\n  • ")}\n\n` +
            `The full text given for this field was:\n\n  ${hero[field]}\n\n`
        )
      }
    })
    return hero
  }
}

function hoistHeroFields(rawHeroTree: RawHeroTree): ExpandedHeroTree {
  return saleStatuses.reduce(
    (a, saleStatus) => ({
      ...a,
      [saleStatus]: userStatuses.reduce(
        (b, userStatus) => ({
          ...b,
          [userStatus]: {
            ...requiredHeroFields.reduce(
              computeField({
                rawHeroTree,
                saleStatus,
                userStatus,
                required: true,
              }),
              {}
            ),
            ...optionalHeroFields.reduce(
              computeField({
                rawHeroTree,
                saleStatus,
                userStatus,
                required: false,
              }),
              {}
            ),
          } as Hero,
        }),
        {} as HeroSaleState
      ),
    }),
    {} as ExpandedHeroTree
  )
}

// for use with `sort`
function alphabeticOrder(
  { id: a }: DecoratedLocale,
  { id: b }: DecoratedLocale
): -1 | 0 | 1 {
  if (a < b) {
    return -1
  } else if (a > b) {
    return 1
  } else {
    return 0
  }
}

const localesDirectory = path.resolve(process.cwd(), "config/i18n")

let fileNames: string[]
try {
  fileNames = fs.readdirSync(localesDirectory)
} catch {
  fileNames = []
}

const IS_JSON = /.json$/

export const locales: DecoratedLocale[] = fileNames
  .filter(f => IS_JSON.test(f))
  .map(fileName => {
    // Remove ".json" from file name to get id
    // TODO: validate that `id` is valid according to https://www.npmjs.com/package/iso-639-1
    const id = fileName.replace(/\.json$/, "")
    const fullPath = path.join(localesDirectory, fileName)
    const fileContents: unknown = JSON.parse(fs.readFileSync(fullPath, "utf8"))
    const i18n = validate(fileContents)

    let hero: ExpandedHeroTree
    try {
      hero = hoistHeroFields(i18n.hero)
    } catch (e: unknown) {
      if (e instanceof LocaleError) {
        throw new Error(`Error parsing ${fileName}:\n\n${e.message}`)
      }
      throw e
    }

    // Combine the data with the id
    return {
      id,
      ...i18n,
      hero,
    }
  })
  .sort(alphabeticOrder)