ajv-ftl-i18n/locale/ko.js

Transpile Fluent (ftl) files into ajv error translations.

const __locales = ["ko"]

const __formatNumber = (value, options) => {
	return new Intl.NumberFormat(__locales, options).format(value)
}

const __formatVariable = (value) => {
  if (typeof value === 'string') return value
  const decimal =  Number.parseFloat(value)
  const number = Number.isInteger(decimal) ? Number.parseInt(value) : decimal
  return __formatNumber(number)
}

const __select = (value, cases, fallback, options) => {
	const pluralRules = new Intl.PluralRules(__locales, options)
	const rule = pluralRules.select(value)
	return cases[value] ?? cases[rule] ?? fallback
}

const defaultMessage = (params) => `"${params?.keyword}"키워드 검사를 통과해야 합니다`
const comparisonLimit = (params) => `${params?.comparison} ${params?.limit} 이여야 합니다`
export const items = (params) => `항목은 아이템을 ${__formatVariable(params?.limit)}개 이상 가질 수 없습니다`
export const additionalItems = (params) => `${items(params)}`
export const additionalProperties = `추가적인 속성은 허용되지 않습니다`
export const anyOf = `"anyOf"의 스키마와 일치해야 합니다`
export const _const = `상수와 같아야합니다`
export const contains = `올바른 아이템을 포함해야 합니다`
export const dependencies = (params) => `${__formatVariable(params?.property)}속성이 있는 경우, ${__formatVariable(params?.deps)} 속성이 있어야합니다`
export const dependentRequired = (params) => `${dependencies(params)}`
export const _enum = `미리 정의된 값중 하나여야 합니다`
export const falseSchema = `boolean 스키마는 올바르지 않습니다`
export const format = (params) => `"${__formatVariable(params?.format)}" 포맷과 일치해야 합니다`
export const formatMaximum = (params) => `${comparisonLimit(params)}`
export const formatExclusiveMaximum = (params) => `${comparisonLimit(params)}`
export const formatMinimum = (params) => `${comparisonLimit(params)}`
export const formatExclusiveMinimum = (params) => `${comparisonLimit(params)}`
export const _if = (params) => `"${__formatVariable(params?.failingKeyword)}" 스키마와 일치해야 합니다`
export const maximum = (params) => `${comparisonLimit(params)}`
export const exclusiveMaximum = (params) => `${maximum(params)}`
export const maxItems = (params) => `아이템이 최대 ${__formatVariable(params?.limit)}개이여야 합니다`
export const maxLength = (params) => `최대 ${__formatVariable(params?.limit)}글자여야 합니다`
export const maxProperties = (params) => `속성은 최대 ${__formatVariable(params?.limit)}개 이내여야 합니다`
export const minimum = (params) => `${comparisonLimit(params)}`
export const exclusiveMinimum = (params) => `${minimum(params)}`
export const minItems = (params) => `아이템이 최소 ${__formatVariable(params?.limit)}개이여야 합니다`
export const minLength = (params) => `최소 ${__formatVariable(params?.limit)}글자여야 합니다`
export const minProperties = (params) => `속성은 최소 ${__formatVariable(params?.limit)}개 이상이여야 합니다`
export const multipleOf = (params) => `${__formatVariable(params?.multipleOf)}의 배수여야 합니다`
export const not = `"not"스키마에 따라 유효하지 않아야 합니다`
export const oneOf = `"oneOf" 스키마중 하나와 정확하게 일치해야 합니다`
export const pattern = (params) => `"${__formatVariable(params?.pattern)}"패턴과 일치해야 합니다`
export const patternRequired = (params) => `"${__formatVariable(params?.missingPattern)}"패턴과 일치하는 속성을 가져야 합니다`
export const propertyNames = `속성명이 올바르지 않습니다`
export const required = (params) => `${__formatVariable(params?.missingProperty)} 속성은 필수입니다`
export const type = (params) => `${__formatVariable(params?.type)}${__select(
    params?.nullable,
    {
      'true': `/null`
    },
    `${""}`
  )}이여야 합니다`
export const unevaluatedItems = (params) => `항목이 ${__formatVariable(params?.len)}개 아이템을 초과하면 안됩니다`
export const unevaluatedProperties = `평가되지 않은 속성이 없어야합니다.`
export const uniqueItems = (params) => `중복 아이템이 없어야 합니다 (아이템${__formatVariable(params?.j)}과 아이템${__formatVariable(params?.i)}가 동일합니다)`
export const discriminator = (params) => `${__select(
    params?.error,
    {
      'tag': `"${__formatVariable(params?.tag)}"태그는 반드시 문자열이여야 합니다`,
      'mapping': `"${__formatVariable(params?.tag)}"태그의 값은 반드시 oneOf에 있어야 합니다`
    },
    `${type(params)}`
  )}`
export const properties = (params) => `${__select(
    params?.error,
    {
      'additional': `추가적인 속성은 허용되지 않습니다`,
      'missing': `${__formatVariable(params?.missingProperty)} 속성은 필수입니다`
    },
    `${type(params)}`
  )}`
export const elements = (params) => `${type(params)}`
export const values = (params) => `${type(params)}`
export const union = `"union"의 스키마와 일치해야 합니다`
const __exports = {
  items,
  additionalItems,
  additionalProperties,
  anyOf,
  'const': _const,
  contains,
  dependencies,
  dependentRequired,
  'enum': _enum,
  falseSchema,
  format,
  formatMaximum,
  formatExclusiveMaximum,
  formatMinimum,
  formatExclusiveMinimum,
  'if': _if,
  maximum,
  exclusiveMaximum,
  maxItems,
  maxLength,
  maxProperties,
  minimum,
  exclusiveMinimum,
  minItems,
  minLength,
  minProperties,
  multipleOf,
  not,
  oneOf,
  pattern,
  patternRequired,
  propertyNames,
  required,
  type,
  unevaluatedItems,
  unevaluatedProperties,
  uniqueItems,
  discriminator,
  properties,
  elements,
  values,
  union
}
export default (errors) => {
  if (!errors?.length) return
  for (const e of errors) {
    let { keyword } = e
    if (keyword === 'false schema') keyword = 'falseSchema'
    let source = __exports[keyword] ?? __exports['_'+keyword]
    let values = {}
    if (keyword === 'errorMessage') {
      const [message, ...valuesPairs] = e.message.split(', ')
      ;(valuesPairs.join(', ').match(regExpJsonPointerPairs) ?? []).forEach(pair => {
        const [key, value] = pair.split(':')
        values[key] = value.replace(regExpJsonPointerQuote, '')
      })
      source ??= __exports[message] ?? __exports['_'+message] ?? e.message
    } else {
      source ??= __exports.defaultMessage
    }
    if (typeof source === 'function') {
      e.message = source({keyword:e.keyword, ...e.params, ...values})
    } else {
      e.message = source
    }
  }
}
const regExpJsonPointerPairs = /([a-zA-Z0-9_-]+):(".*"|[^,"]+)/g
const regExpJsonPointerQuote = /(^"|"$)/g