@zainulbr/i18n-webpack-plugin/dist/index.js

Rewrite original embed localization into your bundle with support webpack 5

"use strict";

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

var _ConstDependency = _interopRequireDefault(require("webpack/lib/dependencies/ConstDependency"));

var _NullFactory = _interopRequireDefault(require("webpack/lib/NullFactory"));

var _MissingLocalizationError = _interopRequireDefault(require("./MissingLocalizationError"));

var _MakeLocalizeFunction = _interopRequireDefault(require("./MakeLocalizeFunction"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }

function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }

/**
 *
 * @param {object|function} localization
 * @param {object|string} Options object or obselete functionName string
 * @constructor
 */
var I18nPlugin = /*#__PURE__*/function () {
  function I18nPlugin(localization, poptions, failOnMissing) {
    _classCallCheck(this, I18nPlugin);

    var options = poptions; // Backward-compatiblility

    if (typeof options === 'string') {
      options = {
        functionName: options
      };
    }

    if (typeof failOnMissing !== 'undefined') {
      options.failOnMissing = failOnMissing;
    }

    this.options = options || {};
    var plocalization = typeof localization === 'function' ? localization : (0, _MakeLocalizeFunction.default)(localization, !!this.options.nested);
    this.localization = localization ? plocalization : {};
    this.functionName = this.options.functionName || '__';
    this.failOnMissing = !!this.options.failOnMissing;
    this.hideMessage = this.options.hideMessage || false;
  }

  _createClass(I18nPlugin, [{
    key: "apply",
    value: function apply(compiler) {
      var PLUGIN_NAME = 'I18nPlugin';
      var localization = this.localization,
          failOnMissing = this.failOnMissing,
          hideMessage = this.hideMessage; // eslint-disable-line no-unused-vars

      var name = this.functionName;
      compiler.hooks.compilation.tap(PLUGIN_NAME, function (compilation, _ref) {
        var normalModuleFactory = _ref.normalModuleFactory;
        compilation.dependencyFactories.set(_ConstDependency.default, new _NullFactory.default());
        compilation.dependencyTemplates.set(_ConstDependency.default, new _ConstDependency.default.Template());

        var handler = function handler(parser) {
          // eslint-disable-line no-unused-vars
          // should use function here instead of arrow function due to save the Tapable's context
          parser.hooks.call.for(name).tap("call ".concat(name), function (expr) {
            var param;
            var defaultValue;

            switch (expr.arguments.length) {
              case 2:
                param = expr.arguments[1].value;
                if (typeof param !== 'string') return;
                defaultValue = expr.arguments[0].value;
                if (typeof defaultValue !== 'string') return;
                break;

              case 1:
                param = expr.arguments[0].value;
                if (typeof param !== 'string') return;
                defaultValue = param;
                break;

              default:
                return;
            }

            var result = localization && typeof localization === 'function' ? localization(param) : defaultValue;

            if (typeof result === 'undefined') {
              var error = parser.state.module[__dirname];

              if (!error) {
                error = new _MissingLocalizationError.default(parser.state.module, param, defaultValue);
                parser.state.module[__dirname] = error;

                if (failOnMissing) {
                  parser.state.module.errors.push(error);
                } else if (!hideMessage) {
                  parser.state.module.warnings.push(error);
                }
              } else if (!error.requests.includes(param)) {
                error.add(param, defaultValue);
              }

              result = defaultValue;
            }

            var dep = new _ConstDependency.default(JSON.stringify(result), expr.range);
            dep.loc = expr.loc;
            parser.state.current.addDependency(dep);
            return true;
          });
        };

        normalModuleFactory.hooks.parser.for('javascript/auto').tap(PLUGIN_NAME, handler);
        normalModuleFactory.hooks.parser.for('javascript/dynamic').tap(PLUGIN_NAME, handler);
        normalModuleFactory.hooks.parser.for('javascript/esm').tap(PLUGIN_NAME, handler);
      });
    }
  }]);

  return I18nPlugin;
}();

var _default = I18nPlugin;
exports.default = _default;