@common.js/use-intl 4.13.1

package/dist/esm/development/format-message/index.js

@@ -0,0 +1,238 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return formatMessage;
+    }
+});
+var _intlMessageformat = require("intl-messageformat");
+var _react = require("react");
+var _formattersR4AAmsMPJs = require("../formatters-r4aAmsMP.js");
+function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _arrayWithHoles(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _defineProperty(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterableToArrayLimit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _objectSpread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _defineProperty(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _objectSpreadProps(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _slicedToArray(arr, i) {
+    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+var _typeof = function(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+};
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+/**
+ * `intl-messageformat` uses separate keys for `date` and `time`, but there's
+ * only one native API: `Intl.DateTimeFormat`. Additionally you might want to
+ * include both a time and a date in a value, therefore the separation doesn't
+ * seem so useful. We offer a single `dateTime` namespace instead, but we have
+ * to convert the format before `intl-messageformat` can be used.
+ */ function convertFormatsToIntlMessageFormat(globalFormats, inlineFormats, timeZone) {
+    var mfDateDefaults = _intlMessageformat.IntlMessageFormat.formats.date;
+    var mfTimeDefaults = _intlMessageformat.IntlMessageFormat.formats.time;
+    var dateTimeFormats = _objectSpread({}, globalFormats === null || globalFormats === void 0 ? void 0 : globalFormats.dateTime, inlineFormats === null || inlineFormats === void 0 ? void 0 : inlineFormats.dateTime);
+    var allFormats = {
+        date: _objectSpread({}, mfDateDefaults, dateTimeFormats),
+        time: _objectSpread({}, mfTimeDefaults, dateTimeFormats),
+        number: _objectSpread({}, globalFormats === null || globalFormats === void 0 ? void 0 : globalFormats.number, inlineFormats === null || inlineFormats === void 0 ? void 0 : inlineFormats.number)
+    };
+    if (timeZone) {
+        // The only way to set a time zone with `intl-messageformat` is to merge it into the formats
+        // https://github.com/formatjs/formatjs/blob/8256c5271505cf2606e48e3c97ecdd16ede4f1b5/packages/intl/src/message.ts#L15
+        [
+            "date",
+            "time"
+        ].forEach(function(property) {
+            var formats = allFormats[property];
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                for(var _iterator = Object.entries(formats)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                    var _value = _slicedToArray(_step.value, 2), key = _value[0], value = _value[1];
+                    formats[key] = _objectSpread({
+                        timeZone: timeZone
+                    }, value);
+                }
+            } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
+        });
+    }
+    return allFormats;
+}
+// Placed here for improved tree shaking. Somehow when this is placed in
+// `formatters.tsx`, then it can't be shaken off from `next-intl`.
+function createMessageFormatter(cache, intlFormatters) {
+    var getMessageFormat = (0, _formattersR4AAmsMPJs.m)(function() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        return new _intlMessageformat.IntlMessageFormat(args[0], args[1], args[2], _objectSpread({
+            formatters: intlFormatters
+        }, args[3]));
+    }, cache.message);
+    return getMessageFormat;
+}
+function getPlainMessage(candidate, values) {
+    // To improve runtime performance, only compile message if:
+    return(// 1. Values are provided
+    values || // 2. There are ICU escape sequences (e.g. "'{name'}")
+    /'[{}<#|']/.test(candidate) || // 3. There are missing arguments or tags (dev-only error handling)
+    /<|{/.test(candidate) ? undefined // Compile
+     : candidate // Don't compile
+    );
+}
+/**
+ * Compiles and formats an ICU message at runtime using intl-messageformat.
+ * This is the default implementation used when messages are not precompiled.
+ */ function formatMessage() {
+    /** The raw ICU message string (or precompiled message, though this implementation ignores precompilation) */ for(var _len = arguments.length, _tmp = new Array(_len), _key = 0; _key < _len; _key++){
+        _tmp[_key] = arguments[_key];
+    }
+    var __tmp = _slicedToArray(_tmp, 4), key = __tmp[0], message = __tmp[1], values = __tmp[2], options = __tmp[3];
+    if (Array.isArray(message)) {
+        throw new _formattersR4AAmsMPJs.I(_formattersR4AAmsMPJs.a.INVALID_MESSAGE, "Message at `".concat(key, "` resolved to an array, but only strings are supported. See https://next-intl.dev/docs/usage/translations#arrays-of-messages"));
+    }
+    if (typeof message === "object") {
+        throw new _formattersR4AAmsMPJs.I(_formattersR4AAmsMPJs.a.INSUFFICIENT_PATH, "Message at `".concat(key, "` resolved to `").concat(typeof message === "undefined" ? "undefined" : _typeof(message), "`, but only strings are supported. Use a `.` to retrieve nested messages. See https://next-intl.dev/docs/usage/translations#structuring-messages"));
+    }
+    // Hot path that avoids creating an `IntlMessageFormat` instance
+    if (typeof message === "string") {
+        var plainMessage = getPlainMessage(message, values);
+        if (plainMessage) return plainMessage;
+    }
+    var cache = options.cache, formats = options.formats, formatters = options.formatters, globalFormats = options.globalFormats, locale = options.locale, timeZone = options.timeZone;
+    // Lazy init the message formatter for better tree
+    // shaking in case message formatting is not used.
+    if (!formatters.getMessageFormat) {
+        formatters.getMessageFormat = createMessageFormatter(cache, formatters);
+    }
+    var messageFormat;
+    try {
+        messageFormat = formatters.getMessageFormat(message, locale, convertFormatsToIntlMessageFormat(globalFormats, formats, timeZone), {
+            formatters: _objectSpreadProps(_objectSpread({}, formatters), {
+                getDateTimeFormat: function getDateTimeFormat(locales, dateTimeOptions) {
+                    var ref;
+                    // Workaround for https://github.com/formatjs/formatjs/issues/4279
+                    return formatters.getDateTimeFormat(locales, _objectSpreadProps(_objectSpread({}, dateTimeOptions), {
+                        timeZone: (ref = dateTimeOptions === null || dateTimeOptions === void 0 ? void 0 : dateTimeOptions.timeZone) !== null && ref !== void 0 ? ref : timeZone
+                    }));
+                }
+            })
+        });
+    } catch (error) {
+        throw new _formattersR4AAmsMPJs.I(_formattersR4AAmsMPJs.a.INVALID_MESSAGE, "".concat(error.message, " (").concat(error.originalMessage, ")"));
+    }
+    var formattedMessage = messageFormat.format(// @ts-expect-error `intl-messageformat` expects a different format
+    // for rich text elements since a recent minor update. This
+    // needs to be evaluated in detail, possibly also in regard
+    // to be able to format to parts.
+    values);
+    // Limit the function signature to return strings or React elements
+    return /*#__PURE__*/ (0, _react.isValidElement)(formattedMessage) || // Arrays of React elements
+    Array.isArray(formattedMessage) || typeof formattedMessage === "string" ? formattedMessage : String(formattedMessage);
+}
+// `t.raw` is supported
+formatMessage.raw = true;

package/dist/esm/development/formatters-r4aAmsMP.js

@@ -0,0 +1,266 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    I: function() {
+        return IntlError;
+    },
+    a: function() {
+        return IntlErrorCode;
+    },
+    b: function() {
+        return createCache;
+    },
+    c: function() {
+        return createIntlFormatters;
+    },
+    m: function() {
+        return memoFn;
+    }
+});
+var _fastMemoize = require("@formatjs/fast-memoize");
+function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+function _assertThisInitialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Date.prototype.toString.call(Reflect.construct(Date, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _construct(Parent, args, Class) {
+    if (isNativeReflectConstruct()) {
+        _construct = Reflect.construct;
+    } else {
+        _construct = function _construct(Parent, args, Class) {
+            var a = [
+                null
+            ];
+            a.push.apply(a, args);
+            var Constructor = Function.bind.apply(Parent, a);
+            var instance = new Constructor();
+            if (Class) _setPrototypeOf(instance, Class.prototype);
+            return instance;
+        };
+    }
+    return _construct.apply(null, arguments);
+}
+function _getPrototypeOf(o) {
+    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _getPrototypeOf(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _setPrototypeOf(subClass, superClass);
+}
+function _isNativeFunction(fn) {
+    return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+function _iterableToArray(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _nonIterableSpread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _possibleConstructorReturn(self, call) {
+    if (call && (_typeof(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assertThisInitialized(self);
+}
+function _setPrototypeOf(o, p) {
+    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _setPrototypeOf(o, p);
+}
+function _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+var _typeof = function(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+};
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+function _wrapNativeSuper(Class) {
+    var _cache = typeof Map === "function" ? new Map() : undefined;
+    _wrapNativeSuper = function _wrapNativeSuper(Class) {
+        if (Class === null || !_isNativeFunction(Class)) return Class;
+        if (typeof Class !== "function") {
+            throw new TypeError("Super expression must either be null or a function");
+        }
+        if (typeof _cache !== "undefined") {
+            if (_cache.has(Class)) return _cache.get(Class);
+            _cache.set(Class, Wrapper);
+        }
+        function Wrapper() {
+            return _construct(Class, arguments, _getPrototypeOf(this).constructor);
+        }
+        Wrapper.prototype = Object.create(Class.prototype, {
+            constructor: {
+                value: Wrapper,
+                enumerable: false,
+                writable: true,
+                configurable: true
+            }
+        });
+        return _setPrototypeOf(Wrapper, Class);
+    };
+    return _wrapNativeSuper(Class);
+}
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
+var IntlError = /*#__PURE__*/ function(Error1) {
+    "use strict";
+    _inherits(IntlError, Error1);
+    var _super = _createSuper(IntlError);
+    function IntlError(code, originalMessage) {
+        _classCallCheck(this, IntlError);
+        var _this;
+        var message = code;
+        if (originalMessage) {
+            message += ": " + originalMessage;
+        }
+        _this = _super.call(this, message);
+        _this.code = code;
+        if (originalMessage) {
+            _this.originalMessage = originalMessage;
+        }
+        return _this;
+    }
+    return IntlError;
+}(_wrapNativeSuper(Error));
+var IntlErrorCode = /*#__PURE__*/ function(IntlErrorCode) {
+    IntlErrorCode["MISSING_MESSAGE"] = "MISSING_MESSAGE";
+    IntlErrorCode["MISSING_FORMAT"] = "MISSING_FORMAT";
+    IntlErrorCode["ENVIRONMENT_FALLBACK"] = "ENVIRONMENT_FALLBACK";
+    IntlErrorCode["INSUFFICIENT_PATH"] = "INSUFFICIENT_PATH";
+    IntlErrorCode["INVALID_MESSAGE"] = "INVALID_MESSAGE";
+    IntlErrorCode["INVALID_KEY"] = "INVALID_KEY";
+    IntlErrorCode["FORMATTING_ERROR"] = "FORMATTING_ERROR";
+    return IntlErrorCode;
+}(IntlErrorCode || {});
+function createCache() {
+    return {
+        dateTime: {},
+        number: {},
+        message: {},
+        relativeTime: {},
+        pluralRules: {},
+        list: {},
+        displayNames: {}
+    };
+}
+function createMemoCache(store) {
+    return {
+        create: function create() {
+            return {
+                get: function get(key) {
+                    return store[key];
+                },
+                set: function set(key, value) {
+                    store[key] = value;
+                }
+            };
+        }
+    };
+}
+function memoFn(fn, cache) {
+    return (0, _fastMemoize.memoize)(fn, {
+        cache: createMemoCache(cache),
+        strategy: _fastMemoize.strategies.variadic
+    });
+}
+function memoConstructor(ConstructorFn, cache) {
+    return memoFn(function() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        return _construct(ConstructorFn, _toConsumableArray(args));
+    }, cache);
+}
+function createIntlFormatters(cache) {
+    var getDateTimeFormat = memoConstructor(Intl.DateTimeFormat, cache.dateTime);
+    var getNumberFormat = memoConstructor(Intl.NumberFormat, cache.number);
+    var getPluralRules = memoConstructor(Intl.PluralRules, cache.pluralRules);
+    var getRelativeTimeFormat = memoConstructor(Intl.RelativeTimeFormat, cache.relativeTime);
+    var getListFormat = memoConstructor(Intl.ListFormat, cache.list);
+    var getDisplayNames = memoConstructor(Intl.DisplayNames, cache.displayNames);
+    return {
+        getDateTimeFormat: getDateTimeFormat,
+        getNumberFormat: getNumberFormat,
+        getPluralRules: getPluralRules,
+        getRelativeTimeFormat: getRelativeTimeFormat,
+        getListFormat: getListFormat,
+        getDisplayNames: getDisplayNames
+    };
+}

package/dist/esm/development/index.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    IntlError: function() {
+        return _formattersR4AAmsMPJs.I;
+    },
+    IntlErrorCode: function() {
+        return _formattersR4AAmsMPJs.a;
+    },
+    "_createCache": function() {
+        return _formattersR4AAmsMPJs.b;
+    },
+    "_createIntlFormatters": function() {
+        return _formattersR4AAmsMPJs.c;
+    },
+    createTranslator: function() {
+        return _coreJs.createTranslator;
+    },
+    hasLocale: function() {
+        return _coreJs.hasLocale;
+    },
+    createFormatter: function() {
+        return _initializeConfigCUsOI8U2Js.c;
+    },
+    initializeConfig: function() {
+        return _initializeConfigCUsOI8U2Js.i;
+    },
+    IntlProvider: function() {
+        return _reactJs.IntlProvider;
+    },
+    "_useExtracted": function() {
+        return _reactJs["_useExtracted"];
+    },
+    useFormatter: function() {
+        return _reactJs.useFormatter;
+    },
+    useLocale: function() {
+        return _reactJs.useLocale;
+    },
+    useMessages: function() {
+        return _reactJs.useMessages;
+    },
+    useNow: function() {
+        return _reactJs.useNow;
+    },
+    useTimeZone: function() {
+        return _reactJs.useTimeZone;
+    },
+    useTranslations: function() {
+        return _reactJs.useTranslations;
+    }
+});
+var _formattersR4AAmsMPJs = require("./formatters-r4aAmsMP.js");
+var _coreJs = require("./core.js");
+var _initializeConfigCUsOI8U2Js = require("./initializeConfig-CUsOI8u2.js");
+var _reactJs = require("./react.js");