@leabankab/component-library 8.10.0 → 8.12.0

package/dist/next-intl/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The `@leabankab/component-library/next-intl` entry: the library in an app
+ * that uses next-intl. `LeaIntlProvider` sets the library's language and
+ * country from next-intl's locale, and `useTexts` reads the app's own texts
+ * in that language, with every language of the app's locales required.
+ * Server components use `@leabankab/component-library/next-intl/server`.
+ *
+ * It is an entry of its own so that next-intl stays an optional peer: the
+ * main entry never imports it. Two rules for the files in this folder, both
+ * checked by tests/entries.test.tsx:
+ *
+ * - What they share with the main entry at run time (`LeaProvider`,
+ *   `CountryProvider`) they import from "../index". The build leaves that
+ *   module out and points the import at the main bundle, so the language
+ *   reaches the app's copy of the components.
+ * - Anything else they import from `src/` is bundled in, so it has to be
+ *   plain data or a helper without state: `toLanguage`.
+ */
+export { LeaIntlProvider, type LeaIntlProviderProps, } from './lea-intl-provider';
+export { useTexts } from './use-texts';
+export type { AppLanguage, LanguagesOf, TextFunction, Texts, TextsResult, TextValue, TranslatedText, } from './texts';

package/dist/next-intl/lea-intl-provider.d.ts

@@ -0,0 +1,35 @@
+import { Locale } from 'next-intl';
+import { ReactNode } from 'react';
+import { Country } from '../index';
+import { UnsupportedLocaleKey } from './texts';
+export type LeaIntlProviderProps = {
+    /**
+     * The country of the formatting hooks (`useFormatCurrency` and the rest).
+     * Give it where the country is not the locale's. By default it is the
+     * locale's region when that is a Lea Bank country (`sv-FI`), or else the
+     * country of its language.
+     */
+    country?: Country;
+    children: ReactNode;
+} & {
+    [K in UnsupportedLocaleKey<Locale>]: never;
+};
+/**
+ * Sets the library's language and country from next-intl's locale: what
+ * `LeaProvider` and `CountryProvider` do, with no map from locale to
+ * language in the app. Put it inside `NextIntlClientProvider`, once:
+ *
+ * ```tsx
+ * // app/[locale]/layout.tsx
+ * import { NextIntlClientProvider } from "next-intl";
+ * import { LeaIntlProvider } from "@leabankab/component-library/next-intl";
+ *
+ * <NextIntlClientProvider>
+ *   <LeaIntlProvider>{children}</LeaIntlProvider>
+ * </NextIntlClientProvider>
+ * ```
+ *
+ * The library's components then speak the locale's language, and the
+ * formatting hooks format for its country.
+ */
+export declare function LeaIntlProvider({ country, children }: LeaIntlProviderProps): import("react").JSX.Element;

package/dist/next-intl/server.d.ts

@@ -0,0 +1,24 @@
+import { Locale } from 'next-intl';
+import { AppLanguage, TextsResult } from './texts';
+export type GetTextsOptions = {
+    /**
+     * The locale, where next-intl can't tell it: in `generateMetadata` of a
+     * page that is rendered statically. By default, next-intl's `getLocale()`.
+     */
+    locale?: Locale;
+};
+/**
+ * Texts in the language of next-intl's locale, for a server component. The
+ * texts are the same `satisfies Texts` objects that `useTexts` reads:
+ *
+ * ```tsx
+ * import { getTexts } from "@leabankab/component-library/next-intl/server";
+ *
+ * export default async function Page() {
+ *   const { t } = await getTexts();
+ *   return <h1>{t(texts.title)}</h1>;
+ * }
+ * ```
+ */
+export declare function getTexts<L extends AppLanguage = AppLanguage>(options?: GetTextsOptions): Promise<TextsResult<L>>;
+export type { AppLanguage, LanguagesOf, TextFunction, Texts, TextsResult, TextValue, TranslatedText, } from './texts';

package/dist/next-intl/texts.d.ts

@@ -0,0 +1,77 @@
+import { Locale } from 'next-intl';
+import { ReactElement } from 'react';
+import { Language, LanguageOfLocale } from '../i18n/languages';
+/**
+ * What a text can be in one language: a string, or an element for a text
+ * with markup in it (a link, a bold word).
+ */
+export type TextValue = string | ReactElement;
+/** The locales in `L` that stand for no language of the library. */
+type UnsupportedLocale<L extends string> = L extends string ? [LanguageOfLocale<L>] extends [never] ? L : never : never;
+/**
+ * The guard on the app's locales. For each locale the library has no
+ * language for, a key that every text is then missing, so the error names
+ * the locale. `never` when every locale has a language.
+ */
+export type UnsupportedLocaleKey<L extends string> = string extends L ? never : `No library language for locale "${UnsupportedLocale<L>}"`;
+/**
+ * The languages that texts for the locales `L` must have: the language of
+ * each locale, by `LanguageOfLocale`. `"sv" | "fi" | "nb"` gives
+ * `"se" | "fi" | "no"`. Without a list of locales (`string`), all four.
+ */
+export type LanguagesOf<L extends string> = string extends L ? Language : LanguageOfLocale<L> | UnsupportedLocaleKey<L>;
+/**
+ * The languages every text in the app must have: one for each locale the app
+ * declares to next-intl. With
+ *
+ * ```ts
+ * declare module "next-intl" {
+ *   interface AppConfig {
+ *     Locale: "sv" | "fi" | "nb";
+ *   }
+ * }
+ * ```
+ *
+ * it is `"se" | "fi" | "no"`. An app that declares no `Locale` needs all
+ * four.
+ */
+export type AppLanguage = LanguagesOf<Locale>;
+/** One text, in every language of `L`. */
+export type TranslatedText<L extends string = AppLanguage> = {
+    readonly [K in L]: TextValue;
+};
+/**
+ * The texts of a component or a page: texts, functions that take what goes
+ * into a text and return it, and groups of either. Check the object with
+ * `satisfies Texts`, so a text that lacks one of the app's languages is a
+ * type error:
+ *
+ * ```tsx
+ * const texts = {
+ *   title: { se: "Ditt lån", no: "Ditt lån", fi: "Lainasi" },
+ *   greeting: (name: string) => ({ se: `Hej ${name}`, no: `Hei ${name}`, fi: `Hei ${name}` }),
+ * } satisfies Texts;
+ * ```
+ *
+ * `Texts<"se">` is for a feature that only some markets have. Read its texts
+ * with `useTexts<"se">()`.
+ */
+export type Texts<L extends string = AppLanguage> = {
+    readonly [key: string]: TranslatedText<L> | ((...args: never[]) => TranslatedText<L>) | Texts<L>;
+};
+/**
+ * `t`: a text in the current language. A string text gives a string, an
+ * element an element. Where `L` leaves out some of the app's languages, the
+ * text may have none for the current one, so the result can be `undefined`.
+ */
+export type TextFunction<L extends string = AppLanguage> = <T extends TranslatedText<L>>(text: T) => [AppLanguage] extends [L] ? T[L] : T[L] | undefined;
+/** What `useTexts` and `getTexts` give. */
+export type TextsResult<L extends string = AppLanguage> = {
+    /** A text in the current language. */
+    t: TextFunction<L>;
+    /** The current language, from next-intl's locale. */
+    language: AppLanguage;
+};
+/** The `t` and `language` for a language. Shared by the hook and the server. */
+export declare function createTexts<L extends string>(language: Language): TextsResult<L>;
+export {};

package/dist/next-intl/use-texts.d.ts

@@ -0,0 +1,28 @@
+import { AppLanguage, TextsResult } from './texts';
+/**
+ * Texts in the language of next-intl's locale, for a client component. Keep
+ * the texts beside the component and check them with `satisfies Texts`:
+ *
+ * ```tsx
+ * "use client";
+ * import { useTexts, type Texts } from "@leabankab/component-library/next-intl";
+ *
+ * const texts = {
+ *   title: { se: "Ditt lån", no: "Ditt lån", fi: "Lainasi" },
+ *   greeting: (name: string) => ({ se: `Hej ${name}`, no: `Hei ${name}`, fi: `Hei ${name}` }),
+ * } satisfies Texts;
+ *
+ * function LoanHeader({ name }: { name: string }) {
+ *   const { t } = useTexts();
+ *   return <h1>{t(texts.title)}, {t(texts.greeting(name))}</h1>;
+ * }
+ * ```
+ *
+ * It reads the locale from `NextIntlClientProvider`, so it needs no provider
+ * of the library's. In a server component, use `getTexts` from
+ * `@leabankab/component-library/next-intl/server`.
+ *
+ * `useTexts<"se">()` reads texts that only some markets have (`Texts<"se">`).
+ * `t` then gives `undefined` in a language the text doesn't have.
+ */
+export declare function useTexts<L extends AppLanguage = AppLanguage>(): TextsResult<L>;

package/dist/next-intl-server.mjs

@@ -0,0 +1,11 @@
+import { n as e, t } from "./next-intl-texts-De3tiuSm.mjs";
+import { getLocale as n } from "next-intl/server";
+//#region src/next-intl/server.ts
+async function r(r = {}) {
+	let i = r.locale ?? await n();
+	return t(e(i));
+}
+//#endregion
+export { r as getTexts };
+
+//# sourceMappingURL=next-intl-server.mjs.map

package/dist/next-intl-server.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"next-intl-server.mjs","names":[],"sources":["../src/next-intl/server.ts"],"sourcesContent":["/**\n * The `@leabankab/component-library/next-intl/server` entry: `getTexts`,\n * the server component's `useTexts`.\n *\n * It is apart from `next-intl` because that one is a client module, and a\n * server component can't call a function from a client module. For the same\n * reason nothing here imports from \"../index\", the main bundle, which is a\n * client module too. tests/entries.test.tsx checks both.\n */\nimport type { Locale } from \"next-intl\";\nimport { getLocale } from \"next-intl/server\";\n\nimport { toLanguage } from \"../i18n/languages\";\nimport { type AppLanguage, createTexts, type TextsResult } from \"./texts\";\n\nexport type GetTextsOptions = {\n  /**\n   * The locale, where next-intl can't tell it: in `generateMetadata` of a\n   * page that is rendered statically. By default, next-intl's `getLocale()`.\n   */\n  locale?: Locale;\n};\n\n/**\n * Texts in the language of next-intl's locale, for a server component. The\n * texts are the same `satisfies Texts` objects that `useTexts` reads:\n *\n * ```tsx\n * import { getTexts } from \"@leabankab/component-library/next-intl/server\";\n *\n * export default async function Page() {\n *   const { t } = await getTexts();\n *   return <h1>{t(texts.title)}</h1>;\n * }\n * ```\n */\nexport async function getTexts<L extends AppLanguage = AppLanguage>(\n  options: GetTextsOptions = {},\n): Promise<TextsResult<L>> {\n  const locale = options.locale ?? (await getLocale());\n  return createTexts<L>(toLanguage(locale));\n}\n\nexport type {\n  AppLanguage,\n  LanguagesOf,\n  TextFunction,\n  Texts,\n  TextsResult,\n  TextValue,\n  TranslatedText,\n} from \"./texts\";\n"],"mappings":";;;AAoCA,eAAsB,EACpB,IAA2B,CAAC,GACH;CACzB,IAAM,IAAS,EAAQ,UAAW,MAAM,EAAU;CAClD,OAAO,EAAe,EAAW,CAAM,CAAC;AAC1C"}

package/dist/next-intl-texts-De3tiuSm.mjs

@@ -0,0 +1,25 @@
+var e = {
+	no: "no",
+	nb: "no",
+	nn: "no",
+	sv: "se",
+	se: "se",
+	fi: "fi",
+	es: "es"
+};
+function t(t) {
+	let n = t.toLowerCase().split("-")[0];
+	return Object.hasOwn(e, n) ? e[n] : "no";
+}
+//#endregion
+//#region src/next-intl/texts.ts
+function n(e) {
+	return {
+		t: (t) => t[e],
+		language: e
+	};
+}
+//#endregion
+export { t as n, n as t };
+
+//# sourceMappingURL=next-intl-texts-De3tiuSm.mjs.map

package/dist/next-intl-texts-De3tiuSm.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"next-intl-texts-De3tiuSm.mjs","names":[],"sources":["../src/i18n/languages.ts","../src/next-intl/texts.ts"],"sourcesContent":["/**\n * Languages supported by the component library's built-in translations. The\n * consumer selects one via `LeaProvider`'s `language` prop; components read it\n * with `useLanguage` (usually through `createTranslation`).\n */\nexport const LANGUAGES = [\"no\", \"se\", \"fi\", \"es\"] as const;\n\nexport type Language = (typeof LANGUAGES)[number];\n\n/** Fallback language used when no provider is present or a key is missing. */\nexport const DEFAULT_LANGUAGE = \"no\" satisfies Language;\n\n/**\n * The language each first part of a locale code stands for. Bokmål, Nynorsk\n * and Norwegian are all `no`. Swedish is `se`, the library's name for it,\n * which some apps also use as their locale.\n */\nconst LANGUAGE_BY_SUBTAG = {\n  no: \"no\",\n  nb: \"no\",\n  nn: \"no\",\n  sv: \"se\",\n  se: \"se\",\n  fi: \"fi\",\n  es: \"es\",\n} as const satisfies Record<string, Language>;\n\ntype LanguageSubtag = keyof typeof LANGUAGE_BY_SUBTAG;\n\n/**\n * The library language a locale code stands for, read from its first part:\n * `nb`, `nb-NO`, `nn` and `no` are `\"no\"`; `sv`, `sv-SE` and `se` are `\"se\"`;\n * `fi-FI` is `\"fi\"` and `es-ES` is `\"es\"`. `never` for a code the library has\n * no language for, such as `en`. The type of what `toLanguage` returns.\n */\nexport type LanguageOfLocale<L extends string> =\n  L extends `${infer Subtag}-${string}`\n    ? Subtag extends LanguageSubtag\n      ? (typeof LANGUAGE_BY_SUBTAG)[Subtag]\n      : never\n    : L extends LanguageSubtag\n      ? (typeof LANGUAGE_BY_SUBTAG)[L]\n      : never;\n\n/**\n * The library language for a locale code as an app writes it for next-intl\n * or `Intl`, by the rules of `LanguageOfLocale`, in upper or lower case. A\n * code the library has no language for gives `DEFAULT_LANGUAGE`.\n *\n * ```tsx\n * toLanguage(\"nb\"); // \"no\"\n * toLanguage(\"sv-SE\"); // \"se\"\n * ```\n */\nexport function toLanguage(locale: string): Language {\n  const subtag = locale.toLowerCase().split(\"-\")[0];\n  return Object.hasOwn(LANGUAGE_BY_SUBTAG, subtag)\n    ? LANGUAGE_BY_SUBTAG[subtag as LanguageSubtag]\n    : DEFAULT_LANGUAGE;\n}\n","import type { Locale } from \"next-intl\";\nimport type { ReactElement } from \"react\";\n\nimport type { Language, LanguageOfLocale } from \"../i18n/languages\";\n\n/**\n * What a text can be in one language: a string, or an element for a text\n * with markup in it (a link, a bold word).\n */\nexport type TextValue = string | ReactElement;\n\n/** The locales in `L` that stand for no language of the library. */\ntype UnsupportedLocale<L extends string> = L extends string\n  ? [LanguageOfLocale<L>] extends [never]\n    ? L\n    : never\n  : never;\n\n/**\n * The guard on the app's locales. For each locale the library has no\n * language for, a key that every text is then missing, so the error names\n * the locale. `never` when every locale has a language.\n */\nexport type UnsupportedLocaleKey<L extends string> = string extends L\n  ? never\n  : `No library language for locale \"${UnsupportedLocale<L>}\"`;\n\n/**\n * The languages that texts for the locales `L` must have: the language of\n * each locale, by `LanguageOfLocale`. `\"sv\" | \"fi\" | \"nb\"` gives\n * `\"se\" | \"fi\" | \"no\"`. Without a list of locales (`string`), all four.\n */\nexport type LanguagesOf<L extends string> = string extends L\n  ? Language\n  : LanguageOfLocale<L> | UnsupportedLocaleKey<L>;\n\n/**\n * The languages every text in the app must have: one for each locale the app\n * declares to next-intl. With\n *\n * ```ts\n * declare module \"next-intl\" {\n *   interface AppConfig {\n *     Locale: \"sv\" | \"fi\" | \"nb\";\n *   }\n * }\n * ```\n *\n * it is `\"se\" | \"fi\" | \"no\"`. An app that declares no `Locale` needs all\n * four.\n */\nexport type AppLanguage = LanguagesOf<Locale>;\n\n/** One text, in every language of `L`. */\nexport type TranslatedText<L extends string = AppLanguage> = {\n  readonly [K in L]: TextValue;\n};\n\n/**\n * The texts of a component or a page: texts, functions that take what goes\n * into a text and return it, and groups of either. Check the object with\n * `satisfies Texts`, so a text that lacks one of the app's languages is a\n * type error:\n *\n * ```tsx\n * const texts = {\n *   title: { se: \"Ditt lån\", no: \"Ditt lån\", fi: \"Lainasi\" },\n *   greeting: (name: string) => ({ se: `Hej ${name}`, no: `Hei ${name}`, fi: `Hei ${name}` }),\n * } satisfies Texts;\n * ```\n *\n * `Texts<\"se\">` is for a feature that only some markets have. Read its texts\n * with `useTexts<\"se\">()`.\n */\nexport type Texts<L extends string = AppLanguage> = {\n  readonly [key: string]:\n    | TranslatedText<L>\n    | ((...args: never[]) => TranslatedText<L>)\n    | Texts<L>;\n};\n\n/**\n * `t`: a text in the current language. A string text gives a string, an\n * element an element. Where `L` leaves out some of the app's languages, the\n * text may have none for the current one, so the result can be `undefined`.\n */\nexport type TextFunction<L extends string = AppLanguage> = <\n  T extends TranslatedText<L>,\n>(\n  text: T,\n) => [AppLanguage] extends [L] ? T[L] : T[L] | undefined;\n\n/** What `useTexts` and `getTexts` give. */\nexport type TextsResult<L extends string = AppLanguage> = {\n  /** A text in the current language. */\n  t: TextFunction<L>;\n  /** The current language, from next-intl's locale. */\n  language: AppLanguage;\n};\n\n/** The `t` and `language` for a language. Shared by the hook and the server. */\nexport function createTexts<L extends string>(\n  language: Language,\n): TextsResult<L> {\n  const t = (text: Partial<Record<Language, TextValue>>) => text[language];\n  return {\n    t: t as TextFunction<L>,\n    language: language as AppLanguage,\n  };\n}\n"],"mappings":"AAiBA,IAAM,IAAqB;CACzB,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,IAAI;AACN;AA6BA,SAAgB,EAAW,GAA0B;CACnD,IAAM,IAAS,EAAO,YAAY,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC;CAC/C,OAAO,OAAO,OAAO,GAAoB,CAAM,IAC3C,EAAmB,KAAA;AAEzB;;;AC0CA,SAAgB,EACd,GACgB;CAEhB,OAAO;EACF,IAFM,MAA+C,EAAK;EAGnD;CACZ;AACF"}

package/dist/next-intl.mjs

@@ -0,0 +1,37 @@
+"use client";
+import { n as e, t } from "./next-intl-texts-De3tiuSm.mjs";
+import { useLocale as n } from "next-intl";
+import { COUNTRIES as r, CountryProvider as i, LeaProvider as a } from "./component-library.es.js";
+import { jsx as o } from "react/jsx-runtime";
+import { useMemo as s } from "react";
+//#region src/next-intl/lea-intl-provider.tsx
+var c = {
+	no: "NO",
+	se: "SE",
+	fi: "FI",
+	es: "ES"
+};
+function l(t) {
+	let n = t.split("-")[1]?.toUpperCase();
+	return n !== void 0 && Object.hasOwn(r, n) ? n : c[e(t)];
+}
+function u({ country: t, children: r }) {
+	let s = n();
+	return /* @__PURE__ */ o(a, {
+		language: e(s),
+		children: /* @__PURE__ */ o(i, {
+			country: t ?? l(s),
+			children: r
+		})
+	});
+}
+//#endregion
+//#region src/next-intl/use-texts.ts
+function d() {
+	let r = n();
+	return s(() => t(e(r)), [r]);
+}
+//#endregion
+export { u as LeaIntlProvider, d as useTexts };
+
+//# sourceMappingURL=next-intl.mjs.map

package/dist/next-intl.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"next-intl.mjs","names":[],"sources":["../src/next-intl/lea-intl-provider.tsx","../src/next-intl/use-texts.ts"],"sourcesContent":["\"use client\";\n\nimport { type Locale, useLocale } from \"next-intl\";\nimport { type ReactNode } from \"react\";\n\nimport { type Language, toLanguage } from \"../i18n/languages\";\nimport { COUNTRIES, type Country, CountryProvider, LeaProvider } from \"../index\";\nimport type { UnsupportedLocaleKey } from \"./texts\";\n\n/** The country whose language each language is. */\nconst COUNTRY_OF_LANGUAGE = {\n  no: \"NO\",\n  se: \"SE\",\n  fi: \"FI\",\n  es: \"ES\",\n} as const satisfies Record<Language, Country>;\n\n/**\n * The country of a locale: its region, when that is one of Lea Bank's\n * countries (`sv-FI` is Finland), or else the country of its language.\n */\nfunction countryOf(locale: string): Country {\n  const region = locale.split(\"-\")[1]?.toUpperCase();\n  return region !== undefined && Object.hasOwn(COUNTRIES, region)\n    ? (region as Country)\n    : COUNTRY_OF_LANGUAGE[toLanguage(locale)];\n}\n\nexport type LeaIntlProviderProps = {\n  /**\n   * The country of the formatting hooks (`useFormatCurrency` and the rest).\n   * Give it where the country is not the locale's. By default it is the\n   * locale's region when that is a Lea Bank country (`sv-FI`), or else the\n   * country of its language.\n   */\n  country?: Country;\n  children: ReactNode;\n} & {\n  // The guard on the app's locales: a locale the library has no language for\n  // makes this a prop that can't be given, and the error names the locale.\n  [K in UnsupportedLocaleKey<Locale>]: never;\n};\n\n/**\n * Sets the library's language and country from next-intl's locale: what\n * `LeaProvider` and `CountryProvider` do, with no map from locale to\n * language in the app. Put it inside `NextIntlClientProvider`, once:\n *\n * ```tsx\n * // app/[locale]/layout.tsx\n * import { NextIntlClientProvider } from \"next-intl\";\n * import { LeaIntlProvider } from \"@leabankab/component-library/next-intl\";\n *\n * <NextIntlClientProvider>\n *   <LeaIntlProvider>{children}</LeaIntlProvider>\n * </NextIntlClientProvider>\n * ```\n *\n * The library's components then speak the locale's language, and the\n * formatting hooks format for its country.\n */\nexport function LeaIntlProvider({ country, children }: LeaIntlProviderProps) {\n  const locale = useLocale();\n  return (\n    <LeaProvider language={toLanguage(locale)}>\n      <CountryProvider country={country ?? countryOf(locale)}>\n        {children}\n      </CountryProvider>\n    </LeaProvider>\n  );\n}\n","\"use client\";\n\nimport { useLocale } from \"next-intl\";\nimport { useMemo } from \"react\";\n\nimport { toLanguage } from \"../i18n/languages\";\nimport { type AppLanguage, createTexts, type TextsResult } from \"./texts\";\n\n/**\n * Texts in the language of next-intl's locale, for a client component. Keep\n * the texts beside the component and check them with `satisfies Texts`:\n *\n * ```tsx\n * \"use client\";\n * import { useTexts, type Texts } from \"@leabankab/component-library/next-intl\";\n *\n * const texts = {\n *   title: { se: \"Ditt lån\", no: \"Ditt lån\", fi: \"Lainasi\" },\n *   greeting: (name: string) => ({ se: `Hej ${name}`, no: `Hei ${name}`, fi: `Hei ${name}` }),\n * } satisfies Texts;\n *\n * function LoanHeader({ name }: { name: string }) {\n *   const { t } = useTexts();\n *   return <h1>{t(texts.title)}, {t(texts.greeting(name))}</h1>;\n * }\n * ```\n *\n * It reads the locale from `NextIntlClientProvider`, so it needs no provider\n * of the library's. In a server component, use `getTexts` from\n * `@leabankab/component-library/next-intl/server`.\n *\n * `useTexts<\"se\">()` reads texts that only some markets have (`Texts<\"se\">`).\n * `t` then gives `undefined` in a language the text doesn't have.\n */\nexport function useTexts<\n  L extends AppLanguage = AppLanguage,\n>(): TextsResult<L> {\n  const locale = useLocale();\n  return useMemo(() => createTexts<L>(toLanguage(locale)), [locale]);\n}\n"],"mappings":";;;;;;;AAUA,IAAM,IAAsB;CAC1B,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,IAAI;AACN;AAMA,SAAS,EAAU,GAAyB;CAC1C,IAAM,IAAS,EAAO,MAAM,GAAG,CAAC,CAAC,EAAE,EAAE,YAAY;CACjD,OAAO,MAAW,KAAA,KAAa,OAAO,OAAO,GAAW,CAAM,IACzD,IACD,EAAoB,EAAW,CAAM;AAC3C;AAmCA,SAAgB,EAAgB,EAAE,YAAS,eAAkC;CAC3E,IAAM,IAAS,EAAU;CACzB,OACE,kBAAC,GAAD;EAAa,UAAU,EAAW,CAAM;EACtC,UAAA,kBAAC,GAAD;GAAiB,SAAS,KAAW,EAAU,CAAM;GAClD;EACc,CAAA;CACN,CAAA;AAEjB;;;ACpCA,SAAgB,IAEI;CAClB,IAAM,IAAS,EAAU;CACzB,OAAO,QAAc,EAAe,EAAW,CAAM,CAAC,GAAG,CAAC,CAAM,CAAC;AACnE"}

package/dist/theme/tokens/text-styles.d.ts

@@ -63,7 +63,7 @@ export declare const textStyleEntries: (readonly [TextStyleToken, TextStyleDefin
 export declare const resolveTextStyle: (name: TextStyleToken) => {
     fontSize: string;
     fontWeight: 200 | 300 | 400 | 500 | 600 | 700 | 800;
-    lineHeight: 1 | 1.25 | 1.5 | 1.4;
+    lineHeight: 1 | 1.25 | 1.4 | 1.5;
     letterSpacing: string;
 };
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leabankab/component-library",
-  "version": "8.10.0",
+  "version": "8.12.0",
   "description": "@leabankab/component-library — Lea Bank's React component library.",
   "engines": {
     "node": ">=20"
@@ -46,6 +46,14 @@
       "import": "./dist/website.mjs",
       "require": "./dist/website.cjs"
     },
+    "./next-intl": {
+      "types": "./dist/next-intl/index.d.ts",
+      "import": "./dist/next-intl.mjs"
+    },
+    "./next-intl/server": {
+      "types": "./dist/next-intl/server.d.ts",
+      "import": "./dist/next-intl-server.mjs"
+    },
     "./cookie-consent.css": "./dist/cookie-consent.css",
     "./styles.css": "./dist/index.css",
     "./tailwind.css": "./dist/tailwind.css",
@@ -77,6 +85,7 @@
     "@mui/system": "^9.0.0",
     "@mui/x-date-pickers": "^9.0.0",
     "date-fns": "^4.0.0",
+    "next-intl": "^4.0.0",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
     "react-hook-form": "^7.56.0",
@@ -101,6 +110,9 @@
     "date-fns": {
       "optional": true
     },
+    "next-intl": {
+      "optional": true
+    },
     "react-hook-form": {
       "optional": true
     },
@@ -138,6 +150,7 @@
     "eslint-plugin-storybook": "^10.5.5",
     "husky": "^9.1.7",
     "jsdom": "^29.1.1",
+    "next-intl": "^4.14.9",
     "playwright": "^1.62.1",
     "postcss": "^8.5.25",
     "react": "^19.2.8",
@@ -157,7 +170,7 @@
   "scripts": {
     "preinstall": "npx only-allow pnpm",
     "dev": "storybook dev -p 6006",
-    "build": "cross-env NODE_OPTIONS=--max-old-space-size=4096 vite build && vite build -c vite.cookie-consent.config.ts && vite build -c vite.react-hook-form.config.ts && vite build -c vite.date-picker.config.ts && vite build -c vite.dev-panel.config.ts && vite build -c vite.website.config.ts",
+    "build": "cross-env NODE_OPTIONS=--max-old-space-size=4096 vite build && vite build -c vite.cookie-consent.config.ts && vite build -c vite.react-hook-form.config.ts && vite build -c vite.date-picker.config.ts && vite build -c vite.dev-panel.config.ts && vite build -c vite.website.config.ts && vite build -c vite.next-intl.config.ts",
     "watch": "cross-env NODE_OPTIONS=--max-old-space-size=4096 vite build --watch",
     "watch:all": "cross-env NODE_OPTIONS=--max-old-space-size=4096 node scripts/watch-all.mjs",
     "storybook": "storybook dev -p 6006",

package/dist/components/animations/icons/index.d.ts

@@ -1 +0,0 @@
-export * from './status-icon';

package/dist/components/animations/illustrations/index.d.ts

@@ -1,3 +0,0 @@
-export * from './check-animation';
-export * from './pulse-animation';
-export * from './status-animation';

package/dist/components/animations/illustrations/pulse-animation.d.ts

@@ -1,16 +0,0 @@
-import { AnimationSize } from '../shared';
-type PulseAnimationProps = {
-    /**
-     * `"sm"` is 90px, `"lg"` 150px.
-     * @default "lg"
-     */
-    size?: AnimationSize;
-    /**
-     * Accessible name for the spinner; defaults to the translated word for
-     * "loading" in the `LeaProvider` language. `StatusAnimation` hides the pulse
-     * from assistive tech and announces its own status text instead.
-     */
-    label?: string;
-};
-export declare const PulseAnimation: ({ size, label }: PulseAnimationProps) => import("react").JSX.Element;
-export {};