@open-mercato/core 0.6.8-develop.6925.1.cefa200fa4 → 0.6.8-develop.6930.1.1e5976efc3

package/src/modules/eudr/index.ts

@@ -0,0 +1,13 @@
+import type { ModuleInfo } from '@open-mercato/shared/modules/registry'
+
+export const metadata: ModuleInfo = {
+  name: 'eudr',
+  title: 'EUDR Compliance',
+  version: '0.1.0',
+  description: 'EU Deforestation Regulation compliance: product commodity mappings, supplier origin evidence, due diligence statements.',
+  author: 'Open Mercato Team',
+  license: 'MIT',
+  ejectable: true,
+}
+
+export { features } from './acl'

package/src/modules/eudr/lib/annual-report.ts

@@ -0,0 +1,120 @@
+import { z } from 'zod'
+import {
+  serializeExport,
+  type CrudExportColumn,
+  type PreparedExport,
+} from '@open-mercato/shared/lib/crud/exporters'
+
+const nonNegativeIntegerSchema = z.number().int().nonnegative()
+
+const supplementaryQuantitySchema = z.object({
+  unit: z.string(),
+  quantity: z.string(),
+})
+
+const commodityReportSchema = z.object({
+  commodity: z.string(),
+  count: nonNegativeIntegerSchema,
+  quantityKg: z.string(),
+  supplementaryQuantities: z.array(supplementaryQuantitySchema),
+})
+
+export const annualReportSchema = z.object({
+  year: z.number().int(),
+  generatedAt: z.string().datetime(),
+  statements: z.object({
+    total: nonNegativeIntegerSchema,
+    byStatus: z.record(z.string(), nonNegativeIntegerSchema),
+    byCommodity: z.array(commodityReportSchema),
+  }),
+  countries: z.array(z.object({
+    country: z.string(),
+    tier: z.string(),
+    submissionCount: nonNegativeIntegerSchema,
+  })).optional(),
+  risk: z.object({
+    assessments: nonNegativeIntegerSchema,
+    negligible: nonNegativeIntegerSchema,
+    nonNegligible: nonNegativeIntegerSchema,
+    simplified: nonNegativeIntegerSchema,
+  }).optional(),
+  mitigation: z.object({
+    total: nonNegativeIntegerSchema,
+    completed: nonNegativeIntegerSchema,
+  }).optional(),
+})
+
+export type AnnualReport = z.infer<typeof annualReportSchema>
+
+function parseThousandths(value: string | number | null): bigint | null {
+  if (value === null) return 0n
+  const normalized = typeof value === 'number' ? value.toFixed(3) : value.trim()
+  const match = /^([+-]?)(\d+)(?:\.(\d{1,3}))?$/.exec(normalized)
+  if (match === null) return null
+
+  const sign = match[1] === '-' ? -1n : 1n
+  const whole = BigInt(match[2]) * 1000n
+  const fraction = BigInt((match[3] ?? '').padEnd(3, '0') || '0')
+  return sign * (whole + fraction)
+}
+
+function formatThousandths(value: bigint): string {
+  const sign = value < 0n ? '-' : ''
+  const absolute = value < 0n ? -value : value
+  const whole = absolute / 1000n
+  const fraction = (absolute % 1000n).toString().padStart(3, '0')
+  return `${sign}${whole}.${fraction}`
+}
+
+export function accumulateSupplementaryQuantities(
+  rows: Array<{ unit: string | null; quantity: string | number | null }>,
+): Array<{ unit: string; quantity: string }> {
+  const quantities = new Map<string, bigint>()
+
+  for (const row of rows) {
+    const unit = row.unit?.trim().toUpperCase() ?? ''
+    if (unit.length === 0) continue
+    const quantity = parseThousandths(row.quantity)
+    if (quantity === null) continue
+    quantities.set(unit, (quantities.get(unit) ?? 0n) + quantity)
+  }
+
+  return Array.from(quantities, ([unit, quantity]) => ({
+    unit,
+    quantity: formatThousandths(quantity),
+  }))
+}
+
+const annualReportCsvColumns: CrudExportColumn[] = [
+  { field: 'commodity', header: 'commodity' },
+  { field: 'count', header: 'count' },
+  { field: 'quantityKg', header: 'quantityKg' },
+  { field: 'supplementaryUnit', header: 'supplementaryUnit' },
+  { field: 'supplementaryQuantity', header: 'supplementaryQuantity' },
+]
+
+export function buildAnnualReportCsv(report: AnnualReport): { content: string; contentType: string } {
+  const rows: PreparedExport['rows'] = report.statements.byCommodity.flatMap((commodity) => {
+    const supplementaryQuantities = commodity.supplementaryQuantities.length > 0
+      ? commodity.supplementaryQuantities
+      : [null]
+
+    return supplementaryQuantities.map((supplementaryQuantity) => ({
+      commodity: commodity.commodity,
+      count: commodity.count,
+      quantityKg: commodity.quantityKg,
+      supplementaryUnit: supplementaryQuantity?.unit ?? '',
+      supplementaryQuantity: supplementaryQuantity?.quantity ?? '',
+    }))
+  })
+  const prepared: PreparedExport = {
+    columns: annualReportCsvColumns,
+    rows,
+  }
+  const serialized = serializeExport(prepared, 'csv')
+
+  return {
+    content: serialized.body,
+    contentType: serialized.contentType,
+  }
+}

package/src/modules/eudr/lib/completeness.ts

@@ -0,0 +1,90 @@
+import { GEOJSON_TYPES } from '../data/validators'
+
+export const COMPLETENESS_DIMENSIONS = ['origin_country', 'geolocation', 'quantity', 'harvest_period', 'producer', 'documents'] as const
+export const REQUIRED_DIMENSIONS = COMPLETENESS_DIMENSIONS
+export type CompletenessDimension = (typeof COMPLETENESS_DIMENSIONS)[number]
+
+export type CompletenessInput = {
+  originCountry?: string | null
+  geolocation?: unknown
+  quantityKg?: string | number | null
+  harvestFrom?: Date | string | null
+  harvestTo?: Date | string | null
+  producerName?: string | null
+  attachmentIds?: string[] | null
+}
+
+export type CompletenessContext = {
+  linkedAttachmentCount?: number
+  activePlotCount?: number
+}
+
+export type CompletenessResult = { score: number; missingFields: CompletenessDimension[] }
+
+function isOriginCountryComplete(value: string | null | undefined): boolean {
+  return typeof value === 'string' && /^[A-Za-z]{2}$/.test(value.trim())
+}
+
+function isGeolocationComplete(value: unknown): boolean {
+  if (value === null || typeof value !== 'object') return false
+  const candidate = value as { type?: unknown }
+  return typeof candidate.type === 'string' && GEOJSON_TYPES.includes(candidate.type as (typeof GEOJSON_TYPES)[number])
+}
+
+function isQuantityComplete(value: string | number | null | undefined): boolean {
+  if (typeof value !== 'string' && typeof value !== 'number') return false
+  const quantity = Number(value)
+  return Number.isFinite(quantity) && quantity > 0
+}
+
+function parseDate(value: Date | string | null | undefined): Date | null {
+  if (value == null) return null
+  const date = value instanceof Date ? value : new Date(value)
+  return Number.isNaN(date.getTime()) ? null : date
+}
+
+function isHarvestPeriodComplete(harvestFrom: Date | string | null | undefined, harvestTo: Date | string | null | undefined): boolean {
+  const parsedHarvestFrom = parseDate(harvestFrom)
+  const parsedHarvestTo = parseDate(harvestTo)
+  return parsedHarvestFrom !== null && parsedHarvestTo !== null && parsedHarvestFrom <= parsedHarvestTo
+}
+
+function isProducerComplete(value: string | null | undefined): boolean {
+  return typeof value === 'string' && value.trim().length > 0
+}
+
+function isDocumentsComplete(value: string[] | null | undefined): boolean {
+  return Array.isArray(value) && value.length >= 1
+}
+
+export function computeCompleteness(input: CompletenessInput, context: CompletenessContext = {}): CompletenessResult {
+  const completionByDimension: Record<CompletenessDimension, boolean> = {
+    origin_country: isOriginCountryComplete(input.originCountry),
+    geolocation: isGeolocationComplete(input.geolocation) || (context.activePlotCount ?? 0) > 0,
+    quantity: isQuantityComplete(input.quantityKg),
+    harvest_period: isHarvestPeriodComplete(input.harvestFrom, input.harvestTo),
+    producer: isProducerComplete(input.producerName),
+    documents: isDocumentsComplete(input.attachmentIds) || (context.linkedAttachmentCount ?? 0) > 0,
+  }
+
+  const missingFields = COMPLETENESS_DIMENSIONS.filter((dimension) => !completionByDimension[dimension])
+  const metCount = COMPLETENESS_DIMENSIONS.length - missingFields.length
+  const score = Math.round((metCount / COMPLETENESS_DIMENSIONS.length) * 100)
+
+  return { score, missingFields }
+}
+
+export function computeSubmissionCompleteness(input: CompletenessInput, context?: CompletenessContext): CompletenessResult {
+  return computeCompleteness(input, context)
+}
+
+export const HARVEST_CUTOFF_DATE = new Date('2020-12-31T23:59:59.999Z')
+
+export function computeHarvestCutoffWarning(
+  harvestFrom: Date | string | null | undefined,
+  harvestTo: Date | string | null | undefined,
+): 'harvest_before_cutoff' | null {
+  const windowEnd = parseDate(harvestTo) ?? parseDate(harvestFrom)
+  if (!windowEnd) return null
+  return windowEnd.getTime() <= HARVEST_CUTOFF_DATE.getTime() ? 'harvest_before_cutoff' : null
+}

package/src/modules/eudr/lib/detail-read-scope.ts

@@ -0,0 +1,44 @@
+export type DetailReadScope = {
+  tenantId: string
+  /** Matches the organization scope the list query itself used. */
+  organizationFilter: string | { $in: string[] }
+  /**
+   * Fallback organization for decryption only. `decryptEntitiesWithFallbackScope`
+   * prefers each record's own tenant/organization and consults this only when the
+   * record carries none, so a single value stays correct for multi-org reads.
+   */
+  decryptionOrganizationId: string | null
+}
+
+type DetailReadScopeContext = {
+  auth?: { tenantId?: string | null; orgId?: string | null } | null
+  organizationIds?: string[] | null
+  selectedOrganizationId?: string | null
+}
+
+/**
+ * Resolves the scope for an `afterList` detail re-fetch (the decryption pass).
+ *
+ * The list query is scoped by the full `organizationIds` array, so re-fetching by
+ * a single organization silently drops decrypted fields for a multi-org user who
+ * has not selected one. Returns null when no scope can be established, so callers
+ * fail closed rather than reading across the tenant.
+ */
+export function resolveDetailReadScope(ctx: DetailReadScopeContext): DetailReadScope | null {
+  const tenantId = ctx.auth?.tenantId ?? null
+  if (!tenantId) return null
+
+  const scopedOrganizationIds = Array.isArray(ctx.organizationIds) && ctx.organizationIds.length
+    ? Array.from(new Set(ctx.organizationIds))
+    : null
+  const singleOrganizationId = ctx.selectedOrganizationId ?? ctx.auth?.orgId ?? null
+  if (!scopedOrganizationIds && !singleOrganizationId) return null
+
+  return {
+    tenantId,
+    organizationFilter: scopedOrganizationIds
+      ? { $in: scopedOrganizationIds }
+      : (singleOrganizationId as string),
+    decryptionOrganizationId: singleOrganizationId,
+  }
+}

package/src/modules/eudr/lib/geometry.ts

@@ -0,0 +1,191 @@
+export type EudrPlotGeometryType = 'point' | 'polygon'
+
+type GeoJsonPosition = [number, number]
+type GeoJsonPoint = { type: 'Point'; coordinates: GeoJsonPosition }
+type GeoJsonPolygon = { type: 'Polygon'; coordinates: GeoJsonPosition[][] }
+type GeoJsonMultiPolygon = { type: 'MultiPolygon'; coordinates: GeoJsonPosition[][][] }
+type GeoJsonSupportedGeometry = GeoJsonPoint | GeoJsonPolygon | GeoJsonMultiPolygon
+
+export type GeoJsonFeature = {
+  type: 'Feature'
+  properties: Record<string, unknown>
+  geometry: GeoJsonSupportedGeometry
+}
+
+export type GeometryValidationResult =
+  | { ok: true; feature: GeoJsonFeature; plotType: EudrPlotGeometryType; computedAreaHa: number | null; warnings: string[] }
+  | { ok: false; errorKey: string }
+
+type PositionValidationResult =
+  | { ok: true; position: GeoJsonPosition; lowPrecision: boolean }
+  | { ok: false; errorKey: 'geometryOutOfRange' }
+
+const MAX_GEOMETRY_SIZE = 262_144
+const MAX_IMPORT_SIZE = 1_048_576
+const MAX_FEATURE_COLLECTION_FEATURES = 500
+const EARTH_RADIUS_METERS = 6_371_008.8
+
+export const POINT_MAX_AREA_HA = 4
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+}
+
+function serializedLength(value: unknown): number | null {
+  try {
+    const serialized = JSON.stringify(value)
+    return typeof serialized === 'string' ? serialized.length : null
+  } catch {
+    return null
+  }
+}
+
+function decimalPlaces(value: number): number {
+  const decimal = String(value).split(/[eE]/)[0]?.split('.')[1]
+  return decimal?.length ?? 0
+}
+
+function validatePosition(input: unknown): PositionValidationResult {
+  if (!Array.isArray(input) || input.length < 2) return { ok: false, errorKey: 'geometryOutOfRange' }
+  const [longitude, latitude] = input
+  if (typeof longitude !== 'number' || typeof latitude !== 'number') return { ok: false, errorKey: 'geometryOutOfRange' }
+  if (!Number.isFinite(longitude) || !Number.isFinite(latitude)) return { ok: false, errorKey: 'geometryOutOfRange' }
+  if (longitude < -180 || longitude > 180 || latitude < -90 || latitude > 90) return { ok: false, errorKey: 'geometryOutOfRange' }
+
+  return {
+    ok: true,
+    position: [longitude, latitude],
+    lowPrecision: decimalPlaces(longitude) < 6 || decimalPlaces(latitude) < 6,
+  }
+}
+
+function positionsEqual(left: GeoJsonPosition, right: GeoJsonPosition): boolean {
+  return left[0] === right[0] && left[1] === right[1]
+}
+
+function validateRing(input: unknown): { ok: true; ring: GeoJsonPosition[]; lowPrecision: boolean } | { ok: false; errorKey: string } {
+  if (!Array.isArray(input)) return { ok: false, errorKey: 'geometryInvalid' }
+  if (input.length < 4) return { ok: false, errorKey: 'geometryRingNotClosed' }
+
+  const ring: GeoJsonPosition[] = []
+  let lowPrecision = false
+  for (const candidate of input) {
+    const result = validatePosition(candidate)
+    if (!result.ok) return result
+    ring.push(result.position)
+    lowPrecision = lowPrecision || result.lowPrecision
+  }
+
+  if (!positionsEqual(ring[0], ring[ring.length - 1])) return { ok: false, errorKey: 'geometryRingNotClosed' }
+  return { ok: true, ring, lowPrecision }
+}
+
+function validatePolygonCoordinates(input: unknown): { ok: true; rings: GeoJsonPosition[][]; lowPrecision: boolean } | { ok: false; errorKey: string } {
+  if (!Array.isArray(input) || input.length === 0) return { ok: false, errorKey: 'geometryInvalid' }
+
+  const rings: GeoJsonPosition[][] = []
+  let lowPrecision = false
+  for (const candidate of input) {
+    const result = validateRing(candidate)
+    if (!result.ok) return result
+    rings.push(result.ring)
+    lowPrecision = lowPrecision || result.lowPrecision
+  }
+
+  return { ok: true, rings, lowPrecision }
+}
+
+function validateGeometry(input: unknown): { ok: true; geometry: GeoJsonSupportedGeometry; lowPrecision: boolean } | { ok: false; errorKey: string } {
+  if (!isRecord(input) || typeof input.type !== 'string') return { ok: false, errorKey: 'geometryInvalid' }
+
+  if (input.type === 'Point') {
+    const result = validatePosition(input.coordinates)
+    if (!result.ok) return result
+    return { ok: true, geometry: { type: 'Point', coordinates: result.position }, lowPrecision: result.lowPrecision }
+  }
+
+  if (input.type === 'Polygon') {
+    const result = validatePolygonCoordinates(input.coordinates)
+    if (!result.ok) return result
+    return { ok: true, geometry: { type: 'Polygon', coordinates: result.rings }, lowPrecision: result.lowPrecision }
+  }
+
+  if (input.type === 'MultiPolygon') {
+    if (!Array.isArray(input.coordinates) || input.coordinates.length === 0) return { ok: false, errorKey: 'geometryInvalid' }
+    const polygons: GeoJsonPosition[][][] = []
+    let lowPrecision = false
+    for (const candidate of input.coordinates) {
+      const result = validatePolygonCoordinates(candidate)
+      if (!result.ok) return result
+      polygons.push(result.rings)
+      lowPrecision = lowPrecision || result.lowPrecision
+    }
+    return { ok: true, geometry: { type: 'MultiPolygon', coordinates: polygons }, lowPrecision }
+  }
+
+  return { ok: false, errorKey: 'geometryInvalid' }
+}
+
+function toRadians(value: number): number {
+  return (value * Math.PI) / 180
+}
+
+function ringAreaSquareMeters(ring: GeoJsonPosition[]): number {
+  let total = 0
+  for (let index = 0; index < ring.length - 1; index += 1) {
+    const [longitude1, latitude1] = ring[index]
+    const [longitude2, latitude2] = ring[index + 1]
+    total += (toRadians(longitude2) - toRadians(longitude1)) * (2 + Math.sin(toRadians(latitude1)) + Math.sin(toRadians(latitude2)))
+  }
+  return Math.abs((total * EARTH_RADIUS_METERS * EARTH_RADIUS_METERS) / 2)
+}
+
+function polygonAreaSquareMeters(rings: GeoJsonPosition[][]): number {
+  const [exterior, ...holes] = rings
+  const holesArea = holes.reduce((sum, ring) => sum + ringAreaSquareMeters(ring), 0)
+  return Math.max(0, ringAreaSquareMeters(exterior) - holesArea)
+}
+
+function areaHa(geometry: GeoJsonPolygon | GeoJsonMultiPolygon): number {
+  // Spherical-excess area is approximate, but is within about 0.5% at normal
+  // plot scale and sufficient for the 4-ha EUDR threshold hinting flow.
+  const squareMeters = geometry.type === 'Polygon'
+    ? polygonAreaSquareMeters(geometry.coordinates)
+    : geometry.coordinates.reduce((sum, polygon) => sum + polygonAreaSquareMeters(polygon), 0)
+
+  return Math.round((squareMeters / 10_000) * 10_000) / 10_000
+}
+
+export function validatePlotGeometry(input: unknown): GeometryValidationResult {
+  const length = serializedLength(input)
+  if (length === null) return { ok: false, errorKey: 'geometryInvalid' }
+  if (length > MAX_GEOMETRY_SIZE) return { ok: false, errorKey: 'geometryTooLarge' }
+
+  const isFeature = isRecord(input) && input.type === 'Feature'
+  const geometryInput = isFeature ? input.geometry : input
+  const properties = isFeature && isRecord(input.properties) ? input.properties : {}
+  const result = validateGeometry(geometryInput)
+  if (!result.ok) return result
+
+  const plotType: EudrPlotGeometryType = result.geometry.type === 'Point' ? 'point' : 'polygon'
+  return {
+    ok: true,
+    feature: { type: 'Feature', properties, geometry: result.geometry },
+    plotType,
+    computedAreaHa: result.geometry.type === 'Point' ? null : areaHa(result.geometry),
+    warnings: result.lowPrecision ? ['low_precision'] : [],
+  }
+}
+
+export function collectFeatures(featureCollection: unknown): { ok: true; features: unknown[] } | { ok: false; errorKey: string } {
+  const length = serializedLength(featureCollection)
+  if (length === null) return { ok: false, errorKey: 'geometryInvalid' }
+  if (length > MAX_IMPORT_SIZE) return { ok: false, errorKey: 'importTooLarge' }
+
+  if (!isRecord(featureCollection) || featureCollection.type !== 'FeatureCollection' || !Array.isArray(featureCollection.features)) {
+    return { ok: false, errorKey: 'geometryInvalid' }
+  }
+
+  if (featureCollection.features.length > MAX_FEATURE_COLLECTION_FEATURES) return { ok: false, errorKey: 'importTooManyFeatures' }
+  return { ok: true, features: featureCollection.features }
+}

package/src/modules/eudr/lib/notifications.ts

@@ -0,0 +1,85 @@
+import { createLogger } from '@open-mercato/shared/lib/logger'
+import { buildFeatureNotificationFromType } from '../../notifications/lib/notificationBuilder'
+import { resolveNotificationService } from '../../notifications/lib/notificationService'
+import { notificationTypes } from '../notifications'
+
+const logger = createLogger('eudr').child({ component: 'notifications' })
+
+export type EudrNotificationTypeId =
+  | 'eudr.statement.submitted'
+  | 'eudr.statement.reference_issued'
+  | 'eudr.statement.withdrawn'
+  | 'eudr.risk.non_negligible'
+  | 'eudr.mitigation.completed'
+
+export type EudrNotificationContainer = {
+  resolve: (name: string) => unknown
+}
+
+type EudrNotificationPayload = {
+  tenantId: string
+  organizationId: string | null
+  entityId: string
+  occurredAt: string
+  bodyVariables: Record<string, string>
+  linkHref: string
+  sourceEntityType: string
+}
+
+type DeliverEudrNotificationInput = {
+  container: EudrNotificationContainer
+  typeId: EudrNotificationTypeId
+  payload: EudrNotificationPayload
+}
+
+const REQUIRED_FEATURE_BY_TYPE: Record<EudrNotificationTypeId, string> = {
+  'eudr.statement.submitted': 'eudr.statements.manage',
+  'eudr.statement.reference_issued': 'eudr.statements.manage',
+  'eudr.statement.withdrawn': 'eudr.statements.manage',
+  'eudr.risk.non_negligible': 'eudr.risk.manage',
+  'eudr.mitigation.completed': 'eudr.risk.manage',
+}
+
+export async function deliverEudrNotification({
+  container,
+  typeId,
+  payload,
+}: DeliverEudrNotificationInput): Promise<void> {
+  let notificationService: ReturnType<typeof resolveNotificationService>
+  try {
+    notificationService = resolveNotificationService(container)
+  } catch (err) {
+    logger.debug('Notification service unavailable; skipping EUDR notification', {
+      typeId,
+      entityId: payload.entityId,
+      err,
+    })
+    return
+  }
+
+  const typeDef = notificationTypes.find((candidate) => candidate.type === typeId)
+  if (!typeDef) {
+    throw new Error(`[internal] EUDR notification type is not registered: ${typeId}`)
+  }
+
+  const requiredFeature = REQUIRED_FEATURE_BY_TYPE[typeId]
+  const content = buildFeatureNotificationFromType(typeDef, {
+    requiredFeature,
+    bodyVariables: payload.bodyVariables,
+    sourceEntityType: payload.sourceEntityType,
+    sourceEntityId: payload.entityId,
+    linkHref: payload.linkHref,
+    groupKey: `${typeId}:${payload.entityId}:${payload.occurredAt}`,
+  })
+
+  await notificationService.createForFeature(
+    {
+      ...content,
+      restrictRecipientsToOrganization: true,
+    },
+    {
+      tenantId: payload.tenantId,
+      organizationId: payload.organizationId,
+    },
+  )
+}

package/src/modules/eudr/lib/plural.ts

@@ -0,0 +1,36 @@
+type Translator = (
+  key: string,
+  fallbackOrParams?: string | Record<string, string | number>,
+  params?: Record<string, string | number>,
+) => string
+
+const pluralRulesCache = new Map<string, Intl.PluralRules>()
+
+function pluralRulesFor(locale: string): Intl.PluralRules {
+  const cached = pluralRulesCache.get(locale)
+  if (cached) return cached
+  let rules: Intl.PluralRules
+  try {
+    rules = new Intl.PluralRules(locale)
+  } catch {
+    rules = new Intl.PluralRules('en')
+  }
+  pluralRulesCache.set(locale, rules)
+  return rules
+}
+
+export function translatePlural(
+  translate: Translator,
+  locale: string,
+  baseKey: string,
+  count: number,
+  params?: Record<string, string | number>,
+): string {
+  const category = pluralRulesFor(locale).select(count)
+  const mergedParams = { count, ...(params ?? {}) }
+  for (const key of [`${baseKey}.${category}`, `${baseKey}.other`, baseKey]) {
+    const result = translate(key, mergedParams)
+    if (result !== key) return result
+  }
+  return translate(baseKey, mergedParams)
+}