@skyra/i18next-backend/dist/cjs/index.cjs

A fast and modern filesystem-based i18next backend for Node.js.

'use strict';

var fs = require('fs');
var promises = require('fs/promises');
var url = require('url');

var __defProp = Object.defineProperty;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
var _Backend = class _Backend {
  constructor() {
    __publicField(this, "type", "backend");
    __publicField(this, "paths");
    __publicField(this, "i18nextOptions");
  }
  init(_, backendOptions, i18nextOptions) {
    this.paths = backendOptions.paths ?? [];
    this.i18nextOptions = i18nextOptions;
  }
  read(language, namespace, callback) {
    if (this.paths.length === 0) return callback(new Error("No files registered"), null);
    if (this.i18nextOptions.initImmediate === true) {
      try {
        return callback(null, this.readPathsSync(language, namespace));
      } catch (error) {
        return callback(error, false);
      }
    }
    this.readPaths(language, namespace).then((data) => callback(null, data)).catch((error) => callback(error, false));
  }
  async readPaths(language, namespace) {
    if (this.paths.length === 1) return _Backend.readPath(_Backend.resolvePath(language, namespace, this.paths[0]));
    const results = await Promise.allSettled(this.paths.map((path) => _Backend.readPath(_Backend.resolvePath(language, namespace, path))));
    return _Backend.handleResults(results);
  }
  readPathsSync(language, namespace) {
    if (this.paths.length === 1) return _Backend.readPathSync(_Backend.resolvePath(language, namespace, this.paths[0]));
    const results = this.paths.map((path) => {
      try {
        return { status: "fulfilled", value: _Backend.readPathSync(_Backend.resolvePath(language, namespace, path)) };
      } catch (error) {
        return { status: "rejected", reason: error };
      }
    });
    return _Backend.handleResults(results);
  }
  static async readPath(path) {
    return JSON.parse(await promises.readFile(path, "utf8"));
  }
  static readPathSync(path) {
    return JSON.parse(fs.readFileSync(path, "utf8"));
  }
  static handleResults(results) {
    const filtered = results.filter((result) => result.status === "fulfilled");
    if (filtered.length === 0) {
      throw new AggregateError(
        results.map((result) => result.reason),
        "Could not find the file in any of the registered paths"
      );
    }
    return Object.assign({}, ...filtered.map((result) => result.value));
  }
  static resolvePath(language, namespace, path) {
    if (typeof path === "function") return path(language, namespace);
    if (typeof path !== "string") path = url.fileURLToPath(path);
    return path.replaceAll(/\{\{(?:lng|ns)\}\}/g, (match) => match === "{{lng}}" ? language : namespace);
  }
};
__name(_Backend, "Backend");
__publicField(_Backend, "type", "backend");
var Backend = _Backend;

exports.Backend = Backend;
//# sourceMappingURL=index.cjs.map
//# sourceMappingURL=index.cjs.map