@intlayer/use-intl 9.0.0-canary.2

package/dist/esm/shared/namespaceTranslator.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"namespaceTranslator.mjs","names":[],"sources":["../../../src/shared/namespaceTranslator.tsx"],"sourcesContent":["import { getIntlayer } from '@intlayer/core/interpreter';\nimport {\n  type MessageValues,\n  parseTaggedMessage,\n  resolveMessage,\n  type TaggedMessageToken,\n} from '@intlayer/core/messageFormat';\nimport type {\n  DictionaryKeys,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { Fragment, type ReactNode } from 'react';\n\n/** Chunk renderer used by `t.rich()` — maps tag children to a React node. */\nexport type RichChunkRenderer = (chunks: ReactNode) => ReactNode;\n\n/** Chunk renderer used by `t.markup()` — maps tag children to a string. */\nexport type MarkupChunkRenderer = (chunks: string) => string;\n\n/**\n * Reads a dotted `path` (e.g. `counter.label`) out of a nested object value.\n *\n * @param objectValue - The object to read from.\n * @param path - Dot-separated path. An empty path returns `objectValue`.\n * @returns The value found at `path`, or `undefined` when any segment is absent.\n */\nexport const navigatePath = (objectValue: unknown, path: string): unknown => {\n  if (!path) return objectValue;\n  const parts = path.split('.');\n  let current: unknown = objectValue;\n  for (const part of parts) {\n    if (\n      current === null ||\n      current === undefined ||\n      typeof current !== 'object'\n    ) {\n      return undefined;\n    }\n    current = (current as Record<string, unknown>)[part];\n  }\n  return current;\n};\n\n/** Splits rich values into scalar interpolation values and tag renderers. */\nconst splitRichValues = (\n  values: Record<string, unknown> = {}\n): { scalarValues: MessageValues; renderers: Record<string, unknown> } => {\n  const scalarValues: MessageValues = {};\n  const renderers: Record<string, unknown> = {};\n\n  for (const [valueKey, value] of Object.entries(values)) {\n    if (typeof value === 'function') renderers[valueKey] = value;\n    else scalarValues[valueKey] = value;\n  }\n\n  return { scalarValues, renderers };\n};\n\nconst renderRichTokens = (\n  tokens: TaggedMessageToken[],\n  renderers: Record<string, unknown>\n): ReactNode[] =>\n  tokens.map((token, tokenIndex) => {\n    if (typeof token === 'string') return token;\n\n    const children = renderRichTokens(token.children, renderers);\n    const renderer = renderers[token.tag];\n\n    if (typeof renderer === 'function') {\n      return (\n        <Fragment key={tokenIndex}>\n          {(renderer as RichChunkRenderer)(children)}\n        </Fragment>\n      );\n    }\n\n    // No renderer provided for the tag — render its children unwrapped\n    return <Fragment key={tokenIndex}>{children}</Fragment>;\n  });\n\nconst renderMarkupTokens = (\n  tokens: TaggedMessageToken[],\n  renderers: Record<string, unknown>\n): string =>\n  tokens\n    .map((token) => {\n      if (typeof token === 'string') return token;\n\n      const children = renderMarkupTokens(token.children, renderers);\n      const renderer = renderers[token.tag];\n\n      if (typeof renderer === 'function') {\n        return (renderer as MarkupChunkRenderer)(children);\n      }\n\n      return children;\n    })\n    .join('');\n\n/**\n * The untyped runtime translator shared by `useTranslations` (React hook) and\n * `createTranslator` (non-React core).\n *\n * Behaviour matches use-intl / next-intl:\n * - namespace `'about'` → keys resolved inside the `about` dictionary\n * - namespace `'about.counter'` → dictionary `about`, key prefix `counter`\n * - no namespace → the first segment of each key is the dictionary key\n * - messages support ICU syntax (plural, select, `#`, formatted arguments)\n * - `t.rich` / `t.markup` map `<tag>chunks</tag>` through the provided\n *   renderers; `t.raw` returns the raw value; `t.has` checks existence\n *\n * @param locale - The locale dictionaries are resolved for.\n * @param namespace - Optional dictionary key, optionally with a nested scope.\n * @returns A translate function augmented with `has`, `raw`, `rich`, `markup`.\n */\nexport const createNamespaceTranslator = (\n  locale: LocalesValues,\n  namespace?: string\n) => {\n  const [dictionaryKey, ...prefixSegments] = (namespace ?? '').split('.');\n  const keyPrefix = prefixSegments.join('.');\n\n  const lookup = (key: string): unknown => {\n    let targetDictionaryKey = dictionaryKey;\n    let path = keyPrefix ? `${keyPrefix}.${key}` : key;\n\n    if (!targetDictionaryKey) {\n      // Root scope — the first key segment designates the dictionary\n      const [firstSegment, ...restSegments] = key.split('.');\n      targetDictionaryKey = firstSegment;\n      path = restSegments.join('.');\n    }\n\n    try {\n      const dictionary = getIntlayer(\n        targetDictionaryKey as DictionaryKeys,\n        locale\n      );\n      return navigatePath(dictionary, path);\n    } catch {\n      return undefined;\n    }\n  };\n\n  const resolveToString = (\n    key: string,\n    values: MessageValues = {}\n  ): string | undefined => {\n    const rawValue = lookup(key);\n    if (rawValue === null || rawValue === undefined) return undefined;\n    return resolveMessage(rawValue, values, locale, 'icu');\n  };\n\n  const missingKeyFallback = (key: string): string =>\n    namespace ? `${namespace}.${key}` : key;\n\n  const translate = (key: string, values?: MessageValues): string =>\n    resolveToString(key, values) ?? missingKeyFallback(key);\n\n  return Object.assign(translate, {\n    /** Returns `true` if the given key exists in the namespace. */\n    has: (key: string): boolean => lookup(key) !== undefined,\n\n    /** Returns the raw unprocessed content for the given key. */\n    raw: (key: string): unknown => lookup(key),\n\n    /**\n     * Resolves a message containing `<tag>chunks</tag>` markup, mapping each\n     * tag through the matching renderer in `values`.\n     */\n    rich: (key: string, values?: Record<string, unknown>): ReactNode => {\n      const { scalarValues, renderers } = splitRichValues(values);\n      const message = resolveToString(key, scalarValues);\n      if (message === undefined) return missingKeyFallback(key);\n      return <>{renderRichTokens(parseTaggedMessage(message), renderers)}</>;\n    },\n\n    /**\n     * Resolves a message containing `<tag>chunks</tag>` markup into a string,\n     * mapping each tag through the matching string renderer in `values`.\n     */\n    markup: (key: string, values?: Record<string, unknown>): string => {\n      const { scalarValues, renderers } = splitRichValues(values);\n      const message = resolveToString(key, scalarValues);\n      if (message === undefined) return missingKeyFallback(key);\n      return renderMarkupTokens(parseTaggedMessage(message), renderers);\n    },\n  });\n};\n\nexport type CompatTranslator = ReturnType<typeof createNamespaceTranslator>;\n"],"mappings":";;;;;;;;;;;;;AA0BA,MAAa,gBAAgB,aAAsB,SAA0B;AAC3E,KAAI,CAAC,KAAM,QAAO;CAClB,MAAM,QAAQ,KAAK,MAAM,IAAI;CAC7B,IAAI,UAAmB;AACvB,MAAK,MAAM,QAAQ,OAAO;AACxB,MACE,YAAY,QACZ,YAAY,UACZ,OAAO,YAAY,SAEnB;AAEF,YAAW,QAAoC;;AAEjD,QAAO;;;AAIT,MAAM,mBACJ,SAAkC,EAAE,KACoC;CACxE,MAAM,eAA8B,EAAE;CACtC,MAAM,YAAqC,EAAE;AAE7C,MAAK,MAAM,CAAC,UAAU,UAAU,OAAO,QAAQ,OAAO,CACpD,KAAI,OAAO,UAAU,WAAY,WAAU,YAAY;KAClD,cAAa,YAAY;AAGhC,QAAO;EAAE;EAAc;EAAW;;AAGpC,MAAM,oBACJ,QACA,cAEA,OAAO,KAAK,OAAO,eAAe;AAChC,KAAI,OAAO,UAAU,SAAU,QAAO;CAEtC,MAAM,WAAW,iBAAiB,MAAM,UAAU,UAAU;CAC5D,MAAM,WAAW,UAAU,MAAM;AAEjC,KAAI,OAAO,aAAa,WACtB,QACE,oBAAC,UAAD,YACI,SAA+B,SAAS,EACjC,EAFI,WAEJ;AAKf,QAAO,oBAAC,UAAD,EAA4B,UAAoB,EAAjC,WAAiC;EACvD;AAEJ,MAAM,sBACJ,QACA,cAEA,OACG,KAAK,UAAU;AACd,KAAI,OAAO,UAAU,SAAU,QAAO;CAEtC,MAAM,WAAW,mBAAmB,MAAM,UAAU,UAAU;CAC9D,MAAM,WAAW,UAAU,MAAM;AAEjC,KAAI,OAAO,aAAa,WACtB,QAAQ,SAAiC,SAAS;AAGpD,QAAO;EACP,CACD,KAAK,GAAG;;;;;;;;;;;;;;;;;AAkBb,MAAa,6BACX,QACA,cACG;CACH,MAAM,CAAC,eAAe,GAAG,mBAAmB,aAAa,IAAI,MAAM,IAAI;CACvE,MAAM,YAAY,eAAe,KAAK,IAAI;CAE1C,MAAM,UAAU,QAAyB;EACvC,IAAI,sBAAsB;EAC1B,IAAI,OAAO,YAAY,GAAG,UAAU,GAAG,QAAQ;AAE/C,MAAI,CAAC,qBAAqB;GAExB,MAAM,CAAC,cAAc,GAAG,gBAAgB,IAAI,MAAM,IAAI;AACtD,yBAAsB;AACtB,UAAO,aAAa,KAAK,IAAI;;AAG/B,MAAI;AAKF,UAAO,aAJY,YACjB,qBACA,OAE4B,EAAE,KAAK;UAC/B;AACN;;;CAIJ,MAAM,mBACJ,KACA,SAAwB,EAAE,KACH;EACvB,MAAM,WAAW,OAAO,IAAI;AAC5B,MAAI,aAAa,QAAQ,aAAa,OAAW,QAAO;AACxD,SAAO,eAAe,UAAU,QAAQ,QAAQ,MAAM;;CAGxD,MAAM,sBAAsB,QAC1B,YAAY,GAAG,UAAU,GAAG,QAAQ;CAEtC,MAAM,aAAa,KAAa,WAC9B,gBAAgB,KAAK,OAAO,IAAI,mBAAmB,IAAI;AAEzD,QAAO,OAAO,OAAO,WAAW;;EAE9B,MAAM,QAAyB,OAAO,IAAI,KAAK;;EAG/C,MAAM,QAAyB,OAAO,IAAI;;;;;EAM1C,OAAO,KAAa,WAAgD;GAClE,MAAM,EAAE,cAAc,cAAc,gBAAgB,OAAO;GAC3D,MAAM,UAAU,gBAAgB,KAAK,aAAa;AAClD,OAAI,YAAY,OAAW,QAAO,mBAAmB,IAAI;AACzD,UAAO,4CAAG,iBAAiB,mBAAmB,QAAQ,EAAE,UAAU,EAAI;;;;;;EAOxE,SAAS,KAAa,WAA6C;GACjE,MAAM,EAAE,cAAc,cAAc,gBAAgB,OAAO;GAC3D,MAAM,UAAU,gBAAgB,KAAK,aAAa;AAClD,OAAI,YAAY,OAAW,QAAO,mBAAmB,IAAI;AACzD,UAAO,mBAAmB,mBAAmB,QAAQ,EAAE,UAAU;;EAEpE,CAAC"}

package/dist/esm/useDictionary.mjs

@@ -0,0 +1,35 @@
+'use client';
+
+import { navigatePath } from "./shared/namespaceTranslator.mjs";
+import { useDictionary as useDictionary$1 } from "react-intlayer";
+
+//#region src/useDictionary.ts
+/**
+* Dictionary-accepting variant of `useTranslations`.
+*
+* Used internally by the build-time optimization: instead of looking up the
+* dictionary at runtime by key, the babel/swc plugin pre-imports the dictionary
+* JSON at build time and passes it directly here. This enables tree-shaking of
+* unused locale content.
+*
+* @example (generated by the plugin, not written manually)
+* import _abc from '.intlayer/dictionaries/about.json' with { type: 'json' };
+* const t = useDictionary(_abc);
+*/
+const useDictionary = (dictionary, namespacePrefix) => {
+	const content = useDictionary$1(dictionary);
+	const resolveKey = (key) => namespacePrefix ? `${namespacePrefix}.${key}` : key;
+	return Object.assign((lookup, params) => {
+		const rawValue = navigatePath(content, resolveKey(String(lookup)));
+		const text = String(rawValue ?? resolveKey(String(lookup)));
+		if (!params) return text;
+		return text.replace(/\{(\w+)\}/g, (_match, key) => params[key] != null ? String(params[key]) : `{${key}}`);
+	}, {
+		has: (lookup) => navigatePath(content, resolveKey(String(lookup))) != null,
+		raw: (lookup) => navigatePath(content, resolveKey(String(lookup)))
+	});
+};
+
+//#endregion
+export { useDictionary };
+//# sourceMappingURL=useDictionary.mjs.map

package/dist/esm/useDictionary.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDictionary.mjs","names":["useDictionaryBase"],"sources":["../../src/useDictionary.ts"],"sourcesContent":["'use client';\n\nimport type { ValidDotPathsFor } from '@intlayer/core/transpiler';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport { useDictionary as useDictionaryBase } from 'react-intlayer';\nimport { navigatePath } from './shared/namespaceTranslator';\n\n/**\n * Dictionary-accepting variant of `useTranslations`.\n *\n * Used internally by the build-time optimization: instead of looking up the\n * dictionary at runtime by key, the babel/swc plugin pre-imports the dictionary\n * JSON at build time and passes it directly here. This enables tree-shaking of\n * unused locale content.\n *\n * @example (generated by the plugin, not written manually)\n * import _abc from '.intlayer/dictionaries/about.json' with { type: 'json' };\n * const t = useDictionary(_abc);\n */\nexport const useDictionary = <T extends Dictionary>(\n  dictionary: T,\n  namespacePrefix?: string\n) => {\n  const content = useDictionaryBase(dictionary);\n\n  const resolveKey = (key: string): string =>\n    namespacePrefix ? `${namespacePrefix}.${key}` : key;\n\n  return Object.assign(\n    <P extends ValidDotPathsFor<string>>(\n      lookup: P,\n      params?: Record<string, unknown>\n    ): string => {\n      const rawValue = navigatePath(content, resolveKey(String(lookup)));\n      const text = String(rawValue ?? resolveKey(String(lookup)));\n      if (!params) return text;\n      return text.replace(/\\{(\\w+)\\}/g, (_match, key) =>\n        params[key] != null ? String(params[key]) : `{${key}}`\n      );\n    },\n    {\n      has: <P extends ValidDotPathsFor<string>>(lookup: P): boolean =>\n        navigatePath(content, resolveKey(String(lookup))) != null,\n      raw: <P extends ValidDotPathsFor<string>>(lookup: P): unknown =>\n        navigatePath(content, resolveKey(String(lookup))),\n    }\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAmBA,MAAa,iBACX,YACA,oBACG;CACH,MAAM,UAAUA,gBAAkB,WAAW;CAE7C,MAAM,cAAc,QAClB,kBAAkB,GAAG,gBAAgB,GAAG,QAAQ;AAElD,QAAO,OAAO,QAEV,QACA,WACW;EACX,MAAM,WAAW,aAAa,SAAS,WAAW,OAAO,OAAO,CAAC,CAAC;EAClE,MAAM,OAAO,OAAO,YAAY,WAAW,OAAO,OAAO,CAAC,CAAC;AAC3D,MAAI,CAAC,OAAQ,QAAO;AACpB,SAAO,KAAK,QAAQ,eAAe,QAAQ,QACzC,OAAO,QAAQ,OAAO,OAAO,OAAO,KAAK,GAAG,IAAI,IAAI,GACrD;IAEH;EACE,MAA0C,WACxC,aAAa,SAAS,WAAW,OAAO,OAAO,CAAC,CAAC,IAAI;EACvD,MAA0C,WACxC,aAAa,SAAS,WAAW,OAAO,OAAO,CAAC,CAAC;EACpD,CACF"}

package/dist/esm/useDictionaryDynamic.mjs

@@ -0,0 +1,29 @@
+'use client';
+
+import { navigatePath } from "./shared/namespaceTranslator.mjs";
+import { useDictionaryDynamic as useDictionaryDynamic$1 } from "react-intlayer";
+
+//#region src/useDictionaryDynamic.ts
+/**
+* Dynamic dictionary-accepting variant of `useTranslations`.
+*
+* Counterpart to {@link useDictionary} for dictionaries imported lazily per
+* locale. Used internally by the build-time optimization.
+*/
+const useDictionaryDynamic = (dictionaryPromise, key, namespacePrefix) => {
+	const content = useDictionaryDynamic$1(dictionaryPromise, key);
+	const resolveKey = (lookupKey) => namespacePrefix ? `${namespacePrefix}.${lookupKey}` : lookupKey;
+	return Object.assign((lookup, params) => {
+		const rawValue = navigatePath(content, resolveKey(String(lookup)));
+		const text = String(rawValue ?? resolveKey(String(lookup)));
+		if (!params) return text;
+		return text.replace(/\{(\w+)\}/g, (_match, key) => params[key] != null ? String(params[key]) : `{${key}}`);
+	}, {
+		has: (lookup) => navigatePath(content, resolveKey(String(lookup))) != null,
+		raw: (lookup) => navigatePath(content, resolveKey(String(lookup)))
+	});
+};
+
+//#endregion
+export { useDictionaryDynamic };
+//# sourceMappingURL=useDictionaryDynamic.mjs.map

package/dist/esm/useDictionaryDynamic.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDictionaryDynamic.mjs","names":["useDictionaryDynamicBase"],"sources":["../../src/useDictionaryDynamic.ts"],"sourcesContent":["'use client';\n\nimport type { ValidDotPathsFor } from '@intlayer/core/transpiler';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport type { StrictModeLocaleMap } from '@intlayer/types/module_augmentation';\nimport { useDictionaryDynamic as useDictionaryDynamicBase } from 'react-intlayer';\nimport { navigatePath } from './shared/namespaceTranslator';\n\n/**\n * Dynamic dictionary-accepting variant of `useTranslations`.\n *\n * Counterpart to {@link useDictionary} for dictionaries imported lazily per\n * locale. Used internally by the build-time optimization.\n */\nexport const useDictionaryDynamic = <\n  const T extends Dictionary,\n  const K extends string,\n>(\n  dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>,\n  key: K,\n  namespacePrefix?: string\n) => {\n  const content = useDictionaryDynamicBase<T, K>(dictionaryPromise, key);\n\n  const resolveKey = (lookupKey: string): string =>\n    namespacePrefix ? `${namespacePrefix}.${lookupKey}` : lookupKey;\n\n  return Object.assign(\n    <P extends ValidDotPathsFor<string>>(\n      lookup: P,\n      params?: Record<string, unknown>\n    ): string => {\n      const rawValue = navigatePath(content, resolveKey(String(lookup)));\n      const text = String(rawValue ?? resolveKey(String(lookup)));\n      if (!params) return text;\n      return text.replace(/\\{(\\w+)\\}/g, (_match, key) =>\n        params[key] != null ? String(params[key]) : `{${key}}`\n      );\n    },\n    {\n      has: <P extends ValidDotPathsFor<string>>(lookup: P): boolean =>\n        navigatePath(content, resolveKey(String(lookup))) != null,\n      raw: <P extends ValidDotPathsFor<string>>(lookup: P): unknown =>\n        navigatePath(content, resolveKey(String(lookup))),\n    }\n  );\n};\n"],"mappings":";;;;;;;;;;;;AAcA,MAAa,wBAIX,mBACA,KACA,oBACG;CACH,MAAM,UAAUA,uBAA+B,mBAAmB,IAAI;CAEtE,MAAM,cAAc,cAClB,kBAAkB,GAAG,gBAAgB,GAAG,cAAc;AAExD,QAAO,OAAO,QAEV,QACA,WACW;EACX,MAAM,WAAW,aAAa,SAAS,WAAW,OAAO,OAAO,CAAC,CAAC;EAClE,MAAM,OAAO,OAAO,YAAY,WAAW,OAAO,OAAO,CAAC,CAAC;AAC3D,MAAI,CAAC,OAAQ,QAAO;AACpB,SAAO,KAAK,QAAQ,eAAe,QAAQ,QACzC,OAAO,QAAQ,OAAO,OAAO,OAAO,KAAK,GAAG,IAAI,IAAI,GACrD;IAEH;EACE,MAA0C,WACxC,aAAa,SAAS,WAAW,OAAO,OAAO,CAAC,CAAC,IAAI;EACvD,MAA0C,WACxC,aAAa,SAAS,WAAW,OAAO,OAAO,CAAC,CAAC;EACpD,CACF"}

package/dist/types/core/createFormatter.d.ts

@@ -0,0 +1,21 @@
+import { createFormatter as createFormatter$1 } from "use-intl";
+
+//#region src/core/createFormatter.d.ts
+/**
+ * Drop-in for use-intl's `createFormatter`.
+ *
+ * Returns locale-aware formatters backed by the native `Intl.*` APIs:
+ * `dateTime`, `number`, `dateTimeRange`, `relativeTime`, `list`, and
+ * `displayName`. `now`, `timeZone`, `formats`, and `onError` are accepted for
+ * API compatibility but only `locale` influences the output.
+ *
+ * @example
+ * ```ts
+ * const format = createFormatter({ locale: 'en' });
+ * format.number(1234.5, { style: 'currency', currency: 'USD' });
+ * ```
+ */
+declare const createFormatter: typeof createFormatter$1;
+//#endregion
+export { createFormatter };
+//# sourceMappingURL=createFormatter.d.ts.map

package/dist/types/core/createFormatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createFormatter.d.ts","names":[],"sources":["../../../src/core/createFormatter.ts"],"mappings":";;;;;AAiBA;;;;;;;;;;;;cAAa,eAAA,SAAwB,iBAAA"}

package/dist/types/core/createTranslator.d.ts

@@ -0,0 +1,56 @@
+import { LooseTranslateFunction, TranslateFunction } from "../shared/translateFunctionTypes.js";
+import { DictionaryKeys, LocalesValues } from "@intlayer/types/module_augmentation";
+
+//#region src/core/createTranslator.d.ts
+/**
+ * Configuration accepted by {@link createTranslator}.
+ *
+ * Mirrors use-intl's `IntlConfig`, but `messages`, `formats`, `now`,
+ * `timeZone`, `onError`, and `getMessageFallback` have no effect — Intlayer
+ * resolves content from its own compiled dictionaries.
+ */
+type CreateTranslatorConfig<N extends DictionaryKeys> = {
+  /** The locale dictionaries are resolved for. */locale: LocalesValues; /** A bare dictionary key, or a nested `'dictionary.scope'` namespace. */
+  namespace?: N | (string & {});
+  /**
+   * @deprecated has no use case with intlayer. Messages are loaded
+   * automatically under the hood for bundle optimization reason.
+   */
+  messages?: never;
+} & Record<string, unknown>;
+/**
+ * Overload set for {@link createTranslator}:
+ *
+ * 1. A bare dictionary key → fully-typed `t()` (autocompleted dot-paths).
+ * 2. A nested namespace `'dictionary.sub.scope'` → `t()` accepts relative
+ *    `string` paths, matching use-intl's scoped-namespace behaviour.
+ * 3. No namespace → root scope; the first segment of each key designates
+ *    the dictionary (`t('about.title')`).
+ */
+type CreateTranslator = {
+  <N extends DictionaryKeys>(config: CreateTranslatorConfig<N> & {
+    namespace: N;
+  }): TranslateFunction<N>;
+  (config: CreateTranslatorConfig<DictionaryKeys> & {
+    namespace: `${string}.${string}`;
+  }): LooseTranslateFunction;
+  (config: CreateTranslatorConfig<DictionaryKeys>): LooseTranslateFunction;
+};
+/**
+ * Drop-in for use-intl's `createTranslator`.
+ *
+ * Returns a translate function (with `rich`, `markup`, `raw`, `has`) that
+ * resolves messages from Intlayer's compiled dictionaries for the given
+ * `locale`. Messages support ICU MessageFormat syntax.
+ *
+ * @example
+ * ```ts
+ * const t = createTranslator({ locale: 'en', namespace: 'about' });
+ * t('counter.label'); // ✓ typed
+ * t('items', { count: 3 }); // ICU plural
+ * ```
+ */
+declare const createTranslator: CreateTranslator;
+//#endregion
+export { CreateTranslatorConfig, createTranslator };
+//# sourceMappingURL=createTranslator.d.ts.map

package/dist/types/core/createTranslator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTranslator.d.ts","names":[],"sources":["../../../src/core/createTranslator.ts"],"mappings":";;;;;;AAoBA;;;;;KAAY,sBAAA,WAAiC,cAAA;EAUzC,gDARF,MAAA,EAAQ,aAAA,EAQA;EANR,SAAA,GAAY,CAAA;EAJ+B;;;;EAS3C,QAAA;AAAA,IACE,MAAA;;;;AAAwB;;;;;;KAWvB,gBAAA;EAAA,WACQ,cAAA,EACT,MAAA,EAAQ,sBAAA,CAAuB,CAAA;IAAO,SAAA,EAAW,CAAA;EAAA,IAChD,iBAAA,CAAkB,CAAA;EAAA,CAEnB,MAAA,EAAQ,sBAAA,CAAuB,cAAA;IAC7B,SAAA;EAAA,IAED,sBAAA;EAAA,CACF,MAAA,EAAQ,sBAAA,CAAuB,cAAA,IAAkB,sBAAA;AAAA;;;;;;;;;;;;;;;cAiBvC,gBAAA,EAaP,gBAAA"}

package/dist/types/core/errors.d.ts

@@ -0,0 +1,31 @@
+//#region src/core/errors.d.ts
+/**
+ * Drop-in for use-intl's `IntlErrorCode` enum.
+ *
+ * Re-implemented locally (rather than re-exported) because `use-intl` is
+ * aliased to this package at build time, so importing its runtime value would
+ * be circular.
+ */
+declare enum IntlErrorCode {
+  MISSING_MESSAGE = "MISSING_MESSAGE",
+  MISSING_FORMAT = "MISSING_FORMAT",
+  ENVIRONMENT_FALLBACK = "ENVIRONMENT_FALLBACK",
+  INSUFFICIENT_PATH = "INSUFFICIENT_PATH",
+  INVALID_MESSAGE = "INVALID_MESSAGE",
+  INVALID_KEY = "INVALID_KEY",
+  FORMATTING_ERROR = "FORMATTING_ERROR"
+}
+/**
+ * Drop-in for use-intl's `IntlError`.
+ *
+ * Carries the {@link IntlErrorCode} and the original message, matching
+ * use-intl's error shape so consumer `onError` handlers keep working.
+ */
+declare class IntlError extends Error {
+  readonly code: IntlErrorCode;
+  readonly originalMessage: string | undefined;
+  constructor(code: IntlErrorCode, originalMessage?: string);
+}
+//#endregion
+export { IntlError, IntlErrorCode };
+//# sourceMappingURL=errors.d.ts.map

package/dist/types/core/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","names":[],"sources":["../../../src/core/errors.ts"],"mappings":";;AAOA;;;;;;aAAY,aAAA;EACV,eAAA;EACA,cAAA;EACA,oBAAA;EACA,iBAAA;EACA,eAAA;EACA,WAAA;EACA,gBAAA;AAAA;;;;;;;cASW,SAAA,SAAkB,KAAA;EAAA,SACb,IAAA,EAAM,aAAA;EAAA,SACN,eAAA;cAEJ,IAAA,EAAM,aAAA,EAAe,eAAA;AAAA"}

package/dist/types/core/hasLocale.d.ts

@@ -0,0 +1,18 @@
+import { hasLocale as hasLocale$1 } from "use-intl";
+
+//#region src/core/hasLocale.d.ts
+/**
+ * Drop-in for use-intl's `hasLocale`.
+ *
+ * Narrows a locale candidate to the given locales list. When the list is
+ * omitted, the locales configured in intlayer are used.
+ *
+ * @example
+ * ```ts
+ * if (hasLocale(['en', 'fr'], requested)) { … }
+ * ```
+ */
+declare const hasLocale: typeof hasLocale$1;
+//#endregion
+export { hasLocale };
+//# sourceMappingURL=hasLocale.d.ts.map

package/dist/types/core/hasLocale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hasLocale.d.ts","names":[],"sources":["../../../src/core/hasLocale.ts"],"mappings":";;;;;AAcA;;;;;;;;;cAAa,SAAA,SAAkB,WAAA"}

package/dist/types/core/index.d.ts

@@ -0,0 +1,7 @@
+import { createFormatter } from "./createFormatter.js";
+import { CreateTranslatorConfig, createTranslator } from "./createTranslator.js";
+import { IntlError, IntlErrorCode } from "./errors.js";
+import { hasLocale } from "./hasLocale.js";
+import { initializeConfig } from "./initializeConfig.js";
+import { AbstractIntlMessages, AppConfig, DateTimeFormatOptions, Formats, ICUArgs, ICUTags, IntlConfig, Locale, MarkupTagsFunction, MarkupTranslationValues, MessageKeys, Messages, NamespaceKeys, NestedKeyOf, NestedValueOf, NumberFormatOptions, RelativeTimeFormatOptions, RichTagsFunction, RichTranslationValues, Timezone, TranslationValues } from "./types.js";
+export { AbstractIntlMessages, AppConfig, type CreateTranslatorConfig, DateTimeFormatOptions, Formats, ICUArgs, ICUTags, IntlConfig, IntlError, IntlErrorCode, Locale, MarkupTagsFunction, MarkupTranslationValues, MessageKeys, Messages, NamespaceKeys, NestedKeyOf, NestedValueOf, NumberFormatOptions, RelativeTimeFormatOptions, RichTagsFunction, RichTranslationValues, Timezone, TranslationValues, createFormatter, createTranslator, hasLocale, initializeConfig };

package/dist/types/core/initializeConfig.d.ts

@@ -0,0 +1,14 @@
+import { initializeConfig as initializeConfig$1 } from "use-intl";
+
+//#region src/core/initializeConfig.d.ts
+/**
+ * Drop-in for use-intl's `initializeConfig`.
+ *
+ * Enhances an incoming config with defaults. With intlayer, `messages` and
+ * `formats` are not consumed at runtime (content comes from compiled
+ * dictionaries) but the shape is preserved so callers keep type-checking.
+ */
+declare const initializeConfig: typeof initializeConfig$1;
+//#endregion
+export { initializeConfig };
+//# sourceMappingURL=initializeConfig.d.ts.map

package/dist/types/core/initializeConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initializeConfig.d.ts","names":[],"sources":["../../../src/core/initializeConfig.ts"],"mappings":";;;;;AASA;;;;;cAAa,gBAAA,SAAyB,kBAAA"}

package/dist/types/core/types.d.ts

@@ -0,0 +1,2 @@
+import { AbstractIntlMessages, AppConfig, DateTimeFormatOptions, Formats, ICUArgs, ICUTags, IntlConfig, Locale, MarkupTagsFunction, MarkupTranslationValues, MessageKeys, Messages, NamespaceKeys, NestedKeyOf, NestedValueOf, NumberFormatOptions, RelativeTimeFormatOptions, RichTagsFunction, RichTranslationValues, Timezone, TranslationValues } from "use-intl";
+export { type AbstractIntlMessages, type AppConfig, type DateTimeFormatOptions, type Formats, type ICUArgs, type ICUTags, type IntlConfig, type Locale, type MarkupTagsFunction, type MarkupTranslationValues, type MessageKeys, type Messages, type NamespaceKeys, type NestedKeyOf, type NestedValueOf, type NumberFormatOptions, type RelativeTimeFormatOptions, type RichTagsFunction, type RichTranslationValues, type Timezone, type TranslationValues };

package/dist/types/index.d.ts

@@ -0,0 +1,14 @@
+import { createFormatter } from "./core/createFormatter.js";
+import { CreateTranslatorConfig, createTranslator } from "./core/createTranslator.js";
+import { IntlError, IntlErrorCode } from "./core/errors.js";
+import { hasLocale } from "./core/hasLocale.js";
+import { initializeConfig } from "./core/initializeConfig.js";
+import { AbstractIntlMessages, AppConfig, DateTimeFormatOptions, Formats, ICUArgs, ICUTags, IntlConfig, Locale, MarkupTagsFunction, MarkupTranslationValues, MessageKeys, Messages, NamespaceKeys, NestedKeyOf, NestedValueOf, NumberFormatOptions, RelativeTimeFormatOptions, RichTagsFunction, RichTranslationValues, Timezone, TranslationValues } from "./core/types.js";
+import { IntlProvider, IntlProviderProps } from "./react/IntlProvider.js";
+import { useFormatter, useMessages, useNow, useTimeZone } from "./react/helpers.js";
+import { useLocale } from "./react/useLocale.js";
+import { useTranslations } from "./react/useTranslations.js";
+import { useDictionary } from "./useDictionary.js";
+import { useDictionaryDynamic } from "./useDictionaryDynamic.js";
+import { _useExtracted } from "./react/index.js";
+export { AbstractIntlMessages, AppConfig, CreateTranslatorConfig, DateTimeFormatOptions, Formats, ICUArgs, ICUTags, IntlConfig, IntlError, IntlErrorCode, IntlProvider, IntlProviderProps, Locale, MarkupTagsFunction, MarkupTranslationValues, MessageKeys, Messages, NamespaceKeys, NestedKeyOf, NestedValueOf, NumberFormatOptions, RelativeTimeFormatOptions, RichTagsFunction, RichTranslationValues, Timezone, TranslationValues, _useExtracted, createFormatter, createTranslator, hasLocale, initializeConfig, useDictionary, useDictionaryDynamic, useFormatter, useLocale, useMessages, useNow, useTimeZone, useTranslations };

package/dist/types/plugin/index.d.ts

@@ -0,0 +1,22 @@
+import { PluginOption } from "vite";
+import { intlayer } from "vite-intlayer";
+
+//#region src/plugin/index.d.ts
+/**
+ * A Vite plugin for use-intl compat that wraps vite-intlayer and configures
+ * resolve aliases so `use-intl` imports are served by `@intlayer/use-intl`.
+ *
+ * @example
+ * ```ts
+ * // vite.config.ts
+ * import useIntlVitePlugin from '@intlayer/use-intl/plugin';
+ *
+ * export default defineConfig({
+ *   plugins: [useIntlVitePlugin()],
+ * });
+ * ```
+ */
+declare const useIntlVitePlugin: (options?: Parameters<typeof intlayer>[0]) => PluginOption[];
+//#endregion
+export { useIntlVitePlugin as default, useIntlVitePlugin };
+//# sourceMappingURL=index.d.ts.map

package/dist/types/plugin/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/plugin/index.ts"],"mappings":";;;;;;AA6CA;;;;;;;;;;;;cAAa,iBAAA,GACX,OAAA,GAAU,UAAA,QAAkB,QAAA,SAC3B,YAAA"}

package/dist/types/react/IntlProvider.d.ts

@@ -0,0 +1,29 @@
+import { IntlProvider as IntlProvider$1 } from "use-intl";
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+import { ComponentProps } from "react";
+
+//#region src/react/IntlProvider.d.ts
+/**
+ * Drop-in for use-intl's `IntlProvider`.
+ *
+ * Wraps Intlayer's `IntlayerProvider`, seeding the client locale from the
+ * `locale` prop. `messages`, `formats`, `now`, `timeZone`, `onError`, and
+ * `getMessageFallback` are accepted for API compatibility but have no effect —
+ * Intlayer uses its own compiled dictionaries.
+ */
+declare const IntlProvider: typeof IntlProvider$1;
+/**
+ * Props accepted by {@link IntlProvider}. `messages` is deprecated — Intlayer
+ * loads content from compiled dictionaries automatically.
+ */
+type IntlProviderProps = Omit<ComponentProps<typeof IntlProvider$1>, 'messages' | 'locale'> & {
+  /**
+   * @deprecated has no use case with intlayer. Messages are loaded
+   * automatically under the hood for bundle optimization reason.
+   */
+  messages?: never; /** The active locale. */
+  locale: LocalesValues;
+};
+//#endregion
+export { IntlProvider, IntlProviderProps };
+//# sourceMappingURL=IntlProvider.d.ts.map

package/dist/types/react/IntlProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IntlProvider.d.ts","names":[],"sources":["../../../src/react/IntlProvider.tsx"],"mappings":";;;;;;;AAkBA;;;;;AAoCA;cApCa,YAAA,SAAqB,cAAA;;;;;KAoCtB,iBAAA,GAAoB,IAAA,CAC9B,cAAA,QAAsB,cAAA;EASD;;;;EAFrB,QAAA;EAEA,MAAA,EAAQ,aAAA;AAAA"}

package/dist/types/react/helpers.d.ts

@@ -0,0 +1,31 @@
+import { useFormatter as useFormatter$1, useMessages as useMessages$1, useNow as useNow$1, useTimeZone as useTimeZone$1 } from "use-intl";
+
+//#region src/react/helpers.d.ts
+/**
+ * Drop-in for use-intl's `useNow`.
+ * Returns the current `Date`. The `updateInterval` option is ignored.
+ */
+declare const useNow: typeof useNow$1;
+/**
+ * Drop-in for use-intl's `useTimeZone`.
+ * Returns the system time zone resolved from `Intl.DateTimeFormat`.
+ */
+declare const useTimeZone: typeof useTimeZone$1;
+/**
+ * Drop-in for use-intl's `useMessages`.
+ *
+ * @deprecated useMessages has no use case with intlayer.
+ * Messages are loaded automatically under the hood.
+ * @returns An empty object.
+ */
+declare const useMessages: typeof useMessages$1;
+/**
+ * Drop-in for use-intl's `useFormatter`.
+ * Returns locale-aware formatters backed by the native `Intl.*` APIs:
+ * `dateTime`, `number`, `dateTimeRange`, `relativeTime`, `list`, and
+ * `displayName`.
+ */
+declare const useFormatter: typeof useFormatter$1;
+//#endregion
+export { useFormatter, useMessages, useNow, useTimeZone };
+//# sourceMappingURL=helpers.d.ts.map

package/dist/types/react/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","names":[],"sources":["../../../src/react/helpers.ts"],"mappings":";;;;;AAkBA;;cAAa,MAAA,SAAe,QAAA;;;AAM5B;;cAAa,WAAA,SAAoB,aAAA;;;AAUjC;;;;;cAAa,WAAA,SAAoB,aAAA;;;;;;;cAiBpB,YAAA,SAAqB,cAAA"}

package/dist/types/react/index.d.ts

@@ -0,0 +1,16 @@
+import { IntlProvider, IntlProviderProps } from "./IntlProvider.js";
+import { useFormatter, useMessages, useNow, useTimeZone } from "./helpers.js";
+import { useLocale } from "./useLocale.js";
+import { useTranslations } from "./useTranslations.js";
+import { useDictionary } from "../useDictionary.js";
+import { useDictionaryDynamic } from "../useDictionaryDynamic.js";
+
+//#region src/react/index.d.ts
+/**
+ * @internal Private use-intl export, kept so aliased `_useExtracted` imports
+ * resolve. Not part of the supported public surface.
+ */
+declare const _useExtracted: () => Record<string, never>;
+//#endregion
+export { IntlProvider, type IntlProviderProps, _useExtracted, useDictionary, useDictionaryDynamic, useFormatter, useLocale, useMessages, useNow, useTimeZone, useTranslations };
+//# sourceMappingURL=index.d.ts.map

package/dist/types/react/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/react/index.ts"],"mappings":";;;;;;;;;;AAWA;;cAAa,aAAA,QAAoB,MAAA"}

package/dist/types/react/useLocale.d.ts

@@ -0,0 +1,12 @@
+import { useLocale as useLocale$1 } from "use-intl";
+
+//#region src/react/useLocale.d.ts
+/**
+ * Drop-in for use-intl's `useLocale`.
+ *
+ * Returns the active locale string from Intlayer's client context.
+ */
+declare const useLocale: typeof useLocale$1;
+//#endregion
+export { useLocale };
+//# sourceMappingURL=useLocale.d.ts.map

package/dist/types/react/useLocale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLocale.d.ts","names":[],"sources":["../../../src/react/useLocale.ts"],"mappings":";;;;;AAUA;;;cAAa,SAAA,SAAkB,WAAA"}

package/dist/types/react/useTranslations.d.ts

@@ -0,0 +1,44 @@
+import { LooseTranslateFunction, TranslateFunction } from "../shared/translateFunctionTypes.js";
+import { DictionaryKeys } from "@intlayer/types/module_augmentation";
+
+//#region src/react/useTranslations.d.ts
+/**
+ * Overload set for {@link useTranslations}:
+ *
+ * 1. A bare dictionary key → fully-typed `t()` (autocompleted dot-paths).
+ * 2. A nested namespace `'dictionary.sub.scope'` → `t()` accepts relative
+ *    `string` paths, matching use-intl's scoped-namespace behaviour.
+ * 3. No namespace → root scope; the first segment of each key designates
+ *    the dictionary (`t('about.title')`).
+ */
+type UseTranslations = {
+  <N extends DictionaryKeys>(namespace: N): TranslateFunction<N>;
+  (namespace: `${string}.${string}`): LooseTranslateFunction;
+  (): LooseTranslateFunction;
+};
+/**
+ * Drop-in for use-intl's `useTranslations`.
+ *
+ * Messages support ICU MessageFormat syntax: simple arguments (`{name}`),
+ * plural (`{count, plural, one {…} other {…}}`, `#`), select, and formatted
+ * arguments (`{value, number}`). Rich text is available through `t.rich()`
+ * and `t.markup()`.
+ *
+ * @example
+ * ```tsx
+ * const t = useTranslations('about');
+ * t('counter.label'); // ✓ typed
+ * t('items', { count: 3 }); // ICU plural
+ *
+ * // Scoped to a nested object (use-intl idiom)
+ * const t = useTranslations('about.counter');
+ * t('label'); // resolves about → counter.label
+ *
+ * // Rich text
+ * t.rich('terms', { link: (chunks) => <a href="/terms">{chunks}</a> });
+ * ```
+ */
+declare const useTranslations: UseTranslations;
+//#endregion
+export { useTranslations };
+//# sourceMappingURL=useTranslations.d.ts.map

package/dist/types/react/useTranslations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTranslations.d.ts","names":[],"sources":["../../../src/react/useTranslations.ts"],"mappings":";;;;;;AAY0C;;;;;;;KAWrC,eAAA;EAAA,WACQ,cAAA,EAAgB,SAAA,EAAW,CAAA,GAAI,iBAAA,CAAkB,CAAA;EAAA,CAC3D,SAAA,0BAAmC,sBAAA;EAAA,IAChC,sBAAA;AAAA;;;;;;;;;;;AAyBN;;;;;;;;;;;;cAAa,eAAA,EAOP,eAAA"}

package/dist/types/shared/intlFormatter.d.ts

@@ -0,0 +1,19 @@
+import { createFormatter } from "use-intl";
+
+//#region src/shared/intlFormatter.d.ts
+/** The formatter object shape exposed by use-intl. */
+type Formatter = ReturnType<typeof createFormatter>;
+/**
+ * Builds a use-intl compatible formatter backed by the native `Intl.*` APIs
+ * for the given locale.
+ *
+ * Shared by `useFormatter` (React hook) and `createFormatter` (non-React core).
+ *
+ * @param locale - The locale used by every `Intl.*` formatter instance.
+ * @returns A formatter exposing `dateTime`, `number`, `dateTimeRange`,
+ *   `relativeTime`, `list`, and `displayName`.
+ */
+declare const buildIntlFormatter: (locale: string) => Formatter;
+//#endregion
+export { Formatter, buildIntlFormatter };
+//# sourceMappingURL=intlFormatter.d.ts.map

package/dist/types/shared/intlFormatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intlFormatter.d.ts","names":[],"sources":["../../../src/shared/intlFormatter.ts"],"mappings":";;;;KAGY,SAAA,GAAY,UAAA,QAAkB,eAAA;AAA1C;;;;;AA0BA;;;;;AA1BA,cA0Ba,kBAAA,GAAsB,MAAA,aAAiB,SAAA"}

package/dist/types/shared/namespaceTranslator.d.ts

@@ -0,0 +1,51 @@
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+import { ReactNode } from "react";
+import { MessageValues } from "@intlayer/core/messageFormat";
+
+//#region src/shared/namespaceTranslator.d.ts
+/** Chunk renderer used by `t.rich()` — maps tag children to a React node. */
+type RichChunkRenderer = (chunks: ReactNode) => ReactNode;
+/** Chunk renderer used by `t.markup()` — maps tag children to a string. */
+type MarkupChunkRenderer = (chunks: string) => string;
+/**
+ * Reads a dotted `path` (e.g. `counter.label`) out of a nested object value.
+ *
+ * @param objectValue - The object to read from.
+ * @param path - Dot-separated path. An empty path returns `objectValue`.
+ * @returns The value found at `path`, or `undefined` when any segment is absent.
+ */
+declare const navigatePath: (objectValue: unknown, path: string) => unknown;
+/**
+ * The untyped runtime translator shared by `useTranslations` (React hook) and
+ * `createTranslator` (non-React core).
+ *
+ * Behaviour matches use-intl / next-intl:
+ * - namespace `'about'` → keys resolved inside the `about` dictionary
+ * - namespace `'about.counter'` → dictionary `about`, key prefix `counter`
+ * - no namespace → the first segment of each key is the dictionary key
+ * - messages support ICU syntax (plural, select, `#`, formatted arguments)
+ * - `t.rich` / `t.markup` map `<tag>chunks</tag>` through the provided
+ *   renderers; `t.raw` returns the raw value; `t.has` checks existence
+ *
+ * @param locale - The locale dictionaries are resolved for.
+ * @param namespace - Optional dictionary key, optionally with a nested scope.
+ * @returns A translate function augmented with `has`, `raw`, `rich`, `markup`.
+ */
+declare const createNamespaceTranslator: (locale: LocalesValues, namespace?: string) => ((key: string, values?: MessageValues) => string) & {
+  /** Returns `true` if the given key exists in the namespace. */has: (key: string) => boolean; /** Returns the raw unprocessed content for the given key. */
+  raw: (key: string) => unknown;
+  /**
+   * Resolves a message containing `<tag>chunks</tag>` markup, mapping each
+   * tag through the matching renderer in `values`.
+   */
+  rich: (key: string, values?: Record<string, unknown>) => ReactNode;
+  /**
+   * Resolves a message containing `<tag>chunks</tag>` markup into a string,
+   * mapping each tag through the matching string renderer in `values`.
+   */
+  markup: (key: string, values?: Record<string, unknown>) => string;
+};
+type CompatTranslator = ReturnType<typeof createNamespaceTranslator>;
+//#endregion
+export { CompatTranslator, MarkupChunkRenderer, RichChunkRenderer, createNamespaceTranslator, navigatePath };
+//# sourceMappingURL=namespaceTranslator.d.ts.map

package/dist/types/shared/namespaceTranslator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"namespaceTranslator.d.ts","names":[],"sources":["../../../src/shared/namespaceTranslator.tsx"],"mappings":";;;;;;KAcY,iBAAA,IAAqB,MAAA,EAAQ,SAAA,KAAc,SAAA;AAAvD;AAAA,KAGY,mBAAA,IAAuB,MAAA;;;;;;;;cAStB,YAAA,GAAgB,WAAA,WAAsB,IAAA;;;;;AAAnD;;;;;AAyFA;;;;;;;cAAa,yBAAA,GACX,MAAA,EAAQ,aAAA,EACR,SAAA,gBAAkB,GAAA,UAuCY,MAAA,GAAW,aAAA;EAyBF,8FAjE/B;;EACR;;;;sBAqDoB,MAAA,GAAW,MAAA,sBAA0B,SAAA;;;;;wBAWnC,MAAA,GAAW,MAAA;AAAA;AAAA,KASvB,gBAAA,GAAmB,UAAA,QAAkB,yBAAA"}

package/dist/types/shared/translateFunctionTypes.d.ts

@@ -0,0 +1,34 @@
+import { MarkupChunkRenderer, RichChunkRenderer } from "./namespaceTranslator.js";
+import { DictionaryKeys } from "@intlayer/types/module_augmentation";
+import { ValidDotPathsFor } from "@intlayer/core/transpiler";
+import { ReactNode } from "react";
+
+//#region src/shared/translateFunctionTypes.d.ts
+/**
+ * The translation function returned for a bare dictionary key namespace.
+ *
+ * `key` is validated against the dictionary's dot-paths. Beyond the call
+ * signature, the function exposes:
+ * - `has(key)` — returns `true` when the key exists in the namespace.
+ * - `raw(key)` — returns the unprocessed content value.
+ * - `rich(key, values)` — resolves `<tag>chunks</tag>` markup to React nodes.
+ * - `markup(key, values)` — resolves `<tag>chunks</tag>` markup to a string.
+ */
+type TranslateFunction<N extends DictionaryKeys> = {
+  /** Translate a key to a string, with optional ICU interpolation params. */<P extends ValidDotPathsFor<N>>(key: P, params?: Record<string, unknown>): string; /** Returns `true` if the given key exists in the namespace. */
+  has<P extends ValidDotPathsFor<N>>(key: P): boolean; /** Returns the raw unprocessed content for the given key. */
+  raw<P extends ValidDotPathsFor<N>>(key: P): unknown; /** Resolves rich-text markup, mapping tags through React renderers. */
+  rich<P extends ValidDotPathsFor<N>>(key: P, values?: Record<string, RichChunkRenderer | ReactNode>): ReactNode; /** Resolves rich-text markup, mapping tags through string renderers. */
+  markup<P extends ValidDotPathsFor<N>>(key: P, values?: Record<string, MarkupChunkRenderer | string | number>): string;
+};
+/** Loosely-typed function returned for nested `'dict.scope'` namespaces. */
+type LooseTranslateFunction = {
+  (key: string, params?: Record<string, unknown>): string;
+  has(key: string): boolean;
+  raw(key: string): unknown;
+  rich(key: string, values?: Record<string, RichChunkRenderer | ReactNode>): ReactNode;
+  markup(key: string, values?: Record<string, MarkupChunkRenderer | string | number>): string;
+};
+//#endregion
+export { LooseTranslateFunction, TranslateFunction };
+//# sourceMappingURL=translateFunctionTypes.d.ts.map

package/dist/types/shared/translateFunctionTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"translateFunctionTypes.d.ts","names":[],"sources":["../../../src/shared/translateFunctionTypes.ts"],"mappings":";;;;;;;;AAkBA;;;;;;;;KAAY,iBAAA,WAA4B,cAAA;EAOxB,sFALH,gBAAA,CAAiB,CAAA,GAC1B,GAAA,EAAK,CAAA,EACL,MAAA,GAAS,MAAA,4BAKoB;EAF/B,GAAA,WAAc,gBAAA,CAAiB,CAAA,GAAI,GAAA,EAAK,CAAA,YAEA;EAAxC,GAAA,WAAc,gBAAA,CAAiB,CAAA,GAAI,GAAA,EAAK,CAAA,YAEzB;EAAf,IAAA,WAAe,gBAAA,CAAiB,CAAA,GAC9B,GAAA,EAAK,CAAA,EACL,MAAA,GAAS,MAAA,SAAe,iBAAA,GAAoB,SAAA,IAC3C,SAAA,EADuB;EAG1B,MAAA,WAAiB,gBAAA,CAAiB,CAAA,GAChC,GAAA,EAAK,CAAA,EACL,MAAA,GAAS,MAAA,SAAe,mBAAA;AAAA;;KAKhB,sBAAA;EAAA,CACT,GAAA,UAAa,MAAA,GAAS,MAAA;EACvB,GAAA,CAAI,GAAA;EACJ,GAAA,CAAI,GAAA;EACJ,IAAA,CACE,GAAA,UACA,MAAA,GAAS,MAAA,SAAe,iBAAA,GAAoB,SAAA,IAC3C,SAAA;EACH,MAAA,CACE,GAAA,UACA,MAAA,GAAS,MAAA,SAAe,mBAAA;AAAA"}