@hi18n/cli/dist/export.js

Message internationalization meets immutability and type-safety - command line tool

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.export_ = export_;

var _push = _interopRequireDefault(require("core-js-pure/stable/instance/push.js"));

var _nodeFs = _interopRequireDefault(require("node:fs"));

var _nodePath = _interopRequireDefault(require("node:path"));

var _nodeUtil = _interopRequireDefault(require("node:util"));

var _glob = _interopRequireDefault(require("glob"));

var _utils = require("@typescript-eslint/utils");

var _eslintPlugin = require("@hi18n/eslint-plugin");

var _config = require("./config");

async function export_(options) {
  const {
    cwd
  } = options;
  const config = await (0, _config.loadConfig)(cwd);
  const include = config.include;
  const exclude = config.exclude;

  if (include === undefined || include.length === 0) {
    throw new Error("No include specified");
  }

  if (!config.connector) {
    throw new Error("Connector not configured");
  }

  const linterConfig = {
    parser: config.parser,
    parserOptions: config.parserOptions
  };
  const linter = new _utils.TSESLint.Linter({
    cwd
  });
  const catalogDefs = [];
  linter.defineRule("@hi18n/collect-catalog-definitions", _eslintPlugin.rules["collect-catalog-definitions"]);
  const files = [];

  for (const includeGlob of include) {
    (0, _push.default)(files).call(files, ...(await _nodeUtil.default.promisify(_glob.default)(includeGlob, {
      cwd,
      nodir: true,
      ignore: exclude
    })));
  }

  for (const relative of files) {
    const filename = _nodePath.default.join(cwd, relative);

    const source = await _nodeFs.default.promises.readFile(filename, "utf-8");
    const messages = linter.verify(source, { ...linterConfig,
      rules: {
        "@hi18n/collect-catalog-definitions": ["error", c => {
          (0, _push.default)(catalogDefs).call(catalogDefs, c);
        }, {
          requestMessages: true
        }]
      }
    }, {
      filename
    });
    checkMessages(relative, messages);
  }

  const translations = {};

  for (const catalogDef of catalogDefs) {
    var _translations$locale;

    if (!catalogDef.locale) {
      throw new Error(`No locale given in ${catalogDef.catalogLocation.path}`);
    }

    const locale = catalogDef.locale;
    const catalogData = (_translations$locale = translations[locale]) !== null && _translations$locale !== void 0 ? _translations$locale : translations[locale] = {};

    for (const [key, messageDef] of Object.entries(catalogDef.messages)) {
      catalogData[key] = {
        raw: messageDef.value
      };
    }
  }

  const c = config.connector.connector(config.configPath, config.connectorOptions);

  if (!c.exportData) {
    throw new Error("This connector doesn't support exporting");
  }

  await c.exportData({
    translations
  });
}

function checkMessages(filepath, messages) {
  for (const message of messages) {
    if (/^Definition for rule .* was not found\.$/.test(message.message)) {
      // We load ESLint with minimal rules. Ignore the "missing rule" error.
      continue;
    }

    if (message.severity >= 2) throw new Error(`Error on ${filepath}: ${message.message}`);
  }
}
//# sourceMappingURL=export.js.map