@fluenti/solid 0.1.0

package/src/context.ts

@@ -0,0 +1,337 @@
+import { createSignal, createRoot, type Accessor } from 'solid-js'
+import { formatDate, formatNumber, interpolate as coreInterpolate, buildICUMessage, resolveDescriptorId } from '@fluenti/core'
+import type { FluentConfig, Locale, Messages, CompiledMessage, MessageDescriptor, DateFormatOptions, NumberFormatOptions } from '@fluenti/core'
+
+/** Chunk loader for lazy locale loading */
+export type ChunkLoader = (
+  locale: string,
+) => Promise<Record<string, CompiledMessage> | { default: Record<string, CompiledMessage> }>
+
+interface SplitRuntimeModule {
+  __switchLocale?: (locale: string) => Promise<void>
+  __preloadLocale?: (locale: string) => Promise<void>
+}
+
+const SPLIT_RUNTIME_KEY = Symbol.for('fluenti.runtime.solid')
+
+function getSplitRuntimeModule(): SplitRuntimeModule | null {
+  const runtime = (globalThis as Record<PropertyKey, unknown>)[SPLIT_RUNTIME_KEY]
+  return typeof runtime === 'object' && runtime !== null
+    ? runtime as SplitRuntimeModule
+    : null
+}
+
+function resolveChunkMessages(
+  loaded: Record<string, CompiledMessage> | { default: Record<string, CompiledMessage> },
+): Record<string, CompiledMessage> {
+  return typeof loaded === 'object' && loaded !== null && 'default' in loaded
+    ? (loaded as { default: Record<string, CompiledMessage> }).default
+    : loaded
+}
+
+/** Extended config with lazy locale loading support */
+export interface I18nConfig extends FluentConfig {
+  /** Async chunk loader for lazy locale loading */
+  chunkLoader?: ChunkLoader
+  /** Enable lazy locale loading through chunkLoader */
+  lazyLocaleLoading?: boolean
+  /** Locale-specific fallback chains */
+  fallbackChain?: Record<string, Locale[]>
+  /** Named date format styles */
+  dateFormats?: DateFormatOptions
+  /** Named number format styles */
+  numberFormats?: NumberFormatOptions
+}
+
+/** Reactive i18n context holding locale signal and translation utilities */
+export interface I18nContext {
+  /** Reactive accessor for the current locale */
+  locale(): Locale
+  /** Set the active locale (async when lazy locale loading is enabled) */
+  setLocale(locale: Locale): Promise<void>
+  /** Translate a message by id with optional interpolation values */
+  t(id: string | MessageDescriptor, values?: Record<string, unknown>): string
+  /** Tagged template form: t`Hello ${name}` */
+  t(strings: TemplateStringsArray, ...exprs: unknown[]): string
+  /** Merge additional messages into a locale catalog at runtime */
+  loadMessages(locale: Locale, messages: Messages): void
+  /** Return all locale codes that have loaded messages */
+  getLocales(): Locale[]
+  /** Format a date value for the current locale */
+  d(value: Date | number, style?: string): string
+  /** Format a number value for the current locale */
+  n(value: number, style?: string): string
+  /** Format an ICU message string directly (no catalog lookup) */
+  format(message: string, values?: Record<string, unknown>): string
+  /** Whether a locale chunk is currently being loaded */
+  isLoading: Accessor<boolean>
+  /** Set of locales whose messages have been loaded */
+  loadedLocales: Accessor<Set<string>>
+  /** Preload a locale in the background without switching to it */
+  preloadLocale(locale: string): void
+}
+
+/**
+ * Create a reactive i18n context backed by Solid signals.
+ *
+ * The returned `t()` reads the internal `locale()` signal, so any
+ * Solid computation that calls `t()` will re-run when the locale changes.
+ */
+export function createI18nContext(config: FluentConfig | I18nConfig): I18nContext {
+  const [locale, setLocaleSignal] = createSignal<Locale>(config.locale)
+  const [isLoading, setIsLoading] = createSignal(false)
+  const loadedLocalesSet = new Set<string>([config.locale])
+  const [loadedLocales, setLoadedLocales] = createSignal(new Set(loadedLocalesSet))
+  const messages: Record<string, Messages> = { ...config.messages }
+  const i18nConfig = config as I18nConfig
+  const lazyLocaleLoading = i18nConfig.lazyLocaleLoading
+    ?? (config as I18nConfig & { splitting?: boolean }).splitting
+    ?? false
+
+  function lookupCatalog(
+    id: string,
+    loc: Locale,
+    values?: Record<string, unknown>,
+  ): string | undefined {
+    const catalog = messages[loc]
+    if (!catalog) {
+      return undefined
+    }
+
+    const msg = catalog[id]
+    if (msg === undefined) {
+      return undefined
+    }
+
+    if (typeof msg === 'function') {
+      return msg(values)
+    }
+
+    if (typeof msg === 'string' && values) {
+      return coreInterpolate(msg, values, loc)
+    }
+
+    return String(msg)
+  }
+
+  function lookupWithFallbacks(
+    id: string,
+    loc: Locale,
+    values?: Record<string, unknown>,
+  ): string | undefined {
+    const localesToTry: Locale[] = [loc]
+    const seen = new Set(localesToTry)
+
+    if (config.fallbackLocale && !seen.has(config.fallbackLocale)) {
+      localesToTry.push(config.fallbackLocale)
+      seen.add(config.fallbackLocale)
+    }
+
+    const chainLocales = i18nConfig.fallbackChain?.[loc] ?? i18nConfig.fallbackChain?.['*']
+    if (chainLocales) {
+      for (const chainLocale of chainLocales) {
+        if (!seen.has(chainLocale)) {
+          localesToTry.push(chainLocale)
+          seen.add(chainLocale)
+        }
+      }
+    }
+
+    for (const targetLocale of localesToTry) {
+      const result = lookupCatalog(id, targetLocale, values)
+      if (result !== undefined) {
+        return result
+      }
+    }
+
+    return undefined
+  }
+
+  function resolveMissing(
+    id: string,
+    loc: Locale,
+  ): string | undefined {
+    if (!config.missing) {
+      return undefined
+    }
+
+    const result = config.missing(loc, id)
+    if (result !== undefined) {
+      return result
+    }
+    return undefined
+  }
+
+  function resolveMessage(
+    id: string,
+    loc: Locale,
+    values?: Record<string, unknown>,
+  ): string {
+    const catalogResult = lookupWithFallbacks(id, loc, values)
+    if (catalogResult !== undefined) {
+      return catalogResult
+    }
+
+    const missingResult = resolveMissing(id, loc)
+    if (missingResult !== undefined) {
+      return missingResult
+    }
+
+    if (id.includes('{')) {
+      return coreInterpolate(id, values, loc)
+    }
+
+    return id
+  }
+
+  function t(strings: TemplateStringsArray, ...exprs: unknown[]): string
+  function t(id: string | MessageDescriptor, values?: Record<string, unknown>): string
+  function t(idOrStrings: string | MessageDescriptor | TemplateStringsArray, ...rest: unknown[]): string {
+    // Tagged template form: t`Hello ${name}`
+    if (Array.isArray(idOrStrings) && 'raw' in idOrStrings) {
+      const strings = idOrStrings as TemplateStringsArray
+      const icu = buildICUMessage(strings, rest)
+      const values = Object.fromEntries(rest.map((v, i) => [String(i), v]))
+      return t(icu, values)
+    }
+
+    const id = idOrStrings as string | MessageDescriptor
+    const values = rest[0] as Record<string, unknown> | undefined
+    const currentLocale = locale() // reactive dependency
+    if (typeof id === 'object' && id !== null) {
+      const messageId = resolveDescriptorId(id)
+      if (messageId) {
+        const catalogResult = lookupWithFallbacks(messageId, currentLocale, values)
+        if (catalogResult !== undefined) {
+          return catalogResult
+        }
+
+        const missingResult = resolveMissing(messageId, currentLocale)
+        if (missingResult !== undefined) {
+          return missingResult
+        }
+      }
+
+      if (id.message !== undefined) {
+        return coreInterpolate(id.message, values, currentLocale)
+      }
+
+      return messageId ?? ''
+    }
+
+    return resolveMessage(id, currentLocale, values)
+  }
+
+  const loadMessages = (loc: Locale, msgs: Messages): void => {
+    messages[loc] = { ...messages[loc], ...msgs }
+    loadedLocalesSet.add(loc)
+    setLoadedLocales(new Set(loadedLocalesSet))
+  }
+
+  const setLocale = async (newLocale: Locale): Promise<void> => {
+    if (!lazyLocaleLoading || !i18nConfig.chunkLoader) {
+      setLocaleSignal(newLocale)
+      return
+    }
+
+    const splitRuntime = getSplitRuntimeModule()
+
+    if (loadedLocalesSet.has(newLocale)) {
+      if (splitRuntime?.__switchLocale) {
+        await splitRuntime.__switchLocale(newLocale)
+      }
+      setLocaleSignal(newLocale)
+      return
+    }
+
+    setIsLoading(true)
+    try {
+      const loaded = resolveChunkMessages(await i18nConfig.chunkLoader(newLocale))
+      messages[newLocale] = { ...messages[newLocale], ...loaded }
+      loadedLocalesSet.add(newLocale)
+      setLoadedLocales(new Set(loadedLocalesSet))
+      if (splitRuntime?.__switchLocale) {
+        await splitRuntime.__switchLocale(newLocale)
+      }
+      setLocaleSignal(newLocale)
+    } finally {
+      setIsLoading(false)
+    }
+  }
+
+  const preloadLocale = (loc: string): void => {
+    if (!lazyLocaleLoading || loadedLocalesSet.has(loc) || !i18nConfig.chunkLoader) return
+    const splitRuntime = getSplitRuntimeModule()
+    i18nConfig.chunkLoader(loc).then(async (loaded) => {
+      const resolved = resolveChunkMessages(loaded)
+      messages[loc] = { ...messages[loc], ...resolved }
+      loadedLocalesSet.add(loc)
+      setLoadedLocales(new Set(loadedLocalesSet))
+      if (splitRuntime?.__preloadLocale) {
+        await splitRuntime.__preloadLocale(loc)
+      }
+    }).catch(() => {
+      // Silent failure for preload
+    })
+  }
+
+  const getLocales = (): Locale[] => Object.keys(messages)
+
+  const d = (value: Date | number, style?: string): string =>
+    formatDate(value, locale(), style, i18nConfig.dateFormats)
+
+  const n = (value: number, style?: string): string =>
+    formatNumber(value, locale(), style, i18nConfig.numberFormats)
+
+  const format = (message: string, values?: Record<string, unknown>): string => {
+    return coreInterpolate(message, values, locale())
+  }
+
+  return { locale, setLocale, t, loadMessages, getLocales, d, n, format, isLoading, loadedLocales, preloadLocale }
+}
+
+// ─── Module-level singleton ─────────────────────────────────────────────────
+
+let globalCtx: I18nContext | undefined
+
+/**
+ * Initialize the global i18n singleton.
+ *
+ * Call once at app startup (e.g. in your entry file) before any `useI18n()`.
+ * Signals are created inside a `createRoot` so they outlive any component scope.
+ *
+ * Returns the context for convenience, but `useI18n()` will also find it.
+ */
+export function createI18n(config: FluentConfig | I18nConfig): I18nContext {
+  const ctx = createRoot(() => createI18nContext(config))
+
+  // Only set global singleton in browser (client-side).
+  // In SSR, each request should use <I18nProvider> for per-request isolation.
+  if (typeof window !== 'undefined') {
+    globalCtx = ctx
+  } else {
+    console.warn(
+      '[fluenti] createI18n() detected SSR environment. ' +
+      'Use <I18nProvider> for per-request isolation in SSR.',
+    )
+    // Still set globalCtx as fallback, but document the risk
+    globalCtx = ctx
+  }
+
+  return ctx
+}
+
+/** @internal — used by useI18n and I18nProvider */
+export function getGlobalI18nContext(): I18nContext | undefined {
+  return globalCtx
+}
+
+/** @internal — used by I18nProvider to set context without createRoot wrapper */
+export function setGlobalI18nContext(ctx: I18nContext): void {
+  globalCtx = ctx
+}
+
+/** @internal — reset the global singleton (for testing only) */
+export function resetGlobalI18nContext(): void {
+  globalCtx = undefined
+}

package/src/hooks/__useI18n.ts

@@ -0,0 +1,15 @@
+import { useI18n } from '../use-i18n'
+import type { I18nContext } from '../types'
+
+/**
+ * Internal hook used by the Vite plugin's compiled output.
+ * Returns the i18n context for direct t() calls.
+ *
+ * **Not part of the public API.** Users never write this — the Vite plugin
+ * generates imports of this hook automatically.
+ *
+ * @internal
+ */
+export function __useI18n(): I18nContext {
+  return useI18n()
+}

package/src/index.ts

@@ -0,0 +1,14 @@
+export { createI18nContext, createI18n } from './context'
+export type { I18nContext, I18nConfig } from './context'
+export { I18nProvider, I18nCtx } from './provider'
+export { useI18n } from './use-i18n'
+export { t } from './compile-time-t'
+export { Trans } from './trans'
+export type { TransProps } from './trans'
+export { Plural } from './plural'
+export type { PluralProps } from './plural'
+export { SelectComp as Select } from './select'
+export type { SelectProps } from './select'
+export { msg } from './msg'
+export { DateTime } from './components/DateTime'
+export { NumberFormat } from './components/NumberFormat'

package/src/msg.ts

@@ -0,0 +1,4 @@
+// Re-export msg from @fluenti/core
+// msg`` is the only Fluenti API that requires an explicit import,
+// because it's used outside the component tree where auto-injection can't work.
+export { msg } from '@fluenti/core'

package/src/plural.tsx

@@ -0,0 +1,136 @@
+import { Dynamic } from 'solid-js/web'
+import type { Component, JSX } from 'solid-js'
+import { hashMessage } from '@fluenti/core'
+import { useI18n } from './use-i18n'
+import { reconstruct, serializeRichForms } from './rich-dom'
+
+/** Plural category names in a stable order for ICU message building. */
+const PLURAL_CATEGORIES = ['zero', 'one', 'two', 'few', 'many', 'other'] as const
+
+type PluralCategory = (typeof PLURAL_CATEGORIES)[number]
+
+/**
+ * Build an ICU plural message string from individual category props.
+ *
+ * Given `{ zero: "No items", one: "# item", other: "# items" }`,
+ * produces `"{count, plural, =0 {No items} one {# item} other {# items}}"`.
+ *
+ * @internal
+ */
+function buildICUPluralMessage(
+  forms: Partial<Record<PluralCategory, string>> & { other: string },
+  offset?: number,
+): string {
+  const parts: string[] = []
+  for (const cat of PLURAL_CATEGORIES) {
+    const text = forms[cat]
+    if (text !== undefined) {
+      // Map the `zero` prop to ICU `=0` exact match. In ICU MessageFormat,
+      // `zero` is a CLDR plural category that only activates in languages
+      // with a grammatical zero form (e.g. Arabic). The `=0` exact match
+      // works universally for the common "show this when count is 0" intent.
+      const key = cat === 'zero' ? '=0' : cat
+      parts.push(`${key} {${text}}`)
+    }
+  }
+  const offsetPrefix = offset ? `offset:${offset} ` : ''
+  return `{count, plural, ${offsetPrefix}${parts.join(' ')}}`
+}
+
+/** Props for the `<Plural>` component */
+export interface PluralProps {
+  /** The numeric value to pluralise */
+  value: number
+  /** Override the auto-generated synthetic ICU message id */
+  id?: string
+  /** Message context used for identity and translator disambiguation */
+  context?: string
+  /** Translator-facing note preserved in extraction catalogs */
+  comment?: string
+  /** Offset from value before selecting form */
+  offset?: number
+  /** Message for the "zero" plural category */
+  zero?: string | JSX.Element
+  /** Message for the "one" plural category */
+  one?: string | JSX.Element
+  /** Message for the "two" plural category */
+  two?: string | JSX.Element
+  /** Message for the "few" plural category */
+  few?: string | JSX.Element
+  /** Message for the "many" plural category */
+  many?: string | JSX.Element
+  /** Fallback message when no category-specific prop matches */
+  other: string | JSX.Element
+  /** Wrapper element tag name (default: `'span'`) */
+  tag?: string
+}
+
+/**
+ * `<Plural>` component — shorthand for ICU plural patterns.
+ *
+ * Plural form props (`zero`, `one`, `two`, `few`, `many`, `other`) are treated
+ * as source-language messages. The component builds an ICU plural message,
+ * looks it up via `t()` in the catalog, and interpolates the translated result.
+ *
+ * When no catalog translation exists, the component falls back to interpolating
+ * the source-language ICU message directly via core's `interpolate`.
+ *
+ * Rich text is supported via JSX element props:
+ * ```tsx
+ * <Plural
+ *   value={count()}
+ *   zero={<>No <strong>items</strong> left</>}
+ *   one={<><em>1</em> item remaining</>}
+ *   other={<><strong>{count()}</strong> items remaining</>}
+ * />
+ * ```
+ *
+ * String props still work (backward compatible):
+ * ```tsx
+ * <Plural value={count()} zero="No items" one="# item" other="# items" />
+ * ```
+ */
+export const Plural: Component<PluralProps> = (props) => {
+  const { t } = useI18n()
+
+  /** Resolve a category prop value — handles string, accessor function, and JSX */
+  function resolveProp(val: string | JSX.Element | undefined): string | JSX.Element | undefined {
+    if (typeof val === 'function') return (val as () => string | JSX.Element)()
+    return val
+  }
+
+  return (() => {
+    // Resolve all category values (handles Solid accessors from createMemo)
+    const resolvedValues: Partial<Record<PluralCategory, string | JSX.Element>> = {}
+    for (const cat of PLURAL_CATEGORIES) {
+      const resolved = resolveProp(props[cat])
+      if (resolved !== undefined) {
+        resolvedValues[cat] = resolved
+      }
+    }
+    const { messages, components } = serializeRichForms(PLURAL_CATEGORIES, resolvedValues)
+    const icuMessage = buildICUPluralMessage(
+      {
+        ...(messages['zero'] !== undefined && { zero: messages['zero'] }),
+        ...(messages['one'] !== undefined && { one: messages['one'] }),
+        ...(messages['two'] !== undefined && { two: messages['two'] }),
+        ...(messages['few'] !== undefined && { few: messages['few'] }),
+        ...(messages['many'] !== undefined && { many: messages['many'] }),
+        other: messages['other'] ?? '',
+      },
+      props.offset,
+    )
+
+    const translated = t(
+      {
+        id: props.id ?? (props.context === undefined ? icuMessage : hashMessage(icuMessage, props.context)),
+        message: icuMessage,
+        ...(props.context !== undefined ? { context: props.context } : {}),
+        ...(props.comment !== undefined ? { comment: props.comment } : {}),
+      },
+      { count: props.value },
+    )
+
+    return (<Dynamic component={props.tag ?? 'span'}>{components.length > 0 ? reconstruct(translated, components) : translated}</Dynamic>) as JSX.Element
+  }) as unknown as JSX.Element
+}

package/src/provider.tsx

@@ -0,0 +1,16 @@
+import { createContext } from 'solid-js'
+import type { ParentComponent } from 'solid-js'
+import { createI18nContext } from './context'
+import type { I18nConfig, I18nContext } from './context'
+
+/** Solid context object for i18n — used internally by useI18n() */
+export const I18nCtx = createContext<I18nContext>()
+
+/**
+ * Provide i18n context to the component tree.
+ *
+ */
+export const I18nProvider: ParentComponent<I18nConfig> = (props) => {
+  const ctx = createI18nContext(props)
+  return <I18nCtx.Provider value={ctx}>{props.children}</I18nCtx.Provider>
+}

package/src/rich-dom.tsx

@@ -0,0 +1,170 @@
+import type { JSX } from 'solid-js'
+
+function isNodeLike(value: unknown): value is Node {
+  return typeof Node !== 'undefined' && value instanceof Node
+}
+
+function resolveValue(value: unknown): unknown {
+  if (typeof value === 'function' && !(value as { length?: number }).length) {
+    return (value as () => unknown)()
+  }
+  return value
+}
+
+export function offsetIndices(message: string, offset: number): string {
+  if (offset === 0) return message
+  return message
+    .replace(/<(\d+)(\/?>)/g, (_match, index: string, suffix: string) => `<${Number(index) + offset}${suffix}`)
+    .replace(/<\/(\d+)>/g, (_match, index: string) => `</${Number(index) + offset}>`)
+}
+
+export function extractMessage(value: unknown): {
+  message: string
+  components: Node[]
+} {
+  const components: Node[] = []
+  let message = ''
+
+  function visit(node: unknown): void {
+    const resolved = resolveValue(node)
+    if (resolved === null || resolved === undefined || typeof resolved === 'boolean') return
+    if (Array.isArray(resolved)) {
+      for (const child of resolved) visit(child)
+      return
+    }
+    if (typeof resolved === 'string' || typeof resolved === 'number') {
+      message += String(resolved)
+      return
+    }
+    if (!isNodeLike(resolved)) return
+    if (resolved.nodeType === Node.TEXT_NODE) {
+      message += resolved.textContent ?? ''
+      return
+    }
+    if (resolved.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
+      visit(Array.from(resolved.childNodes))
+      return
+    }
+
+    const idx = components.length
+    const inner = extractMessage(Array.from(resolved.childNodes))
+    components.push((resolved as Element).cloneNode(false))
+    components.push(...inner.components)
+    message += `<${idx}>${offsetIndices(inner.message, idx + 1)}</${idx}>`
+  }
+
+  visit(value)
+  return { message, components }
+}
+
+function appendChild(parent: Node, child: unknown): void {
+  const resolved = resolveValue(child)
+  if (resolved === null || resolved === undefined || typeof resolved === 'boolean') return
+  if (Array.isArray(resolved)) {
+    for (const entry of resolved) appendChild(parent, entry)
+    return
+  }
+  if (typeof resolved === 'string' || typeof resolved === 'number') {
+    parent.appendChild(document.createTextNode(String(resolved)))
+    return
+  }
+  if (isNodeLike(resolved)) {
+    parent.appendChild(resolved)
+  }
+}
+
+export function reconstruct(
+  translated: string,
+  components: Node[],
+): JSX.Element {
+  const tagRe = /<(\d+)>([\s\S]*?)<\/\1>/g
+  const result: unknown[] = []
+  let lastIndex = 0
+  let match: RegExpExecArray | null
+
+  tagRe.lastIndex = 0
+  match = tagRe.exec(translated)
+  while (match !== null) {
+    if (match.index > lastIndex) {
+      result.push(translated.slice(lastIndex, match.index))
+    }
+
+    const idx = Number(match[1])
+    const template = components[idx]
+    const inner = reconstruct(match[2]!, components)
+    if (template) {
+      const clone = template.cloneNode(false)
+      appendChild(clone, inner)
+      result.push(clone)
+    } else {
+      result.push(match[2]!)
+    }
+
+    lastIndex = tagRe.lastIndex
+    match = tagRe.exec(translated)
+  }
+
+  if (lastIndex < translated.length) {
+    result.push(translated.slice(lastIndex))
+  }
+
+  return (result.length <= 1 ? result[0] ?? '' : result) as JSX.Element
+}
+
+export function serializeRichForms<T extends string>(
+  keys: readonly T[],
+  forms: Partial<Record<T, unknown>> & Record<string, unknown>,
+): {
+  messages: Record<string, string>
+  components: Node[]
+} {
+  const messages: Record<string, string> = {}
+  const components: Node[] = []
+
+  for (const key of keys) {
+    const value = forms[key]
+    if (value === undefined) continue
+    const extracted = extractMessage(value)
+    messages[key] = offsetIndices(extracted.message, components.length)
+    components.push(...extracted.components)
+  }
+
+  for (const [key, value] of Object.entries(forms)) {
+    if (keys.includes(key as T) || value === undefined) continue
+    const extracted = extractMessage(value)
+    messages[key] = offsetIndices(extracted.message, components.length)
+    components.push(...extracted.components)
+  }
+
+  return { messages, components }
+}
+
+export function buildICUSelectMessage(forms: Record<string, string>): string {
+  return `{value, select, ${Object.entries(forms).map(([key, text]) => `${key} {${text}}`).join(' ')}}`
+}
+
+export function normalizeSelectForms(forms: Record<string, string>): {
+  forms: Record<string, string>
+  valueMap: Record<string, string>
+} {
+  const normalized: Record<string, string> = {}
+  const valueMap: Record<string, string> = {}
+  let index = 0
+
+  for (const [key, text] of Object.entries(forms)) {
+    if (key === 'other') {
+      normalized['other'] = text
+      continue
+    }
+
+    const safeKey = /^[A-Za-z0-9_]+$/.test(key) ? key : `case_${index++}`
+    normalized[safeKey] = text
+    valueMap[key] = safeKey
+  }
+
+  if (normalized['other'] === undefined) {
+    normalized['other'] = ''
+  }
+
+  return { forms: normalized, valueMap }
+}