@intlayer/core 8.4.0-canary.0 → 8.4.1

package/dist/types/interpreter/getHTML.d.ts

@@ -1,32 +1,2 @@
-//#region src/interpreter/getHTML.d.ts
-/**
- * Component function that receives properly typed props
- * Props include:
- * - children?: any[] - Array of child elements (ReactNode[], VNode[], etc.)
- * - [key: string]: any - Any HTML attributes (className, style, href, etc.)
- */
-type Component = (props: {
-  children?: any[];
-  [key: string]: any;
-}) => any;
-/**
- * Component object that delegates to another component
- */
-type ComponentObject = {
-  tag: string;
-  props?: Record<string, any>;
-};
-/**
- * Components map:
- * - Function components receive typed props
- * - String components delegate to another tag
- * - Object components delegate with additional props
- */
-type Components = Record<string, Component | string | ComponentObject>;
-/**
- * Interprets a string containing HTML-like tags and replaces them with provided components or strings.
- */
-declare const getHTML: (content: string, values: Components) => any;
-//#endregion
-export { getHTML };
-//# sourceMappingURL=getHTML.d.ts.map
+import { t as getHTML } from "../getHTML-CP6OXtdo.js";
+export { getHTML };

package/dist/types/interpreter/getInsertion.d.ts

@@ -1,4 +1,4 @@
-import { InsertionContent } from "../transpiler/insertion/insertion.js";
+import { t as InsertionContent } from "../insertion-M5fwK-29.js";
 //#region src/interpreter/getInsertion.d.ts
 /**
  * Allow to insert values in a string.

package/dist/types/interpreter/getInsertion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getInsertion.d.ts","names":[],"sources":["../../../src/interpreter/getInsertion.ts"],"mappings":";;;;;AAeA;;;;;;;;;;cAAa,YAAA,GACX,OAAA,UACA,MAAA,UAAgB,gBAAA"}
+{"version":3,"file":"getInsertion.d.ts","names":[],"sources":["../../../src/interpreter/getInsertion.ts"],"mappings":";;;;;;;;;;;;;;;cAea,YAAA,GACX,OAAA,UACA,MAAA,UAAgB,gBAAA"}

package/dist/types/interpreter/getIntlayer.d.ts

@@ -1,8 +1,2 @@
-import { DeepTransformContent, IInterpreterPluginState, Plugins } from "./getContent/plugins.js";
-import { DeclaredLocales, DictionaryKeys, DictionaryRegistryContent, LocalesValues } from "@intlayer/types/module_augmentation";
-
-//#region src/interpreter/getIntlayer.d.ts
-declare const getIntlayer: <T extends DictionaryKeys, L extends LocalesValues = DeclaredLocales>(key: T, locale?: L, plugins?: Plugins[]) => DeepTransformContent<DictionaryRegistryContent<T>, IInterpreterPluginState, L>;
-//#endregion
-export { getIntlayer };
-//# sourceMappingURL=getIntlayer.d.ts.map
+import { t as getIntlayer } from "../index-BnEeKNKW.js";
+export { getIntlayer };

package/dist/types/interpreter/getNesting.d.ts

@@ -1,27 +1,2 @@
-import { ValidDotPathsFor } from "../transpiler/nesting/nesting.js";
-import { DeepTransformContent, IInterpreterPluginState, NodeProps } from "./getContent/plugins.js";
-import { GetSubPath } from "@intlayer/types/dictionary";
-import { DictionaryKeys, DictionaryRegistryContent } from "@intlayer/types/module_augmentation";
-
-//#region src/interpreter/getNesting.d.ts
-type GetNestingResult<K extends DictionaryKeys, P = undefined, S = IInterpreterPluginState> = GetSubPath<DeepTransformContent<DictionaryRegistryContent<K>, S>, P>;
-/**
- * Extracts content from another dictionary by its key and an optional path.
- *
- * This allows for reusing content across different dictionaries.
- *
- * @param dictionaryKey - The key of the dictionary to nest.
- * @param path - Optional dot-separated path to a specific field within the nested dictionary.
- * @param props - Optional properties like locale and plugins.
- * @returns The nested content.
- *
- * @example
- * ```ts
- * const content = getNesting("common", "buttons.save");
- * // 'Save'
- * ```
- */
-declare const getNesting: <K extends DictionaryKeys, P>(dictionaryKey: K, path?: P extends ValidDotPathsFor<K> ? P : never, props?: NodeProps) => GetNestingResult<K, P>;
-//#endregion
-export { GetNestingResult, getNesting };
-//# sourceMappingURL=getNesting.d.ts.map
+import { A as GetNestingResult, j as getNesting } from "../index-BnEeKNKW.js";
+export { GetNestingResult, getNesting };

package/dist/types/interpreter/getTranslation.d.ts

@@ -1,30 +1,2 @@
-import { LocalesValues, StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
-
-//#region src/interpreter/getTranslation.d.ts
-/**
- * Picks the appropriate content from a locale map based on the provided locale.
- *
- * It handles:
- * 1. Exact locale match (e.g., 'en-US').
- * 2. Generic locale fallback (e.g., 'en' if 'en-US' is not found).
- * 3. Explicit fallback locale.
- * 4. Deep merging of objects to ensure partial translations are complemented by fallbacks.
- *
- * @param languageContent - A map of locales to content.
- * @param locale - The target locale to retrieve.
- * @param fallback - Optional fallback locale if the target is not found.
- * @returns The translated content.
- *
- * @example
- * ```ts
- * const content = getTranslation({
- *   en: 'Hello',
- *   fr: 'Bonjour',
- * }, 'fr');
- * // 'Bonjour'
- * ```
- */
-declare const getTranslation: <Content = string>(languageContent: StrictModeLocaleMap<Content>, locale: LocalesValues, fallback?: LocalesValues) => Content;
-//#endregion
-export { getTranslation };
-//# sourceMappingURL=getTranslation.d.ts.map
+import { t as getTranslation } from "../getTranslation-BG2Wg-af.js";
+export { getTranslation };

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

@@ -1,12 +1,5 @@
-import { getCondition } from "./getCondition.js";
-import { GetNestingResult, getNesting } from "./getNesting.js";
-import { ConditionCond, DeepTransformContent, EnumerationCond, FileCond, GenderCond, IInterpreterPlugin, IInterpreterPluginState, InsertionCond, IsAny, NestedCond, NodeProps, Plugins, TranslationCond, UnionKeys, ValueAtKey, conditionPlugin, enumerationPlugin, filePlugin, genderPlugin, insertionPlugin, nestedPlugin, translationPlugin } from "./getContent/plugins.js";
-import { deepTransformNode } from "./getContent/deepTransform.js";
-import { getBasePlugins, getContent } from "./getContent/getContent.js";
-import { getDictionary } from "./getDictionary.js";
-import { findMatchingCondition, getEnumeration } from "./getEnumeration.js";
-import { getHTML } from "./getHTML.js";
-import { getIntlayer } from "./getIntlayer.js";
-import { getTranslation } from "./getTranslation.js";
-import { splitInsertionTemplate } from "./splitAndJoinInsertion.js";
+import { A as GetNestingResult, C as conditionPlugin, D as insertionPlugin, E as genderPlugin, M as getCondition, O as nestedPlugin, S as ValueAtKey, T as filePlugin, _ as NestedCond, a as getBasePlugins, b as TranslationCond, c as ConditionCond, d as FileCond, f as GenderCond, g as IsAny, h as InsertionCond, i as getDictionary, j as getNesting, k as translationPlugin, l as DeepTransformContent, m as IInterpreterPluginState, n as findMatchingCondition, o as getContent, p as IInterpreterPlugin, r as getEnumeration, s as deepTransformNode, t as getIntlayer, u as EnumerationCond, v as NodeProps, w as enumerationPlugin, x as UnionKeys, y as Plugins } from "../index-BnEeKNKW.js";
+import { t as getHTML } from "../getHTML-CP6OXtdo.js";
+import { t as getTranslation } from "../getTranslation-BG2Wg-af.js";
+import { t as splitInsertionTemplate } from "../splitAndJoinInsertion-bkuLa7o2.js";
 export { ConditionCond, DeepTransformContent, EnumerationCond, FileCond, GenderCond, GetNestingResult, IInterpreterPlugin, IInterpreterPluginState, InsertionCond, IsAny, NestedCond, NodeProps, Plugins, TranslationCond, UnionKeys, ValueAtKey, conditionPlugin, deepTransformNode, enumerationPlugin, filePlugin, findMatchingCondition, genderPlugin, getBasePlugins, getCondition, getContent, getDictionary, getEnumeration, getHTML, getIntlayer, getNesting, getTranslation, insertionPlugin, nestedPlugin, splitInsertionTemplate, translationPlugin };

package/dist/types/interpreter/splitAndJoinInsertion.d.ts

@@ -1,25 +1,2 @@
-//#region src/interpreter/splitAndJoinInsertion.d.ts
-/**
- * Core logic for splitting insertion strings and joining with values.
- * Returns an array of parts that can be wrapped by framework-specific Fragment implementations.
- *
- * @param template - The template string with {{ placeholder }} syntax
- * @param values - Map of placeholder names to their replacement values
- * @returns Object with `isSimple` flag and `parts` array
- *
- * @example
- * ```ts
- * const result = splitInsertionTemplate('Hello {{ name }}!', { name: 'World' });
- * // { isSimple: true, parts: 'Hello World!' }
- *
- * const result = splitInsertionTemplate('Hello {{ name }}!', { name: <Component /> });
- * // { isSimple: false, parts: ['Hello ', <Component />, '!'] }
- * ```
- */
-declare const splitInsertionTemplate: <T = any>(template: string, values?: Record<string, T>) => {
-  isSimple: boolean;
-  parts: string | T[];
-};
-//#endregion
-export { splitInsertionTemplate };
-//# sourceMappingURL=splitAndJoinInsertion.d.ts.map
+import { t as splitInsertionTemplate } from "../splitAndJoinInsertion-bkuLa7o2.js";
+export { splitInsertionTemplate };

package/dist/types/intl-B2Ap8I5x.d.ts

@@ -0,0 +1,33 @@
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+
+//#region src/utils/intl.d.ts
+type IntlConstructors = { [K in keyof typeof Intl as (typeof Intl)[K] extends (new (...args: any) => any) ? K : never]: (typeof Intl)[K] };
+type ReplaceLocaleWithLocalesValues<T> = T extends (new (locales: any, options?: infer Options) => infer Instance) ? {
+  new (locales?: LocalesValues, options?: Options): Instance;
+  new (options?: Options & {
+    locale?: LocalesValues;
+  }): Instance;
+} : T extends (new (locales: any) => infer Instance) ? {
+  new (locales?: LocalesValues): Instance;
+  new (options?: {
+    locale?: LocalesValues;
+  }): Instance;
+} : T;
+type WrappedIntl = { [K in keyof typeof Intl]: K extends keyof IntlConstructors ? ReplaceLocaleWithLocalesValues<(typeof Intl)[K]> : (typeof Intl)[K] };
+/**
+ * Factory that turns the global `Intl` into a cached clone.
+ */
+declare const createCachedIntl: () => WrappedIntl;
+declare const CachedIntl: WrappedIntl;
+/**
+ * Creates a proxied Intl object with a preset locale.
+ *
+ * @example
+ * const intl = bindIntl(Locales.FRENCH);
+ * new intl.NumberFormat(undefined, { style: 'currency', currency: 'EUR' }).format(10);
+ * // Uses 'fr' automatically
+ */
+declare const bindIntl: (locale: LocalesValues) => WrappedIntl;
+//#endregion
+export { createCachedIntl as i, WrappedIntl as n, bindIntl as r, CachedIntl as t };
+//# sourceMappingURL=intl-B2Ap8I5x.d.ts.map

package/dist/types/intl-B2Ap8I5x.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intl-B2Ap8I5x.d.ts","names":[],"sources":["../../src/utils/intl.ts"],"mappings":";;;KA8BK,gBAAA,wBACgB,IAAA,YAAgB,IAAA,EAAM,CAAA,mBACpC,IAAA,iBAED,CAAA,mBACgB,IAAA,EAAM,CAAA;AAAA,KAIvB,8BAAA,MAAoC,CAAA,eACvC,OAAA,OACA,OAAA;EAAA,KAGS,OAAA,GAAU,aAAA,EAAe,OAAA,GAAU,OAAA,GAAU,QAAA;EAAA,KAC7C,OAAA,GAAU,OAAA;IAAY,MAAA,GAAS,aAAA;EAAA,IAAkB,QAAA;AAAA,IAExD,CAAA,eACI,OAAA;EAAA,KAGK,OAAA,GAAU,aAAA,GAAgB,QAAA;EAAA,KAC1B,OAAA;IAAY,MAAA,GAAS,aAAA;EAAA,IAAkB,QAAA;AAAA,IAE9C,CAAA;AAAA,KAGM,WAAA,wBACS,IAAA,GAAO,CAAA,eAAgB,gBAAA,GACtC,8BAAA,SAAuC,IAAA,EAAM,CAAA,aACrC,IAAA,EAAM,CAAA;;;;cAuFP,gBAAA,QAAuB,WAAA;AAAA,cAiCvB,UAAA,EAAU,WAAA;;AAjJM;;;;;;;cA2JhB,QAAA,GAAY,MAAA,EAAQ,aAAA,KAAgB,WAAA"}

package/dist/types/isSameKeyPath-CkH8NdJh.d.ts

@@ -0,0 +1,7 @@
+import { KeyPath } from "@intlayer/types/keyPath";
+
+//#region src/utils/isSameKeyPath.d.ts
+declare const isSameKeyPath: (keyPath1: KeyPath[], keyPath2: KeyPath[]) => boolean;
+//#endregion
+export { isSameKeyPath as t };
+//# sourceMappingURL=isSameKeyPath-CkH8NdJh.d.ts.map

package/dist/types/isSameKeyPath-CkH8NdJh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isSameKeyPath-CkH8NdJh.d.ts","names":[],"sources":["../../src/utils/isSameKeyPath.ts"],"mappings":";;;cAIa,aAAA,GAAiB,QAAA,EAAU,OAAA,IAAW,QAAA,EAAU,OAAA"}

package/dist/types/isValidReactElement-BsoJ01oP.d.ts

@@ -0,0 +1,12 @@
+//#region src/utils/isValidReactElement.d.ts
+/**
+ * Verifies the object is a ReactElement.
+ * See https://reactjs.org/docs/react-api.html#isvalidelement
+ * @param object
+ * @return True if `object` is a ReactElement.
+ * @final
+ */
+declare const isValidElement: (object: any) => boolean;
+//#endregion
+export { isValidElement as t };
+//# sourceMappingURL=isValidReactElement-BsoJ01oP.d.ts.map

package/dist/types/isValidReactElement-BsoJ01oP.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isValidReactElement-BsoJ01oP.d.ts","names":[],"sources":["../../src/utils/isValidReactElement.ts"],"mappings":";;AAQA;;;;;;cAAa,cAAA,GAAkB,MAAA"}

package/dist/types/list-BdjJM2Gx.d.ts

@@ -0,0 +1,30 @@
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+
+//#region src/formatters/list.d.ts
+/** Locally defined subset of Intl.ListFormatOptions so consumers don't need ES2021.Intl in their lib. */
+type ListFormatOptions = {
+  localeMatcher?: 'lookup' | 'best fit';
+  type?: 'conjunction' | 'disjunction' | 'unit';
+  style?: 'long' | 'short' | 'narrow';
+};
+/**
+ * Formats an array of values into a localized list string using the Intl API.
+ *
+ * @example
+ * list(['apple', 'banana', 'orange']);
+ * // "apple, banana, and orange"
+ *
+ * @example
+ * list(['red', 'green', 'blue'], { locale: Locales.FRENCH, type: 'disjunction' });
+ * // "rouge, vert ou bleu"
+ *
+ * @example
+ * list([1, 2, 3], { type: 'unit' });
+ * // "1, 2, 3"
+ */
+declare const list: (values: (string | number)[], options?: ListFormatOptions & {
+  locale?: LocalesValues;
+}) => string;
+//#endregion
+export { list as t };
+//# sourceMappingURL=list-BdjJM2Gx.d.ts.map

package/dist/types/list-BdjJM2Gx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-BdjJM2Gx.d.ts","names":[],"sources":["../../src/formatters/list.ts"],"mappings":";;;;KAKK,iBAAA;EACH,aAAA;EACA,IAAA;EACA,KAAA;AAAA;;;;;;AAkBF;;;;;;;;;;cAAa,IAAA,GACX,MAAA,uBACA,OAAA,GAAU,iBAAA;EAAsB,MAAA,GAAS,aAAA;AAAA"}

package/dist/types/localeDetector-BWNCQRiZ.d.ts

@@ -0,0 +1,18 @@
+import { Locale } from "@intlayer/types/allLocales";
+
+//#region src/localization/localeDetector.d.ts
+/**
+ * Derives the list of preferred languages based on the Accept-Language header
+ * and an optional list of available languages.
+ */
+declare const getPreferredLanguages: (acceptHeader: string | undefined, availableLanguages?: string[]) => string[];
+/**
+ * Detects the locale from the request headers.
+ *
+ * Headers are provided by the browser/client and can be used to determine the user's preferred language.
+ * This function intersects the user's `Accept-Language` header with the application's available locales.
+ */
+declare const localeDetector: (headers: Record<string, string | undefined>, availableLocales?: Locale[], defaultLocale?: Locale) => Locale;
+//#endregion
+export { localeDetector as n, getPreferredLanguages as t };
+//# sourceMappingURL=localeDetector-BWNCQRiZ.d.ts.map

package/dist/types/localeDetector-BWNCQRiZ.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"localeDetector-BWNCQRiZ.d.ts","names":[],"sources":["../../src/localization/localeDetector.ts"],"mappings":";;;;;AA+MA;;cAAa,qBAAA,GACX,YAAA,sBACA,kBAAA;;;AA+BF;;;;cAAa,cAAA,GACX,OAAA,EAAS,MAAA,8BACT,gBAAA,GAAmB,MAAA,IACnB,aAAA,GAAgB,MAAA,KACf,MAAA"}

package/dist/types/localeMapper-DoAnasqf.d.ts

@@ -0,0 +1,92 @@
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+import { Locale } from "@intlayer/types/allLocales";
+
+//#region src/localization/localeMapper.d.ts
+type LocaleData = {
+  locale: Locale;
+  defaultLocale: Locale;
+  isDefault: boolean;
+  locales: Locale[];
+  urlPrefix: string;
+};
+/**
+ * Map the locale data to an array of objects
+ *
+ * @example
+ * ```ts
+ * const routes = localeMap((localizedData) =>
+ * ({
+ *    path: localizedData.urlPrefix,
+ *    name: localizedData.locale,
+ *    isDefault: localizedData.isDefault,
+ *    locales: localizedData.locales,
+ *    defaultLocale: localizedData.defaultLocale,
+ *  }),
+ * );
+ *
+ * // Result
+ * [
+ *   { path: '/', name: 'en', isDefault: true, locales: ['en'], defaultLocale: 'en', urlPrefix: '' },
+ *   { path: '/fr', name: 'fr', isDefault: false, locales: ['fr'], defaultLocale: 'en', urlPrefix: '/fr' },
+ *   { path: '/es', name: 'es', isDefault: false, locales: ['es'], defaultLocale: 'en', urlPrefix: '/es' },
+ * ]
+ * ```
+ *
+ * @param mapper - The mapper function that returns an object
+ * @returns An array of objects
+ */
+declare const localeMap: <T>(mapper: (locale: LocaleData) => T, locales?: LocalesValues[], defaultLocale?: LocalesValues, mode?: "prefix-no-default" | "prefix-all" | "no-prefix" | "search-params") => T[];
+/**
+ * Flatten the locale map into a single array of objects
+ *
+ * @example
+ * ```ts
+ * const routes = localeMap((localizedData) =>
+ * [{
+ *    path: localizedData.urlPrefix,
+ *    name: localizedData.locale,
+ *    isDefault: localizedData.isDefault,
+ *    locales: localizedData.locales,
+ *    defaultLocale: localizedData.defaultLocale,
+ *  }],
+ * );
+ *
+ * // Result
+ * [
+ *   path: '/', name: 'en', isDefault: true, locales: ['en'], defaultLocale: 'en', urlPrefix: '' ,
+ *   path: '/fr', name: 'fr', isDefault: false, locales: ['fr'], defaultLocale: 'en', urlPrefix: '/fr' ,
+ *   path: '/es', name: 'es', isDefault: false, locales: ['es'], defaultLocale: 'en', urlPrefix: '/es' ,
+ * ]
+ * ```
+ *
+ * @param mapper - The mapper function that returns an array of objects
+ * @returns An array of objects
+ */
+declare const localeFlatMap: <T>(mapper: (locale: LocaleData) => T[], locales?: LocalesValues[], defaultLocale?: LocalesValues, mode?: "prefix-no-default" | "prefix-all" | "no-prefix" | "search-params") => T[];
+/**
+ * Creates a record object mapping locales to values transformed by the mapper function
+ *
+ * @example
+ * ```ts
+ * const translations = localeRecord(({ locale }) =>
+ *   require(`./translations/${locale}.json`)
+ * );
+ *
+ * // Result
+ *
+ *   en: ... , // Content of translations/en.json
+ *   fr: ... , // Content of translations/fr.json
+ *   es: ...
+ *
+ * ```
+ *
+ * @param mapper - Function that takes locale data and returns a value for that locale
+ * @param locales - Array of locale codes to map over (defaults to configured locales)
+ * @param defaultLocale - The default locale (defaults to configured default)
+ * @param mode - URL routing mode for locale handling (defaults to configured value)
+ * @returns Record mapping locale codes to mapped values
+ */
+declare const localeRecord: <T>(mapper: (locale: LocaleData) => T, locales?: LocalesValues[], defaultLocale?: LocalesValues, mode?: "prefix-no-default" | "prefix-all" | "no-prefix" | "search-params") => Record<LocalesValues, T>;
+//#endregion
+export { localeRecord as i, localeFlatMap as n, localeMap as r, LocaleData as t };
+//# sourceMappingURL=localeMapper-DoAnasqf.d.ts.map

package/dist/types/localeMapper-DoAnasqf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"localeMapper-DoAnasqf.d.ts","names":[],"sources":["../../src/localization/localeMapper.ts"],"mappings":";;;;KAKY,UAAA;EACV,MAAA,EAAQ,MAAA;EACR,aAAA,EAAe,MAAA;EACf,SAAA;EACA,OAAA,EAAS,MAAA;EACT,SAAA;AAAA;;;;;;;;;;;;;;AA+CF;;;;;;;;;;;;;cAAa,SAAA,MACX,MAAA,GAAS,MAAA,EAAQ,UAAA,KAAe,CAAA,EAChC,OAAA,GAAS,aAAA,IACT,aAAA,GAAe,aAAA,EAEf,IAAA,0EAKC,CAAA;;;;;;;;;;AAuCH;;;;;;;;;;;;;;;;;cAAa,aAAA,MACX,MAAA,GAAS,MAAA,EAAQ,UAAA,KAAe,CAAA,IAChC,OAAA,GAAS,aAAA,IACT,aAAA,GAAe,aAAA,EAEf,IAAA,0EAKC,CAAA;;;;;;AAoCH;;;;;;;;;;;;;;;;;;cAAa,YAAA,MACX,MAAA,GAAS,MAAA,EAAQ,UAAA,KAAe,CAAA,EAChC,OAAA,GAAS,aAAA,IACT,aAAA,GAAe,aAAA,EAEf,IAAA,0EAKC,MAAA,CAAO,aAAA,EAAe,CAAA"}

package/dist/types/localeResolver-bb7AWQNX.d.ts

@@ -0,0 +1,12 @@
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+import { Locale } from "@intlayer/types/allLocales";
+
+//#region src/localization/localeResolver.d.ts
+/**
+ * Resolves the most specific locale from a user-provided list,
+ * or falls back to the default locale if no match is found.
+ */
+declare const localeResolver: (selectedLocale: LocalesValues | LocalesValues[], locales?: LocalesValues[], defaultLocale?: LocalesValues) => Locale;
+//#endregion
+export { localeResolver as t };
+//# sourceMappingURL=localeResolver-bb7AWQNX.d.ts.map

package/dist/types/localeResolver-bb7AWQNX.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"localeResolver-bb7AWQNX.d.ts","names":[],"sources":["../../src/localization/localeResolver.ts"],"mappings":";;;;;;AAQA;;cAAa,cAAA,GACX,cAAA,EAAgB,aAAA,GAAgB,aAAA,IAChC,OAAA,GAAS,aAAA,IACT,aAAA,GAAe,aAAA,KAEd,MAAA"}

package/dist/types/localeStorage-CZHwY0u3.d.ts

@@ -0,0 +1,108 @@
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+import { Locale } from "@intlayer/types/allLocales";
+
+//#region src/utils/localeStorage.d.ts
+type CookieBuildAttributes = {
+  /**
+   * Cookie domain to store the locale information
+   *
+   * Default: undefined
+   *
+   * Define the domain where the cookie is available. Defaults to
+   * the domain of the page where the cookie was created.
+   */
+  domain?: string;
+  /**
+   * Cookie path to store the locale information
+   *
+   * Default: undefined
+   *
+   * Define the path where the cookie is available. Defaults to '/'
+   */
+  path?: string;
+  /**
+   * Cookie secure to store the locale information
+   *
+   * Default: undefined
+   *
+   * A Boolean indicating if the cookie transmission requires a
+   * secure protocol (https). Defaults to false.
+   */
+  secure?: boolean;
+  /**
+   * Cookie httpOnly to store the locale information
+   *
+   * Default: undefined
+   *
+   * The cookie httpOnly where the locale information is stored.
+   */
+  httpOnly?: boolean;
+  /**
+   * Cookie sameSite to store the locale information
+   *
+   * Default: undefined
+   *
+   * Asserts that a cookie must not be sent with cross-origin requests,
+   * providing some protection against cross-site request forgery
+   * attacks (CSRF)
+   */
+  sameSite?: 'strict' | 'lax' | 'none';
+  /**
+   * Cookie expires to store the locale information
+   *
+   * Default: undefined
+   *
+   * Define when the cookie will be removed. Value can be a Number
+   * which will be interpreted as days from time of creation or a
+   * Date instance. If omitted, the cookie becomes a session cookie.
+   */
+  expires?: number | undefined;
+};
+type LocaleStorageOptions = {
+  overwrite?: boolean;
+  isCookieEnabled?: boolean;
+  setCookieStore?: (name: string, value: string, cookie: CookieBuildAttributes) => void;
+  setCookieString?: (name: string, cookie: string) => void;
+  getCookie?: (name: string) => string | undefined | null;
+  setSessionStorage?: (name: string, value: string) => void;
+  getSessionStorage?: (name: string) => string | undefined | null;
+  setLocaleStorage?: (name: string, value: string) => void;
+  getLocaleStorage?: (name: string) => string | undefined | null;
+  getHeader?: (name: string) => string | undefined | null;
+  setHeader?: (name: string, value: string) => void;
+};
+/**
+ * Retrieves the locale from various storage mechanisms (cookies, localStorage, sessionStorage, headers).
+ * The function checks storage locations in order of priority as defined in the configuration.
+ *
+ * @returns The locale if found in any storage, or undefined if not found
+ */
+declare const getLocaleFromStorage: (options: Pick<LocaleStorageOptions, "getCookie" | "getSessionStorage" | "getLocaleStorage" | "getHeader" | "isCookieEnabled">) => Locale | undefined;
+/**
+ * Stores the locale in various storage mechanisms (cookies, localStorage, sessionStorage, headers).
+ * The function writes to all configured storage locations according to their attributes.
+ * Respects overwrite flags for localStorage and sessionStorage.
+ *
+ * @param locale - The locale to store
+ */
+declare const setLocaleInStorage: (locale: LocalesValues, options?: LocaleStorageOptions) => void;
+/**
+ * Utility object to get and set the locale in the storage by considering the configuration
+ *
+ * @property getLocale - Retrieves the locale from various storage mechanisms (cookies, localStorage, sessionStorage, headers).
+ * Retrieves the locale from various storage mechanisms (cookies, localStorage, sessionStorage, headers).
+ * The function checks storage locations in order of priority as defined in the configuration.
+ *
+ * @property setLocale - Stores the locale in various storage mechanisms (cookies, localStorage, sessionStorage, headers).
+ * The function writes to all configured storage locations according to their attributes.
+ * Respects overwrite flags for localStorage and sessionStorage.
+ *
+ * @returns The locale if found in any storage, or undefined if not found
+ */
+declare const LocaleStorage: (options: LocaleStorageOptions) => {
+  getLocale: () => Locale;
+  setLocale: (locale: LocalesValues) => void;
+};
+//#endregion
+export { setLocaleInStorage as i, LocaleStorageOptions as n, getLocaleFromStorage as r, LocaleStorage as t };
+//# sourceMappingURL=localeStorage-CZHwY0u3.d.ts.map

package/dist/types/localeStorage-CZHwY0u3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"localeStorage-CZHwY0u3.d.ts","names":[],"sources":["../../src/utils/localeStorage.ts"],"mappings":";;;;KAOK,qBAAA;;AAJoE;;;;;;;EAavE,MAAA;EAmCA;;;;AAgCF;;;EA3DE,IAAA;EA4DA;;;;;;;;EAnDA,MAAA;EA0DiC;;;;;;;EAlDjC,QAAA;EAsDA;;;;;;;;;EA5CA,QAAA;EA+CwC;;AAS1C;;;;;;;EA7CE,OAAA;AAAA;AAAA,KAqBU,oBAAA;EACV,SAAA;EACA,eAAA;EACA,cAAA,IACE,IAAA,UACA,KAAA,UACA,MAAA,EAAQ,qBAAA;EAEV,eAAA,IAAmB,IAAA,UAAc,MAAA;EACjC,SAAA,IAAa,IAAA;EACb,iBAAA,IAAqB,IAAA,UAAc,KAAA;EACnC,iBAAA,IAAqB,IAAA;EACrB,gBAAA,IAAoB,IAAA,UAAc,KAAA;EAClC,gBAAA,IAAoB,IAAA;EACpB,SAAA,IAAa,IAAA;EACb,SAAA,IAAa,IAAA,UAAc,KAAA;AAAA;;;AAmM7B;;;;cA1La,oBAAA,GACX,OAAA,EAAS,IAAA,CACP,oBAAA,gGAOD,MAAA;;;;;;;;cA8EU,kBAAA,GACX,MAAA,EAAQ,aAAA,EACR,OAAA,GAAU,oBAAA;;;;;;;;;;;;;;cAiGC,aAAA,GAAiB,OAAA,EAAS,oBAAA;;sBAEjB,aAAA;AAAA"}

package/dist/types/localization/getBrowserLocale.d.ts

@@ -1,35 +1,2 @@
-import { LocaleStorageOptions } from "../utils/localeStorage.js";
-import { Locale } from "@intlayer/types/allLocales";
-
-//#region src/localization/getBrowserLocale.d.ts
-declare enum LanguageDetector {
-  Querystring = "querystring",
-  Storage = "storage",
-  Navigator = "navigator",
-  HtmlTag = "htmlTag"
-}
-declare const localeStorageOptions: LocaleStorageOptions;
-type LanguageDetectorOptions = {
-  order?: LanguageDetector[];
-  lookupQuerystring?: string;
-  htmlTag?: HTMLElement | null;
-};
-/**
- * Core language detector function for browser environments.
- *
- * Detects the user's preferred locale by checking multiple sources in order:
- * 1. Query string parameter
- * 2. Storage (cookies, localStorage, sessionStorage) - uses getLocaleFromStorage
- * 3. Navigator languages - uses localeDetector
- * 4. HTML lang attribute - uses localeDetector
- *
- * @param userOptions - Optional configuration for detection order and lookup keys
- * @returns The detected locale or the default locale
- *
- * @example
- * const locale = getBrowserLocale({ order: [LanguageDetector.Storage, LanguageDetector.Navigator] });
- */
-declare const getBrowserLocale: (userOptions?: LanguageDetectorOptions | undefined) => Locale;
-//#endregion
-export { LanguageDetector, getBrowserLocale, localeStorageOptions };
-//# sourceMappingURL=getBrowserLocale.d.ts.map
+import { n as getBrowserLocale, r as localeStorageOptions, t as LanguageDetector } from "../getBrowserLocale-RD_Mwv1t.js";
+export { LanguageDetector, getBrowserLocale, localeStorageOptions };

package/dist/types/localization/getHTMLTextDir.d.ts

@@ -1,21 +1,2 @@
-import { LocalesValues } from "@intlayer/types/module_augmentation";
-
-//#region src/localization/getHTMLTextDir.d.ts
-type Dir = 'ltr' | 'rtl' | 'auto';
-/**
- * Returns the text direction of the given locale.
- *
- * Example:
- *
- * getHTMLTextDir('en-US') // 'ltr'
- * getHTMLTextDir('en') // 'ltr'
- * getHTMLTextDir('fr-CA') // 'ltr'
- * getHTMLTextDir('fr') // 'ltr'
- *
- * @param locale The locale to get the text direction for.
- * @returns The text direction of the given locale.
- */
-declare const getHTMLTextDir: (locale?: LocalesValues) => Dir;
-//#endregion
-export { getHTMLTextDir };
-//# sourceMappingURL=getHTMLTextDir.d.ts.map
+import { t as getHTMLTextDir } from "../getHTMLTextDir-4Zh8J3x7.js";
+export { getHTMLTextDir };

package/dist/types/localization/getLocale.d.ts

@@ -1,11 +1,2 @@
-import { Locale } from "@intlayer/types/allLocales";
-
-//#region src/localization/getLocale.d.ts
-type RequestContext = {
-  getHeader?: (name: string) => string | null | undefined;
-  getCookie?: (name: string) => string | null | undefined;
-};
-declare const getLocale: (ctx?: RequestContext) => Promise<Locale>;
-//#endregion
-export { RequestContext, getLocale };
-//# sourceMappingURL=getLocale.d.ts.map
+import { n as getLocale, t as RequestContext } from "../getLocale-B9dECUM_.js";
+export { RequestContext, getLocale };

package/dist/types/localization/getLocaleFromPath.d.ts

@@ -1,26 +1,2 @@
-import { LocalesValues } from "@intlayer/types/module_augmentation";
-import { Locale } from "@intlayer/types/allLocales";
-import { RoutingConfig } from "@intlayer/types/config";
-
-//#region src/localization/getLocaleFromPath.d.ts
-type GetLocaleFromPathOptions = {
-  defaultLocale?: LocalesValues;
-  locales?: LocalesValues[];
-  mode?: RoutingConfig['mode'];
-};
-/**
- * Extracts the locale segment from the given URL or pathname based on the routing mode.
- *
- * Mode Behaviors:
- * - 'prefix-no-default': Checks path prefiIf no prefix found, assumes default locale.
- * - 'prefix-all': Checks path prefix.
- * - 'search-params': Checks for 'locale' query parameter.
- * - 'no-prefix': Returns undefined (or default if fallback is true).
- *
- * @param inputUrl - The complete URL string or pathname to process.
- * @returns The detected locale, default locale (if fallback/implicit), or undefined.
- */
-declare const getLocaleFromPath: (inputUrl?: string, options?: GetLocaleFromPathOptions) => Locale | undefined;
-//#endregion
-export { getLocaleFromPath };
-//# sourceMappingURL=getLocaleFromPath.d.ts.map
+import { t as getLocaleFromPath } from "../getLocaleFromPath-621W32QA.js";
+export { getLocaleFromPath };