fimo-react-router 0.21.0-experimental.1

package/dist/active-routes.js

@@ -0,0 +1,60 @@
+const normalizeRoutePath = (path) => {
+    const withSlash = path.startsWith('/') ? path : `/${path}`;
+    const normalized = withSlash.replace(/\/{2,}/g, '/');
+    return normalized.length > 1 ? normalized.replace(/\/+$/, '') : normalized;
+};
+const joinRoutePath = (parentPath, childPath) => {
+    if (!childPath) {
+        return parentPath;
+    }
+    if (childPath.startsWith('/')) {
+        return normalizeRoutePath(childPath);
+    }
+    return normalizeRoutePath(`${parentPath}/${childPath}`);
+};
+/**
+ * Flatten React Router's framework manifest into the route graph the active
+ * router actually loaded. This is intentionally separate from fimo-config:
+ * metadata describes what Studio expects, while this manifest describes what
+ * the iframe can render after its route modules have converged.
+ */
+export function getActiveRouterRoutes(manifest) {
+    const routeRecord = manifest?.routes;
+    if (!routeRecord) {
+        return [];
+    }
+    const entries = Object.values(routeRecord).filter(isActiveRouteManifestEntry);
+    const byId = new Map(entries.map((entry) => [entry.id, entry]));
+    const pathCache = new Map();
+    const resolvePath = (entry, resolving = new Set()) => {
+        const cached = pathCache.get(entry.id);
+        if (cached !== undefined) {
+            return cached;
+        }
+        if (resolving.has(entry.id)) {
+            return '';
+        }
+        const nextResolving = new Set(resolving).add(entry.id);
+        const parentPath = entry.parentId
+            ? resolvePath(byId.get(entry.parentId) ?? { id: entry.parentId }, nextResolving)
+            : '';
+        const path = entry.index ? parentPath || '/' : joinRoutePath(parentPath, entry.path ?? '');
+        pathCache.set(entry.id, path);
+        return path;
+    };
+    return entries.flatMap((entry) => {
+        // A pathless/root layout is part of the framework manifest, but it is not
+        // a URL the router can navigate to. Treat only an explicit index route as
+        // the root path; including the layout would add a phantom `/` entry and
+        // make exact route-graph convergence impossible for apps without a home
+        // page.
+        if ((entry.path === undefined || entry.path === '') && !entry.index) {
+            return [];
+        }
+        const path = normalizeRoutePath(resolvePath(entry));
+        return [{ id: entry.id, path }];
+    });
+}
+function isActiveRouteManifestEntry(value) {
+    return Boolean(value && typeof value === 'object' && typeof value.id === 'string');
+}

package/dist/fixtures/virtual-fimo-config.d.ts

@@ -0,0 +1,3 @@
+declare const config: Record<string, unknown>;
+export default config;
+//# sourceMappingURL=virtual-fimo-config.d.ts.map

package/dist/fixtures/virtual-fimo-config.js

@@ -0,0 +1,3 @@
+// Static stand-in for the `virtual:fimo-config` Vite module in vitest runs.
+const config = {};
+export default config;

package/dist/fixtures/virtual-translations.d.ts

@@ -0,0 +1,5 @@
+export declare const dictionaries: Record<string, Record<string, string>>;
+export declare const defaultLocale = "en";
+export declare const signature = "fixture";
+export declare const updatedAt: string | null;
+//# sourceMappingURL=virtual-translations.d.ts.map

package/dist/fixtures/virtual-translations.js

@@ -0,0 +1,9 @@
+// Static stand-in for the `virtual:translations` Vite module in vitest runs.
+// `fimo-react`'s root barrel imports it, and this package renders against that
+// barrel, so the alias has to exist here too.
+export const dictionaries = {
+    en: { 'hero.title': 'Welcome' },
+};
+export const defaultLocale = 'en';
+export const signature = 'fixture';
+export const updatedAt = null;

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+export { FimoProviders } from './FimoProviders.js';
+export { FimoScripts } from './FimoScripts.js';
+export { useLocale, formClient } from 'fimo-react';
+export { localizeFimoPath, resolveFimoLocale } from 'fimo/config';
+export { FimoLink, useFimoHref, useFimoNavigate } from './navigation.js';
+export { localizeFimoTo } from './navigation-utils.js';
+export { AppRoutesProvider } from './AppRoutesProvider.js';
+export type { AppRoute, SlugInfo } from './AppRoutesProvider.js';
+export type { DisplayRoute, FimoProvidersProps, ParamInfo } from './FimoProviders.js';
+export type { FimoLocaleContextValue } from 'fimo-react';
+export type { FimoLocaleResolution } from 'fimo/config';
+export type { FimoLinkProps, FimoNavigationOptions } from './navigation.js';
+export { Pageview } from './Pageview.js';
+export * from './seo.js';
+export * from 'fimo/seo';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,16 @@
+// `fimo-react-router` — the React Router adapter surface.
+//
+// Everything here needs React Router: the providers that read its location and
+// framework manifest, locale-aware links, the route `meta` helpers, and the
+// legacy `AppRoutesProvider` SPA shell. Content clients, labels, and editable
+// primitives come from `fimo-react`, which has no router dependency.
+export { FimoProviders } from './FimoProviders.js';
+export { FimoScripts } from './FimoScripts.js';
+export { useLocale, formClient } from 'fimo-react';
+export { localizeFimoPath, resolveFimoLocale } from 'fimo/config';
+export { FimoLink, useFimoHref, useFimoNavigate } from './navigation.js';
+export { localizeFimoTo } from './navigation-utils.js';
+export { AppRoutesProvider } from './AppRoutesProvider.js';
+export { Pageview } from './Pageview.js';
+export * from './seo.js';
+export * from 'fimo/seo';

package/dist/navigation-utils.d.ts

@@ -0,0 +1,8 @@
+import { type FimoConfig } from 'fimo/config';
+export type FimoNavigationTo = string | {
+    pathname?: string;
+    search?: string;
+    hash?: string;
+};
+export declare function localizeFimoTo(to: FimoNavigationTo, locale: string, config: Pick<FimoConfig, 'i18n'> | undefined): FimoNavigationTo;
+//# sourceMappingURL=navigation-utils.d.ts.map

package/dist/navigation-utils.js

@@ -0,0 +1,36 @@
+import { localizeFimoPath } from 'fimo/config';
+export function localizeFimoTo(to, locale, config) {
+    if (typeof to === 'string') {
+        return localizeStringTo(to, locale, config);
+    }
+    if (!to.pathname) {
+        return to;
+    }
+    const localizedPathname = localizePathname(to.pathname, locale, config);
+    return localizedPathname === to.pathname ? to : { ...to, pathname: localizedPathname };
+}
+function localizeStringTo(to, locale, config) {
+    if (!shouldLocalizeStringPath(to)) {
+        return to;
+    }
+    const match = /^(?<pathname>[^?#]*)(?<search>\?[^#]*)?(?<hash>#.*)?$/.exec(to);
+    const pathname = match?.groups?.pathname || '/';
+    const search = match?.groups?.search ?? '';
+    const hash = match?.groups?.hash ?? '';
+    return `${localizePathname(pathname, locale, config)}${search}${hash}`;
+}
+function shouldLocalizeStringPath(to) {
+    if (to.startsWith('#') || to.startsWith('?') || to.startsWith('//')) {
+        return false;
+    }
+    if (/^[a-z][a-z\d+.-]*:/i.test(to)) {
+        return false;
+    }
+    return to.startsWith('/');
+}
+function localizePathname(pathname, locale, config) {
+    if (!pathname.startsWith('/')) {
+        return pathname;
+    }
+    return localizeFimoPath(pathname, locale, config);
+}

package/dist/navigation.d.ts

@@ -0,0 +1,12 @@
+import type { LinkProps, NavigateOptions, To } from 'react-router';
+export interface FimoNavigationOptions {
+    locale?: string;
+    preserveLocale?: boolean;
+}
+export interface FimoLinkProps extends Omit<LinkProps, 'to'>, FimoNavigationOptions {
+    to: To;
+}
+export declare function FimoLink({ to, locale, preserveLocale, ...props }: FimoLinkProps): import("react/jsx-runtime").JSX.Element;
+export declare function useFimoHref(to: To, options?: FimoNavigationOptions): To;
+export declare function useFimoNavigate(): (to: To | number, options?: NavigateOptions & FimoNavigationOptions) => void;
+//# sourceMappingURL=navigation.d.ts.map

package/dist/navigation.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useLocale } from 'fimo-react';
+import { Link, useNavigate } from 'react-router';
+// @ts-ignore - virtual module provided by fimoConfigPlugin in fimo-vite
+import fimoConfig from 'virtual:fimo-config';
+import { localizeFimoTo } from './navigation-utils.js';
+export function FimoLink({ to, locale, preserveLocale = true, ...props }) {
+    const href = useFimoHref(to, { locale, preserveLocale });
+    return _jsx(Link, { ...props, to: href });
+}
+export function useFimoHref(to, options = {}) {
+    const active = useLocale();
+    const locale = options.locale ?? (options.preserveLocale === false ? undefined : active.locale);
+    return locale ? localizeFimoTo(to, locale, fimoConfig) : to;
+}
+export function useFimoNavigate() {
+    const navigate = useNavigate();
+    const active = useLocale();
+    return (to, options = {}) => {
+        if (typeof to === 'number') {
+            navigate(to);
+            return;
+        }
+        const locale = options.locale ?? (options.preserveLocale === false ? undefined : active.locale);
+        const localizedTo = locale ? localizeFimoTo(to, locale, fimoConfig) : to;
+        navigate(localizedTo, options);
+    };
+}

package/dist/prefetch.d.ts

@@ -0,0 +1,9 @@
+export declare function resolveFimoLocaleForUrl(url: string): import("fimo-react").FimoLocaleResolution;
+/**
+ * Fetch route data for SEO meta resolution.
+ *
+ * Only entry params are fetched: a locale param is resolved from the URL and
+ * never corresponds to a CMS schema, so it must not produce a request.
+ */
+export declare function resolveMetaEntries(url: string): Promise<Record<string, unknown> | undefined>;
+//# sourceMappingURL=prefetch.d.ts.map

package/dist/prefetch.js

@@ -0,0 +1,39 @@
+import { resolveFimoLocale } from 'fimo/config';
+import { matchFimoRoute } from 'fimo/routes';
+// @ts-ignore - virtual module provided by fimoConfigPlugin in fimo-vite
+import fimoConfig from 'virtual:fimo-config';
+export function resolveFimoLocaleForUrl(url) {
+    return resolveFimoLocale(url, fimoConfig);
+}
+/**
+ * Fetch route data for SEO meta resolution.
+ *
+ * Only entry params are fetched: a locale param is resolved from the URL and
+ * never corresponds to a CMS schema, so it must not produce a request.
+ */
+export async function resolveMetaEntries(url) {
+    // @ts-ignore – import.meta.env is a Vite feature, replaced at build time for both client and SSR
+    const base = import.meta.env.VITE_API_URL;
+    if (!base) {
+        return undefined;
+    }
+    const match = matchFimoRoute(url, fimoConfig);
+    if (!match || match.contract.entryParams.length === 0) {
+        return undefined;
+    }
+    const data = {};
+    await Promise.all(match.contract.entryParams.map(async (param) => {
+        const value = match.entryParams[param.name];
+        if (!value) {
+            return;
+        }
+        const entryUrl = new URL(`${base}/entries/${param.schema}/field/${encodeURIComponent(param.queryField)}/${encodeURIComponent(value)}`);
+        entryUrl.searchParams.set('locale', match.locale);
+        const res = await fetch(entryUrl);
+        if (res.ok) {
+            const json = await res.json();
+            data[param.name] = json.data;
+        }
+    }));
+    return Object.keys(data).length > 0 ? data : undefined;
+}

package/dist/preset.d.ts

@@ -0,0 +1,30 @@
+interface ReactRouterUserConfig {
+    readonly ssr?: boolean;
+}
+interface ReactRouterBuildEndArgs {
+    readonly buildManifest: unknown;
+    readonly reactRouterConfig: unknown;
+    readonly viteConfig: {
+        readonly root: string;
+        readonly build: {
+            readonly assetsDir?: string;
+        };
+    };
+}
+/**
+ * Connect a client-rendered React Router build to Fimo hosting.
+ *
+ * The hosting-provider build contract stays inside Fimo so applications do not
+ * install or import provider packages. SSR needs a deeper server-runtime
+ * adapter and is rejected until Fimo supports that contract explicitly.
+ */
+export declare function fimoPreset(): {
+    name: string;
+    reactRouterConfig({ reactRouterUserConfig }: {
+        reactRouterUserConfig: ReactRouterUserConfig;
+    }): {
+        buildEnd({ buildManifest, reactRouterConfig, viteConfig }: ReactRouterBuildEndArgs): void;
+    };
+};
+export {};
+//# sourceMappingURL=preset.d.ts.map

package/dist/preset.js

@@ -0,0 +1,33 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+const REACT_ROUTER_BUILD_RESULT = '.vercel/react-router-build-result.json';
+/**
+ * Connect a client-rendered React Router build to Fimo hosting.
+ *
+ * The hosting-provider build contract stays inside Fimo so applications do not
+ * install or import provider packages. SSR needs a deeper server-runtime
+ * adapter and is rejected until Fimo supports that contract explicitly.
+ */
+export function fimoPreset() {
+    return {
+        name: 'fimo',
+        reactRouterConfig({ reactRouterUserConfig }) {
+            if (reactRouterUserConfig.ssr !== false) {
+                throw new Error('fimoPreset() currently supports React Router apps configured with ssr: false');
+            }
+            return {
+                buildEnd({ buildManifest, reactRouterConfig, viteConfig }) {
+                    const buildResultPath = join(viteConfig.root, REACT_ROUTER_BUILD_RESULT);
+                    const assetsDir = viteConfig.build.assetsDir;
+                    const result = {
+                        buildManifest,
+                        reactRouterConfig,
+                        viteConfig: assetsDir ? { build: { assetsDir } } : undefined,
+                    };
+                    mkdirSync(dirname(buildResultPath), { recursive: true });
+                    writeFileSync(buildResultPath, `${JSON.stringify(result, null, 2)}\n`);
+                },
+            };
+        },
+    };
+}

package/dist/routes.d.ts

@@ -0,0 +1,35 @@
+import { type FimoConfig } from 'fimo/config';
+export interface FimoReactRouterRoute {
+    id?: string;
+    path?: string;
+    file?: string;
+    index?: boolean;
+    children?: FimoReactRouterRoute[];
+    [key: string]: unknown;
+}
+/**
+ * Structural minimum a route entry must satisfy. Deliberately WITHOUT an
+ * index signature so framework types like React Router's `RouteConfigEntry`
+ * (which has none) remain assignable, and generic so callers get their own
+ * entry type back — `fimoRoutes(routes) satisfies RouteConfig` must keep
+ * compiling in project code.
+ */
+interface FimoRouteShape {
+    id?: string;
+    path?: string;
+    file?: string;
+    index?: boolean;
+    children?: FimoRouteShape[];
+}
+export interface FimoRoutesOptions {
+    config?: Pick<FimoConfig, 'i18n'>;
+    rootDir?: string;
+}
+/**
+ * @deprecated New React Router projects should declare optional `:locale?`
+ * segments directly. This compatibility adapter may be removed in a future
+ * breaking release.
+ */
+export declare function fimoRoutes<T extends FimoRouteShape>(routes: readonly T[], options?: FimoRoutesOptions): T[];
+export {};
+//# sourceMappingURL=routes.d.ts.map

package/dist/routes.js

@@ -0,0 +1,85 @@
+import { getConfigServer, getFimoDefaultLocale, getFimoLocales } from 'fimo/config';
+import { hasLocaleSegment } from 'fimo/routes';
+/**
+ * @deprecated New React Router projects should declare optional `:locale?`
+ * segments directly. This compatibility adapter may be removed in a future
+ * breaking release.
+ */
+export function fimoRoutes(routes, options = {}) {
+    const config = options.config ?? getConfigServer(options.rootDir ?? process.cwd());
+    const strategy = config.i18n?.routing?.strategy ?? 'path-prefix';
+    if (strategy !== 'path-prefix') {
+        return [...routes];
+    }
+    const defaultLocale = getFimoDefaultLocale(config);
+    // The default locale renders at the canonical unprefixed path, so it never
+    // gets an alias.
+    const prefixedLocales = getFimoLocales(config).filter((locale) => locale !== defaultLocale);
+    // A route that declares its own `:locale` segment already carries the locale
+    // in its path; prefixing it again would produce `/es/:locale/...`.
+    const aliasable = routes.filter((route) => !declaresLocaleSegment(route));
+    if (prefixedLocales.length === 0 || aliasable.length === 0) {
+        return [...routes];
+    }
+    return [
+        ...routes,
+        ...prefixedLocales.flatMap((locale) => aliasable.map((route, index) => localizeRouteEntry(route, {
+            locale,
+            prefixThisEntry: true,
+            routeKey: String(index),
+        }))),
+    ];
+}
+function declaresLocaleSegment(route) {
+    if (route.path && hasLocaleSegment(route.path)) {
+        return true;
+    }
+    return (route.children ?? []).some(declaresLocaleSegment);
+}
+function localizeRouteEntry(route, options) {
+    const clone = {
+        ...route,
+        id: localizedRouteId(route, options.locale, options.routeKey),
+    };
+    let prefixAppliedHere = false;
+    if (options.prefixThisEntry) {
+        prefixAppliedHere = applyLocalePrefix(clone, options.locale);
+    }
+    if (route.children) {
+        clone.children = route.children.map((child, index) => localizeRouteEntry(child, {
+            locale: options.locale,
+            prefixThisEntry: !prefixAppliedHere,
+            routeKey: `${options.routeKey}.${index}`,
+        }));
+    }
+    return clone;
+}
+function applyLocalePrefix(route, locale) {
+    if (route.index) {
+        delete route.index;
+        route.path = locale;
+        return true;
+    }
+    if (typeof route.path === 'string') {
+        route.path = joinRoutePath(locale, route.path);
+        return true;
+    }
+    return false;
+}
+function joinRoutePath(prefix, routePath) {
+    const cleanPrefix = prefix.replace(/^\/+|\/+$/g, '');
+    const cleanPath = routePath.replace(/^\/+|\/+$/g, '');
+    return cleanPath ? `${cleanPrefix}/${cleanPath}` : cleanPrefix;
+}
+function localizedRouteId(route, locale, routeKey) {
+    const base = route.id ?? route.path ?? (route.index ? 'index' : route.file) ?? `route-${routeKey}`;
+    return `fimo.${sanitizeRouteId(locale)}.${sanitizeRouteId(base)}`;
+}
+function sanitizeRouteId(value) {
+    const clean = value
+        .replace(/^\.?\//, '')
+        .replace(/\.[tj]sx?$/i, '')
+        .replace(/[^A-Za-z0-9_$-]+/g, '.')
+        .replace(/^\.+|\.+$/g, '');
+    return clean || 'route';
+}

package/dist/seo.d.ts

@@ -0,0 +1,93 @@
+import { type FimoSEO } from 'fimo/config';
+export declare function getSeoForPath(pathname: string, routeData?: unknown): FimoSEO | undefined;
+export declare function buildMetaForPath(pathname: string, routeData?: unknown): ({
+    title: string;
+    name?: undefined;
+    property?: undefined;
+    content?: undefined;
+    tagName?: undefined;
+    rel?: undefined;
+    href?: undefined;
+} | {
+    title?: undefined;
+    name: string;
+    content: string;
+    property?: undefined;
+    tagName?: undefined;
+    rel?: undefined;
+    href?: undefined;
+} | {
+    title?: undefined;
+    name?: undefined;
+    property: string;
+    content: string;
+    tagName?: undefined;
+    rel?: undefined;
+    href?: undefined;
+} | {
+    title?: undefined;
+    name?: undefined;
+    property?: undefined;
+    content?: undefined;
+    tagName: string;
+    rel: string;
+    href: string;
+})[];
+export declare function buildFimoMeta(args: {
+    location: {
+        pathname: string;
+    };
+    matches: readonly unknown[];
+}): ({
+    title: string;
+    name?: undefined;
+    property?: undefined;
+    content?: undefined;
+    tagName?: undefined;
+    rel?: undefined;
+    href?: undefined;
+} | {
+    title?: undefined;
+    name: string;
+    content: string;
+    property?: undefined;
+    tagName?: undefined;
+    rel?: undefined;
+    href?: undefined;
+} | {
+    title?: undefined;
+    name?: undefined;
+    property: string;
+    content: string;
+    tagName?: undefined;
+    rel?: undefined;
+    href?: undefined;
+} | {
+    title?: undefined;
+    name?: undefined;
+    property?: undefined;
+    content?: undefined;
+    tagName: string;
+    rel: string;
+    href: string;
+})[];
+/**
+ * Returns the attributes Fimo injects onto the root `<html>` element.
+ * Currently: `lang` derived from the active locale or `i18n.defaultLocale`.
+ * May grow to include `dir`, `data-theme`, or other a11y/theming attributes
+ * without requiring changes to root.tsx.
+ */
+export declare function fimoHtmlProps(localeOrOptions?: string | {
+    locale?: string;
+}): {
+    lang: string;
+    dir: 'ltr' | 'rtl';
+};
+/** Root-loader helper: per-route SEO entry data plus the resolved locale. */
+export declare function loadFimoMetaData({ request }: {
+    request: Request;
+}): Promise<{
+    fimoMetaData: Record<string, unknown> | undefined;
+    fimoLocale: import("fimo-react").FimoLocaleResolution;
+}>;
+//# sourceMappingURL=seo.d.ts.map

package/dist/seo.js

@@ -0,0 +1,74 @@
+import { getFimoTextDirection, toHtmlLang } from 'fimo/config';
+import { normalizePathname, resolveSeoForPath } from 'fimo/seo';
+// @ts-ignore - virtual module provided by fimoConfigPlugin in fimo-vite
+import rawConfig from 'virtual:fimo-config';
+import { resolveFimoLocaleForUrl, resolveMetaEntries } from './prefetch.js';
+const config = rawConfig;
+export function getSeoForPath(pathname, routeData) {
+    return resolveSeoForPath(pathname, config, routeData);
+}
+function buildCanonicalUrl(seoUrl, pathname) {
+    if (!seoUrl) {
+        return undefined;
+    }
+    try {
+        return new URL(normalizePathname(pathname), seoUrl).toString();
+    }
+    catch {
+        return undefined;
+    }
+}
+function seoToMeta(seo, pathname) {
+    const canonical = buildCanonicalUrl(seo.url, pathname);
+    return [
+        ...(seo.title ? [{ title: seo.title }] : []),
+        ...(seo.description ? [{ name: 'description', content: seo.description }] : []),
+        ...(seo.siteName ? [{ property: 'og:site_name', content: seo.siteName }] : []),
+        ...(seo.title ? [{ property: 'og:title', content: seo.title }] : []),
+        ...(seo.description ? [{ property: 'og:description', content: seo.description }] : []),
+        ...(canonical ? [{ property: 'og:url', content: canonical }] : []),
+        ...(seo.image ? [{ property: 'og:image', content: seo.image }] : []),
+        ...(seo.locale ? [{ property: 'og:locale', content: seo.locale }] : []),
+        ...(seo.title ? [{ name: 'twitter:title', content: seo.title }] : []),
+        ...(seo.description ? [{ name: 'twitter:description', content: seo.description }] : []),
+        ...(seo.image ? [{ name: 'twitter:image', content: seo.image }] : []),
+        ...(canonical ? [{ tagName: 'link', rel: 'canonical', href: canonical }] : []),
+    ];
+}
+export function buildMetaForPath(pathname, routeData) {
+    const seo = getSeoForPath(pathname, routeData);
+    if (!seo) {
+        return [];
+    }
+    return seoToMeta(seo, pathname);
+}
+export function buildFimoMeta(args) {
+    const pathname = args.location.pathname;
+    const firstMatch = args.matches[0];
+    const rootData = firstMatch && typeof firstMatch === 'object' && 'data' in firstMatch
+        ? firstMatch.data
+        : undefined;
+    const routeData = rootData && typeof rootData === 'object' ? rootData.fimoMetaData : undefined;
+    const seo = getSeoForPath(pathname, routeData);
+    if (!seo) {
+        return [];
+    }
+    return seoToMeta(seo, pathname);
+}
+/**
+ * Returns the attributes Fimo injects onto the root `<html>` element.
+ * Currently: `lang` derived from the active locale or `i18n.defaultLocale`.
+ * May grow to include `dir`, `data-theme`, or other a11y/theming attributes
+ * without requiring changes to root.tsx.
+ */
+export function fimoHtmlProps(localeOrOptions) {
+    const explicitLocale = typeof localeOrOptions === 'string' ? localeOrOptions : localeOrOptions?.locale;
+    const locale = explicitLocale ?? config.i18n?.defaultLocale ?? 'en';
+    return { lang: toHtmlLang(locale), dir: getFimoTextDirection(locale) };
+}
+/** Root-loader helper: per-route SEO entry data plus the resolved locale. */
+export async function loadFimoMetaData({ request }) {
+    const fimoMetaData = await resolveMetaEntries(request.url);
+    const fimoLocale = resolveFimoLocaleForUrl(request.url);
+    return { fimoMetaData, fimoLocale };
+}

package/dist/vite.d.ts

@@ -0,0 +1,20 @@
+import { type FimoViteOptions } from 'fimo-vite';
+import type { PluginOption } from 'vite';
+export type { FimoViteOptions } from 'fimo-vite';
+/**
+ * Whether the project at `root` is a React Router framework-mode app.
+ *
+ * Gates the one framework-mode-only line below, so a plain-Vite React project
+ * that uses `BrowserRouter` never inherits it. Checks the manifest first: the
+ * config file can carry any of four extensions, but framework mode is
+ * impossible without `@react-router/dev`.
+ */
+export declare function isReactRouterProject(root: string): boolean;
+/**
+ * The Fimo Vite plugin for React Router projects: `fimo-vite`'s neutral
+ * plugins plus the React/React-Router dependency pre-bundling those projects
+ * need. Options are `fimo-vite`'s; `seo` applies to a plain Vite index.html,
+ * while React Router framework mode owns SEO through route `meta` exports.
+ */
+export declare function fimo(opts?: FimoViteOptions): PluginOption[];
+//# sourceMappingURL=vite.d.ts.map