@eouia/intl-msg 0.1.0

package/dist/esm/compose.js

@@ -0,0 +1,60 @@
+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
+}
+
+export { composeDictionaries, composeDictionaries as default };

package/dist/esm/loaders.js

@@ -0,0 +1,66 @@
+function defaultResolvePath({ locale, source }) {
+  return `./dictionaries/${source}/${locale}.json`
+}
+
+function defaultResolveUrl({ locale, source }) {
+  return `/dictionaries/${source}/${locale}.json`
+}
+
+function createMemoryLoader(registry = {}) {
+  return async function memoryLoader({ locale, source }) {
+    return registry?.[source]?.[locale] ?? null
+  }
+}
+
+function createFetchLoader({
+  resolveUrl = defaultResolveUrl,
+  fetchImpl = globalThis.fetch,
+  parse = async (response) => response.json(),
+} = {}) {
+  if (typeof resolveUrl !== 'function') throw new TypeError('resolveUrl must be a function')
+  if (typeof fetchImpl !== 'function') throw new TypeError('fetchImpl must be a function')
+  if (typeof parse !== 'function') throw new TypeError('parse must be a function')
+
+  return async function fetchLoader(entry) {
+    const url = await resolveUrl(entry);
+    if (!url) return null
+
+    const response = await fetchImpl(url);
+    if (!response?.ok) return null
+
+    const dictionary = await parse(response);
+    return dictionary ?? null
+  }
+}
+
+function createPathLoader({
+  resolvePath = defaultResolvePath,
+  readFile,
+  parse = JSON.parse,
+} = {}) {
+  if (typeof resolvePath !== 'function') throw new TypeError('resolvePath must be a function')
+  if (typeof readFile !== 'function') throw new TypeError('readFile must be a function')
+  if (typeof parse !== 'function') throw new TypeError('parse must be a function')
+
+  return async function pathLoader(entry) {
+    const path = await resolvePath(entry);
+    if (!path) return null
+
+    try {
+      const fileContents = await readFile(path, 'utf8');
+      const dictionary = await parse(fileContents);
+      return dictionary ?? null
+    } catch (error) {
+      if (error && (error.code === 'ENOENT' || error.code === 'ENOTDIR')) return null
+      throw error
+    }
+  }
+}
+
+var loaders = {
+  createMemoryLoader,
+  createFetchLoader,
+  createPathLoader,
+};
+
+export { createFetchLoader, createMemoryLoader, createPathLoader, loaders as default };