fimo-react 0.21.0-experimental.1

package/dist/runtime/content/react-content-client.d.ts

@@ -0,0 +1,10 @@
+import { type ContentRuntime } from 'fimo/content';
+import type { CollectionContentClient, ContentClientConfig } from './types.js';
+export declare const SOURCE_TRACKED_QUERY_OPTIONS: {
+    readonly structuralSharing: false;
+};
+export type UseContentLocale = (requestedLocale: string | undefined, defaultLocale: string) => string;
+export declare function createReactContentClient<T extends {
+    id: string;
+}, TInput extends object>(config: ContentClientConfig, runtime: ContentRuntime, useContentLocale: UseContentLocale): CollectionContentClient<T, TInput>;
+//# sourceMappingURL=react-content-client.d.ts.map

package/dist/runtime/content/react-content-client.js

@@ -0,0 +1,164 @@
+import { useInfiniteQuery, useMutation, useQuery, useQueryClient, useSuspenseQuery } from '@tanstack/react-query';
+import { createCollectionContentCore, readCollectionLocale, withMutationLocale, } from 'fimo/content';
+export const SOURCE_TRACKED_QUERY_OPTIONS = { structuralSharing: false };
+export function createReactContentClient(config, runtime, useContentLocale) {
+    const { client: core, defaultLocale, queryKeys } = createCollectionContentCore(config, runtime);
+    const { getById, getBySlug, getByField, list, create, update, remove } = core;
+    function activeLocale(requested) {
+        return useContentLocale(requested, defaultLocale);
+    }
+    function useGetById(id, options = {}) {
+        const localizedOptions = { ...options, locale: activeLocale(options.locale) };
+        return useQuery({
+            queryKey: queryKeys.byId(id, localizedOptions),
+            queryFn: () => getById(id, localizedOptions),
+            ...SOURCE_TRACKED_QUERY_OPTIONS,
+        });
+    }
+    function useGetBySlug(slug, options = {}) {
+        const locale = readCollectionLocale(options, activeLocale(options.locale));
+        const localizedOptions = { ...options, locale };
+        return useQuery({
+            queryKey: queryKeys.bySlug(slug, localizedOptions),
+            queryFn: () => getBySlug(slug, localizedOptions),
+            ...SOURCE_TRACKED_QUERY_OPTIONS,
+            enabled: !!slug,
+        });
+    }
+    function useGetByField(fieldName, value, options = {}) {
+        const locale = readCollectionLocale(options, activeLocale(options.locale));
+        const localizedOptions = { ...options, locale };
+        return useQuery({
+            queryKey: queryKeys.byField(fieldName, value, localizedOptions),
+            queryFn: () => getByField(fieldName, value, localizedOptions),
+            ...SOURCE_TRACKED_QUERY_OPTIONS,
+            enabled: !!value,
+        });
+    }
+    function useGet(params = {}) {
+        const locale = readCollectionLocale(params, activeLocale(params.locale));
+        const localizedParams = { ...params, locale };
+        return useQuery({
+            queryKey: queryKeys.list(localizedParams),
+            queryFn: () => list(localizedParams),
+            ...SOURCE_TRACKED_QUERY_OPTIONS,
+            select: (page) => page.items,
+        });
+    }
+    function useList(params = {}) {
+        const locale = readCollectionLocale(params, activeLocale(params.locale));
+        const localizedParams = { ...params, locale };
+        return useQuery({
+            queryKey: queryKeys.list(localizedParams),
+            queryFn: () => list(localizedParams),
+            ...SOURCE_TRACKED_QUERY_OPTIONS,
+        });
+    }
+    function useInfiniteList(params = {}) {
+        const locale = readCollectionLocale(params, activeLocale(params.locale));
+        const localizedParams = { ...params, locale };
+        const query = useInfiniteQuery({
+            queryKey: queryKeys.infiniteList(localizedParams),
+            queryFn: ({ pageParam }) => list({ ...localizedParams, offset: pageParam }),
+            ...SOURCE_TRACKED_QUERY_OPTIONS,
+            initialPageParam: 0,
+            getNextPageParam: (lastPage) => lastPage.pageInfo.nextOffset ?? undefined,
+        });
+        return {
+            ...query,
+            items: query.data?.pages.flatMap((page) => page.items) ?? [],
+            total: query.data?.pages[0]?.pageInfo.total ?? 0,
+            hasMore: query.hasNextPage,
+            loadMore: () => query.fetchNextPage(),
+            isLoadingMore: query.isFetchingNextPage,
+        };
+    }
+    function useSuspenseGetById(id, options = {}) {
+        const localizedOptions = { ...options, locale: activeLocale(options.locale) };
+        return useSuspenseQuery({
+            queryKey: queryKeys.byId(id, localizedOptions),
+            queryFn: () => getById(id, localizedOptions),
+            ...SOURCE_TRACKED_QUERY_OPTIONS,
+        });
+    }
+    function useSuspenseGetBySlug(slug, options = {}) {
+        const locale = readCollectionLocale(options, activeLocale(options.locale));
+        const localizedOptions = { ...options, locale };
+        return useSuspenseQuery({
+            queryKey: queryKeys.bySlug(slug, localizedOptions),
+            queryFn: () => getBySlug(slug, localizedOptions),
+            ...SOURCE_TRACKED_QUERY_OPTIONS,
+        });
+    }
+    function useSuspenseGetByField(fieldName, value, options = {}) {
+        const locale = readCollectionLocale(options, activeLocale(options.locale));
+        const localizedOptions = { ...options, locale };
+        return useSuspenseQuery({
+            queryKey: queryKeys.byField(fieldName, value, localizedOptions),
+            queryFn: () => getByField(fieldName, value, localizedOptions),
+            ...SOURCE_TRACKED_QUERY_OPTIONS,
+        });
+    }
+    function useSuspenseGet(params = {}) {
+        const locale = readCollectionLocale(params, activeLocale(params.locale));
+        const localizedParams = { ...params, locale };
+        return useSuspenseQuery({
+            queryKey: queryKeys.list(localizedParams),
+            queryFn: () => list(localizedParams),
+            ...SOURCE_TRACKED_QUERY_OPTIONS,
+            select: (page) => page.items,
+        });
+    }
+    function useCreate() {
+        const queryClient = useQueryClient();
+        const locale = activeLocale();
+        return useMutation({
+            mutationFn: (payload) => create(withMutationLocale(payload, locale)),
+            onSuccess: () => queryClient.invalidateQueries({ queryKey: queryKeys.root }),
+        });
+    }
+    function useUpdate() {
+        const queryClient = useQueryClient();
+        const locale = activeLocale();
+        return useMutation({
+            mutationFn: ({ id, ...patch }) => update(id, withMutationLocale(patch, locale)),
+            onSuccess: (_data, variables) => {
+                queryClient.invalidateQueries({ queryKey: queryKeys.root });
+                queryClient.invalidateQueries({
+                    queryKey: queryKeys.byId(variables.id, { locale: variables.locale ?? locale }),
+                });
+            },
+        });
+    }
+    function useRemove() {
+        const queryClient = useQueryClient();
+        const active = activeLocale();
+        return useMutation({
+            mutationFn: (value) => {
+                const { id, locale } = typeof value === 'string' ? { id: value, locale: active } : { ...value, locale: value.locale ?? active };
+                return remove(id, { locale });
+            },
+            onSuccess: (_data, value) => {
+                const { id, locale } = typeof value === 'string' ? { id: value, locale: active } : { ...value, locale: value.locale ?? active };
+                queryClient.invalidateQueries({ queryKey: queryKeys.root });
+                queryClient.removeQueries({ queryKey: queryKeys.byId(id, { locale }), exact: false });
+            },
+        });
+    }
+    return {
+        ...core,
+        useGetById,
+        useGetBySlug,
+        useGetByField,
+        useGet,
+        useList,
+        useInfiniteList,
+        useSuspenseGetById,
+        useSuspenseGetBySlug,
+        useSuspenseGetByField,
+        useSuspenseGet,
+        useCreate,
+        useUpdate,
+        useRemove,
+    };
+}

package/dist/runtime/content/react-singleton-client.d.ts

@@ -0,0 +1,7 @@
+import { type ContentRuntime } from 'fimo/content';
+import { type UseContentLocale } from './react-content-client.js';
+import type { ContentClientConfig, SingletonContentClient } from './types.js';
+export declare function createReactSingletonClient<T extends {
+    id: string;
+}, TInput extends object>(config: ContentClientConfig, runtime: ContentRuntime, useContentLocale: UseContentLocale): SingletonContentClient<T, TInput>;
+//# sourceMappingURL=react-singleton-client.d.ts.map

package/dist/runtime/content/react-singleton-client.js

@@ -0,0 +1,37 @@
+import { useMutation, useQuery, useQueryClient, useSuspenseQuery } from '@tanstack/react-query';
+import { createSingletonContentCore, withMutationLocale } from 'fimo/content';
+import { SOURCE_TRACKED_QUERY_OPTIONS } from './react-content-client.js';
+export function createReactSingletonClient(config, runtime, useContentLocale) {
+    const { client: core, defaultLocale, localize, queryKeys } = createSingletonContentCore(config, runtime);
+    const { get, update } = core;
+    function activeLocale(requested) {
+        return useContentLocale(requested, defaultLocale);
+    }
+    function useGet(options = {}) {
+        const locale = localize(options, activeLocale(options.locale));
+        const localizedOptions = { ...options, locale };
+        return useQuery({
+            queryKey: queryKeys.document(localizedOptions),
+            queryFn: () => get(localizedOptions),
+            ...SOURCE_TRACKED_QUERY_OPTIONS,
+        });
+    }
+    function useSuspenseGet(options = {}) {
+        const locale = localize(options, activeLocale(options.locale));
+        const localizedOptions = { ...options, locale };
+        return useSuspenseQuery({
+            queryKey: queryKeys.document(localizedOptions),
+            queryFn: () => get(localizedOptions),
+            ...SOURCE_TRACKED_QUERY_OPTIONS,
+        });
+    }
+    function useUpdate() {
+        const queryClient = useQueryClient();
+        const locale = activeLocale();
+        return useMutation({
+            mutationFn: (payload) => update(withMutationLocale(payload, locale)),
+            onSuccess: () => queryClient.invalidateQueries({ queryKey: queryKeys.root }),
+        });
+    }
+    return { ...core, useGet, useSuspenseGet, useUpdate };
+}

package/dist/runtime/content/retrieve-data-sources.d.ts

@@ -0,0 +1,29 @@
+type FieldData = Record<string, string>;
+interface RecordData {
+    id: string;
+    locale?: string;
+    data: FieldData;
+    visible: boolean;
+}
+export type GroupedDataSources = Record<string, RecordData[]>;
+/**
+ * Parses a `data-fimo-source` attribute into its schema, identity, and field
+ * parts. The field itself may contain dots (e.g. a blocks leaf such as
+ * "body[0].title"), so only the first two segments are fixed positions.
+ */
+export declare function parseDataSource(source: string): {
+    schemaName: string;
+    identity: {
+        id: string;
+        locale?: string;
+    };
+    fieldName: string;
+} | null;
+/**
+ * Finds all visible elements with a `data-fimo-source` attribute and groups them
+ * by schema and ID into a structured object.
+ * @returns An object where keys are schema names and values are lists of records.
+ */
+export declare function retrieveVisibleDataSources(): GroupedDataSources;
+export {};
+//# sourceMappingURL=retrieve-data-sources.d.ts.map

package/dist/runtime/content/retrieve-data-sources.js

@@ -0,0 +1,107 @@
+function parseRecordIdentity(token) {
+    if (!token.startsWith('id:')) {
+        return token.includes(':') ? null : { id: token };
+    }
+    const [format, id, encodedLocale, ...rest] = token.split(':');
+    if (format !== 'id' || !id || !encodedLocale || rest.length > 0) {
+        return null;
+    }
+    try {
+        const locale = decodeURIComponent(encodedLocale);
+        return locale ? { id, locale } : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Parses a `data-fimo-source` attribute into its schema, identity, and field
+ * parts. The field itself may contain dots (e.g. a blocks leaf such as
+ * "body[0].title"), so only the first two segments are fixed positions.
+ */
+export function parseDataSource(source) {
+    const parts = source.split('.');
+    if (parts.length < 3) {
+        return null;
+    }
+    const [schemaName, identityToken] = parts;
+    const fieldName = parts.slice(2).join('.');
+    const identity = parseRecordIdentity(identityToken);
+    if (!identity) {
+        return null;
+    }
+    return { schemaName, identity, fieldName };
+}
+/**
+ * Checks if an element is genuinely visible to the user within the viewport.
+ * @param el The element to check.
+ * @returns True if the element is visible, otherwise false.
+ */
+function isElementVisible(el) {
+    if (!el || el.clientWidth === 0 || el.clientHeight === 0) {
+        return false;
+    }
+    const rect = el.getBoundingClientRect();
+    if (rect.top >= window.innerHeight || rect.left >= window.innerWidth || rect.bottom <= 0 || rect.right <= 0) {
+        return false;
+    }
+    const style = window.getComputedStyle(el);
+    if (style.display === 'none' || style.visibility === 'hidden' || parseFloat(style.opacity) === 0) {
+        return false;
+    }
+    // Check if the element is occluded (covered by another element)
+    const pointX = rect.left + rect.width / 2;
+    const pointY = rect.top + rect.height / 2;
+    const elementAtPoint = document.elementFromPoint(pointX, pointY);
+    return elementAtPoint === el || el.contains(elementAtPoint);
+}
+/**
+ * Finds all visible elements with a `data-fimo-source` attribute and groups them
+ * by schema and ID into a structured object.
+ * @returns An object where keys are schema names and values are lists of records.
+ */
+export function retrieveVisibleDataSources() {
+    // Use an intermediate object for easier data assembly.
+    const tempGroupedData = {};
+    const elementsWithSource = document.querySelectorAll('[data-fimo-source]');
+    elementsWithSource.forEach((el) => {
+        const source = el.getAttribute('data-fimo-source');
+        if (!source) {
+            return;
+        }
+        const parsed = parseDataSource(source);
+        if (!parsed) {
+            return;
+        }
+        const { schemaName, identity, fieldName } = parsed;
+        const { id, locale } = identity;
+        const recordKey = JSON.stringify([id, locale ?? null]);
+        // Skip __translations
+        if (schemaName === '__translations') {
+            return;
+        }
+        // Ensure the schema key exists
+        if (!tempGroupedData[schemaName]) {
+            tempGroupedData[schemaName] = {};
+        }
+        // Ensure the record (by ID) exists for  this schema
+        if (!tempGroupedData[schemaName][recordKey]) {
+            tempGroupedData[schemaName][recordKey] = {
+                id: id,
+                ...(locale ? { locale } : {}),
+                data: {},
+                visible: isElementVisible(el),
+            };
+        }
+        // Add the field and its text content to the record
+        if (el.textContent) {
+            tempGroupedData[schemaName][recordKey].data[fieldName] = el.textContent.trim();
+        }
+    });
+    // Convert the temporary object into the final desired array structure.
+    const finalResult = {};
+    for (const schemaName in tempGroupedData) {
+        finalResult[schemaName] = Object.values(tempGroupedData[schemaName]);
+    }
+    return finalResult;
+}

package/dist/runtime/content/types.d.ts

@@ -0,0 +1,42 @@
+import type { InfiniteData, UseInfiniteQueryResult, UseMutationResult, UseQueryResult, UseSuspenseQueryResult } from '@tanstack/react-query';
+import type { CollectionContentCore, CollectionPage, ContentReadOptions, ContentResult, SingletonContentCore } from 'fimo/content';
+import type { Fields, Populate, Query } from 'fimo/primitives';
+export type { CollectionContentCore, CollectionPage, CollectionPageInfo, ContentClientConfig, ContentClientHandle, ContentModuleMeta, ContentModuleRef, ContentReadOptions, ContentResult, ContentSchema, ContentSchemaField, SingletonContentCore, } from 'fimo/content';
+export type InfiniteListResult<TItem> = UseInfiniteQueryResult<InfiniteData<CollectionPage<TItem>>, Error> & {
+    readonly items: TItem[];
+    readonly total: number;
+    readonly hasMore: boolean;
+    readonly loadMore: () => ReturnType<UseInfiniteQueryResult<InfiniteData<CollectionPage<TItem>>, Error>['fetchNextPage']>;
+    readonly isLoadingMore: boolean;
+};
+export interface CollectionContentClient<T extends {
+    id: string;
+}, TInput extends object> extends CollectionContentCore<T, TInput> {
+    useGetById<TPopulate extends Populate<T> | undefined = undefined>(id: string, options?: ContentReadOptions<TPopulate>): UseQueryResult<ContentResult<T, undefined, TPopulate>, Error>;
+    useGetBySlug<TPopulate extends Populate<T> | undefined = undefined>(slug: string, options?: ContentReadOptions<TPopulate>): UseQueryResult<ContentResult<T, undefined, TPopulate> | null, Error>;
+    useGetByField<TPopulate extends Populate<T> | undefined = undefined>(fieldName: string, value: string, options?: ContentReadOptions<TPopulate>): UseQueryResult<ContentResult<T, undefined, TPopulate> | null, Error>;
+    useGet<TFields extends Fields<T> | undefined = undefined, TPopulate extends Populate<T> | undefined = undefined>(params?: Query<T, TFields, TPopulate>): UseQueryResult<ContentResult<T, TFields, TPopulate>[], Error>;
+    useList<TFields extends Fields<T> | undefined = undefined, TPopulate extends Populate<T> | undefined = undefined>(params?: Query<T, TFields, TPopulate>): UseQueryResult<CollectionPage<ContentResult<T, TFields, TPopulate>>, Error>;
+    useInfiniteList<TFields extends Fields<T> | undefined = undefined, TPopulate extends Populate<T> | undefined = undefined>(params?: Omit<Query<T, TFields, TPopulate>, 'offset'>): InfiniteListResult<ContentResult<T, TFields, TPopulate>>;
+    useSuspenseGetById<TPopulate extends Populate<T> | undefined = undefined>(id: string, options?: ContentReadOptions<TPopulate>): UseSuspenseQueryResult<ContentResult<T, undefined, TPopulate>, Error>;
+    useSuspenseGetBySlug<TPopulate extends Populate<T> | undefined = undefined>(slug: string, options?: ContentReadOptions<TPopulate>): UseSuspenseQueryResult<ContentResult<T, undefined, TPopulate> | null, Error>;
+    useSuspenseGetByField<TPopulate extends Populate<T> | undefined = undefined>(fieldName: string, value: string, options?: ContentReadOptions<TPopulate>): UseSuspenseQueryResult<ContentResult<T, undefined, TPopulate> | null, Error>;
+    useSuspenseGet<TFields extends Fields<T> | undefined = undefined, TPopulate extends Populate<T> | undefined = undefined>(params?: Query<T, TFields, TPopulate>): UseSuspenseQueryResult<ContentResult<T, TFields, TPopulate>[], Error>;
+    useCreate(): UseMutationResult<T, Error, TInput>;
+    useUpdate(): UseMutationResult<T, Error, {
+        id: string;
+        locale?: string;
+    } & Partial<TInput>>;
+    useRemove(): UseMutationResult<void, Error, string | {
+        id: string;
+        locale?: string;
+    }>;
+}
+export interface SingletonContentClient<T extends {
+    id: string;
+}, TInput extends object> extends SingletonContentCore<T, TInput> {
+    useGet<TPopulate extends Populate<T> | undefined = undefined>(options?: ContentReadOptions<TPopulate>): UseQueryResult<ContentResult<T, undefined, TPopulate>, Error>;
+    useSuspenseGet<TPopulate extends Populate<T> | undefined = undefined>(options?: ContentReadOptions<TPopulate>): UseSuspenseQueryResult<ContentResult<T, undefined, TPopulate>, Error>;
+    useUpdate(): UseMutationResult<T, Error, Partial<TInput>>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/runtime/content/types.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/content/useQueryLocale.d.ts

@@ -0,0 +1,2 @@
+export declare function useQueryLocale(locale?: string, fallbackLocale?: string): string;
+//# sourceMappingURL=useQueryLocale.d.ts.map

package/dist/runtime/content/useQueryLocale.js

@@ -0,0 +1,5 @@
+import { useLocale } from '../i18n-context.js';
+export function useQueryLocale(locale, fallbackLocale = 'en') {
+    const activeLocale = useLocale().locale;
+    return locale ?? activeLocale ?? fallbackLocale;
+}

package/dist/runtime/content/vite-runtime.d.ts

@@ -0,0 +1,3 @@
+import type { ContentRuntime } from 'fimo/content';
+export declare const viteContentRuntime: ContentRuntime;
+//# sourceMappingURL=vite-runtime.d.ts.map

package/dist/runtime/content/vite-runtime.js

@@ -0,0 +1,23 @@
+// @ts-ignore - virtual module provided by fimoConfigPlugin in fimo/vite
+import fimoConfig from 'virtual:fimo-config';
+export const viteContentRuntime = {
+    apiBase() {
+        // @ts-ignore - import.meta.env is a Vite feature
+        return import.meta.env.VITE_API_URL;
+    },
+    defaultLocale() {
+        return fimoConfig.i18n?.defaultLocale ?? 'en';
+    },
+    headers(extra) {
+        const headers = { ...extra };
+        // @ts-ignore - import.meta.env is a Vite feature
+        const env = import.meta.env.FIMO_ENV;
+        if (env) {
+            headers['X-Fimo-Env'] = env;
+        }
+        return headers;
+    },
+    fetch(input, init) {
+        return globalThis.fetch(input, init);
+    },
+};

package/dist/runtime/core/AppErrorBoundary.d.ts

@@ -0,0 +1,10 @@
+/**
+ * NOTE: Preferable over using a useEffect in App Error Boundary, it sometimes results in errors
+ *
+ * When a component using hooks is rendered under a different React instance (or an alias mis-resolves),
+ * React's exports can be null in that module graph.
+ * When rendering AppErrorBoundary fallback; useEffect inside it gets called with a "React" export that's null, yielding "Cannot read properties of null (reading 'useEffect')".
+ */
+export declare function onError(error: unknown): void;
+export declare function AppErrorBoundary(): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=AppErrorBoundary.d.ts.map

package/dist/runtime/core/AppErrorBoundary.js

@@ -0,0 +1,27 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * NOTE: Preferable over using a useEffect in App Error Boundary, it sometimes results in errors
+ *
+ * When a component using hooks is rendered under a different React instance (or an alias mis-resolves),
+ * React's exports can be null in that module graph.
+ * When rendering AppErrorBoundary fallback; useEffect inside it gets called with a "React" export that's null, yielding "Cannot read properties of null (reading 'useEffect')".
+ */
+export function onError(error) {
+    let heading = 'Something went wrong!';
+    let message = 'An unexpected error occurred.';
+    if (error instanceof Error) {
+        message = error.message;
+    }
+    window.parent.postMessage({
+        type: 'app/error',
+        payload: {
+            heading,
+            message,
+            stack: error instanceof Error ? error.stack : undefined,
+        },
+    }, '*');
+}
+// This component now receives props from react-error-boundary and serves as the fallback UI.
+export function AppErrorBoundary() {
+    return (_jsx("div", { role: "alert", style: { padding: '20px' } }));
+}

package/dist/runtime/core/ViteLifecycles.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+export declare function ViteLifecycles({ children }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=ViteLifecycles.d.ts.map

package/dist/runtime/core/ViteLifecycles.js

@@ -0,0 +1,35 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { useEffect } from 'react';
+// Dev-only provider to forward Vite HMR lifecycle events to the parent window
+export function ViteLifecycles({ children }) {
+    useEffect(() => {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore - Vite injects `import.meta.hot` in dev
+        const hot = import.meta?.hot;
+        if (!hot) {
+            return;
+        }
+        const beforeUpdate = (payload) => {
+            window.parent.postMessage({ type: 'hmr/beforeUpdate', payload: { ts: Date.now(), payload } }, '*');
+        };
+        const afterUpdate = () => {
+            window.parent.postMessage({ type: 'hmr/afterUpdate', payload: { ts: Date.now() } }, '*');
+        };
+        // Vite names the module that forced the reload (`path`/`triggeredBy`).
+        // Forward it: a full reload costs seconds and resets client state, and
+        // without the culprit there is no way to tell an unavoidable reload from
+        // one our own plugins caused by regenerating a module nobody can accept.
+        const beforeFullReload = (payload) => {
+            window.parent.postMessage({ type: 'hmr/beforeFullReload', payload: { ts: Date.now(), payload } }, '*');
+        };
+        const onError = (err) => {
+            window.parent.postMessage({ type: 'hmr/error', payload: { ts: Date.now(), err } }, '*');
+        };
+        hot.on('vite:beforeUpdate', beforeUpdate);
+        hot.on('vite:afterUpdate', afterUpdate);
+        hot.on('vite:beforeFullReload', beforeFullReload);
+        hot.on('vite:error', onError);
+        // No cleanup API for Vite HMR event bus; listeners are ephemeral in dev
+    }, []);
+    return _jsx(_Fragment, { children: children });
+}

package/dist/runtime/i18n-context.d.ts

@@ -0,0 +1,9 @@
+import type { FimoLocaleResolution } from 'fimo/config';
+import React from 'react';
+export type FimoLocaleContextValue = Pick<FimoLocaleResolution, 'locale' | 'defaultLocale' | 'locales' | 'routePath' | 'pathname' | 'dir'>;
+export declare function FimoLocaleProvider({ value, children }: {
+    value: FimoLocaleContextValue;
+    children?: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useLocale(): FimoLocaleContextValue;
+//# sourceMappingURL=i18n-context.d.ts.map

package/dist/runtime/i18n-context.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from 'react';
+const fallbackLocale = {
+    locale: 'en',
+    defaultLocale: 'en',
+    locales: ['en'],
+    pathname: '/',
+    routePath: '/',
+    dir: 'ltr',
+};
+const FimoLocaleContext = createContext(fallbackLocale);
+export function FimoLocaleProvider({ value, children }) {
+    return _jsx(FimoLocaleContext.Provider, { value: value, children: children });
+}
+export function useLocale() {
+    return useContext(FimoLocaleContext);
+}

package/dist/runtime/iframe/ConsoleErrorProvider.d.ts

@@ -0,0 +1,3 @@
+import type { FC, PropsWithChildren } from 'react';
+export declare const ConsoleErrorProvider: FC<PropsWithChildren>;
+//# sourceMappingURL=ConsoleErrorProvider.d.ts.map

package/dist/runtime/iframe/ConsoleErrorProvider.js

@@ -0,0 +1,103 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { useEffect } from 'react';
+function toMessage(args) {
+    try {
+        if (!args || args.length === 0) {
+            return '';
+        }
+        const first = args[0];
+        if (first instanceof Error) {
+            return first.message || String(first);
+        }
+        if (typeof first === 'string') {
+            return first;
+        }
+        return String(first);
+    }
+    catch {
+        return '';
+    }
+}
+function toStack(args) {
+    try {
+        const errArg = args.find((a) => a instanceof Error);
+        if (errArg && errArg.stack) {
+            return errArg.stack;
+        }
+        try {
+            throw new Error(toMessage(args));
+        }
+        catch (e) {
+            return e?.stack || '';
+        }
+    }
+    catch {
+        return '';
+    }
+}
+function firstAppFrame(stack) {
+    try {
+        const origin = window.location.origin;
+        const lines = (stack || '').split('\n');
+        for (const raw of lines) {
+            const line = raw.trim();
+            if (!line) {
+                continue;
+            }
+            const isApp = line.includes(origin) && !/\/node_modules\//.test(line) && !/\/@/.test(line) && !/vite/i.test(line);
+            if (isApp) {
+                return line;
+            }
+        }
+        return '';
+    }
+    catch {
+        return '';
+    }
+}
+function hashString(input) {
+    let h = 2166136261;
+    for (let i = 0; i < input.length; i++) {
+        h ^= input.charCodeAt(i);
+        h += (h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24);
+    }
+    return (h >>> 0).toString(16);
+}
+export const ConsoleErrorProvider = ({ children }) => {
+    useEffect(() => {
+        const original = console.error.bind(console);
+        const counts = new Map();
+        console.error = (...args) => {
+            try {
+                original(...args);
+                const message = toMessage(args);
+                const stack = toStack(args);
+                const top = firstAppFrame(stack);
+                if (!top) {
+                    return;
+                }
+                const hash = hashString(`${message}|${top}`);
+                const next = (counts.get(hash) || 0) + 1;
+                counts.set(hash, next);
+                window.parent.postMessage({
+                    type: 'app/console/error',
+                    payload: {
+                        heading: 'Error',
+                        message,
+                        stack,
+                        hash,
+                        count: next,
+                    },
+                }, '*');
+            }
+            catch { }
+        };
+        return () => {
+            try {
+                console.error = original;
+            }
+            catch { }
+        };
+    }, []);
+    return _jsx(_Fragment, { children: children });
+};