@eouia/intl-msg 0.1.0

package/dist/browser/intl-msg.js

@@ -0,0 +1,591 @@
+var IntlMsg = (function () {
+  'use strict';
+
+  var _intl = null;
+  if (typeof Intl !== 'undefined') {
+    _intl = Intl;
+  }
+
+
+  function sanitizeLocaleInput(locale) {
+    if (typeof locale !== 'string') return null
+    return locale.replace(/_/g, '-')
+  }
+
+  function createLocaleInfo(locale) {
+    const sanitizedLocale = sanitizeLocaleInput(locale);
+    if (!sanitizedLocale) return null
+
+    try {
+      const canonicalLocales = _intl.getCanonicalLocales(sanitizedLocale);
+      const canonicalLocale = Array.isArray(canonicalLocales) ? canonicalLocales[0] : canonicalLocales;
+      const localeInfo = {
+        original: locale,
+        sanitized: sanitizedLocale,
+        canonical: canonicalLocale,
+        baseName: canonicalLocale,
+      };
+
+      if (typeof _intl.Locale === 'function') {
+        const intlLocale = new _intl.Locale(canonicalLocale);
+        localeInfo.baseName = intlLocale.baseName || canonicalLocale;
+        localeInfo.language = intlLocale.language;
+        localeInfo.script = intlLocale.script;
+        localeInfo.region = intlLocale.region;
+      }
+
+      return localeInfo
+    } catch (e) {
+      return null
+    }
+  }
+
+  function normalizeToBcp47 (locale, func = ()=>{}) {
+    const localeInfo = createLocaleInfo(locale);
+    if (!localeInfo) return null
+    const canonicalLocales = [localeInfo.canonical];
+    if (typeof func === 'function') func(canonicalLocales);
+    return localeInfo.canonical
+  }
+
+  function isPlainObject(value) {
+  	if (Object.prototype.toString.call(value) !== '[object Object]') {
+  		return false;
+  	}
+
+  	const prototype = Object.getPrototypeOf(value);
+  	return prototype === null || prototype === Object.prototype;
+  }
+
+  function toArray (item) {
+    if(!item) return []
+    return [...((Array.isArray(item)) ? [...item] : [item])]
+  }
+
+  function toShortStr (something, len = 20) {
+    var c = (something?.toString() || String(something));
+    return (c.length > len) ? c.slice(0, len) + '...' : c
+  }
+
+  function toDate (dateLike) {
+    if (dateLike instanceof Date) return new Date(dateLike.getTime())
+    var date = new Date(dateLike);
+    if (date.toString() === 'Invalid Date') return dateLike
+    return date
+  }
+
+  function isRangeObject(value) {
+    return isPlainObject(value) && Object.hasOwn(value, 'start') && Object.hasOwn(value, 'end')
+  }
+
+  function getSupportedIntlValues(key) {
+    if (typeof _intl.supportedValuesOf !== 'function') return null
+    try {
+      return _intl.supportedValuesOf(key)
+    } catch (e) {
+      return null
+    }
+  }
+
+  function normalizeIntlOptionValue(key, value) {
+    if (typeof value !== 'string') return value
+    if (key === 'currency') return value.toUpperCase()
+    if (key === 'calendar' || key === 'numberingSystem' || key === 'unit') return value.toLowerCase()
+    return value
+  }
+
+  function normalizeRelativeTimeUnit(unit) {
+    const normalizedUnit = normalizeIntlOptionValue('unit', unit);
+    const supportedUnits = getSupportedIntlValues('unit');
+    if (!supportedUnits) return normalizedUnit
+    if (supportedUnits.includes(normalizedUnit)) return normalizedUnit
+    if (normalizedUnit.endsWith('s')) {
+      const singularUnit = normalizedUnit.slice(0, -1);
+      if (supportedUnits.includes(singularUnit)) return singularUnit
+    }
+    return normalizedUnit
+  }
+
+  function validateIntlOptions(options = {}, log = DEFAULT_LOGGER) {
+    if (!isPlainObject(options)) return { valid: false, options }
+
+    const supportedOptionKeys = ['currency', 'unit', 'calendar', 'numberingSystem'];
+    for (const key of supportedOptionKeys) {
+      if (!Object.hasOwn(options, key)) continue
+
+      const normalizedValue = normalizeIntlOptionValue(key, options[key]);
+      const supportedValues = getSupportedIntlValues(key);
+      if (!supportedValues) {
+        options[key] = normalizedValue;
+        continue
+      }
+
+      if (!supportedValues.includes(normalizedValue)) {
+        log.warn(`Invalid Intl option '${key}':`, normalizedValue);
+        return { valid: false, options }
+      }
+
+      options[key] = normalizedValue;
+    }
+
+    return { valid: true, options }
+  }
+
+  function setPostFormatContext(config, context) {
+    if (!isPlainObject(config)) return
+    config.__postFormatContext = context;
+  }
+
+  function applyPostFormat(postFormat, context, fallbackValue, log, formatName, formatters = {}) {
+    if (typeof postFormat !== 'string') return fallbackValue
+    const transform = formatters?.[postFormat];
+    if (typeof transform !== 'function') return fallbackValue
+    try {
+      return transform(context) ?? fallbackValue
+    } catch (e) {
+      log.error(`Formatter '${formatName}' postFormat error.`);
+      log.error({
+        formatterConfig: context,
+        postFormat,
+      });
+      return fallbackValue
+    }
+  }
+
+  function toPossibleLocales(locales = []) {
+    if (!(Array.isArray(locales) && locales.length > 0)) return []
+    return locales.reduce((result, locale) => {
+      const localeInfo = createLocaleInfo(locale);
+      if (!localeInfo) return result
+
+      if (!result.includes(localeInfo.canonical)) result.push(localeInfo.canonical);
+
+      var lcParts = localeInfo.baseName.split('-');
+      while(lcParts.length > 0) {
+        var search = lcParts.join('-');
+        if (!result.includes(search)) result.push(search);
+        lcParts.pop();
+      }
+      return result
+    }, [])
+  }
+
+  function applyIntl(obj) {
+    const required = [
+      'getCanonicalLocales', 'PluralRules', 'DateTimeFormat', 'RelativeTimeFormat',
+      'ListFormat', 'NumberFormat', 'Locale'
+    ];
+    if (
+      obj !== null && typeof obj === 'object'
+      && required.every((p) => {
+        return obj.hasOwnProperty(p)
+      })
+    ) _intl = obj;
+    if (!_intl || !_intl.hasOwnProperty(required[0])) throw new Error(
+      "This module requires native 'Intl' feature or representative polyfill injection."
+    )
+  }
+
+  const DEFAULT_LOGGER = {
+    log: () => {},
+    info: () => {},
+    warn: () => {},
+    error: () => {}
+  };
+
+  class Dictionary {
+    #terms = new Map()
+    #formatters = new Map()
+    #name = ''
+    constructor (locale) {
+      normalizeToBcp47(locale, (lc) => {
+        this.#name = (Array.isArray(lc)) ? lc[0] || locale : locale;
+      });
+      if (!this.#name) throw new Error(`Invalid locale name '${locale}' as dictionary`)
+      this.setTerm('TEST', 'This is a test phrase by default.');
+    }
+    setTerm (key, message) {
+      return this.#terms.set(key, message)
+    }
+    getTerm (key) {
+      return this.#terms.get(key)
+    }
+    getName () {
+      return this.#name
+    }
+    setFormatter (key, formatter) {
+      return this.#formatters.set(key, formatter)
+    }
+    getFormatter (key) {
+      return this.#formatters.get(key)
+    }
+  }
+
+  class IntlMsg {
+    #dictionaries = new Map()
+    #locales = []
+    #formatters = {}
+    #log = DEFAULT_LOGGER
+
+    constructor ({ log = null, intlPolyfill = null, verbose = false } = {}) {
+      applyIntl(intlPolyfill);
+      if (!_intl.hasOwnProperty('getCanonicalLocales')) throw new Error("This module required native 'Intl' module or ")
+      this.#initFormatters();
+      this.setLogger(log, verbose);
+    }
+
+    static factory ({ log = null, intlPolyfill = null, verbose = false, locales = null, dictionaries = null } = {}) {
+      const instance = new IntlMsg({ log, intlPolyfill, verbose });
+      if (locales) instance.addLocale(locales);
+      if (dictionaries) instance.addDictionary(dictionaries);
+      return instance
+    }
+
+    setLogger (log = null, verbose = false) {
+      if (!log) return
+      const required = ['log', 'info', 'warn', 'error'];
+      if (required.every((m) => { return log.hasOwnProperty(m)}) && verbose) this.#log = log;
+    }
+
+    getLocale () {
+      return [...this.#locales]
+    }
+
+
+    setLocale (locales = []) {
+      this.#locales = [];
+      this.addLocale(locales);
+      return this
+    }
+
+
+    addLocale (locales = []) {
+      var newLocales = toArray(locales); 
+      if (newLocales.length < 1) return this
+      newLocales.forEach((lc) => {
+        normalizeToBcp47(lc, (filtered) => {
+          if (!(Array.isArray(filtered) && filtered.length >= 1)) return
+          filtered.forEach((f) => {
+            if (this.#locales.includes(f)) return
+            this.#locales.push(f);
+          });
+        }); 
+      });
+      return this
+    }
+
+    addDictionary(json = {}) {
+      if (!isPlainObject(json)) {
+        this.#log.warn('Invalid dictionary data:', toShortStr(json));
+        return this
+      }
+      Object.keys(json).forEach((locale) => {
+        var dict = json[locale];
+        this.#mergeDictionary(locale, dict);
+      });
+      return this
+    }
+
+    #mergeDictionary(locale, dictData = {}) {
+      if (!isPlainObject(dictData)) {
+        this.#log.warn(`Invalid dictionary entry for locale '${locale}':`, toShortStr(dictData));
+        return this
+      }
+
+      var {translations = {}, formatters = {}} = dictData;
+      var lc = normalizeToBcp47(locale);
+      if (!lc) return this
+      var dictionary = this.getDictionary(lc);
+      if (!(dictionary instanceof Dictionary)) {
+        dictionary = new Dictionary(lc);
+        this.#dictionaries.set(lc, dictionary);
+      }
+      if (translations && typeof translations === 'object') {
+        for(let [key, value] of Object.entries(translations)) {
+          if (typeof key === 'string')
+          dictionary.setTerm(key, value);
+        }
+      }
+      if (formatters && typeof formatters === 'object') {
+        for(let [key, value] of Object.entries(formatters)) {
+          if (typeof key === 'string')
+          dictionary.setFormatter(key, value);
+        }
+      }
+      return this
+    } 
+
+    getDictionary(locale) {
+      var lc = normalizeToBcp47(locale);
+      if (this.#dictionaries.has(lc)) return this.#dictionaries.get(lc)
+      return null
+    }
+
+    addTermToDictionary(locale, key, value) {
+      var dict = this.getDictionary(locale);
+      if (dict instanceof Dictionary) dict.setTerm(key, value);
+      return this
+    }
+    
+    getTermFromDictionary(locale, key) {
+      var dict = this.getDictionary(locale);
+      if (!(dict instanceof Dictionary)) return undefined
+      return dict.getTerm(key)
+    }
+
+    getDictionaryNames () {
+      return [...this.#dictionaries.keys()]
+    }
+
+    #findTerms (key, locales = null) {
+      var rootLocales = locales ? toArray(locales) : [...this.#locales];
+
+      const dictionaryList = [...this.#dictionaries.keys()];
+      var found = null;
+      var originalLocale = null;
+      for (let rootLc of rootLocales) {
+        if (found) break
+        for (let lc of toPossibleLocales([rootLc])) {
+          if (dictionaryList.includes(lc) && this.#dictionaries.get(lc).getTerm(key) !== undefined) {
+            found = lc;
+            originalLocale = rootLc;
+            break
+          }
+        }
+      }
+      return {
+        message: found ? this.#dictionaries.get(found).getTerm(key) : key,
+        dictionaryName: found,
+        originalLocale: originalLocale,
+      }
+    }
+
+    getRawMessage(key, locales = null) {
+      var { message } = this.#findTerms(key, locales);
+      return message
+    }
+
+    message (key, options = {}) {
+      var { message, dictionaryName, originalLocale } = this.#findTerms(key);
+
+      for (const prop of Object.keys(options)) {
+        var pattern = `{{((?<t>${prop})((?:\\:)(?<f>\\w+))?)}}`;
+        var rx = new RegExp(pattern, 'gm');
+        [...message.matchAll(rx)].map((i) => {
+          var val = options[prop];
+          var placeholder = i[0];
+          var groups = i?.groups;
+          if (groups.f) {
+            var formatterDefinition = this.#dictionaries.get(dictionaryName)?.getFormatter(groups.f);
+            var formatterConfig = isPlainObject(formatterDefinition) ? { ...formatterDefinition } : formatterDefinition;
+            var format = formatterConfig?.format;
+            if (typeof this.#formatters[format] === 'function') {
+              try {
+                var rawValue = val;
+                formatterConfig.value = val;
+                if (formatterConfig.locales == null) formatterConfig.locales = originalLocale;
+                val = this.#formatters[format](formatterConfig) ?? {};
+                val = applyPostFormat(
+                  formatterConfig?.postFormat,
+                  formatterConfig?.__postFormatContext ?? {
+                    value: val,
+                    parts: undefined,
+                    rawValue,
+                    locales: formatterConfig.locales,
+                    options: formatterConfig.options,
+                    format,
+                  },
+                  val,
+                  this.#log,
+                  format,
+                  this.#formatters
+                );
+              } catch (e) {
+                this.#log.error (`Formatter '${format}' call error.`);
+                this.#log.error({
+                  key: key,
+                  formatterConfig: formatterConfig,
+                });
+                // val은 원본 값으로 유지 → 아래 message.replace(ph, val)에서 원본 값으로 치환
+              }
+            }
+          }
+          message = message.replace(placeholder, val);
+          return i?.groups
+        });
+      }
+      return message
+    }
+
+    
+
+    #initFormatters () {
+      this.registerFormatter('pluralRules', function({locales, value, options, rules}) {
+        if (isNaN(value)) return ''
+        var plural = new _intl.PluralRules(locales, options).select(value);
+        return rules?.[plural] ?? rules?.other ?? ''
+      });
+      this.registerFormatter('pluralRange', ({locales, value, options, rules}) => {
+        if (!isRangeObject(value)) return rules?.other ?? `${value?.toString() || value}`
+        if (isNaN(value.start) || isNaN(value.end)) return rules?.other ?? `${value.start} - ${value.end}`
+
+        var pluralRules = new _intl.PluralRules(locales, options);
+        if (typeof pluralRules.selectRange !== 'function') {
+          this.#log.warn("Formatter 'pluralRange' requires Intl.PluralRules.prototype.selectRange support.");
+          return rules?.other ?? `${value.start}-${value.end}`
+        }
+
+        var plural = pluralRules.selectRange(value.start, value.end);
+        return rules?.[plural] ?? rules?.other ?? ''
+      });
+      this.registerFormatter('list', (formatterConfig = {}) => {
+        var {locales, value, options = {}} = formatterConfig;
+        if (!Array.isArray(value)) return value?.toString() || value
+        var formatter = new _intl.ListFormat(locales, options);
+        var ret = formatter.format(value);
+        var parts = typeof formatter.formatToParts === 'function' ? formatter.formatToParts(value) : undefined;
+        setPostFormatContext(formatterConfig, { value: ret, parts, rawValue: value, locales, options, format: 'list' });
+        return ret
+      });
+      this.registerFormatter('number', (formatterConfig = {}) => {
+        var {locales, value, options = {}} = formatterConfig;
+        if (isNaN(value)) return value?.toString() || value
+        var { valid, options: validatedOptions } = validateIntlOptions(options, this.#log);
+        if (!valid) return value?.toString() || value
+        var formatter = new _intl.NumberFormat(locales, validatedOptions);
+        var ret = formatter.format(value);
+        var parts = typeof formatter.formatToParts === 'function' ? formatter.formatToParts(value) : undefined;
+        setPostFormatContext(formatterConfig, { value: ret, parts, rawValue: value, locales, options: validatedOptions, format: 'number' });
+        return ret
+      });
+      this.registerFormatter('numberRange', (formatterConfig = {}) => {
+        var {locales, value, options = {}} = formatterConfig;
+        if (!isRangeObject(value)) return value?.toString() || value
+        if (isNaN(value.start) || isNaN(value.end)) return `${value.start} - ${value.end}`
+
+        var { valid, options: validatedOptions } = validateIntlOptions(options, this.#log);
+        if (!valid) return `${value.start} - ${value.end}`
+
+        var formatter = new _intl.NumberFormat(locales, validatedOptions);
+        if (typeof formatter.formatRange !== 'function') {
+          this.#log.warn("Formatter 'numberRange' requires Intl.NumberFormat.prototype.formatRange support.");
+          return `${formatter.format(value.start)} - ${formatter.format(value.end)}`
+        }
+        var ret = formatter.formatRange(value.start, value.end);
+        var parts = typeof formatter.formatRangeToParts === 'function' ? formatter.formatRangeToParts(value.start, value.end) : undefined;
+        setPostFormatContext(formatterConfig, { value: ret, parts, rawValue: value, locales, options: validatedOptions, format: 'numberRange' });
+        return ret
+      });
+      this.registerFormatter('select', function({locales, value, options}) {
+        if (options?.[value]) return options?.[value]
+        return options?.["other"] ?? value?.toString() ?? value
+      });
+      this.registerFormatter('dateTime', (formatterConfig = {}) => {
+        var {locales, value, options = {}} = formatterConfig;
+        var date = toDate(value);
+        if (!(date instanceof Date)) return value
+        var { valid, options: validatedOptions } = validateIntlOptions(options, this.#log);
+        if (!valid) return value
+        var formatter = new _intl.DateTimeFormat(locales, validatedOptions);
+        var ret = formatter.format(date);
+        var parts = typeof formatter.formatToParts === 'function' ? formatter.formatToParts(date) : undefined;
+        setPostFormatContext(formatterConfig, { value: ret, parts, rawValue: value, locales, options: validatedOptions, format: 'dateTime' });
+        return ret
+      });
+      this.registerFormatter('dateTimeRange', (formatterConfig = {}) => {
+        var {locales, value, options = {}} = formatterConfig;
+        if (!isRangeObject(value)) return value?.toString() || value
+
+        var start = toDate(value.start);
+        var end = toDate(value.end);
+        var { valid, options: validatedOptions } = validateIntlOptions(options, this.#log);
+
+        if (!valid) return `${value.start} - ${value.end}`
+
+        var formatter = new _intl.DateTimeFormat(locales, validatedOptions);
+
+        if (!(start instanceof Date) || !(end instanceof Date)) return `${value.start} - ${value.end}`
+        if (typeof formatter.formatRange !== 'function') {
+          this.#log.warn("Formatter 'dateTimeRange' requires Intl.DateTimeFormat.prototype.formatRange support.");
+          return `${formatter.format(start)} - ${formatter.format(end)}`
+        }
+        var ret = formatter.formatRange(start, end);
+        var parts = typeof formatter.formatRangeToParts === 'function' ? formatter.formatRangeToParts(start, end) : undefined;
+        setPostFormatContext(formatterConfig, { value: ret, parts, rawValue: value, locales, options: validatedOptions, format: 'dateTimeRange' });
+        return ret
+      });
+      this.registerFormatter('relativeTime', (formatterConfig = {}) => {
+        var {locales, value, options = {}, unit='seconds'} = formatterConfig;
+        if (isNaN(value)) return value?.toString() || value
+        var normalizedUnit = normalizeRelativeTimeUnit(unit);
+        var { valid, options: validatedOptions } = validateIntlOptions(options, this.#log);
+        var supportedUnits = getSupportedIntlValues('unit');
+
+        if (!valid) return value?.toString() || value
+        if (supportedUnits && !supportedUnits.includes(normalizedUnit)) {
+          this.#log.warn("Invalid Intl option 'unit':", normalizedUnit);
+          return value?.toString() || value
+        }
+
+        var formatter = new _intl.RelativeTimeFormat(locales, validatedOptions);
+        var ret = formatter.format(value, normalizedUnit);
+        var parts = typeof formatter.formatToParts === 'function' ? formatter.formatToParts(value, normalizedUnit) : undefined;
+        setPostFormatContext(formatterConfig, { value: ret, parts, rawValue: value, locales, options: validatedOptions, format: 'relativeTime', unit: normalizedUnit });
+        return ret
+      });
+      this.registerFormatter('duration', ({locales, value, options = {}}) => {
+        if (typeof _intl.DurationFormat !== 'function') {
+          this.#log.warn("Formatter 'duration' requires Intl.DurationFormat support.");
+          return isPlainObject(value) ? JSON.stringify(value) : value?.toString() || value
+        }
+        if (!isPlainObject(value)) return value?.toString() || value
+        var { valid, options: validatedOptions } = validateIntlOptions(options, this.#log);
+        if (!valid) return isPlainObject(value) ? JSON.stringify(value) : value?.toString() || value
+        return new _intl.DurationFormat(locales, validatedOptions).format(value)
+      });
+      this.registerFormatter('humanizedRelativeTime', ({locales, value, options = {}}) => {
+        var date = toDate(value);
+        if (!(date instanceof Date)) return value
+        var unit = 'seconds';
+        var now = Date.now();
+        var diff = Math.round((date - now) / 1000);
+        var aDiff = Math.abs(diff);
+        var gap = diff;
+        const rules = [
+          ['minutes', 60] ,
+          ['hours', 60 * 60],
+          ['days', 60 * 60 * 24],
+          ['weeks', 60 * 60 * 24 * 7],
+          ['months',  60 * 60 * 24 * 30],
+          ['quarters', 60 * 60 * 24 * 90],
+          ['years', 60 * 60 * 24 * 365]
+        ];
+        for (let [u, f] of rules) {
+          if (Math.floor(aDiff / f) < 1) continue
+          unit = u;
+          gap = Math.floor(diff / f);
+        }
+        var normalizedUnit = normalizeRelativeTimeUnit(unit);
+        var { valid, options: validatedOptions } = validateIntlOptions(options, this.#log);
+        var supportedUnits = getSupportedIntlValues('unit');
+
+        if (!valid) return value
+        if (supportedUnits && !supportedUnits.includes(normalizedUnit)) {
+          this.#log.warn("Invalid Intl option 'unit':", normalizedUnit);
+          return value
+        }
+
+        return new _intl.RelativeTimeFormat(locales, validatedOptions).format(gap, normalizedUnit)
+      });
+      return this
+    }
+
+    registerFormatter (format, func) {
+      if (typeof func === 'function') { this.#formatters[format] = func; }
+      return this
+    }
+  }
+
+  return IntlMsg;
+
+})();

package/dist/cjs/compose.cjs

@@ -0,0 +1,65 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function isPlainObject(value) {
+  if (Object.prototype.toString.call(value) !== '[object Object]') {
+    return false
+  }
+
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === null || prototype === Object.prototype
+}
+
+function mergeDictionaryEntry(target = {}, source = {}) {
+  const mergedTranslations = {
+    ...(isPlainObject(target.translations) ? target.translations : {}),
+    ...(isPlainObject(source.translations) ? source.translations : {}),
+  };
+  const mergedFormatters = {
+    ...(isPlainObject(target.formatters) ? target.formatters : {}),
+    ...(isPlainObject(source.formatters) ? source.formatters : {}),
+  };
+
+  const result = {};
+  if (Object.keys(mergedTranslations).length > 0) result.translations = mergedTranslations;
+  if (Object.keys(mergedFormatters).length > 0) result.formatters = mergedFormatters;
+  return result
+}
+
+function mergeDictionaries(target = {}, source = {}) {
+  if (!isPlainObject(source)) return target
+
+  const result = { ...target };
+  for (const locale of Object.keys(source)) {
+    const existingEntry = isPlainObject(result[locale]) ? result[locale] : {};
+    const nextEntry = isPlainObject(source[locale]) ? source[locale] : null;
+    if (!nextEntry) continue
+    result[locale] = mergeDictionaryEntry(existingEntry, nextEntry);
+  }
+  return result
+}
+
+async function composeDictionaries(plan = [], loader, options = {}) {
+  if (!Array.isArray(plan)) throw new TypeError('plan must be an array')
+  if (typeof loader !== 'function') throw new TypeError('loader must be a function')
+
+  const onError = options.onError ?? 'throw';
+  let merged = {};
+
+  for (const entry of plan) {
+    try {
+      const loaded = await loader(entry);
+      if (!loaded) continue
+      merged = mergeDictionaries(merged, loaded);
+    } catch (error) {
+      if (onError === 'skip') continue
+      throw error
+    }
+  }
+
+  return merged
+}
+
+exports.composeDictionaries = composeDictionaries;
+exports.default = composeDictionaries;