fimo 0.11.0 → 0.12.0-staging.1

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

@@ -1,6 +1,4 @@
 import { pascalCase } from 'change-case';
-// @ts-ignore - virtual module provided by fimoConfigPlugin in fimo/vite
-import fimoConfig from 'virtual:fimo-config';
 import { FIMO_SOURCE, FimoBoolean, FimoMedia, FimoRichText, FimoString } from '../../primitives/lib/primitives.js';
 export function interpretSchema(schema) {
     if (!schema || typeof schema.uid !== 'string' || schema.uid.length === 0) {
@@ -41,32 +39,16 @@ export function validateReferences(info, references) {
         }
     }
 }
-export function apiBase() {
-    // @ts-ignore - import.meta.env is a Vite feature, replaced at build time for both client and SSR
-    return import.meta.env.VITE_API_URL;
-}
-export function defaultLocale() {
-    return fimoConfig.i18n?.defaultLocale ?? 'en';
-}
-export function fimoHeaders(extra) {
-    const h = { ...extra };
-    // @ts-ignore - import.meta.env is a Vite feature
-    const env = import.meta.env.FIMO_ENV;
-    if (env) {
-        h['X-Fimo-Env'] = env;
-    }
-    return h;
-}
 function populateFields(populate) {
     if (populate == null) {
         return [];
     }
     return typeof populate === 'string' ? [populate] : [...populate];
 }
-export function readCollectionLocale(options, fallbackLocale = defaultLocale()) {
+export function readCollectionLocale(options, fallbackLocale = 'en') {
     return options.locale ?? fallbackLocale;
 }
-export function readSingletonLocale(options, ownerUsesLocale, localizedReferenceFields, fallbackLocale = defaultLocale()) {
+export function readSingletonLocale(options, ownerUsesLocale, localizedReferenceFields, fallbackLocale = 'en') {
     const populatesLocalizedTarget = populateFields(options.populate).some((field) => localizedReferenceFields.has(field));
     return ownerUsesLocale || populatesLocalizedTarget ? (options.locale ?? fallbackLocale) : undefined;
 }
@@ -276,7 +258,7 @@ export function wrapEntry(info, entry, options) {
     const id = entry.id;
     const entryId = entry.entryId;
     const documentId = entry.documentId ?? id;
-    const locale = entry.locale ?? defaultLocale();
+    const locale = entry.locale ?? options.defaultLocale;
     const sourcePrefix = `${info.pascal}.id:${id}:${encodeURIComponent(locale)}`;
     const entryFimo = entry.__fimo && typeof entry.__fimo === 'object' ? entry.__fimo : {};
     const wrapped = {

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

@@ -0,0 +1,10 @@
+import type { ContentRuntime } from './runtime.js';
+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/client/react-content-client.js

@@ -0,0 +1,165 @@
+import { useInfiniteQuery, useMutation, useQuery, useQueryClient, useSuspenseQuery } from '@tanstack/react-query';
+import { createCollectionContentCore } from './collection-core.js';
+import { readCollectionLocale, withMutationLocale } from './internal.js';
+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/client/react-singleton-client.d.ts

@@ -0,0 +1,7 @@
+import { type UseContentLocale } from './react-content-client.js';
+import type { ContentRuntime } from './runtime.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/client/react-singleton-client.js

@@ -0,0 +1,38 @@
+import { useMutation, useQuery, useQueryClient, useSuspenseQuery } from '@tanstack/react-query';
+import { withMutationLocale } from './internal.js';
+import { SOURCE_TRACKED_QUERY_OPTIONS } from './react-content-client.js';
+import { createSingletonContentCore } from './singleton-core.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/client/runtime.d.ts

@@ -0,0 +1,8 @@
+export interface ContentRuntime {
+    apiBase(): string;
+    defaultLocale(): string;
+    headers(extra?: Record<string, string>): Record<string, string>;
+    fetch(input: string | URL | Request, init?: RequestInit): Promise<Response>;
+}
+export declare function requireContentApiUrl(value: string | undefined, source: string): string;
+//# sourceMappingURL=runtime.d.ts.map

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

@@ -0,0 +1,7 @@
+export function requireContentApiUrl(value, source) {
+    const apiUrl = value?.trim().replace(/\/$/, '');
+    if (!apiUrl) {
+        throw new Error(`Missing ${source}. Configure the Fimo content API URL before reading content.`);
+    }
+    return apiUrl;
+}

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

@@ -0,0 +1,9 @@
+import type { ContentRuntime } from './runtime.js';
+import type { CollectionContentClient, ContentClientConfig, SingletonContentClient } from './types.js';
+export declare function createServerContentClient<T extends {
+    id: string;
+}, TInput extends object>(config: ContentClientConfig, runtime: ContentRuntime): CollectionContentClient<T, TInput>;
+export declare function createServerSingletonClient<T extends {
+    id: string;
+}, TInput extends object>(config: ContentClientConfig, runtime: ContentRuntime): SingletonContentClient<T, TInput>;
+//# sourceMappingURL=server-content-client.d.ts.map

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

@@ -0,0 +1,35 @@
+import { createCollectionContentCore } from './collection-core.js';
+import { createSingletonContentCore } from './singleton-core.js';
+function clientHook(name) {
+    return () => {
+        throw new Error(`${name} is a Client Component hook. Call it only below a "use client" boundary.`);
+    };
+}
+export function createServerContentClient(config, runtime) {
+    const { client } = createCollectionContentCore(config, runtime);
+    return {
+        ...client,
+        useGetById: clientHook('useGetById'),
+        useGetBySlug: clientHook('useGetBySlug'),
+        useGetByField: clientHook('useGetByField'),
+        useGet: clientHook('useGet'),
+        useList: clientHook('useList'),
+        useInfiniteList: clientHook('useInfiniteList'),
+        useSuspenseGetById: clientHook('useSuspenseGetById'),
+        useSuspenseGetBySlug: clientHook('useSuspenseGetBySlug'),
+        useSuspenseGetByField: clientHook('useSuspenseGetByField'),
+        useSuspenseGet: clientHook('useSuspenseGet'),
+        useCreate: clientHook('useCreate'),
+        useUpdate: clientHook('useUpdate'),
+        useRemove: clientHook('useRemove'),
+    };
+}
+export function createServerSingletonClient(config, runtime) {
+    const { client } = createSingletonContentCore(config, runtime);
+    return {
+        ...client,
+        useGet: clientHook('useGet'),
+        useSuspenseGet: clientHook('useSuspenseGet'),
+        useUpdate: clientHook('useUpdate'),
+    };
+}

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

@@ -0,0 +1,26 @@
+import type { Populate } from '../../primitives/lib/query.js';
+import type { ContentRuntime } from './runtime.js';
+import type { ContentClientConfig, ContentModuleMeta, ContentReadOptions, ContentResult } from './types.js';
+export interface SingletonContentCore<T extends {
+    id: string;
+}, TInput extends object> {
+    readonly meta: ContentModuleMeta;
+    wrapWithSource(entry: Record<string, any>): T;
+    get<TPopulate extends Populate<T> | undefined = undefined>(options?: ContentReadOptions<TPopulate>): Promise<ContentResult<T, undefined, TPopulate>>;
+    update(payload: Partial<TInput>): Promise<T>;
+}
+export interface SingletonCoreState<T extends {
+    id: string;
+}, TInput extends object> {
+    client: SingletonContentCore<T, TInput>;
+    defaultLocale: string;
+    localize<TPopulate extends Populate<T> | undefined>(options: ContentReadOptions<TPopulate>, fallbackLocale?: string): string | undefined;
+    queryKeys: {
+        root: readonly [string];
+        document(options?: ContentReadOptions<Populate<T> | undefined>): readonly unknown[];
+    };
+}
+export declare function createSingletonContentCore<T extends {
+    id: string;
+}, TInput extends object>(config: ContentClientConfig, runtime: ContentRuntime): SingletonCoreState<T, TInput>;
+//# sourceMappingURL=singleton-core.d.ts.map

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

@@ -0,0 +1,73 @@
+import { buildReadPath, interpretSchema, readSingletonLocale, referenceTargetUids, resolveClientHandle, splitWritePayload, validateReferences, wrapEntry, } from './internal.js';
+export function createSingletonContentCore(config, runtime) {
+    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 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]);
+    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,
+            defaultLocale,
+            resolve,
+        });
+    }
+    function localize(options, fallbackLocale = defaultLocale) {
+        return readSingletonLocale(options, info.localized, getLocalizedReferenceFields(), fallbackLocale);
+    }
+    function readPath(url, options) {
+        return buildReadPath(url, localize(options), options.populate, options.localeFallbacks);
+    }
+    async function get(options = {}) {
+        const response = await runtime.fetch(`${runtime.apiBase()}${readPath(`/documents/${info.uid}`, options)}`, {
+            headers: runtime.headers(),
+        });
+        if (!response.ok) {
+            throw new Error(await response.text());
+        }
+        const body = await response.json();
+        return wrapWithSource(body.data);
+    }
+    async function update(payload) {
+        const write = splitWritePayload(payload);
+        const url = buildReadPath(`/documents/${info.uid}`, localize({ locale: write.locale }), 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);
+    }
+    const queryKeys = {
+        root: [info.pascal],
+        document: (options = {}) => [info.pascal, 'document', options.locale, options.populate],
+    };
+    return { client: { meta, wrapWithSource, get, update }, defaultLocale, localize, queryKeys };
+}

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

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

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

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

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

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

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

@@ -0,0 +1,16 @@
+import type { ContentRuntime } from './client/runtime.js';
+import type { ContentClientConfig } from './client/types.js';
+export declare function createContentCore<T extends {
+    id: string;
+}, TInput extends object>(config: ContentClientConfig, runtime: ContentRuntime): import("./index.js").CollectionContentCore<T, TInput>;
+export declare function createSingletonCore<T extends {
+    id: string;
+}, TInput extends object>(config: ContentClientConfig, runtime: ContentRuntime): import("./index.js").SingletonContentCore<T, TInput>;
+export type { CollectionContentCore } from './client/collection-core.js';
+export type { ContentRuntime } from './client/runtime.js';
+export type { SingletonContentCore } from './client/singleton-core.js';
+export { serializeContent, type SerializedContent, type SerializedMedia } from './serialization.js';
+export type { CollectionPage, CollectionPageInfo, ContentClientConfig, ContentClientHandle, ContentModuleMeta, ContentModuleRef, ContentReadOptions, ContentResult, ContentSchema, ContentSchemaField, } from './client/types.js';
+export { FIMO_PARTS, FIMO_SOURCE, FimoBoolean, FimoDate, FimoMedia, FimoRichText, FimoString, getFimoParts, getFimoSource, hasFimoSource, isFimoDate, isFimoString, type FimoPart, type FimoPolymorphicReference, type FimoReference, type FimoRichTextComponents, type FimoRichTextContent, type FimoRichTextMarkProps, type FimoRichTextNodeProps, type FimoSource, } from '../primitives/lib/primitives.js';
+export type { BoolOps, DateOps, Field, Fields, FilterFor, NullOnlyOps, NumberOps, Populate, Populated, PopulatedResult, Projected, ProjectedWithPopulate, Query, ReferenceField, ReferenceMap, ScalarOps, Sort, SortField, StringOps, Where, WithReferences, } from '../primitives/lib/query.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/content/index.js

@@ -0,0 +1,10 @@
+import { createCollectionContentCore } from './client/collection-core.js';
+import { createSingletonContentCore } from './client/singleton-core.js';
+export function createContentCore(config, runtime) {
+    return createCollectionContentCore(config, runtime).client;
+}
+export function createSingletonCore(config, runtime) {
+    return createSingletonContentCore(config, runtime).client;
+}
+export { serializeContent } from './serialization.js';
+export { FIMO_PARTS, FIMO_SOURCE, FimoBoolean, FimoDate, FimoMedia, FimoRichText, FimoString, getFimoParts, getFimoSource, hasFimoSource, isFimoDate, isFimoString, } from '../primitives/lib/primitives.js';

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

@@ -0,0 +1,22 @@
+import { FimoBoolean, FimoDate, FimoMedia, FimoRichText, FimoString, type FimoRichTextContent } from '../primitives/lib/primitives.js';
+export interface SerializedMedia {
+    url: string;
+    alt: string;
+    name: string;
+    mime: string;
+    width?: number;
+    height?: number;
+}
+/** The plain-data counterpart of source-tracked Fimo content. */
+export type SerializedContent<T> = T extends FimoString ? string : T extends FimoDate ? string : T extends FimoBoolean ? boolean : T extends FimoMedia ? SerializedMedia : T extends FimoRichText ? FimoRichTextContent : T extends readonly (infer TItem)[] ? SerializedContent<TItem>[] : T extends object ? {
+    [TKey in keyof T]: SerializedContent<T[TKey]>;
+} : T;
+/**
+ * Convert source-tracked content to the API-shaped plain data required by
+ * framework boundaries such as Next.js Pages Router props.
+ *
+ * Use the generated schema module's `hydrate` function on the receiving side
+ * to restore source tracking without shipping private metadata in the payload.
+ */
+export declare function serializeContent<T>(value: T): SerializedContent<T>;
+//# sourceMappingURL=serialization.d.ts.map

package/dist/runtime/content/serialization.js

@@ -0,0 +1,42 @@
+import { FimoBoolean, FimoDate, FimoMedia, FimoRichText, FimoString, } from '../primitives/lib/primitives.js';
+/**
+ * Convert source-tracked content to the API-shaped plain data required by
+ * framework boundaries such as Next.js Pages Router props.
+ *
+ * Use the generated schema module's `hydrate` function on the receiving side
+ * to restore source tracking without shipping private metadata in the payload.
+ */
+export function serializeContent(value) {
+    if (value instanceof FimoString) {
+        return value.toString();
+    }
+    if (value instanceof FimoDate) {
+        return value.toISOString();
+    }
+    if (value instanceof FimoBoolean) {
+        return value.valueOf();
+    }
+    if (value instanceof FimoMedia) {
+        const media = {
+            url: value.url,
+            alt: value.alt,
+            name: value.name,
+            mime: value.mime,
+            ...(value.width === undefined ? {} : { width: value.width }),
+            ...(value.height === undefined ? {} : { height: value.height }),
+        };
+        return media;
+    }
+    if (value instanceof FimoRichText) {
+        return serializeContent(value.content);
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => serializeContent(item));
+    }
+    if (value !== null && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value)
+            .filter(([, item]) => item !== undefined)
+            .map(([key, item]) => [key, serializeContent(item)]));
+    }
+    return value;
+}

package/dist/runtime/next/Text.d.ts

@@ -0,0 +1,10 @@
+import { type ElementType } from 'react';
+import type { TextProps } from '../primitives/components/Text.js';
+/**
+ * Server-safe text primitive for Next.js Server Components.
+ *
+ * It intentionally shares the same public props as the interactive React
+ * primitive while rendering source metadata without client hooks.
+ */
+export declare function Text<T extends ElementType = 'span'>({ value, as, children, ...props }: TextProps<T>): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=Text.d.ts.map

package/dist/runtime/next/Text.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Fragment } from 'react';
+import { getFimoParts, getFimoSource } from '../content/index.js';
+/**
+ * Server-safe text primitive for Next.js Server Components.
+ *
+ * It intentionally shares the same public props as the interactive React
+ * primitive while rendering source metadata without client hooks.
+ */
+export function Text({ value, as, children, ...props }) {
+    const Component = as || 'span';
+    const parts = getFimoParts(value);
+    if (parts && parts.length > 1 && !children) {
+        return (_jsx(Component, { ...props, children: parts.map((part, index) => part.source ? (_jsx("span", { "data-fimo-source": part.source, children: part.text }, index)) : (_jsx(Fragment, { children: part.text }, index))) }));
+    }
+    const text = String(value);
+    return (_jsx(Component, { ...props, "data-fimo-source": getFimoSource(value), children: children ? children(text) : text }));
+}

package/dist/runtime/next/client-runtime.d.ts

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

package/dist/runtime/next/client-runtime.js

@@ -0,0 +1,20 @@
+import { requireContentApiUrl } from '../content/client/runtime.js';
+export const nextClientContentRuntime = {
+    apiBase() {
+        return requireContentApiUrl(process.env.NEXT_PUBLIC_FIMO_API_URL, 'NEXT_PUBLIC_FIMO_API_URL');
+    },
+    defaultLocale() {
+        return process.env.NEXT_PUBLIC_FIMO_DEFAULT_LOCALE?.trim() || 'en';
+    },
+    headers(extra) {
+        const headers = { ...extra };
+        const env = process.env.NEXT_PUBLIC_FIMO_ENV?.trim();
+        if (env) {
+            headers['X-Fimo-Env'] = env;
+        }
+        return headers;
+    },
+    fetch(input, init) {
+        return globalThis.fetch(input, init);
+    },
+};