use-intl 0.0.0-canary-5bbd7ad56b530e283b07cff950de61d6af81f00c

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Jan Amann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,83 @@
+# 🌐 use-intl
+
+> Internationalization (i18n) for React
+
+## Features
+
+Internationalization (i18n) is an essential part of the user experience, therefore `use-intl` gives you all the parts you need to get language nuances right.
+
+- 🌟 **ICU message syntax**: Localize your messages with interpolation, cardinal & ordinal plurals, enum-based label selection and rich text.
+- 📅 **Dates, times & numbers**: Apply appropriate formatting without worrying about server/client differences like time zones.
+- ✅ **Type-safe**: Speed up development with autocompletion for message keys and catch typos early with compile-time checks.
+- 💡 **Hooks-based API**: Learn a single API that can be used across your code base to turn translations into plain strings or rich text.
+- ⚔️ **Standards-based**: Use the best parts of built-in JavaScript APIs and supplemental lower-level APIs from Format.JS.
+
+## What does it look like?
+
+```jsx
+// UserProfile.tsx
+import {useTranslations} from 'use-intl';
+ 
+export default function UserProfile({user}) {
+  const t = useTranslations('UserProfile');
+ 
+  return (
+    <section>
+      <h1>{t('title', {firstName: user.firstName})}</h1>
+      <p>{t('membership', {memberSince: user.memberSince})}</p>
+      <p>{t('followers', {count: user.numFollowers})}</p>
+    </section>
+  );
+}
+```
+
+```js
+// en.json
+{
+  "UserProfile": {
+    "title": "{username}'s profile",
+    "membership": "Member since {memberSince, date, short}",
+    "followers": "{count, plural, ↵
+                    =0 {No followers yet} ↵
+                    =1 {One follower} ↵
+                    other {# followers} ↵
+                  }"
+  }
+}
+```
+
+## Installation
+
+1. `npm install use-intl`
+2. Add the provider
+3. Use internationalization in components
+
+```jsx
+import {IntlProvider, useTranslations} from 'use-intl';
+
+// You can get the messages from anywhere you like. You can also
+// fetch them from within a component and then render the provider 
+// along with your app once you have the messages.
+const messages = {
+  "App": {
+    "hello": 'Hello {username}!'
+  }
+};
+
+function Root() {
+  return (
+    <IntlProvider messages={messages} locale="en">
+      <App user={{name: 'Jane'}} />
+    </IntlProvider>
+  );
+}
+
+function App({user}) {
+  const t = useTranslations('App');
+  return <h1>{t('hello', {username: user.name})}</h1>;
+}
+```
+
+Have a look at [the minimal setup example](https://github.com/amannn/next-intl/tree/main/examples/example-use-intl) to explore a working app.
+
+### [→ Read the docs](https://next-intl-docs.vercel.app/docs/environments/core-library)

package/_IntlProvider.d.ts

@@ -0,0 +1 @@
+export * from './dist/types/src/_IntlProvider';

package/_useLocale.d.ts

@@ -0,0 +1 @@
+export * from './dist/types/src/_useLocale';

package/core.d.ts

@@ -0,0 +1 @@
+export * from './dist/types/src/core';

package/dist/_IntlProvider.js

@@ -0,0 +1,7 @@
+'use strict';
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./production/_IntlProvider.js');
+} else {
+  module.exports = require('./development/_IntlProvider.js');
+}

package/dist/_useLocale.js

@@ -0,0 +1,7 @@
+'use strict';
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./production/_useLocale.js');
+} else {
+  module.exports = require('./development/_useLocale.js');
+}

package/dist/core.js

@@ -0,0 +1,7 @@
+'use strict';
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./production/core.js');
+} else {
+  module.exports = require('./development/core.js');
+}

package/dist/development/IntlContext-BKfsnzBx.js

@@ -0,0 +1,7 @@
+'use strict';
+
+var React = require('react');
+
+const IntlContext = /*#__PURE__*/React.createContext(undefined);
+
+exports.IntlContext = IntlContext;

package/dist/development/_IntlProvider.js

@@ -0,0 +1,61 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+var initializeConfig = require('./initializeConfig-o7L_y07P.js');
+var IntlContext = require('./IntlContext-BKfsnzBx.js');
+require('@formatjs/fast-memoize');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefault(React);
+
+function IntlProvider(_ref) {
+  let {
+    children,
+    defaultTranslationValues,
+    formats,
+    getMessageFallback,
+    locale,
+    messages,
+    now,
+    onError,
+    timeZone
+  } = _ref;
+  // 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).
+  const cache = React.useMemo(() => {
+    return initializeConfig.createCache();
+  }, [locale]);
+  const formatters = React.useMemo(() => initializeConfig.createIntlFormatters(cache), [cache]);
+
+  // 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
+  const value = React.useMemo(() => ({
+    ...initializeConfig.initializeConfig({
+      locale,
+      defaultTranslationValues,
+      formats,
+      getMessageFallback,
+      messages,
+      now,
+      onError,
+      timeZone
+    }),
+    formatters,
+    cache
+  }), [cache, defaultTranslationValues, formats, formatters, getMessageFallback, locale, messages, now, onError, timeZone]);
+  return /*#__PURE__*/React__default.default.createElement(IntlContext.IntlContext.Provider, {
+    value: value
+  }, children);
+}
+
+exports.IntlProvider = IntlProvider;

package/dist/development/_useLocale-0Rl9uR82.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var React = require('react');
+var IntlContext = require('./IntlContext-BKfsnzBx.js');
+
+function useIntlContext() {
+  const context = React.useContext(IntlContext.IntlContext);
+  if (!context) {
+    throw new Error('No intl context found. Have you configured the provider? See https://next-intl-docs.vercel.app/docs/usage/configuration#client-server-components' );
+  }
+  return context;
+}
+
+function useLocale() {
+  return useIntlContext().locale;
+}
+
+exports.useIntlContext = useIntlContext;
+exports.useLocale = useLocale;

package/dist/development/_useLocale.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _useLocale = require('./_useLocale-0Rl9uR82.js');
+require('react');
+require('./IntlContext-BKfsnzBx.js');
+
+
+
+exports.useLocale = _useLocale.useLocale;

package/dist/development/core.js

@@ -0,0 +1,69 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var initializeConfig = require('./initializeConfig-o7L_y07P.js');
+var createFormatter = require('./createFormatter-TZTkYRKI.js');
+require('@formatjs/fast-memoize');
+require('intl-messageformat');
+require('react');
+
+function createTranslatorImpl(_ref, namespacePrefix) {
+  let {
+    messages,
+    namespace,
+    ...rest
+  } = _ref;
+  // The `namespacePrefix` is part of the type system.
+  // See the comment in the function invocation.
+  messages = messages[namespacePrefix];
+  namespace = createFormatter.resolveNamespace(namespace, namespacePrefix);
+  return createFormatter.createBaseTranslator({
+    ...rest,
+    messages,
+    namespace
+  });
+}
+
+/**
+ * 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 createTranslator(_ref) {
+  let {
+    _cache = initializeConfig.createCache(),
+    _formatters = initializeConfig.createIntlFormatters(_cache),
+    getMessageFallback = initializeConfig.defaultGetMessageFallback,
+    messages,
+    namespace,
+    onError = initializeConfig.defaultOnError,
+    ...rest
+  } = _ref;
+  // We have to wrap the actual function so the type inference for the optional
+  // namespace works correctly. See https://stackoverflow.com/a/71529575/343045
+  // The prefix ("!") is arbitrary.
+  return createTranslatorImpl({
+    ...rest,
+    onError,
+    cache: _cache,
+    formatters: _formatters,
+    getMessageFallback,
+    // @ts-expect-error `messages` is allowed to be `undefined` here and will be handled internally
+    messages: {
+      '!': messages
+    },
+    namespace: namespace ? "!.".concat(namespace) : '!'
+  }, '!');
+}
+
+exports.IntlError = initializeConfig.IntlError;
+exports.IntlErrorCode = initializeConfig.IntlErrorCode;
+exports._createCache = initializeConfig.createCache;
+exports._createIntlFormatters = initializeConfig.createIntlFormatters;
+exports.initializeConfig = initializeConfig.initializeConfig;
+exports.createFormatter = createFormatter.createFormatter;
+exports.createTranslator = createTranslator;