@i18n-micro/solid 1.2.16 → 2.0.1

package/dist/index.d.ts

@@ -1,107 +1,109 @@
 import { Accessor } from 'solid-js';
-import { BaseI18n } from '@i18n-micro/core';
 import { CleanTranslation } from '@i18n-micro/types';
 import { Component } from 'solid-js';
 import { Context } from 'solid-js';
 import { defaultPlural } from '@i18n-micro/core';
 import { FormatService } from '@i18n-micro/core';
 import { Getter } from '@i18n-micro/types';
+import { I18n } from '@i18n-micro/runtime';
+import { I18nOptions } from '@i18n-micro/runtime';
 import { interpolate } from '@i18n-micro/core';
 import { JSX } from 'solid-js';
 import { Locale } from '@i18n-micro/types';
 import { LocaleCode } from '@i18n-micro/types';
-import { Location as Location_2 } from '@solidjs/router';
 import { ModuleOptions } from '@i18n-micro/types';
 import { Params } from '@i18n-micro/types';
 import { ParentComponent } from 'solid-js';
 import { PluralFunc } from '@i18n-micro/types';
+import { ResolveTextOptions } from '@i18n-micro/core';
 import { TranslationKey } from '@i18n-micro/types';
 import { Translations } from '@i18n-micro/types';
-import { TranslationStorage } from '@i18n-micro/core';
-import { useNavigate } from '@solidjs/router';
 
 export { CleanTranslation }
 
-export declare function createI18n(options: SolidI18nOptions): SolidI18n;
-
-/**
- * Factory for Solid Router adapter
- * Implements routing utilities for Solid Router
- * Uses @solidjs/router APIs for navigation and path resolution
- *
- * **IMPORTANT**: This function must be called inside a SolidJS component or reactive context
- * (e.g., inside a component function, not at module level). This is required because
- * `createSignal` and `createEffect` need to be within a reactive owner context.
- *
- * @example
- * ```tsx
- * const RouterRoot: Component = () => {
- *   const navigate = useNavigate()
- *   const location = useLocation()
- *   const routingStrategy = createSolidRouterAdapter(
- *     locales,
- *     defaultLocale,
- *     navigate,
- *     location,
- *   )
- *   // ...
- * }
- * ```
- *
- * @param locales - Array of locale configurations
- * @param defaultLocale - Default locale code
- * @param navigate - Navigation function from @solidjs/router's useNavigate hook
- * @param location - Location object from @solidjs/router's useLocation hook
- * @returns I18nRoutingStrategy with reactive pathname accessor
- */
-export declare function createSolidRouterAdapter(locales: Locale[], defaultLocale: string, navigate: NavigateFunction, location: Location_2): I18nRoutingStrategy & {
-    getCurrentPathAccessor: Accessor<string>;
+declare function createApi(context: I18nContextValue, options?: UseI18nOptions): {
+    instance: SolidI18n;
+    locale: Accessor<string>;
+    getLocales: () => Locale[];
+    defaultLocale: () => string;
+    getLocaleName: () => string | null;
+    localeRoute: (to: RouteTarget, code?: string) => RouteTarget;
+    localePath: (to: RouteTarget, locale?: string) => string;
+    switchLocale: (newLocale: string) => void;
+    t: (key: TranslationKey, params?: Params, defaultValue?: string | null, routeContext?: unknown) => CleanTranslation;
+    ts: (key: TranslationKey, params?: Params, defaultValue?: string, routeContext?: unknown) => string;
+    tc: (key: TranslationKey, count: number | Params, defaultValue?: string) => string;
+    tn: {
+        (value: number, options?: Intl.NumberFormatOptions): string;
+        (value: number, key: string, overrides?: Intl.NumberFormatOptions): string;
+        (value: number, key: string, locale: string, overrides?: Intl.NumberFormatOptions): string;
+    };
+    td: {
+        (value: Date | number | string, options?: Intl.DateTimeFormatOptions): string;
+        (value: Date | number | string, key: string, overrides?: Intl.DateTimeFormatOptions): string;
+        (value: Date | number | string, key: string, locale: string, overrides?: Intl.DateTimeFormatOptions): string;
+    };
+    tdr: (value: Date | number | string, options?: Intl.RelativeTimeFormatOptions) => string;
+    has: (key: TranslationKey, routeContext?: unknown) => boolean;
+    setRoute: (routeName: string) => void;
+    getRoute: () => string;
+    getLocale: () => string;
+    addTranslations: (locale: string, translations: Translations, merge?: boolean) => void;
+    addRouteTranslations: (locale: string, routeName: string, translations: Translations, merge?: boolean) => void;
+    resolveTranslations: (routeContext?: unknown) => Translations;
+    setTranslation: (key: TranslationKey, value: unknown) => void;
+    clearCache: () => void;
 };
 
+export declare function createI18n(options: SolidI18nOptions): SolidI18n;
+
 export { defaultPlural }
 
 export { FormatService }
 
 export { Getter }
 
-export declare const I18nContext: Context<SolidI18n | undefined>;
+export declare const I18nContext: Context<I18nContextValue | undefined>;
 
-export declare const I18nDefaultLocaleContext: Context<string | undefined>;
+/** Everything a provider hands down: getters over its props, so they stay reactive. */
+export declare interface I18nContextValue {
+    readonly i18n: SolidI18n;
+    readonly locales: Locale[] | undefined;
+    readonly defaultLocale: string | undefined;
+    readonly router: I18nRoutingStrategy | undefined;
+    /** The `useI18n()` object: one per provider, signals do the rest. */
+    api?: UseI18nReturn;
+}
 
 export declare const I18nGroup: Component<I18nGroupProps>;
 
-declare interface I18nGroupProps extends JSX.HTMLAttributes<HTMLDivElement> {
+export declare interface I18nGroupProps extends Omit<JSX.HTMLAttributes<HTMLDivElement>, 'children'> {
     prefix: string;
     groupClass?: string;
+    children?: JSX.Element | ((props: {
+        prefix: string;
+        t: (key: string, params?: Record<string, string | number | boolean>) => string;
+    }) => JSX.Element);
 }
 
 export declare const I18nLink: Component<I18nLinkProps>;
 
-declare interface I18nLinkProps extends JSX.AnchorHTMLAttributes<HTMLAnchorElement> {
-    to: string | {
-        path?: string;
-    };
-    localeRoute?: (to: string | {
-        path?: string;
-    }, locale?: string) => string | {
-        path?: string;
-    };
+export declare interface I18nLinkProps extends JSX.AnchorHTMLAttributes<HTMLAnchorElement> {
+    to: RouteTarget;
+    localeRoute?: (to: RouteTarget, locale?: string) => RouteTarget;
     activeStyle?: JSX.CSSProperties;
 }
 
-export declare const I18nLocalesContext: Context<Locale[] | undefined>;
-
 export declare const I18nProvider: ParentComponent<I18nProviderProps>;
 
 export declare interface I18nProviderProps {
-    i18n: SolidI18n;
+    /** Without it, the outer provider's instance. */
+    i18n?: SolidI18n;
     locales?: Locale[];
     defaultLocale?: string;
     routingStrategy?: I18nRoutingStrategy;
 }
 
-export declare const I18nRouterContext: Context<I18nRoutingStrategy | undefined>;
-
 /**
  * Routing strategy interface for i18n
  * Implement this interface to integrate with any router library
@@ -109,32 +111,17 @@ export declare const I18nRouterContext: Context<I18nRoutingStrategy | undefined>
  */
 export declare interface I18nRoutingStrategy {
     /**
-     * Returns current path (without locale prefix if needed, or full path)
-     * Used for determining active classes in links
-     * Note: For SolidJS, this should return the current value synchronously.
-     * For reactive updates, use `getCurrentPathAccessor` instead.
+     * Returns the current path with its query and hash, so a locale switch keeps them. Links compare
+     * it by page. Read a signal or a reactive location here and links and the switcher follow it.
      */
     getCurrentPath: () => string;
-    /**
-     * (SolidJS-specific, highly recommended) Returns reactive accessor for current path
-     * This is REQUIRED for proper reactivity in SolidJS components.
-     * Without this, active link states and path-dependent UI won't update reactively.
-     *
-     * @example
-     * ```tsx
-     * const pathnameAccessor = router.getCurrentPathAccessor?.()
-     * // Use inside createMemo for reactivity:
-     * const currentPath = createMemo(() => pathnameAccessor?.() ?? router.getCurrentPath())
-     * ```
-     */
-    getCurrentPathAccessor?: () => Accessor<string>;
     /**
      * Component to use for rendering links (e.g., RouterLink)
      */
     linkComponent?: string | Component<{
         href: string;
         children?: JSX.Element;
-        style?: JSX.CSSProperties;
+        style?: JSX.CSSProperties | string;
         class?: string;
         [key: string]: unknown;
     }>;
@@ -153,11 +140,7 @@ export declare interface I18nRoutingStrategy {
     /**
      * Generate path for specific locale
      */
-    resolvePath?: (to: string | {
-        path?: string;
-    }, locale: string) => string | {
-        path?: string;
-    };
+    resolvePath?: (to: RouteTarget, locale: string) => RouteTarget;
     /**
      * (Optional) Get current route object for SEO/Meta tags
      */
@@ -169,16 +152,12 @@ export declare interface I18nRoutingStrategy {
 
 export declare const I18nSwitcher: Component<I18nSwitcherProps>;
 
-declare interface I18nSwitcherProps extends JSX.HTMLAttributes<HTMLDivElement> {
+export declare interface I18nSwitcherProps extends JSX.HTMLAttributes<HTMLDivElement> {
     locales?: Locale[];
     currentLocale?: string | (() => string);
     getLocaleName?: () => string | null;
     switchLocale?: (locale: string) => void;
-    localeRoute?: (to: string | {
-        path?: string;
-    }, locale?: string) => string | {
-        path?: string;
-    };
+    localeRoute?: (to: RouteTarget, locale?: string) => RouteTarget;
     customLabels?: Record<string, string>;
     customWrapperStyle?: JSX.CSSProperties;
     customButtonStyle?: JSX.CSSProperties;
@@ -198,18 +177,17 @@ declare interface I18nSwitcherProps extends JSX.HTMLAttributes<HTMLDivElement> {
 
 export declare const I18nT: Component<I18nTProps>;
 
-declare interface I18nTProps extends JSX.HTMLAttributes<HTMLElement> {
-    keypath: TranslationKey;
-    params?: Record<string, string | number | boolean>;
+/** What fills a `{name}` placeholder. A function may run per occurrence; one node can only stand in one place. */
+export declare type I18nTComponent = JSX.Element | (() => JSX.Element);
+
+export declare interface I18nTProps extends Omit<JSX.HTMLAttributes<HTMLElement>, 'children'>, ResolveTextOptions {
     tag?: string;
-    plural?: number | string;
-    defaultValue?: string;
-    html?: boolean;
-    hideIfEmpty?: boolean;
-    customPluralRule?: PluralFunc;
-    number?: number | string;
-    date?: Date | string | number;
-    relativeDate?: Date | string | number;
+    /** Elements for `{name}` placeholders. Beats a param of the same name. */
+    components?: Record<string, I18nTComponent>;
+    /** Replaces the text. As a function it gets the translation, like Vue's default slot. */
+    children?: JSX.Element | ((props: {
+        translation: string;
+    }) => JSX.Element);
 }
 
 export { interpolate }
@@ -220,105 +198,59 @@ export { LocaleCode }
 
 export { ModuleOptions }
 
-declare type NavigateFunction = ReturnType<typeof useNavigate>;
-
 export { Params }
 
 export { PluralFunc }
 
-export declare class SolidI18n extends BaseI18n {
-    private readonly store;
-    private readonly _localeSignal;
-    private readonly _setLocaleSignal;
-    private readonly _routeSignal;
-    private readonly _setRouteSignal;
-    private readonly _fallbackSignal;
-    readonly storage: TranslationStorage;
+/** Where a link or a switch goes. */
+export declare type RouteTarget = string | {
+    path?: string;
+};
+
+/**
+ * The runtime instance with signals over its store. A translation read tracks the revision, which
+ * every change bumps. Reading the locale tracks the locale alone, so `createEffect(() => load(locale()))`
+ * does not wake itself. `getLocale()` and `getRoute()` stay plain, as a write reads them too: track
+ * with `locale` and `currentRoute`.
+ */
+export declare class SolidI18n extends I18n {
+    private readonly revision;
+    private readonly localeSignal;
+    private readonly fallbackSignal;
+    private readonly routeSignal;
+    readonly localeAccessor: Accessor<string>;
+    readonly routeAccessor: Accessor<string>;
     constructor(options: SolidI18nOptions);
-    getLocale(): string;
-    getFallbackLocale(): string;
-    getRoute(): string;
-    set locale(val: string);
+    protected touch(): void;
     get locale(): string;
-    get localeAccessor(): Accessor<string>;
+    set locale(value: string);
     get fallbackLocale(): string;
+    set fallbackLocale(value: string);
     get currentRoute(): string;
-    get routeAccessor(): Accessor<string>;
-    setRoute(val: string): void;
-    addTranslations(locale: string, translations: Translations, merge?: boolean): void;
-    addRouteTranslations(locale: string, routeName: string, translations: Translations, merge?: boolean): void;
-    clearCache(): void;
-    protected onTranslationsChanged(): void;
-    private listeners;
-    subscribe(cb: () => void): () => void;
-    getSnapshot(): string;
-    private notifyListeners;
 }
 
-export declare interface SolidI18nOptions {
-    locale: string;
-    fallbackLocale?: string;
-    messages?: Record<string, Translations>;
-    plural?: PluralFunc;
-    missingWarn?: boolean;
-    missingHandler?: (locale: string, key: string, routeName: string) => void;
-}
+export declare type SolidI18nOptions = I18nOptions;
 
 export { TranslationKey }
 
 export { Translations }
 
-export declare function useI18n(options?: UseI18nOptions): {
-    instance: SolidI18n;
-    locale: Accessor<string>;
-    getLocales: () => Locale[];
-    defaultLocale: () => string;
-    getLocaleName: () => string | null;
-    localeRoute: (to: string | {
-        path?: string;
-    }, localeCode?: string) => string | {
-        path?: string;
-    };
-    localePath: (to: string | {
-        path?: string;
-    }, locale?: string) => string;
-    switchLocale: (newLocale: string) => void;
-    t: (key: TranslationKey, params?: Params, defaultValue?: string | null, routeContext?: unknown) => CleanTranslation;
-    ts: (key: TranslationKey, params?: Params, defaultValue?: string, routeContext?: unknown) => string;
-    tc: (key: TranslationKey, count: number | Params, defaultValue?: string) => string;
-    tn: {
-        (value: number, options?: Intl.NumberFormatOptions): string;
-        (value: number, key: string, overrides?: Intl.NumberFormatOptions): string;
-        (value: number, key: string, locale: string, overrides?: Intl.NumberFormatOptions): string;
-    };
-    td: {
-        (value: Date | number | string, options?: Intl.DateTimeFormatOptions): string;
-        (value: Date | number | string, key: string, overrides?: Intl.DateTimeFormatOptions): string;
-        (value: Date | number | string, key: string, locale: string, overrides?: Intl.DateTimeFormatOptions): string;
-    };
-    tdr: (value: Date | number | string, options?: Intl.RelativeTimeFormatOptions) => string;
-    has: (key: TranslationKey, routeContext?: unknown) => boolean;
-    setRoute: (val: string) => void;
-    getRoute: () => string;
-    getLocale: () => string;
-    addTranslations: (locale: string, translations: Translations, merge?: boolean) => void;
-    addRouteTranslations: (locale: string, routeName: string, translations: Translations, merge?: boolean) => void;
-    resolveTranslations: (routeContext?: unknown) => Translations;
-    setTranslation: (key: TranslationKey, value: unknown) => void;
-    clearCache: () => void;
-};
+/** One object per provider; hook options make their own, and win over the provider. */
+export declare function useI18n(options?: UseI18nOptions): UseI18nReturn;
 
 export declare const useI18nContext: () => SolidI18n;
 
-export declare const useI18nDefaultLocale: () => string;
+export declare const useI18nDefaultLocale: () => string | undefined;
 
-export declare const useI18nLocales: () => Locale[];
+export declare const useI18nLocales: () => Locale[] | undefined;
 
 export declare interface UseI18nOptions {
     locales?: Locale[];
     defaultLocale?: string;
 }
 
+export declare type UseI18nReturn = ReturnType<typeof createApi>;
+
 export declare const useI18nRouter: () => I18nRoutingStrategy | undefined;
 
 export { }