fimo 0.11.0 → 0.12.0-staging.1

package/dist/runtime/content/client/collection-core.d.ts

@@ -0,0 +1,37 @@
+import type { Fields, Populate, Query } from '../../primitives/lib/query.js';
+import type { ContentRuntime } from './runtime.js';
+import type { CollectionPage, ContentClientConfig, ContentModuleMeta, ContentReadOptions, ContentResult } from './types.js';
+export interface CollectionContentCore<T extends {
+    id: string;
+}, TInput extends object> {
+    readonly meta: ContentModuleMeta;
+    wrapWithSource(entry: Record<string, any>): T;
+    getById<TPopulate extends Populate<T> | undefined = undefined>(id: string, options?: ContentReadOptions<TPopulate>): Promise<ContentResult<T, undefined, TPopulate>>;
+    getBySlug<TPopulate extends Populate<T> | undefined = undefined>(slug: string, options?: ContentReadOptions<TPopulate>): Promise<ContentResult<T, undefined, TPopulate> | null>;
+    getByField<TPopulate extends Populate<T> | undefined = undefined>(fieldName: string, value: string, options?: ContentReadOptions<TPopulate>): Promise<ContentResult<T, undefined, TPopulate> | null>;
+    list<TFields extends Fields<T> | undefined = undefined, TPopulate extends Populate<T> | undefined = undefined>(params?: Query<T, TFields, TPopulate>): Promise<CollectionPage<ContentResult<T, TFields, TPopulate>>>;
+    get<TFields extends Fields<T> | undefined = undefined, TPopulate extends Populate<T> | undefined = undefined>(params?: Query<T, TFields, TPopulate>): Promise<ContentResult<T, TFields, TPopulate>[]>;
+    create(payload: TInput): Promise<T>;
+    update(id: string, payload: Partial<TInput>): Promise<T>;
+    remove(id: string, options?: {
+        locale?: string;
+    }): Promise<void>;
+}
+export interface CollectionCoreState<T extends {
+    id: string;
+}, TInput extends object> {
+    client: CollectionContentCore<T, TInput>;
+    defaultLocale: string;
+    queryKeys: {
+        root: readonly [string];
+        byId(id: string, options?: ContentReadOptions<Populate<T> | undefined>): readonly unknown[];
+        bySlug(slug: string, options?: ContentReadOptions<Populate<T> | undefined>): readonly unknown[];
+        byField(field: string, value: string, options?: ContentReadOptions<Populate<T> | undefined>): readonly unknown[];
+        list(params: Query<T, Fields<T> | undefined, Populate<T> | undefined>): readonly unknown[];
+        infiniteList(params: Omit<Query<T, Fields<T> | undefined, Populate<T> | undefined>, 'offset'>): readonly unknown[];
+    };
+}
+export declare function createCollectionContentCore<T extends {
+    id: string;
+}, TInput extends object>(config: ContentClientConfig, runtime: ContentRuntime): CollectionCoreState<T, TInput>;
+//# sourceMappingURL=collection-core.d.ts.map

package/dist/runtime/content/client/collection-core.js

@@ -0,0 +1,149 @@
+import { parseCollectionResponse } from '../parseCollectionResponse.js';
+import { buildReadPath, interpretSchema, readCollectionLocale, resolveClientHandle, splitWritePayload, validateReferences, withMutationLocale, wrapEntry, } from './internal.js';
+export function createCollectionContentCore(config, runtime) {
+    const references = config.references ?? {};
+    const info = interpretSchema(config.schema);
+    if (info.isSingleton) {
+        throw new Error(`Schema "${info.uid}" is a Single — use createSingletonClient instead.`);
+    }
+    validateReferences(info, references);
+    const defaultLocale = runtime.defaultLocale();
+    const meta = { uid: info.uid, pascal: info.pascal, localized: info.localized };
+    const self = { wrapWithSource, meta };
+    const resolve = (uid) => uid === info.uid ? self : resolveClientHandle(references[uid]);
+    function wrapWithSource(entry) {
+        return wrapEntry(info, entry, { alwaysIncludeLocale: true, defaultLocale, resolve });
+    }
+    function readPath(url, options) {
+        return buildReadPath(url, readCollectionLocale(options, defaultLocale), options.populate, options.localeFallbacks);
+    }
+    async function getById(id, options = {}) {
+        const response = await runtime.fetch(`${runtime.apiBase()}${readPath(`/entries/${info.uid}/${id}`, options)}`, {
+            headers: runtime.headers(),
+        });
+        if (!response.ok) {
+            throw new Error(await response.text());
+        }
+        const body = await response.json();
+        return wrapWithSource(body.data);
+    }
+    async function getBySlug(slug, options = {}) {
+        const response = await runtime.fetch(`${runtime.apiBase()}${readPath(`/entries/${info.uid}/slug/${encodeURIComponent(slug)}`, options)}`, { headers: runtime.headers() });
+        if (response.status === 404) {
+            return null;
+        }
+        if (!response.ok) {
+            throw new Error(await response.text());
+        }
+        const body = await response.json();
+        return wrapWithSource(body.data);
+    }
+    async function getByField(fieldName, value, options = {}) {
+        const response = await runtime.fetch(`${runtime.apiBase()}${readPath(`/entries/${info.uid}/field/${encodeURIComponent(fieldName)}/${encodeURIComponent(value)}`, options)}`, { headers: runtime.headers() });
+        if (response.status === 404) {
+            return null;
+        }
+        if (!response.ok) {
+            throw new Error(await response.text());
+        }
+        const body = await response.json();
+        return wrapWithSource(body.data);
+    }
+    function toQueryString(params) {
+        const { where, sort, fields, populate, locale: requestedLocale, ...flat } = params;
+        const query = new URLSearchParams();
+        for (const [key, value] of Object.entries(flat)) {
+            if (value != null) {
+                query.set(key, String(value));
+            }
+        }
+        if (sort != null) {
+            query.set('sort', Array.isArray(sort) ? sort.join(',') : String(sort));
+        }
+        if (fields != null) {
+            query.set('fields', typeof fields === 'string' ? fields : fields.join(','));
+        }
+        if (populate != null) {
+            query.set('populate', typeof populate === 'string' ? populate : populate.join(','));
+        }
+        if (where && Object.keys(where).length > 0) {
+            query.set('where', JSON.stringify(where));
+        }
+        query.set('locale', readCollectionLocale({ locale: requestedLocale }, defaultLocale));
+        return query.toString();
+    }
+    async function list(params = {}) {
+        const query = toQueryString(params);
+        const response = await runtime.fetch(`${runtime.apiBase()}/entries/${info.uid}${query ? `?${query}` : ''}`, {
+            headers: runtime.headers(),
+        });
+        if (!response.ok) {
+            throw new Error(await response.text());
+        }
+        const body = parseCollectionResponse(await response.json());
+        const items = body.data.map(wrapWithSource);
+        const pageInfo = {
+            limit: body.meta.limit,
+            offset: body.meta.offset,
+            total: body.meta.total,
+            hasMore: body.meta.hasMore,
+            nextOffset: body.meta.hasMore ? body.meta.offset + body.meta.limit : null,
+        };
+        return { items, pageInfo };
+    }
+    async function get(params = {}) {
+        return (await list(params)).items;
+    }
+    async function create(payload) {
+        const localizedPayload = info.localized
+            ? withMutationLocale(payload, readCollectionLocale({}, defaultLocale))
+            : payload;
+        const response = await runtime.fetch(`${runtime.apiBase()}/entries/${info.uid}`, {
+            method: 'POST',
+            headers: runtime.headers({ 'Content-Type': 'application/json' }),
+            body: JSON.stringify(splitWritePayload(localizedPayload)),
+        });
+        if (!response.ok) {
+            throw new Error(await response.text());
+        }
+        const body = await response.json();
+        return wrapWithSource(body.data);
+    }
+    async function update(id, payload) {
+        const write = splitWritePayload(payload);
+        const url = buildReadPath(`/entries/${info.uid}/${id}`, readCollectionLocale({ locale: write.locale }, defaultLocale), undefined);
+        const response = await runtime.fetch(`${runtime.apiBase()}${url}`, {
+            method: 'PUT',
+            headers: runtime.headers({ 'Content-Type': 'application/json' }),
+            body: JSON.stringify({ data: write.data }),
+        });
+        if (!response.ok) {
+            throw new Error(await response.text());
+        }
+        const body = await response.json();
+        return wrapWithSource(body.data);
+    }
+    async function remove(id, options = {}) {
+        const url = buildReadPath(`/entries/${info.uid}/${id}`, readCollectionLocale(options, defaultLocale), undefined);
+        const response = await runtime.fetch(`${runtime.apiBase()}${url}`, {
+            method: 'DELETE',
+            headers: runtime.headers(),
+        });
+        if (!response.ok) {
+            throw new Error(await response.text());
+        }
+    }
+    const queryKeys = {
+        root: [info.pascal],
+        byId: (id, options = {}) => [info.pascal, 'id', id, options.locale, options.populate],
+        bySlug: (slug, options = {}) => [info.pascal, 'slug', slug, options.locale, options.populate],
+        byField: (field, value, options = {}) => [info.pascal, field, value, options.locale, options.populate],
+        list: (params) => [info.pascal, params],
+        infiniteList: (params) => [info.pascal, 'infinite', params],
+    };
+    return {
+        client: { meta, wrapWithSource, getById, getBySlug, getByField, list, get, create, update, remove },
+        defaultLocale,
+        queryKeys,
+    };
+}

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

@@ -1,19 +1,6 @@
-import type { CollectionContentClient, ContentClientConfig } from './types.js';
-/**
- * React Query's structural sharing (`replaceEqualDeep`) rebuilds plain objects
- * and arrays key-by-key from `Object.keys`, which silently drops the
- * non-enumerable, symbol-keyed source tag `wrapField` puts on `json` values.
- * A `json` field would then lose its `data-fimo-source` on the first refetch
- * that changes it, making it unselectable in every editing surface. Every other
- * wrapped type is a class instance, which structural sharing returns untouched.
- *
- * Turning it off costs nothing here: `wrapEntry` allocates fresh wrappers on
- * every fetch, so a wrapped entry never compared equal to its predecessor and
- * sharing was already returning the new object.
- */
-export declare const SOURCE_TRACKED_QUERY_OPTIONS: {
-    readonly structuralSharing: false;
-};
+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>;

package/dist/runtime/content/client/createContentClient.js

@@ -1,324 +1,7 @@
-import { useInfiniteQuery, useMutation, useQuery, useQueryClient, useSuspenseQuery } from '@tanstack/react-query';
-import { parseCollectionResponse } from '../parseCollectionResponse.js';
-import { apiBase, buildReadPath, fimoHeaders, interpretSchema, readCollectionLocale, resolveClientHandle, splitWritePayload, validateReferences, withMutationLocale, wrapEntry, } from './internal.js';
+import { createReactContentClient, SOURCE_TRACKED_QUERY_OPTIONS } from './react-content-client.js';
 import { useQueryLocale } from './useQueryLocale.js';
-/**
- * React Query's structural sharing (`replaceEqualDeep`) rebuilds plain objects
- * and arrays key-by-key from `Object.keys`, which silently drops the
- * non-enumerable, symbol-keyed source tag `wrapField` puts on `json` values.
- * A `json` field would then lose its `data-fimo-source` on the first refetch
- * that changes it, making it unselectable in every editing surface. Every other
- * wrapped type is a class instance, which structural sharing returns untouched.
- *
- * Turning it off costs nothing here: `wrapEntry` allocates fresh wrappers on
- * every fetch, so a wrapped entry never compared equal to its predecessor and
- * sharing was already returning the new object.
- */
-export const SOURCE_TRACKED_QUERY_OPTIONS = { structuralSharing: false };
+import { viteContentRuntime } from './vite-runtime.js';
+export { SOURCE_TRACKED_QUERY_OPTIONS };
 export function createContentClient(config) {
-    const references = config.references ?? {};
-    const info = interpretSchema(config.schema);
-    if (info.isSingleton) {
-        throw new Error(`Schema "${info.uid}" is a Single — use createSingletonClient instead.`);
-    }
-    validateReferences(info, references);
-    const meta = { uid: info.uid, pascal: info.pascal, localized: info.localized };
-    const self = { wrapWithSource, meta };
-    const resolve = (uid) => uid === info.uid ? self : resolveClientHandle(references[uid]);
-    function wrapWithSource(entry) {
-        return wrapEntry(info, entry, { alwaysIncludeLocale: true, resolve });
-    }
-    function readPath(url, options) {
-        return buildReadPath(url, readCollectionLocale(options), options.populate, options.localeFallbacks);
-    }
-    async function getById(id, options = {}) {
-        const res = await fetch(`${apiBase()}${readPath(`/entries/${info.uid}/${id}`, options)}`, {
-            headers: fimoHeaders(),
-        });
-        if (!res.ok) {
-            throw new Error(await res.text());
-        }
-        const data = await res.json();
-        return wrapWithSource(data.data);
-    }
-    async function getBySlug(slug, options = {}) {
-        const res = await fetch(`${apiBase()}${readPath(`/entries/${info.uid}/slug/${encodeURIComponent(slug)}`, options)}`, { headers: fimoHeaders() });
-        if (res.status === 404) {
-            return null;
-        }
-        if (!res.ok) {
-            throw new Error(await res.text());
-        }
-        const data = await res.json();
-        return wrapWithSource(data.data);
-    }
-    async function getByField(fieldName, value, options = {}) {
-        const res = await fetch(`${apiBase()}${readPath(`/entries/${info.uid}/field/${encodeURIComponent(fieldName)}/${encodeURIComponent(value)}`, options)}`, { headers: fimoHeaders() });
-        if (res.status === 404) {
-            return null;
-        }
-        if (!res.ok) {
-            throw new Error(await res.text());
-        }
-        const data = await res.json();
-        return wrapWithSource(data.data);
-    }
-    function toQueryString(params) {
-        const { where, sort, fields, populate, locale: requestedLocale, ...flat } = params;
-        const query = new URLSearchParams();
-        for (const [key, value] of Object.entries(flat)) {
-            if (value == null) {
-                continue;
-            }
-            query.set(key, String(value));
-        }
-        if (sort != null) {
-            query.set('sort', Array.isArray(sort) ? sort.join(',') : String(sort));
-        }
-        if (fields != null) {
-            query.set('fields', typeof fields === 'string' ? fields : fields.join(','));
-        }
-        if (populate != null) {
-            query.set('populate', typeof populate === 'string' ? populate : populate.join(','));
-        }
-        if (where && Object.keys(where).length > 0) {
-            query.set('where', JSON.stringify(where));
-        }
-        const locale = readCollectionLocale({ locale: requestedLocale });
-        if (locale) {
-            query.set('locale', locale);
-        }
-        return query.toString();
-    }
-    async function list(params = {}) {
-        const qs = toQueryString(params);
-        const res = await fetch(`${apiBase()}/entries/${info.uid}${qs ? '?' + qs : ''}`, {
-            headers: fimoHeaders(),
-        });
-        if (!res.ok) {
-            throw new Error(await res.text());
-        }
-        const data = parseCollectionResponse(await res.json());
-        const items = data.data.map(wrapWithSource);
-        const pageInfo = {
-            limit: data.meta.limit,
-            offset: data.meta.offset,
-            total: data.meta.total,
-            hasMore: data.meta.hasMore,
-            nextOffset: data.meta.hasMore ? data.meta.offset + data.meta.limit : null,
-        };
-        return { items, pageInfo };
-    }
-    async function get(params = {}) {
-        return (await list(params)).items;
-    }
-    async function create(payload) {
-        const localizedPayload = info.localized ? withMutationLocale(payload, readCollectionLocale({})) : payload;
-        const res = await fetch(`${apiBase()}/entries/${info.uid}`, {
-            method: 'POST',
-            headers: fimoHeaders({ 'Content-Type': 'application/json' }),
-            body: JSON.stringify(splitWritePayload(localizedPayload)),
-        });
-        if (!res.ok) {
-            throw new Error(await res.text());
-        }
-        const data = await res.json();
-        return wrapWithSource(data.data);
-    }
-    async function update(id, payload) {
-        const write = splitWritePayload(payload);
-        const url = buildReadPath(`/entries/${info.uid}/${id}`, readCollectionLocale({ locale: write.locale }), undefined);
-        const res = await fetch(`${apiBase()}${url}`, {
-            method: 'PUT',
-            headers: fimoHeaders({ 'Content-Type': 'application/json' }),
-            body: JSON.stringify({ data: write.data }),
-        });
-        if (!res.ok) {
-            throw new Error(await res.text());
-        }
-        const data = await res.json();
-        return wrapWithSource(data.data);
-    }
-    async function remove(id, options = {}) {
-        const url = buildReadPath(`/entries/${info.uid}/${id}`, readCollectionLocale(options), undefined);
-        const res = await fetch(`${apiBase()}${url}`, { method: 'DELETE', headers: fimoHeaders() });
-        if (!res.ok) {
-            throw new Error(await res.text());
-        }
-    }
-    const qk = {
-        root: [info.pascal],
-        byId: (id, options = {}) => [info.pascal, 'id', id, options.locale, options.populate],
-        bySlug: (slug, options = {}) => [info.pascal, 'slug', slug, options.locale, options.populate],
-        byField: (field, value, options = {}) => [info.pascal, field, value, options.locale, options.populate],
-        list: (params) => [info.pascal, params],
-        infiniteList: (params) => [info.pascal, 'infinite', params],
-    };
-    function useGetById(id, options = {}) {
-        const locale = useQueryLocale(options.locale);
-        const localizedOptions = { ...options, locale };
-        return useQuery({
-            queryKey: qk.byId(id, localizedOptions),
-            queryFn: () => getById(id, localizedOptions),
-            ...SOURCE_TRACKED_QUERY_OPTIONS,
-        });
-    }
-    function useGetBySlug(slug, options = {}) {
-        const locale = readCollectionLocale(options, useQueryLocale(options.locale));
-        const localizedOptions = { ...options, locale };
-        return useQuery({
-            queryKey: qk.bySlug(slug, localizedOptions),
-            queryFn: () => getBySlug(slug, localizedOptions),
-            ...SOURCE_TRACKED_QUERY_OPTIONS,
-            enabled: !!slug,
-        });
-    }
-    function useGetByField(fieldName, value, options = {}) {
-        const locale = readCollectionLocale(options, useQueryLocale(options.locale));
-        const localizedOptions = { ...options, locale };
-        return useQuery({
-            queryKey: qk.byField(fieldName, value, localizedOptions),
-            queryFn: () => getByField(fieldName, value, localizedOptions),
-            ...SOURCE_TRACKED_QUERY_OPTIONS,
-            enabled: !!value,
-        });
-    }
-    function useGet(params = {}) {
-        const locale = readCollectionLocale(params, useQueryLocale(params.locale));
-        const localizedParams = { ...params, locale };
-        return useQuery({
-            queryKey: qk.list(localizedParams),
-            queryFn: () => list(localizedParams),
-            ...SOURCE_TRACKED_QUERY_OPTIONS,
-            select: (page) => page.items,
-        });
-    }
-    function useList(params = {}) {
-        const locale = readCollectionLocale(params, useQueryLocale(params.locale));
-        const localizedParams = { ...params, locale };
-        return useQuery({
-            queryKey: qk.list(localizedParams),
-            queryFn: () => list(localizedParams),
-            ...SOURCE_TRACKED_QUERY_OPTIONS,
-        });
-    }
-    function useInfiniteList(params = {}) {
-        const locale = readCollectionLocale(params, useQueryLocale(params.locale));
-        const localizedParams = { ...params, locale };
-        const query = useInfiniteQuery({
-            queryKey: qk.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 locale = useQueryLocale(options.locale);
-        const localizedOptions = { ...options, locale };
-        return useSuspenseQuery({
-            queryKey: qk.byId(id, localizedOptions),
-            queryFn: () => getById(id, localizedOptions),
-            ...SOURCE_TRACKED_QUERY_OPTIONS,
-        });
-    }
-    function useSuspenseGetBySlug(slug, options = {}) {
-        const locale = readCollectionLocale(options, useQueryLocale(options.locale));
-        const localizedOptions = { ...options, locale };
-        return useSuspenseQuery({
-            queryKey: qk.bySlug(slug, localizedOptions),
-            queryFn: () => getBySlug(slug, localizedOptions),
-            ...SOURCE_TRACKED_QUERY_OPTIONS,
-        });
-    }
-    function useSuspenseGetByField(fieldName, value, options = {}) {
-        const locale = readCollectionLocale(options, useQueryLocale(options.locale));
-        const localizedOptions = { ...options, locale };
-        return useSuspenseQuery({
-            queryKey: qk.byField(fieldName, value, localizedOptions),
-            queryFn: () => getByField(fieldName, value, localizedOptions),
-            ...SOURCE_TRACKED_QUERY_OPTIONS,
-        });
-    }
-    function useSuspenseGet(params = {}) {
-        const locale = readCollectionLocale(params, useQueryLocale(params.locale));
-        const localizedParams = { ...params, locale };
-        return useSuspenseQuery({
-            queryKey: qk.list(localizedParams),
-            queryFn: () => list(localizedParams),
-            ...SOURCE_TRACKED_QUERY_OPTIONS,
-            select: (page) => page.items,
-        });
-    }
-    function useCreate() {
-        const qc = useQueryClient();
-        const activeLocale = useQueryLocale();
-        return useMutation({
-            mutationFn: (payload) => create(withMutationLocale(payload, activeLocale)),
-            onSuccess: () => qc.invalidateQueries({ queryKey: qk.root }),
-        });
-    }
-    function useUpdate() {
-        const qc = useQueryClient();
-        const activeLocale = useQueryLocale();
-        return useMutation({
-            mutationFn: ({ id, ...patch }) => update(id, withMutationLocale(patch, activeLocale)),
-            onSuccess: (_data, vars) => {
-                qc.invalidateQueries({ queryKey: qk.root });
-                qc.invalidateQueries({ queryKey: qk.byId(vars.id, { locale: vars.locale ?? activeLocale }) });
-            },
-        });
-    }
-    function useRemove() {
-        const qc = useQueryClient();
-        const activeLocale = useQueryLocale();
-        return useMutation({
-            mutationFn: (value) => {
-                const { id, locale } = typeof value === 'string'
-                    ? { id: value, locale: activeLocale }
-                    : { ...value, locale: value.locale ?? activeLocale };
-                return remove(id, { locale });
-            },
-            onSuccess: (_data, value) => {
-                const { id, locale } = typeof value === 'string'
-                    ? { id: value, locale: activeLocale }
-                    : { ...value, locale: value.locale ?? activeLocale };
-                qc.invalidateQueries({ queryKey: qk.root });
-                qc.removeQueries({ queryKey: qk.byId(id, { locale }), exact: false });
-            },
-        });
-    }
-    return {
-        meta,
-        wrapWithSource,
-        getById,
-        getBySlug,
-        getByField,
-        list,
-        get,
-        create,
-        update,
-        remove,
-        useGetById,
-        useGetBySlug,
-        useGetByField,
-        useGet,
-        useList,
-        useInfiniteList,
-        useSuspenseGetById,
-        useSuspenseGetBySlug,
-        useSuspenseGetByField,
-        useSuspenseGet,
-        useCreate,
-        useUpdate,
-        useRemove,
-    };
+    return createReactContentClient(config, viteContentRuntime, (requested, fallback) => useQueryLocale(requested, fallback));
 }

package/dist/runtime/content/client/createSingletonClient.js

@@ -1,111 +1,6 @@
-import { useMutation, useQuery, useQueryClient, useSuspenseQuery } from '@tanstack/react-query';
-import { SOURCE_TRACKED_QUERY_OPTIONS } from './createContentClient.js';
-import { apiBase, buildReadPath, fimoHeaders, interpretSchema, readSingletonLocale, referenceTargetUids, resolveClientHandle, splitWritePayload, validateReferences, withMutationLocale, wrapEntry, } from './internal.js';
+import { createReactSingletonClient } from './react-singleton-client.js';
 import { useQueryLocale } from './useQueryLocale.js';
+import { viteContentRuntime } from './vite-runtime.js';
 export function createSingletonClient(config) {
-    const references = config.references ?? {};
-    const info = interpretSchema(config.schema);
-    if (!info.isSingleton) {
-        throw new Error(`Schema "${info.uid}" is a collection — use createContentClient instead.`);
-    }
-    validateReferences(info, references);
-    const meta = { uid: info.uid, pascal: info.pascal, localized: info.localized };
-    const self = { wrapWithSource, meta };
-    const resolve = (uid) => uid === info.uid ? self : resolveClientHandle(references[uid]);
-    // Which reference fields point at a localized schema decides whether a
-    // non-localized singleton read must still send a locale. Target metas live
-    // on other modules in a possibly-cyclic graph, so this is derived lazily on
-    // first request, never at module init.
-    let localizedReferenceFields = null;
-    function getLocalizedReferenceFields() {
-        if (localizedReferenceFields) {
-            return localizedReferenceFields;
-        }
-        const fields = new Set();
-        for (const [key, field] of info.fields) {
-            if (field.type !== 'reference') {
-                continue;
-            }
-            const localizedTarget = referenceTargetUids(field).some((uid) => resolve(uid)?.meta?.localized !== false);
-            if (localizedTarget) {
-                fields.add(key);
-            }
-        }
-        localizedReferenceFields = fields;
-        return fields;
-    }
-    function wrapWithSource(entry) {
-        return wrapEntry(info, entry, { alwaysIncludeLocale: info.localized, resolve });
-    }
-    function readLocale(options, fallbackLocale) {
-        return fallbackLocale === undefined
-            ? readSingletonLocale(options, info.localized, getLocalizedReferenceFields())
-            : readSingletonLocale(options, info.localized, getLocalizedReferenceFields(), fallbackLocale);
-    }
-    function readPath(url, options) {
-        return buildReadPath(url, readLocale(options), options.populate, options.localeFallbacks);
-    }
-    async function get(options = {}) {
-        const res = await fetch(`${apiBase()}${readPath(`/documents/${info.uid}`, options)}`, {
-            headers: fimoHeaders(),
-        });
-        if (!res.ok) {
-            throw new Error(await res.text());
-        }
-        const data = await res.json();
-        return wrapWithSource(data.data);
-    }
-    async function update(payload) {
-        const write = splitWritePayload(payload);
-        const url = buildReadPath(`/documents/${info.uid}`, readLocale({ locale: write.locale }), undefined);
-        const res = await fetch(`${apiBase()}${url}`, {
-            method: 'PUT',
-            headers: fimoHeaders({ 'Content-Type': 'application/json' }),
-            body: JSON.stringify({ data: write.data }),
-        });
-        if (!res.ok) {
-            throw new Error(await res.text());
-        }
-        const data = await res.json();
-        return wrapWithSource(data.data);
-    }
-    const qk = {
-        root: [info.pascal],
-        document: (options = {}) => [info.pascal, 'document', options.locale, options.populate],
-    };
-    function useGet(options = {}) {
-        const locale = readLocale(options, useQueryLocale(options.locale));
-        const localizedOptions = { ...options, locale };
-        return useQuery({
-            queryKey: qk.document(localizedOptions),
-            queryFn: () => get(localizedOptions),
-            ...SOURCE_TRACKED_QUERY_OPTIONS,
-        });
-    }
-    function useSuspenseGet(options = {}) {
-        const locale = readLocale(options, useQueryLocale(options.locale));
-        const localizedOptions = { ...options, locale };
-        return useSuspenseQuery({
-            queryKey: qk.document(localizedOptions),
-            queryFn: () => get(localizedOptions),
-            ...SOURCE_TRACKED_QUERY_OPTIONS,
-        });
-    }
-    function useUpdate() {
-        const qc = useQueryClient();
-        const activeLocale = useQueryLocale();
-        return useMutation({
-            mutationFn: (payload) => update(withMutationLocale(payload, activeLocale)),
-            onSuccess: () => qc.invalidateQueries({ queryKey: qk.root }),
-        });
-    }
-    return {
-        meta,
-        wrapWithSource,
-        get,
-        update,
-        useGet,
-        useSuspenseGet,
-        useUpdate,
-    };
+    return createReactSingletonClient(config, viteContentRuntime, (requested, fallback) => useQueryLocale(requested, fallback));
 }

package/dist/runtime/content/client/internal.d.ts

@@ -9,9 +9,6 @@ export interface InterpretedSchema {
 export declare function interpretSchema(schema: ContentSchema): InterpretedSchema;
 export declare function referenceTargetUids(field: ContentSchemaField): readonly string[];
 export declare function validateReferences(info: InterpretedSchema, references: Readonly<Record<string, ContentModuleRef>>): void;
-export declare function apiBase(): string;
-export declare function defaultLocale(): string;
-export declare function fimoHeaders(extra?: Record<string, string>): Record<string, string>;
 interface LocaleReadOptions {
     locale?: string;
     populate?: string | readonly string[];
@@ -38,6 +35,7 @@ type ReferenceResolver = (uid: string) => ContentClientHandle | undefined;
 export declare function resolveClientHandle(ref: ContentModuleRef | undefined): ContentClientHandle | undefined;
 export declare function wrapEntry(info: InterpretedSchema, entry: Record<string, any>, options: {
     alwaysIncludeLocale: boolean;
+    defaultLocale: string;
     resolve: ReferenceResolver;
 }): Record<string, unknown>;
 export {};