fimo-react 0.21.0-experimental.1

package/README.md

@@ -0,0 +1,21 @@
+# fimo-react
+
+The React runtime for Fimo projects. Install it alongside `fimo` at the same
+version:
+
+```bash
+npm install fimo fimo-react
+```
+
+`fimo-react` owns the React content clients, `useLabels` / `<Label>`, and the
+source-tracked editable primitives. It has no Vite or React Router peer, so a
+Next.js project can build on it directly; its `fimo-react/primitives/server`
+subpath is the hook-free surface server adapters use.
+
+The rest of a React project's Fimo wiring lives next door:
+
+- `fimo-vite` — the framework-neutral Vite plugin (config virtual module,
+  labels, `data-fimo-id`, dev overlay, sitemap/robots/SEO emitters).
+- `fimo-react-router` — `FimoProviders`, `FimoScripts`, `FimoLink`, route
+  `meta` helpers, `fimoRoutes()`, `fimoPreset()`, and the React Router build
+  integration.

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

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

package/dist/runtime/content/DataSourcesProvider.js

@@ -0,0 +1,63 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { useCallback, useEffect } from 'react';
+import { retrieveVisibleDataSources } from './retrieve-data-sources.js';
+const VISIBLE_TRANSLATIONS_SELECTORS = 'h1, h2, h3, nav a, button';
+const MAX_VISIBLE_TRANSLATIONS_ITEMS = 20;
+const MAX_TEXT_LENGTH = 60;
+function isInViewport(el) {
+    const rect = el.getBoundingClientRect();
+    return (rect.bottom > 0 &&
+        rect.top < window.innerHeight &&
+        rect.right > 0 &&
+        rect.left < window.innerWidth &&
+        rect.width > 0 &&
+        rect.height > 0);
+}
+function extractVisibleTranslations() {
+    const elements = document.querySelectorAll(VISIBLE_TRANSLATIONS_SELECTORS);
+    const seen = new Set();
+    const items = [];
+    for (const el of elements) {
+        if (items.length >= MAX_VISIBLE_TRANSLATIONS_ITEMS)
+            break;
+        if (!isInViewport(el))
+            continue;
+        const raw = el.textContent?.trim();
+        if (!raw)
+            continue;
+        // Deduplicate (e.g. nav repeated in header + footer)
+        const key = `${el.tagName.toLowerCase()}:${raw}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        const text = raw.length > MAX_TEXT_LENGTH ? raw.slice(0, MAX_TEXT_LENGTH) + '…' : raw;
+        items.push({ tag: el.tagName.toLowerCase(), text });
+    }
+    return items;
+}
+export function DataSourcesProvider({ children }) {
+    const sendDataSources = useCallback(() => {
+        const dataSources = retrieveVisibleDataSources();
+        window.parent.postMessage({ type: 'content/send-visible', payload: { dataSources } }, '*');
+    }, []);
+    const sendVisibleTranslations = useCallback(() => {
+        const visibleTranslations = extractVisibleTranslations();
+        window.parent.postMessage({ type: 'content/send-visible-translations', payload: { visibleTranslations } }, '*');
+    }, []);
+    // Handle data requests from parent
+    useEffect(() => {
+        const handleMessage = (event) => {
+            if (event.data?.type === 'content/read-visible') {
+                sendDataSources();
+            }
+            if (event.data?.type === 'content/read-visible-translations') {
+                sendVisibleTranslations();
+            }
+        };
+        window.addEventListener('message', handleMessage);
+        return () => {
+            window.removeEventListener('message', handleMessage);
+        };
+    }, [sendDataSources, sendVisibleTranslations]);
+    return _jsx(_Fragment, { children: children });
+}

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

@@ -0,0 +1,19 @@
+import type { FC, PropsWithChildren } from 'react';
+interface ContentRefreshPayload {
+    changes?: Array<{
+        contentType?: string;
+        documentId?: string;
+        id?: string;
+        locale?: string;
+    }>;
+    contentType?: string;
+    documentId?: string;
+    id?: string;
+    locale?: string;
+}
+export declare function normalizeContentQueryRoot(contentType: string): string;
+export declare function getContentRefreshPayload(data: unknown): ContentRefreshPayload | null;
+export declare function shouldInvalidateContentQuery(queryKey: readonly unknown[], payload: ContentRefreshPayload | null): boolean;
+export declare const RefreshContentProvider: FC<PropsWithChildren>;
+export {};
+//# sourceMappingURL=RefreshContentProvider.d.ts.map

package/dist/runtime/content/RefreshContentProvider.js

@@ -0,0 +1,71 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { useQueryClient } from '@tanstack/react-query';
+import { useEffect } from 'react';
+export function normalizeContentQueryRoot(contentType) {
+    return contentType
+        .split(/[^a-zA-Z0-9]+/)
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join('');
+}
+export function getContentRefreshPayload(data) {
+    if (!data || typeof data !== 'object') {
+        return null;
+    }
+    const payload = data.payload ?? data;
+    if (!payload || typeof payload !== 'object') {
+        return null;
+    }
+    return payload;
+}
+function getContentTypes(payload) {
+    if (!payload) {
+        return [];
+    }
+    const contentTypes = new Set();
+    if (payload.contentType) {
+        contentTypes.add(payload.contentType);
+    }
+    for (const change of payload.changes ?? []) {
+        if (change.contentType) {
+            contentTypes.add(change.contentType);
+        }
+    }
+    return [...contentTypes];
+}
+export function shouldInvalidateContentQuery(queryKey, payload) {
+    const contentTypes = getContentTypes(payload);
+    if (contentTypes.length === 0) {
+        return true;
+    }
+    const queryRoots = new Set(contentTypes.flatMap((contentType) => [contentType, normalizeContentQueryRoot(contentType)]));
+    return queryRoots.has(String(queryKey[0]));
+}
+export const RefreshContentProvider = ({ children }) => {
+    const queryClient = useQueryClient();
+    useEffect(() => {
+        const invalidateContent = (payload) => {
+            void queryClient.invalidateQueries({
+                predicate(query) {
+                    return shouldInvalidateContentQuery(query.queryKey, payload);
+                },
+            });
+        };
+        const onMessage = (e) => {
+            if (e.data?.type === 'content/refresh') {
+                invalidateContent(getContentRefreshPayload(e.data));
+            }
+        };
+        const hot = import.meta.hot;
+        const onContentUpdated = (payload) => {
+            invalidateContent(getContentRefreshPayload(payload));
+        };
+        window.addEventListener('message', onMessage);
+        hot?.on('fimo:content-updated', onContentUpdated);
+        return () => {
+            window.removeEventListener('message', onMessage);
+            hot?.off('fimo:content-updated', onContentUpdated);
+        };
+    }, [queryClient]);
+    return _jsx(_Fragment, { children: children });
+};

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

@@ -0,0 +1,7 @@
+import { SOURCE_TRACKED_QUERY_OPTIONS } from './react-content-client.js';
+import type { ContentClientConfig, CollectionContentClient } from './types.js';
+export { SOURCE_TRACKED_QUERY_OPTIONS };
+export declare function createContentClient<T extends {
+    id: string;
+}, TInput extends object>(config: ContentClientConfig): CollectionContentClient<T, TInput>;
+//# sourceMappingURL=createContentClient.d.ts.map

package/dist/runtime/content/createContentClient.js

@@ -0,0 +1,7 @@
+import { createReactContentClient, SOURCE_TRACKED_QUERY_OPTIONS } from './react-content-client.js';
+import { useQueryLocale } from './useQueryLocale.js';
+import { viteContentRuntime } from './vite-runtime.js';
+export { SOURCE_TRACKED_QUERY_OPTIONS };
+export function createContentClient(config) {
+    return createReactContentClient(config, viteContentRuntime, (requested, fallback) => useQueryLocale(requested, fallback));
+}

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

@@ -0,0 +1,5 @@
+import type { ContentClientConfig, SingletonContentClient } from './types.js';
+export declare function createSingletonClient<T extends {
+    id: string;
+}, TInput extends object>(config: ContentClientConfig): SingletonContentClient<T, TInput>;
+//# sourceMappingURL=createSingletonClient.d.ts.map

package/dist/runtime/content/createSingletonClient.js

@@ -0,0 +1,6 @@
+import { createReactSingletonClient } from './react-singleton-client.js';
+import { useQueryLocale } from './useQueryLocale.js';
+import { viteContentRuntime } from './vite-runtime.js';
+export function createSingletonClient(config) {
+    return createReactSingletonClient(config, viteContentRuntime, (requested, fallback) => useQueryLocale(requested, fallback));
+}

package/dist/runtime/content/fixtures/Author.d.ts

@@ -0,0 +1,48 @@
+import type { CollectionContentClient } from '../types.js';
+import type { Author, AuthorFields, AuthorInput, AuthorPopulate, AuthorQuery } from './Author.types.js';
+import * as Post from './Post.js';
+export type { Author, AuthorFields, AuthorFimoMeta, AuthorInput, AuthorPopulate, AuthorQuery, AuthorReferences, AuthorResult, AuthorSort, AuthorWhere, } from './Author.types.js';
+export type { CollectionPage, CollectionPageInfo, InfiniteListResult } from '../types.js';
+export type InfiniteListQuery<TFields extends AuthorFields | undefined = undefined, TPopulate extends AuthorPopulate | undefined = undefined> = Omit<AuthorQuery<TFields, TPopulate>, 'offset'>;
+declare const client: CollectionContentClient<Author, AuthorInput>;
+export declare const getById: <TPopulate extends import("fimo/content").Populate<Author> | undefined = undefined>(id: string, options?: import("fimo/content").ContentReadOptions<TPopulate> | undefined) => Promise<import("fimo/content").PopulatedResult<Author, TPopulate> & {
+    id: string;
+}>, getBySlug: <TPopulate extends import("fimo/content").Populate<Author> | undefined = undefined>(slug: string, options?: import("fimo/content").ContentReadOptions<TPopulate> | undefined) => Promise<(import("fimo/content").PopulatedResult<Author, TPopulate> & {
+    id: string;
+}) | null>, getByField: <TPopulate extends import("fimo/content").Populate<Author> | undefined = undefined>(fieldName: string, value: string, options?: import("fimo/content").ContentReadOptions<TPopulate> | undefined) => Promise<(import("fimo/content").PopulatedResult<Author, TPopulate> & {
+    id: string;
+}) | null>, list: <TFields extends import("fimo/content").Fields<Author> | undefined = undefined, TPopulate extends import("fimo/content").Populate<Author> | undefined = undefined>(params?: import("fimo/content").Query<Author, TFields, TPopulate> | undefined) => Promise<Post.CollectionPage<import("fimo/content").ProjectedWithPopulate<import("fimo/content").PopulatedResult<Author, TPopulate> & {
+    id: string;
+}, TFields, TPopulate>>>, get: <TFields extends import("fimo/content").Fields<Author> | undefined = undefined, TPopulate extends import("fimo/content").Populate<Author> | undefined = undefined>(params?: import("fimo/content").Query<Author, TFields, TPopulate> | undefined) => Promise<import("fimo/content").ProjectedWithPopulate<import("fimo/content").PopulatedResult<Author, TPopulate> & {
+    id: string;
+}, TFields, TPopulate>[]>, create: (payload: AuthorInput) => Promise<Author>, update: (id: string, payload: Partial<AuthorInput>) => Promise<Author>, remove: (id: string, options?: {
+    locale?: string;
+}) => Promise<void>, useGetById: <TPopulate extends import("fimo/content").Populate<Author> | undefined = undefined>(id: string, options?: import("fimo/content").ContentReadOptions<TPopulate> | undefined) => import("@tanstack/react-query").UseQueryResult<import("fimo/content").PopulatedResult<Author, TPopulate> & {
+    id: string;
+}, Error>, useGetBySlug: <TPopulate extends import("fimo/content").Populate<Author> | undefined = undefined>(slug: string, options?: import("fimo/content").ContentReadOptions<TPopulate> | undefined) => import("@tanstack/react-query").UseQueryResult<(import("fimo/content").PopulatedResult<Author, TPopulate> & {
+    id: string;
+}) | null, Error>, useGetByField: <TPopulate extends import("fimo/content").Populate<Author> | undefined = undefined>(fieldName: string, value: string, options?: import("fimo/content").ContentReadOptions<TPopulate> | undefined) => import("@tanstack/react-query").UseQueryResult<(import("fimo/content").PopulatedResult<Author, TPopulate> & {
+    id: string;
+}) | null, Error>, useList: <TFields extends import("fimo/content").Fields<Author> | undefined = undefined, TPopulate extends import("fimo/content").Populate<Author> | undefined = undefined>(params?: import("fimo/content").Query<Author, TFields, TPopulate> | undefined) => import("@tanstack/react-query").UseQueryResult<Post.CollectionPage<import("fimo/content").ProjectedWithPopulate<import("fimo/content").PopulatedResult<Author, TPopulate> & {
+    id: string;
+}, TFields, TPopulate>>, Error>, useInfiniteList: <TFields extends import("fimo/content").Fields<Author> | undefined = undefined, TPopulate extends import("fimo/content").Populate<Author> | undefined = undefined>(params?: Omit<import("fimo/content").Query<Author, TFields, TPopulate>, "offset"> | undefined) => Post.InfiniteListResult<import("fimo/content").ProjectedWithPopulate<import("fimo/content").PopulatedResult<Author, TPopulate> & {
+    id: string;
+}, TFields, TPopulate>>, useGet: <TFields extends import("fimo/content").Fields<Author> | undefined = undefined, TPopulate extends import("fimo/content").Populate<Author> | undefined = undefined>(params?: import("fimo/content").Query<Author, TFields, TPopulate> | undefined) => import("@tanstack/react-query").UseQueryResult<import("fimo/content").ProjectedWithPopulate<import("fimo/content").PopulatedResult<Author, TPopulate> & {
+    id: string;
+}, TFields, TPopulate>[], Error>, useSuspenseGetById: <TPopulate extends import("fimo/content").Populate<Author> | undefined = undefined>(id: string, options?: import("fimo/content").ContentReadOptions<TPopulate> | undefined) => import("@tanstack/react-query").UseSuspenseQueryResult<import("fimo/content").PopulatedResult<Author, TPopulate> & {
+    id: string;
+}, Error>, useSuspenseGet: <TFields extends import("fimo/content").Fields<Author> | undefined = undefined, TPopulate extends import("fimo/content").Populate<Author> | undefined = undefined>(params?: import("fimo/content").Query<Author, TFields, TPopulate> | undefined) => import("@tanstack/react-query").UseSuspenseQueryResult<import("fimo/content").ProjectedWithPopulate<import("fimo/content").PopulatedResult<Author, TPopulate> & {
+    id: string;
+}, TFields, TPopulate>[], Error>, useSuspenseGetByField: <TPopulate extends import("fimo/content").Populate<Author> | undefined = undefined>(fieldName: string, value: string, options?: import("fimo/content").ContentReadOptions<TPopulate> | undefined) => import("@tanstack/react-query").UseSuspenseQueryResult<(import("fimo/content").PopulatedResult<Author, TPopulate> & {
+    id: string;
+}) | null, Error>, useSuspenseGetBySlug: <TPopulate extends import("fimo/content").Populate<Author> | undefined = undefined>(slug: string, options?: import("fimo/content").ContentReadOptions<TPopulate> | undefined) => import("@tanstack/react-query").UseSuspenseQueryResult<(import("fimo/content").PopulatedResult<Author, TPopulate> & {
+    id: string;
+}) | null, Error>, useCreate: () => import("@tanstack/react-query").UseMutationResult<Author, Error, AuthorInput>, useUpdate: () => import("@tanstack/react-query").UseMutationResult<Author, Error, {
+    id: string;
+    locale?: string;
+} & Partial<AuthorInput>>, useRemove: () => import("@tanstack/react-query").UseMutationResult<void, Error, string | {
+    id: string;
+    locale?: string;
+}>;
+export default client;
+//# sourceMappingURL=Author.d.ts.map

package/dist/runtime/content/fixtures/Author.js

@@ -0,0 +1,22 @@
+// Hand-written draft of the future thin generated module — see Post.ts for
+// the provenance banner and the cycle-safety contract this pair exercises.
+import { createContentClient } from '../createContentClient.js';
+import * as Post from './Post.js';
+const schema = {
+    uid: 'Author',
+    name: 'Author',
+    isSingleton: false,
+    i18n: { enabled: true },
+    fields: {
+        name: { type: 'string', required: true },
+        bio: { type: 'richtext' },
+        avatar: { type: 'media' },
+        posts: { type: 'reference', target: 'Post', many: true },
+    },
+};
+const client = createContentClient({
+    schema,
+    references: { Post },
+});
+export const { getById, getBySlug, getByField, list, get, create, update, remove, useGetById, useGetBySlug, useGetByField, useList, useInfiniteList, useGet, useSuspenseGetById, useSuspenseGet, useSuspenseGetByField, useSuspenseGetBySlug, useCreate, useUpdate, useRemove, } = client;
+export default client;

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

@@ -0,0 +1,38 @@
+import type { Fields, FimoMedia, FimoReference, FimoRichText, FimoRichTextContent, FimoString, Populate, PopulatedResult, ProjectedWithPopulate, Query, Sort, Where, WithReferences } from 'fimo/primitives';
+import type { Post } from './Post.types.js';
+export interface AuthorFimoMeta {
+    contentType: string;
+}
+export interface Author extends WithReferences<AuthorReferences> {
+    id: string;
+    entryId: string;
+    documentId: string;
+    slug: FimoString;
+    locale: string;
+    createdAt: string;
+    updatedAt: string;
+    __fimo: AuthorFimoMeta;
+    name: FimoString;
+    bio?: FimoRichText | null;
+    avatar: FimoMedia;
+    posts: FimoReference[];
+}
+export interface AuthorInput {
+    slug?: string;
+    locale?: string;
+    documentId?: string;
+    name: string;
+    bio?: FimoRichTextContent | null;
+    avatar?: Pick<FimoMedia, 'url' | 'alt' | 'name' | 'mime' | 'width' | 'height'>;
+    posts?: FimoReference[];
+}
+export interface AuthorReferences {
+    posts: Post[];
+}
+export type AuthorPopulate = Populate<Author>;
+export type AuthorWhere = Where<Author>;
+export type AuthorSort = Sort<Author>;
+export type AuthorFields = Fields<Author>;
+export type AuthorQuery<TFields extends AuthorFields | undefined = AuthorFields | undefined, TPopulate extends AuthorPopulate | undefined = AuthorPopulate | undefined> = Query<Author, TFields, TPopulate>;
+export type AuthorResult<TFields extends AuthorFields | undefined = undefined, TPopulate extends AuthorPopulate | undefined = undefined> = ProjectedWithPopulate<PopulatedResult<Author, TPopulate>, TFields, TPopulate>;
+//# sourceMappingURL=Author.types.d.ts.map

package/dist/runtime/content/fixtures/Author.types.js

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

package/dist/runtime/content/fixtures/Post.d.ts

@@ -0,0 +1,48 @@
+import type { CollectionContentClient } from '../types.js';
+import * as Author from './Author.js';
+import type { Post, PostFields, PostInput, PostPopulate, PostQuery } from './Post.types.js';
+export type { Post, PostFields, PostFimoMeta, PostInput, PostPopulate, PostQuery, PostReferences, PostResult, PostSort, PostWhere, } from './Post.types.js';
+export type { CollectionPage, CollectionPageInfo, InfiniteListResult } from '../types.js';
+export type InfiniteListQuery<TFields extends PostFields | undefined = undefined, TPopulate extends PostPopulate | undefined = undefined> = Omit<PostQuery<TFields, TPopulate>, 'offset'>;
+declare const client: CollectionContentClient<Post, PostInput>;
+export declare const getById: <TPopulate extends import("fimo/content").Populate<Post> | undefined = undefined>(id: string, options?: import("fimo/content").ContentReadOptions<TPopulate> | undefined) => Promise<import("fimo/content").PopulatedResult<Post, TPopulate> & {
+    id: string;
+}>, getBySlug: <TPopulate extends import("fimo/content").Populate<Post> | undefined = undefined>(slug: string, options?: import("fimo/content").ContentReadOptions<TPopulate> | undefined) => Promise<(import("fimo/content").PopulatedResult<Post, TPopulate> & {
+    id: string;
+}) | null>, getByField: <TPopulate extends import("fimo/content").Populate<Post> | undefined = undefined>(fieldName: string, value: string, options?: import("fimo/content").ContentReadOptions<TPopulate> | undefined) => Promise<(import("fimo/content").PopulatedResult<Post, TPopulate> & {
+    id: string;
+}) | null>, list: <TFields extends import("fimo/content").Fields<Post> | undefined = undefined, TPopulate extends import("fimo/content").Populate<Post> | undefined = undefined>(params?: import("fimo/content").Query<Post, TFields, TPopulate> | undefined) => Promise<Author.CollectionPage<import("fimo/content").ProjectedWithPopulate<import("fimo/content").PopulatedResult<Post, TPopulate> & {
+    id: string;
+}, TFields, TPopulate>>>, get: <TFields extends import("fimo/content").Fields<Post> | undefined = undefined, TPopulate extends import("fimo/content").Populate<Post> | undefined = undefined>(params?: import("fimo/content").Query<Post, TFields, TPopulate> | undefined) => Promise<import("fimo/content").ProjectedWithPopulate<import("fimo/content").PopulatedResult<Post, TPopulate> & {
+    id: string;
+}, TFields, TPopulate>[]>, create: (payload: PostInput) => Promise<Post>, update: (id: string, payload: Partial<PostInput>) => Promise<Post>, remove: (id: string, options?: {
+    locale?: string;
+}) => Promise<void>, useGetById: <TPopulate extends import("fimo/content").Populate<Post> | undefined = undefined>(id: string, options?: import("fimo/content").ContentReadOptions<TPopulate> | undefined) => import("@tanstack/react-query").UseQueryResult<import("fimo/content").PopulatedResult<Post, TPopulate> & {
+    id: string;
+}, Error>, useGetBySlug: <TPopulate extends import("fimo/content").Populate<Post> | undefined = undefined>(slug: string, options?: import("fimo/content").ContentReadOptions<TPopulate> | undefined) => import("@tanstack/react-query").UseQueryResult<(import("fimo/content").PopulatedResult<Post, TPopulate> & {
+    id: string;
+}) | null, Error>, useGetByField: <TPopulate extends import("fimo/content").Populate<Post> | undefined = undefined>(fieldName: string, value: string, options?: import("fimo/content").ContentReadOptions<TPopulate> | undefined) => import("@tanstack/react-query").UseQueryResult<(import("fimo/content").PopulatedResult<Post, TPopulate> & {
+    id: string;
+}) | null, Error>, useList: <TFields extends import("fimo/content").Fields<Post> | undefined = undefined, TPopulate extends import("fimo/content").Populate<Post> | undefined = undefined>(params?: import("fimo/content").Query<Post, TFields, TPopulate> | undefined) => import("@tanstack/react-query").UseQueryResult<Author.CollectionPage<import("fimo/content").ProjectedWithPopulate<import("fimo/content").PopulatedResult<Post, TPopulate> & {
+    id: string;
+}, TFields, TPopulate>>, Error>, useInfiniteList: <TFields extends import("fimo/content").Fields<Post> | undefined = undefined, TPopulate extends import("fimo/content").Populate<Post> | undefined = undefined>(params?: Omit<import("fimo/content").Query<Post, TFields, TPopulate>, "offset"> | undefined) => Author.InfiniteListResult<import("fimo/content").ProjectedWithPopulate<import("fimo/content").PopulatedResult<Post, TPopulate> & {
+    id: string;
+}, TFields, TPopulate>>, useGet: <TFields extends import("fimo/content").Fields<Post> | undefined = undefined, TPopulate extends import("fimo/content").Populate<Post> | undefined = undefined>(params?: import("fimo/content").Query<Post, TFields, TPopulate> | undefined) => import("@tanstack/react-query").UseQueryResult<import("fimo/content").ProjectedWithPopulate<import("fimo/content").PopulatedResult<Post, TPopulate> & {
+    id: string;
+}, TFields, TPopulate>[], Error>, useSuspenseGetById: <TPopulate extends import("fimo/content").Populate<Post> | undefined = undefined>(id: string, options?: import("fimo/content").ContentReadOptions<TPopulate> | undefined) => import("@tanstack/react-query").UseSuspenseQueryResult<import("fimo/content").PopulatedResult<Post, TPopulate> & {
+    id: string;
+}, Error>, useSuspenseGet: <TFields extends import("fimo/content").Fields<Post> | undefined = undefined, TPopulate extends import("fimo/content").Populate<Post> | undefined = undefined>(params?: import("fimo/content").Query<Post, TFields, TPopulate> | undefined) => import("@tanstack/react-query").UseSuspenseQueryResult<import("fimo/content").ProjectedWithPopulate<import("fimo/content").PopulatedResult<Post, TPopulate> & {
+    id: string;
+}, TFields, TPopulate>[], Error>, useSuspenseGetByField: <TPopulate extends import("fimo/content").Populate<Post> | undefined = undefined>(fieldName: string, value: string, options?: import("fimo/content").ContentReadOptions<TPopulate> | undefined) => import("@tanstack/react-query").UseSuspenseQueryResult<(import("fimo/content").PopulatedResult<Post, TPopulate> & {
+    id: string;
+}) | null, Error>, useSuspenseGetBySlug: <TPopulate extends import("fimo/content").Populate<Post> | undefined = undefined>(slug: string, options?: import("fimo/content").ContentReadOptions<TPopulate> | undefined) => import("@tanstack/react-query").UseSuspenseQueryResult<(import("fimo/content").PopulatedResult<Post, TPopulate> & {
+    id: string;
+}) | null, Error>, useCreate: () => import("@tanstack/react-query").UseMutationResult<Post, Error, PostInput>, useUpdate: () => import("@tanstack/react-query").UseMutationResult<Post, Error, {
+    id: string;
+    locale?: string;
+} & Partial<PostInput>>, useRemove: () => import("@tanstack/react-query").UseMutationResult<void, Error, string | {
+    id: string;
+    locale?: string;
+}>;
+export default client;
+//# sourceMappingURL=Post.d.ts.map

package/dist/runtime/content/fixtures/Post.js

@@ -0,0 +1,37 @@
+// Hand-written draft of the future thin generated module. The release-2
+// template stamps this provenance banner on real output:
+//
+//   AUTO-GENERATED by `fimo` from src/schemas/Post.json — DO NOT EDIT.
+//   To change fields, edit the schema and re-run `fimo validate`.
+//   Runtime implementation lives in the fimo-react package.
+//
+// The schema below is inlined here because fixtures live inside the runtime
+// package; generated code imports the real src/schemas/<uid>.json instead.
+// Forms a real ESM cycle with Author.ts — `references` holds namespace
+// imports, and the factory only reads their `default` client at request
+// time, so reciprocal evaluation never touches an uninitialized binding.
+import { createContentClient } from '../createContentClient.js';
+import * as Author from './Author.js';
+const schema = {
+    uid: 'Post',
+    name: 'Post',
+    isSingleton: false,
+    i18n: { enabled: true },
+    fields: {
+        title: { type: 'string', required: true },
+        excerpt: { type: 'text' },
+        body: { type: 'richtext' },
+        cover: { type: 'media' },
+        gallery: { type: 'media', multiple: true },
+        views: { type: 'number' },
+        author: { type: 'reference', target: 'Author' },
+        contributors: { type: 'reference', target: 'Author', many: true },
+        related: { type: 'reference', target: 'Post', many: true },
+    },
+};
+const client = createContentClient({
+    schema,
+    references: { Author },
+});
+export const { getById, getBySlug, getByField, list, get, create, update, remove, useGetById, useGetBySlug, useGetByField, useList, useInfiniteList, useGet, useSuspenseGetById, useSuspenseGet, useSuspenseGetByField, useSuspenseGetBySlug, useCreate, useUpdate, useRemove, } = client;
+export default client;

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

@@ -0,0 +1,50 @@
+import type { Fields, FimoMedia, FimoReference, FimoRichText, FimoRichTextContent, FimoString, Populate, PopulatedResult, ProjectedWithPopulate, Query, Sort, Where, WithReferences } from 'fimo/primitives';
+import type { Author } from './Author.types.js';
+export interface PostFimoMeta {
+    contentType: string;
+}
+export interface Post extends WithReferences<PostReferences> {
+    id: string;
+    entryId: string;
+    documentId: string;
+    slug: FimoString;
+    locale: string;
+    createdAt: string;
+    updatedAt: string;
+    __fimo: PostFimoMeta;
+    title: FimoString;
+    excerpt: FimoString;
+    body?: FimoRichText | null;
+    cover: FimoMedia;
+    gallery: FimoMedia[];
+    views: number;
+    author: FimoReference | null;
+    contributors: FimoReference[];
+    related: FimoReference[];
+}
+export interface PostInput {
+    slug?: string;
+    locale?: string;
+    documentId?: string;
+    title: string;
+    excerpt?: string;
+    body?: FimoRichTextContent | null;
+    cover?: Pick<FimoMedia, 'url' | 'alt' | 'name' | 'mime' | 'width' | 'height'>;
+    gallery?: Pick<FimoMedia, 'url' | 'alt' | 'name' | 'mime' | 'width' | 'height'>[];
+    views?: number;
+    author?: FimoReference | null;
+    contributors?: FimoReference[];
+    related?: FimoReference[];
+}
+export interface PostReferences {
+    author: Author | null;
+    contributors: Author[];
+    related: Post[];
+}
+export type PostPopulate = Populate<Post>;
+export type PostWhere = Where<Post>;
+export type PostSort = Sort<Post>;
+export type PostFields = Fields<Post>;
+export type PostQuery<TFields extends PostFields | undefined = PostFields | undefined, TPopulate extends PostPopulate | undefined = PostPopulate | undefined> = Query<Post, TFields, TPopulate>;
+export type PostResult<TFields extends PostFields | undefined = undefined, TPopulate extends PostPopulate | undefined = undefined> = ProjectedWithPopulate<PopulatedResult<Post, TPopulate>, TFields, TPopulate>;
+//# sourceMappingURL=Post.types.d.ts.map

package/dist/runtime/content/fixtures/Post.types.js

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

package/dist/runtime/content/fixtures/SiteSettings.d.ts

@@ -0,0 +1,42 @@
+import type { Fields, FimoReference, FimoString, Populate, PopulatedResult, ProjectedWithPopulate, Query, Sort, Where, WithReferences } from 'fimo/primitives';
+import type { SingletonContentClient } from '../types.js';
+import type { Author } from './Author.types.js';
+export interface SiteSettingsFimoMeta {
+    contentType: string;
+}
+export interface SiteSettings extends WithReferences<SiteSettingsReferences> {
+    id: string;
+    entryId: string;
+    documentId: string;
+    slug: FimoString;
+    locale?: string;
+    createdAt: string;
+    updatedAt: string;
+    __fimo: SiteSettingsFimoMeta;
+    siteName: FimoString;
+    supportAuthor: FimoReference | null;
+}
+export interface SiteSettingsInput {
+    slug?: string;
+    siteName: string;
+    supportAuthor?: FimoReference | null;
+}
+export interface SiteSettingsReferences {
+    supportAuthor: Author | null;
+}
+export type SiteSettingsPopulate = Populate<SiteSettings>;
+export type SiteSettingsWhere = Where<SiteSettings>;
+export type SiteSettingsSort = Sort<SiteSettings>;
+export type SiteSettingsFields = Fields<SiteSettings>;
+export type SiteSettingsQuery<TFields extends SiteSettingsFields | undefined = SiteSettingsFields | undefined, TPopulate extends SiteSettingsPopulate | undefined = SiteSettingsPopulate | undefined> = Query<SiteSettings, TFields, TPopulate>;
+export type SiteSettingsResult<TFields extends SiteSettingsFields | undefined = undefined, TPopulate extends SiteSettingsPopulate | undefined = undefined> = ProjectedWithPopulate<PopulatedResult<SiteSettings, TPopulate>, TFields, TPopulate>;
+declare const client: SingletonContentClient<SiteSettings, SiteSettingsInput>;
+export declare const get: <TPopulate extends Populate<SiteSettings> | undefined = undefined>(options?: import("fimo/content").ContentReadOptions<TPopulate> | undefined) => Promise<PopulatedResult<SiteSettings, TPopulate> & {
+    id: string;
+}>, update: (payload: Partial<SiteSettingsInput>) => Promise<SiteSettings>, useGet: <TPopulate extends Populate<SiteSettings> | undefined = undefined>(options?: import("fimo/content").ContentReadOptions<TPopulate> | undefined) => import("@tanstack/react-query").UseQueryResult<PopulatedResult<SiteSettings, TPopulate> & {
+    id: string;
+}, Error>, useSuspenseGet: <TPopulate extends Populate<SiteSettings> | undefined = undefined>(options?: import("fimo/content").ContentReadOptions<TPopulate> | undefined) => import("@tanstack/react-query").UseSuspenseQueryResult<PopulatedResult<SiteSettings, TPopulate> & {
+    id: string;
+}, Error>, useUpdate: () => import("@tanstack/react-query").UseMutationResult<SiteSettings, Error, Partial<SiteSettingsInput>>;
+export default client;
+//# sourceMappingURL=SiteSettings.d.ts.map

package/dist/runtime/content/fixtures/SiteSettings.js

@@ -0,0 +1,15 @@
+import { createSingletonClient } from '../createSingletonClient.js';
+import * as AuthorModule from './Author.js';
+const schema = {
+    uid: 'SiteSettings',
+    name: 'SiteSettings',
+    isSingleton: true,
+    i18n: { enabled: false },
+    fields: {
+        siteName: { type: 'string', required: true },
+        supportAuthor: { type: 'reference', target: 'Author' },
+    },
+};
+const client = createSingletonClient({ schema, references: { Author: AuthorModule } });
+export const { get, update, useGet, useSuspenseGet, useUpdate } = client;
+export default client;

package/dist/runtime/content/fixtures/usage-contract.d.ts

@@ -0,0 +1,3 @@
+export declare function fetchContract(): Promise<void>;
+export declare function useHookContract(): void;
+//# sourceMappingURL=usage-contract.d.ts.map

package/dist/runtime/content/fixtures/usage-contract.js

@@ -0,0 +1,57 @@
+import Post from './Post.js';
+import SiteSettings from './SiteSettings.js';
+export async function fetchContract() {
+    const page = await Post.list({
+        fields: ['title', 'author'],
+        populate: ['author'],
+        limit: 12,
+        offset: 24,
+    });
+    const pagePosts = page.items;
+    const firstAuthorName = pagePosts[0]?.author ? String(pagePosts[0].author.name) : '';
+    const total = page.pageInfo.total;
+    const nextOffset = page.pageInfo.nextOffset;
+    const legacyPosts = await Post.get({ limit: 3 });
+    const populated = await Post.getBySlug('hello', { populate: ['author', 'contributors'] });
+    const contributorNames = populated ? populated.contributors.map((author) => String(author.name)) : [];
+    const settings = await SiteSettings.get({
+        populate: ['supportAuthor'],
+    });
+    const supportAuthor = settings.supportAuthor;
+    void [pagePosts, firstAuthorName, total, nextOffset, legacyPosts, contributorNames, supportAuthor];
+}
+export function useHookContract() {
+    const legacy = Post.useGet({ limit: 3 });
+    const page = Post.useList({
+        fields: ['title', 'author'],
+        populate: ['author'],
+        limit: 12,
+    });
+    const infinite = Post.useInfiniteList({
+        fields: ['title', 'author'],
+        populate: ['author'],
+        limit: 12,
+    });
+    const legacyPosts = legacy.data ?? [];
+    const pagePosts = page.data?.items ?? [];
+    const infinitePosts = infinite.items;
+    const hasMore = infinite.hasMore;
+    const isLoadingMore = infinite.isLoadingMore;
+    void infinite.loadMore();
+    // @ts-expect-error infinite lists own offset progression
+    Post.useInfiniteList({ offset: 12 });
+    const create = Post.useCreate();
+    create.mutate({ title: 'Hello' });
+    // @ts-expect-error create payload must satisfy the generated Input type
+    create.mutate({ title: 123 });
+    const update = Post.useUpdate();
+    update.mutate({ id: 'p1', title: 'Renamed', locale: 'fr' });
+    const removeEntry = Post.useRemove();
+    removeEntry.mutate('p1');
+    removeEntry.mutate({ id: 'p1', locale: 'fr' });
+    const settings = SiteSettings.useGet({ populate: ['supportAuthor'] });
+    const supportAuthor = settings.data?.supportAuthor;
+    // @ts-expect-error singleton clients have no collection reads
+    const missingUseList = SiteSettings.useList;
+    void [legacyPosts, pagePosts, infinitePosts, hasMore, isLoadingMore, supportAuthor, missingUseList];
+}

package/dist/runtime/content/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/runtime/content/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/runtime/content/index.d.ts

@@ -0,0 +1,5 @@
+export { createReactContentClient, SOURCE_TRACKED_QUERY_OPTIONS } from './react-content-client.js';
+export { createReactSingletonClient } from './react-singleton-client.js';
+export type { UseContentLocale } from './react-content-client.js';
+export type { CollectionContentClient, CollectionPage, CollectionPageInfo, ContentClientConfig, ContentClientHandle, ContentModuleMeta, ContentModuleRef, ContentReadOptions, ContentResult, ContentSchema, ContentSchemaField, InfiniteListResult, SingletonContentClient, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/content/index.js

@@ -0,0 +1,2 @@
+export { createReactContentClient, SOURCE_TRACKED_QUERY_OPTIONS } from './react-content-client.js';
+export { createReactSingletonClient } from './react-singleton-client.js';