@common.js/use-intl 4.13.1

package/dist/esm/development/react.js

@@ -0,0 +1,390 @@
+"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, {
+    IntlProvider: function() {
+        return IntlProvider;
+    },
+    "_useExtracted": function() {
+        return useExtracted;
+    },
+    useFormatter: function() {
+        return useFormatter;
+    },
+    useLocale: function() {
+        return useLocale;
+    },
+    useMessages: function() {
+        return useMessages;
+    },
+    useNow: function() {
+        return useNow;
+    },
+    useTimeZone: function() {
+        return useTimeZone;
+    },
+    useTranslations: function() {
+        return useTranslations;
+    }
+});
+var _react = require("react");
+var _formattersR4AAmsMPJs = require("./formatters-r4aAmsMP.js");
+var _initializeConfigCUsOI8U2Js = require("./initializeConfig-CUsOI8u2.js");
+var _jsxRuntime = require("react/jsx-runtime");
+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 _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) return _arrayLikeToArray(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 _iterableToArray(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+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 _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 _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();
+}
+function _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+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);
+}
+var IntlContext = /*#__PURE__*/ (0, _react.createContext)(undefined);
+function IntlProvider(param) {
+    var children = param.children, formats = param.formats, getMessageFallback = param.getMessageFallback, locale = param.locale, messages = param.messages, now = param.now, onError = param.onError, timeZone = param.timeZone;
+    var prevContext = (0, _react.useContext)(IntlContext);
+    // The formatter cache is released when the locale changes. For
+    // long-running apps with a persistent `IntlProvider` at the root,
+    // this can reduce the memory footprint (e.g. in React Native).
+    var cache = (0, _react.useMemo)(function() {
+        return (prevContext === null || prevContext === void 0 ? void 0 : prevContext.cache) || (0, _formattersR4AAmsMPJs.b)();
+    }, [
+        locale,
+        prevContext === null || prevContext === void 0 ? void 0 : prevContext.cache
+    ]);
+    var formatters = (0, _react.useMemo)(function() {
+        return (prevContext === null || prevContext === void 0 ? void 0 : prevContext.formatters) || (0, _formattersR4AAmsMPJs.c)(cache);
+    }, [
+        cache,
+        prevContext === null || prevContext === void 0 ? void 0 : prevContext.formatters
+    ]);
+    // Memoizing this value helps to avoid triggering a re-render of all
+    // context consumers in case the configuration didn't change. However,
+    // if some of the non-primitive values change, a re-render will still
+    // be triggered. Note that there's no need to put `memo` on `IntlProvider`
+    // itself, because the `children` typically change on every render.
+    // There's some burden on the consumer side if it's important to reduce
+    // re-renders, put that's how React works.
+    // See: https://blog.isquaredsoftware.com/2020/05/blogged-answers-a-mostly-complete-guide-to-react-rendering-behavior/#context-updates-and-render-optimizations
+    var value = (0, _react.useMemo)(function() {
+        return _objectSpreadProps(_objectSpread({}, (0, _initializeConfigCUsOI8U2Js.i)({
+            locale: locale,
+            // (required by provider)
+            formats: formats === undefined ? prevContext === null || prevContext === void 0 ? void 0 : prevContext.formats : formats,
+            getMessageFallback: getMessageFallback || (prevContext === null || prevContext === void 0 ? void 0 : prevContext.getMessageFallback),
+            messages: messages === undefined ? prevContext === null || prevContext === void 0 ? void 0 : prevContext.messages : messages,
+            now: now || (prevContext === null || prevContext === void 0 ? void 0 : prevContext.now),
+            onError: onError || (prevContext === null || prevContext === void 0 ? void 0 : prevContext.onError),
+            timeZone: timeZone || (prevContext === null || prevContext === void 0 ? void 0 : prevContext.timeZone)
+        })), {
+            formatters: formatters,
+            cache: cache
+        });
+    }, [
+        cache,
+        formats,
+        formatters,
+        getMessageFallback,
+        locale,
+        messages,
+        now,
+        onError,
+        prevContext,
+        timeZone
+    ]);
+    return /*#__PURE__*/ (0, _jsxRuntime.jsx)(IntlContext.Provider, {
+        value: value,
+        children: children
+    });
+}
+function useIntlContext() {
+    var context = (0, _react.useContext)(IntlContext);
+    if (!context) {
+        throw new Error("No intl context found. Have you configured the provider? See https://next-intl.dev/docs/usage/configuration#server-client-components");
+    }
+    return context;
+}
+var hasWarnedForMissingTimezone = false;
+var isServer = typeof window === "undefined";
+function useTranslationsImpl(allMessagesPrefixed, namespacePrefixed, namespacePrefix) {
+    var ref = useIntlContext(), cache = ref.cache, globalFormats = ref.formats, formatters = ref.formatters, getMessageFallback = ref.getMessageFallback, locale = ref.locale, onError = ref.onError, timeZone = ref.timeZone;
+    // The `namespacePrefix` is part of the type system.
+    // See the comment in the hook invocation.
+    var allMessages = allMessagesPrefixed[namespacePrefix];
+    var namespace = (0, _initializeConfigCUsOI8U2Js.r)(namespacePrefixed, namespacePrefix);
+    if (!timeZone && !hasWarnedForMissingTimezone && isServer) {
+        // eslint-disable-next-line react-compiler/react-compiler
+        hasWarnedForMissingTimezone = true;
+        onError(new _formattersR4AAmsMPJs.I(_formattersR4AAmsMPJs.a.ENVIRONMENT_FALLBACK, "There is no `timeZone` configured, this can lead to markup mismatches caused by environment differences. Consider adding a global default: https://next-intl.dev/docs/configuration#time-zone"));
+    }
+    var translate = (0, _react.useMemo)(function() {
+        return (0, _initializeConfigCUsOI8U2Js.a)({
+            cache: cache,
+            formatters: formatters,
+            getMessageFallback: getMessageFallback,
+            messages: allMessages,
+            namespace: namespace,
+            onError: onError,
+            formats: globalFormats,
+            locale: locale,
+            timeZone: timeZone
+        });
+    }, [
+        cache,
+        formatters,
+        getMessageFallback,
+        allMessages,
+        namespace,
+        onError,
+        globalFormats,
+        locale,
+        timeZone
+    ]);
+    return translate;
+}
+/**
+ * Translates messages from the given namespace by using the ICU syntax.
+ * See https://formatjs.io/docs/core-concepts/icu-syntax.
+ *
+ * If no namespace is provided, all available messages are returned.
+ * The namespace can also indicate nesting by using a dot
+ * (e.g. `namespace.Component`).
+ */ function useTranslations(namespace) {
+    var context = useIntlContext();
+    var messages = context.messages;
+    // We have to wrap the actual hook so the type inference for the optional
+    // namespace works correctly. See https://stackoverflow.com/a/71529575/343045
+    // The prefix ("!") is arbitrary.
+    // @ts-expect-error Use the explicit annotation instead
+    return useTranslationsImpl({
+        "!": messages
+    }, // @ts-expect-error
+    namespace ? "!.".concat(namespace) : "!", "!");
+}
+function useLocale() {
+    return useIntlContext().locale;
+}
+function getNow() {
+    return new Date();
+}
+/**
+ * @see https://next-intl.dev/docs/usage/dates-times#relative-times-usenow
+ */ function useNow(options) {
+    var updateInterval = options === null || options === void 0 ? void 0 : options.updateInterval;
+    var ref = useIntlContext(), globalNow = ref.now;
+    var ref1 = _slicedToArray((0, _react.useState)(globalNow || getNow()), 2), now = ref1[0], setNow = ref1[1];
+    (0, _react.useEffect)(function() {
+        if (!updateInterval) return;
+        var intervalId = setInterval(function() {
+            setNow(getNow());
+        }, updateInterval);
+        return function() {
+            clearInterval(intervalId);
+        };
+    }, [
+        globalNow,
+        updateInterval
+    ]);
+    return updateInterval == null && globalNow ? globalNow : now;
+}
+function useTimeZone() {
+    return useIntlContext().timeZone;
+}
+function useMessages() {
+    var context = useIntlContext();
+    if (!context.messages) {
+        throw new Error("No messages found. Have you configured them correctly? See https://next-intl.dev/docs/configuration#messages");
+    }
+    return context.messages;
+}
+function useFormatter() {
+    var ref = useIntlContext(), formats = ref.formats, formatters = ref.formatters, locale = ref.locale, globalNow = ref.now, onError = ref.onError, timeZone = ref.timeZone;
+    return (0, _react.useMemo)(function() {
+        return (0, _initializeConfigCUsOI8U2Js.c)({
+            formats: formats,
+            locale: locale,
+            now: globalNow,
+            onError: onError,
+            timeZone: timeZone,
+            _formatters: formatters
+        });
+    }, [
+        formats,
+        formatters,
+        globalNow,
+        locale,
+        onError,
+        timeZone
+    ]);
+}
+function getArgs(messageOrParams) {
+    for(var _len = arguments.length, rest = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
+        rest[_key - 1] = arguments[_key];
+    }
+    var message, values, formats;
+    if (typeof messageOrParams === "string") {
+        message = messageOrParams;
+        values = rest[0];
+        formats = rest[1];
+    } else {
+        message = messageOrParams.message;
+        values = messageOrParams.values;
+        formats = messageOrParams.formats;
+    // `description` is not used at runtime
+    }
+    // @ts-expect-error -- Secret fallback parameter
+    return [
+        undefined,
+        // Always use fallback if not compiled
+        values,
+        formats,
+        message
+    ];
+}
+// Note: This API is usually compiled into `useTranslations`,
+// but there is some fallback handling which allows this hook
+// to still work when not being compiled.
+//
+// This is relevant for:
+// - Isolated environments like tests, Storybook, etc.
+// - Fallbacks in case an extracted message is not yet available
+function useExtracted(namespace) {
+    var // @ts-expect-error -- Passing `undefined` as an ID is secretly allowed here
+    _t, // @ts-expect-error -- Passing `undefined` as an ID is secretly allowed here
+    _t1;
+    var translateFn = function translateFn() {
+        for(var _len = arguments.length, params = new Array(_len), _key = 0; _key < _len; _key++){
+            params[_key] = arguments[_key];
+        }
+        // @ts-expect-error -- Passing `undefined` as an ID is secretly allowed here
+        return t.apply(void 0, _toConsumableArray(getArgs.apply(void 0, _toConsumableArray(params))));
+    };
+    var t = useTranslations(namespace);
+    translateFn.rich = function() {
+        for(var _len = arguments.length, params = new Array(_len), _key = 0; _key < _len; _key++){
+            params[_key] = arguments[_key];
+        }
+        return (_t = t).rich.apply(_t, _toConsumableArray(getArgs.apply(void 0, _toConsumableArray(params))));
+    };
+    translateFn.markup = function() {
+        for(var _len = arguments.length, params = new Array(_len), _key = 0; _key < _len; _key++){
+            params[_key] = arguments[_key];
+        }
+        return (_t1 = t).markup.apply(_t1, _toConsumableArray(getArgs.apply(void 0, _toConsumableArray(params))));
+    };
+    translateFn.has = function translateHasFn(// eslint-disable-next-line @typescript-eslint/no-unused-vars
+    message) {
+        // Not really something better we can do here
+        return true;
+    };
+    return translateFn;
+}

package/dist/esm/production/core.js

@@ -0,0 +1,149 @@
+"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 _formattersCJcico0NJs.I;
+    },
+    IntlErrorCode: function() {
+        return _formattersCJcico0NJs.a;
+    },
+    createFormatter: function() {
+        return _initializeConfigCHgjheiiJs.c;
+    },
+    initializeConfig: function() {
+        return _initializeConfigCHgjheiiJs.i;
+    },
+    "_createCache": function() {
+        return _formattersCJcico0NJs.b;
+    },
+    "_createIntlFormatters": function() {
+        return _formattersCJcico0NJs.c;
+    },
+    createTranslator: function() {
+        return n;
+    },
+    hasLocale: function() {
+        return f;
+    }
+});
+var _formattersCJcico0NJs = require("./formatters-CJcico0N.js");
+var _initializeConfigCHgjheiiJs = require("./initializeConfig-CHgjheii.js");
+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 _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 _objectWithoutProperties(source, excluded) {
+    if (source == null) return {};
+    var target = _objectWithoutPropertiesLoose(source, excluded);
+    var key, i;
+    if (Object.getOwnPropertySymbols) {
+        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+        for(i = 0; i < sourceSymbolKeys.length; i++){
+            key = sourceSymbolKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+function _objectWithoutPropertiesLoose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+function n(_param) {
+    var tmp = _param._cache, a = tmp === void 0 ? (0, _formattersCJcico0NJs.b)() : tmp, tmp1 = _param._formatters, i = tmp1 === void 0 ? (0, _formattersCJcico0NJs.c)(a) : tmp1, tmp2 = _param.getMessageFallback, n = tmp2 === void 0 ? _initializeConfigCHgjheiiJs.d : tmp2, c = _param.messages, f = _param.namespace, tmp3 = _param.onError, g = tmp3 === void 0 ? _initializeConfigCHgjheiiJs.b : tmp3, l = _objectWithoutProperties(_param, [
+        "_cache",
+        "_formatters",
+        "getMessageFallback",
+        "messages",
+        "namespace",
+        "onError"
+    ]);
+    return function(_param, o) {
+        var _$e = _param.messages, a = _param.namespace, _$r = _objectWithoutProperties(_param, [
+            "messages",
+            "namespace"
+        ]);
+        return _$e = _$e[o], a = (0, _initializeConfigCHgjheiiJs.r)(a, o), (0, _initializeConfigCHgjheiiJs.a)(_objectSpreadProps(_objectSpread({}, _$r), {
+            messages: _$e,
+            namespace: a
+        }));
+    }(_objectSpreadProps(_objectSpread({}, l), {
+        onError: g,
+        cache: a,
+        formatters: i,
+        getMessageFallback: n,
+        messages: {
+            "!": c
+        },
+        namespace: f ? "!.".concat(f) : "!"
+    }), "!");
+}
+function f(e, a) {
+    return e.includes(a);
+}