fimo 0.8.0 → 0.9.0-experimental.2

package/dist/runtime/shared/labels-fetch.server.js

@@ -0,0 +1,97 @@
+// Framework-neutral label fetching (server-side). Shared by the Vite
+// translations plugin (fimo/vite) and the Next server loaders (fimo/next/server).
+// The fetch core is in labels-fetch.pure.ts (client-safe); this module adds
+// the node-flavored parts: env-file reading, config resolution, signatures.
+import { Buffer } from 'node:buffer';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { getFimoDefaultLocale, getFimoLocales } from '../i18n/locale.js';
+import { getConfigServer } from './fimo-config.server.js';
+import { API_URL_ENV_KEYS, fetchLabelBundle, serializeBundle, } from './labels-fetch.pure.js';
+export { API_URL_ENV_KEYS, fetchLabelBundle, fetchLabelDictionary, fetchWithTimeout, resolveTenantApiUrl, serializeBundle, } from './labels-fetch.pure.js';
+export function labelSignature(bundle) {
+    return Buffer.from(serializeBundle(bundle)).toString('base64');
+}
+export function emptyLabelBundle(rootDir) {
+    const config = getConfigServer(rootDir);
+    const defaultLocale = getFimoDefaultLocale(config);
+    const locales = getFimoLocales(config);
+    return {
+        dictionaries: Object.fromEntries(locales.map((locale) => [locale, {}])),
+        defaultLocale,
+        locales,
+        updatedAt: null,
+    };
+}
+export async function loadLabelBundle(rootDir) {
+    const config = getConfigServer(rootDir);
+    const defaultLocale = getFimoDefaultLocale(config);
+    const locales = getFimoLocales(config);
+    const env = await readProjectEnv(rootDir);
+    const apiUrl = resolveTenantApiUrlFromEnv(env);
+    if (!apiUrl) {
+        return {
+            dictionaries: Object.fromEntries(locales.map((locale) => [locale, {}])),
+            defaultLocale,
+            locales,
+            updatedAt: null,
+        };
+    }
+    try {
+        return await fetchLabelBundle(apiUrl, locales, defaultLocale);
+    }
+    catch {
+        return {
+            dictionaries: Object.fromEntries(locales.map((locale) => [locale, {}])),
+            defaultLocale,
+            locales,
+            updatedAt: null,
+        };
+    }
+}
+function resolveTenantApiUrlFromEnv(env) {
+    for (const key of API_URL_ENV_KEYS) {
+        if (env[key]) {
+            return env[key];
+        }
+    }
+    return undefined;
+}
+export async function readProjectEnv(rootDir) {
+    const values = {
+        ...(await readEnvFile(join(rootDir, '.env'))),
+        ...(await readEnvFile(join(rootDir, '.env.local'))),
+    };
+    for (const key of API_URL_ENV_KEYS) {
+        if (process.env[key]) {
+            values[key] = process.env[key];
+        }
+    }
+    return values;
+}
+async function readEnvFile(filePath) {
+    try {
+        const content = await readFile(filePath, 'utf8');
+        const values = {};
+        for (const line of content.split(/\r?\n/)) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#')) {
+                continue;
+            }
+            const index = trimmed.indexOf('=');
+            if (index === -1) {
+                continue;
+            }
+            const key = trimmed.slice(0, index).trim();
+            const value = trimmed
+                .slice(index + 1)
+                .trim()
+                .replace(/^['"]|['"]$/g, '');
+            values[key] = value;
+        }
+        return values;
+    }
+    catch {
+        return {};
+    }
+}

package/dist/runtime/shared/labels-t.pure.d.ts

@@ -0,0 +1,2 @@
+export declare function makeFimoT(labels: Record<string, string> | null | undefined): (key: string, fallback?: string) => string;
+//# sourceMappingURL=labels-t.pure.d.ts.map

package/dist/runtime/shared/labels-t.pure.js

@@ -0,0 +1,10 @@
+// Pure label accessor factory — no node builtins, no framework imports.
+// Template frameworks load the dictionary server-side (+layout.server.ts
+// load, a Vue data service, …), hand it to components through their own
+// data flow, and build `t` locally:
+//
+//   const t = makeFimoT(data.fimoLabels);
+//   <h1 {...fimoLabelAttrs('hero.title')}>{t('hero.title', 'Fallback')}</h1>
+export function makeFimoT(labels) {
+    return (key, fallback = '') => labels?.[key] ?? fallback;
+}

package/dist/runtime/strapi/client.d.ts

@@ -0,0 +1,30 @@
+import { type FimoServerOptions } from '../wrapped/server.js';
+import { type FieldShapes } from './reshape.js';
+export interface FimoStrapiFetchOptions extends FimoServerOptions {
+    /** Strapi REST path segment (pluralName) → Fimo type name. */
+    types: Record<string, string>;
+    /** Fimo type names that are single types (served as `{data:{}}`, not a list). */
+    singletons?: string[];
+    /** Path prefix before the content segment (Strapi default `/api`). */
+    apiPrefix?: string;
+    /** Per-type structural field-shape manifest (single-component unwrap + block
+     *  item reshaping). Baked by the migration; absent → pure value-inspection. */
+    fieldShapes?: Record<string, FieldShapes>;
+}
+export interface ParsedStrapiUrl {
+    pluralName: string;
+    documentId?: string;
+    locale?: string;
+    pageSize?: number;
+    where?: Record<string, unknown>;
+}
+/**
+ * Parse a Strapi REST URL into the parts the Fimo read needs. Best-effort:
+ * pagination + locale + top-level `$eq` filters (enough for list, detail-by-slug,
+ * and singleton reads); richer `qs` filters are ignored (fake content tolerates
+ * an unfiltered set).
+ */
+export declare function parseStrapiUrl(rawUrl: string, apiPrefix?: string): ParsedStrapiUrl | null;
+/** Build a `fetch`-compatible function that serves scaffolded content from Fimo. */
+export declare function createFimoStrapiFetch(options: FimoStrapiFetchOptions, realFetch?: typeof fetch): typeof fetch;
+//# sourceMappingURL=client.d.ts.map

package/dist/runtime/strapi/client.js

@@ -0,0 +1,89 @@
+// Native `fimo/strapi` read adapter — the generic interception point. Every
+// Strapi client (hand-rolled or `@strapi/client`) ultimately does a single
+// `fetch(<strapiRestUrl>)`; this returns a `fetch`-compatible function that
+// serves that request from Fimo (via `fetchEntries` + the reshape) when the URL
+// maps to a scaffolded content type, and transparently falls through to the
+// real fetch (the live CMS) otherwise. Intercepting at the fetch boundary is
+// what makes "any Strapi project" work — the client's method surface is
+// irrelevant.
+import { fetchEntries } from '../wrapped/server.js';
+import { fimoEntriesToStrapiList, fimoEntryToStrapiSingle } from './reshape.js';
+function positiveInt(value) {
+    if (value == null) {
+        return undefined;
+    }
+    const n = Number(value);
+    return Number.isFinite(n) && n > 0 ? n : undefined;
+}
+/**
+ * Parse a Strapi REST URL into the parts the Fimo read needs. Best-effort:
+ * pagination + locale + top-level `$eq` filters (enough for list, detail-by-slug,
+ * and singleton reads); richer `qs` filters are ignored (fake content tolerates
+ * an unfiltered set).
+ */
+export function parseStrapiUrl(rawUrl, apiPrefix = '/api') {
+    let url;
+    try {
+        url = new URL(rawUrl, 'http://fimo.local');
+    }
+    catch {
+        return null;
+    }
+    const marker = `${apiPrefix}/`;
+    const at = url.pathname.indexOf(marker);
+    if (at === -1) {
+        return null;
+    }
+    const segments = url.pathname
+        .slice(at + marker.length)
+        .split('/')
+        .filter(Boolean);
+    if (segments.length === 0) {
+        return null;
+    }
+    const q = url.searchParams;
+    const where = {};
+    for (const [key, value] of q.entries()) {
+        const eq = key.match(/^filters\[([^\][]+)\]\[\$eq\]$/);
+        if (eq) {
+            where[eq[1]] = value;
+        }
+    }
+    return {
+        pluralName: segments[0],
+        documentId: segments[1],
+        locale: q.get('locale') ?? undefined,
+        pageSize: positiveInt(q.get('pagination[pageSize]') ?? q.get('pagination[limit]')),
+        where: Object.keys(where).length > 0 ? where : undefined,
+    };
+}
+/** Build a `fetch`-compatible function that serves scaffolded content from Fimo. */
+export function createFimoStrapiFetch(options, realFetch = fetch) {
+    const singletons = new Set(options.singletons ?? []);
+    const read = { apiUrl: options.apiUrl, rootDir: options.rootDir };
+    return (async (input, init) => {
+        const rawUrl = typeof input === 'string' ? input : input instanceof URL ? input.href : input.url;
+        const parsed = parseStrapiUrl(rawUrl ?? '', options.apiPrefix);
+        const typeName = parsed ? options.types[parsed.pluralName] : undefined;
+        if (!parsed || !typeName) {
+            return realFetch(input, init); // not a mapped content read → real CMS
+        }
+        const entries = await fetchEntries(typeName, {
+            ...read,
+            ...(parsed.where ? { where: parsed.where } : {}),
+            ...(parsed.pageSize ? { limit: parsed.pageSize } : {}),
+        });
+        if (entries.length === 0) {
+            return realFetch(input, init); // nothing scaffolded → fall back to the CMS
+        }
+        const shapes = options.fieldShapes?.[typeName];
+        const single = Boolean(parsed.documentId) || singletons.has(typeName);
+        const payload = single
+            ? fimoEntryToStrapiSingle(parsed.documentId ? (entries.find((e) => e.id === parsed.documentId) ?? entries[0]) : entries[0], shapes)
+            : fimoEntriesToStrapiList(entries, { pageSize: parsed.pageSize, total: entries.length, shapes });
+        return new Response(JSON.stringify(payload), {
+            status: 200,
+            headers: { 'content-type': 'application/json' },
+        });
+    });
+}

package/dist/runtime/strapi/index.d.ts

@@ -0,0 +1,5 @@
+export { createFimoStrapiFetch, parseStrapiUrl } from './client.js';
+export type { FimoStrapiFetchOptions, ParsedStrapiUrl } from './client.js';
+export { fimoEntriesToStrapiList, fimoEntryToStrapiItem, fimoEntryToStrapiSingle } from './reshape.js';
+export type { StrapiListEnvelope, StrapiPagination, StrapiSingleEnvelope } from './reshape.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/strapi/index.js

@@ -0,0 +1,6 @@
+// `fimo/strapi` — native read adapter that serves a wrapped Strapi frontend's
+// content from Fimo. Drop `createFimoStrapiFetch(...)` in at the CMS client's
+// single `fetch` and every read (list, detail, singleton) is served from Fimo,
+// falling through to the live CMS for anything not scaffolded.
+export { createFimoStrapiFetch, parseStrapiUrl } from './client.js';
+export { fimoEntriesToStrapiList, fimoEntryToStrapiItem, fimoEntryToStrapiSingle } from './reshape.js';

package/dist/runtime/strapi/reshape.d.ts

@@ -0,0 +1,46 @@
+import type { FimoEntry } from '../wrapped/server.js';
+export interface StrapiPagination {
+    page: number;
+    pageSize: number;
+    pageCount: number;
+    total: number;
+}
+export interface StrapiListEnvelope {
+    data: Record<string, unknown>[];
+    meta: {
+        pagination: StrapiPagination;
+    };
+}
+export interface StrapiSingleEnvelope {
+    data: Record<string, unknown> | null;
+    meta: Record<string, unknown>;
+}
+/**
+ * The field-shape manifest, baked into the generated `fimo-strapi.ts` by the
+ * migration. It carries ONLY the structural (blocks) fields — a Fimo blocks
+ * value is always an array, but a Strapi single component reads as an object, so
+ * the reshape needs to know which array to unwrap. Leaf fields (scalars, media,
+ * richtext, references) never appear here; they are handled by value-inspection.
+ * Kept in sync with `computeFieldShapes` in `scripts/cms/strapi/shapes.ts`.
+ */
+export interface BlockFieldShape {
+    /** 'single' → unwrap the one-item array to an object; 'list' → keep the array. */
+    readonly kind: 'single' | 'list';
+    /** Nested structural shapes for a fixed-shape block (single/repeatable component). */
+    readonly fields?: FieldShapes;
+    /** Per-variant nested shapes for a dynamic zone, keyed by variant uid (`_type`). */
+    readonly variants?: Record<string, FieldShapes>;
+}
+export type FieldShapes = Record<string, BlockFieldShape>;
+/** One Fimo entry → one Strapi-v5 item (`id` + `documentId` + reshaped fields). */
+export declare function fimoEntryToStrapiItem(entry: FimoEntry, shapes?: FieldShapes): Record<string, unknown>;
+/** Fimo entries → a Strapi-v5 collection envelope (`{ data, meta.pagination }`). */
+export declare function fimoEntriesToStrapiList(entries: FimoEntry[], options?: {
+    page?: number;
+    pageSize?: number;
+    total?: number;
+    shapes?: FieldShapes;
+}): StrapiListEnvelope;
+/** Fimo entry → a Strapi-v5 single/singleton envelope (`{ data, meta }`). */
+export declare function fimoEntryToStrapiSingle(entry: FimoEntry | undefined, shapes?: FieldShapes): StrapiSingleEnvelope;
+//# sourceMappingURL=reshape.d.ts.map

package/dist/runtime/strapi/reshape.js

@@ -0,0 +1,114 @@
+// Native `fimo/strapi` read adapter — the generic reshape from Fimo entries
+// (as `fetchEntries` returns them) into the Strapi-v5 response shape a wrapped
+// Strapi frontend's components read. Value-inspection based, so it is generic:
+// no content-type or field names are hardcoded. Relation POPULATION (turning a
+// reference handle into a nested object) is resolved one level up in the client
+// — this module reshapes a single entry's own field values.
+/** ProseMirror/TipTap doc → plain text (Strapi richtext is a string; string
+ *  consumers like read-time estimates must never receive an object). */
+function docToText(node) {
+    if (!node || typeof node !== 'object') {
+        return '';
+    }
+    const record = node;
+    if (typeof record.text === 'string') {
+        return record.text;
+    }
+    if (Array.isArray(record.content)) {
+        return record.content.map(docToText).join(' ').trim();
+    }
+    return '';
+}
+function isRichTextDoc(value) {
+    return Boolean(value) && typeof value === 'object' && value.type === 'doc';
+}
+/** A Fimo media value (seeded/loaded as `{ url, alt, width, height, … }`). */
+function isMedia(value) {
+    return (Boolean(value) &&
+        typeof value === 'object' &&
+        !Array.isArray(value) &&
+        typeof value.url === 'string');
+}
+function reshapeMedia(value) {
+    return {
+        url: value.url,
+        alternativeText: value.alt ?? value.alternativeText ?? null,
+        ...(typeof value.width === 'number' ? { width: value.width } : {}),
+        ...(typeof value.height === 'number' ? { height: value.height } : {}),
+        ...(typeof value.name === 'string' ? { name: value.name } : {}),
+        ...(typeof value.mime === 'string' ? { mime: value.mime } : {}),
+    };
+}
+function reshapeValue(value) {
+    if (isRichTextDoc(value)) {
+        return docToText(value);
+    }
+    if (isMedia(value)) {
+        return reshapeMedia(value);
+    }
+    return value; // scalars, arrays, reference handles pass through
+}
+/** Reshape one block item: drop Fimo-internal `_key`/`_type` (exposing `_key` as
+ *  Strapi's `id`), keep everything else — `__component` passes through, nested
+ *  structural fields recurse per the manifest, leaves are value-inspected. */
+function reshapeBlockItem(item, shape) {
+    if (!item || typeof item !== 'object' || Array.isArray(item)) {
+        return {};
+    }
+    const record = item;
+    const nested = shape.variants ? (shape.variants[String(record._type)] ?? {}) : (shape.fields ?? {});
+    const out = {};
+    if (typeof record._key === 'string') {
+        out.id = record._key;
+    }
+    for (const [key, value] of Object.entries(record)) {
+        if (key === '_key' || key === '_type') {
+            continue;
+        }
+        out[key] = reshapeFieldValue(value, nested[key]);
+    }
+    return out;
+}
+/** Reshape a single field value against its manifest entry. No entry → a leaf. */
+function reshapeFieldValue(value, shape) {
+    if (!shape) {
+        return reshapeValue(value);
+    }
+    const items = Array.isArray(value) ? value : [];
+    if (shape.kind === 'single') {
+        return items.length > 0 ? reshapeBlockItem(items[0], shape) : null;
+    }
+    return items.map((item) => reshapeBlockItem(item, shape));
+}
+function reshapeEntryData(data, shapes) {
+    const out = {};
+    for (const [field, value] of Object.entries(data)) {
+        out[field] = reshapeFieldValue(value, shapes[field]);
+    }
+    return out;
+}
+/** One Fimo entry → one Strapi-v5 item (`id` + `documentId` + reshaped fields). */
+export function fimoEntryToStrapiItem(entry, shapes = {}) {
+    return { id: entry.id, documentId: entry.id, ...reshapeEntryData(entry.data, shapes) };
+}
+/** Fimo entries → a Strapi-v5 collection envelope (`{ data, meta.pagination }`). */
+export function fimoEntriesToStrapiList(entries, options = {}) {
+    const data = entries.map((entry) => fimoEntryToStrapiItem(entry, options.shapes));
+    const total = options.total ?? data.length;
+    const pageSize = options.pageSize ?? (data.length || 1);
+    return {
+        data,
+        meta: {
+            pagination: {
+                page: options.page ?? 1,
+                pageSize,
+                pageCount: pageSize > 0 ? Math.max(1, Math.ceil(total / pageSize)) : 1,
+                total,
+            },
+        },
+    };
+}
+/** Fimo entry → a Strapi-v5 single/singleton envelope (`{ data, meta }`). */
+export function fimoEntryToStrapiSingle(entry, shapes = {}) {
+    return { data: entry ? fimoEntryToStrapiItem(entry, shapes) : null, meta: {} };
+}

package/dist/runtime/svelte/index.d.ts

@@ -0,0 +1,3 @@
+export { fimoLabelAttrs, fimoMediaAttrs, FIMO_SOURCE_ATTR } from '../wrapped/dom.js';
+export { makeFimoT } from '../shared/labels-t.pure.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/svelte/index.js

@@ -0,0 +1,7 @@
+// fimo/svelte — CLIENT-SAFE surface for .svelte components (they hydrate:
+// importing the server barrel here pulls node builtins into the client
+// bundle, the exact class the Nuxt dogfood broke on). Server loaders live in
+// fimo/svelte/server, called from +layout.server.ts / +page.server.ts —
+// SvelteKit's own server-only convention.
+export { fimoLabelAttrs, fimoMediaAttrs, FIMO_SOURCE_ATTR } from '../wrapped/dom.js';
+export { makeFimoT } from '../shared/labels-t.pure.js';

package/dist/runtime/svelte/server.d.ts

@@ -0,0 +1,3 @@
+export * from '../wrapped/server.js';
+export { fimoLabelAttrs, fimoMediaAttrs } from '../wrapped/dom.js';
+//# sourceMappingURL=server.d.ts.map

package/dist/runtime/svelte/server.js

@@ -0,0 +1,6 @@
+// fimo/svelte/server — SvelteKit adapter, server surface. The loaders are
+// framework-neutral (SvelteKit needs no React): call them in server-side code
+// (frontmatter / load functions / useAsyncData) and render values with the
+// DOM attribute helpers so edit mode can select the elements.
+export * from '../wrapped/server.js';
+export { fimoLabelAttrs, fimoMediaAttrs } from '../wrapped/dom.js';

package/dist/runtime/vue/index.d.ts

@@ -0,0 +1,3 @@
+export { fimoLabelAttrs, fimoMediaAttrs, FIMO_SOURCE_ATTR } from '../wrapped/dom.js';
+export { makeFimoT } from '../shared/labels-t.pure.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/vue/index.js

@@ -0,0 +1,5 @@
+// fimo/vue — CLIENT-SAFE surface for Vue SFCs (same rule as fimo/svelte:
+// never re-export the server barrel from a surface component code imports).
+// Server loaders live in fimo/vue/server.
+export { fimoLabelAttrs, fimoMediaAttrs, FIMO_SOURCE_ATTR } from '../wrapped/dom.js';
+export { makeFimoT } from '../shared/labels-t.pure.js';

package/dist/runtime/vue/server.d.ts

@@ -0,0 +1,3 @@
+export * from '../wrapped/server.js';
+export { fimoLabelAttrs, fimoMediaAttrs } from '../wrapped/dom.js';
+//# sourceMappingURL=server.d.ts.map

package/dist/runtime/vue/server.js

@@ -0,0 +1,6 @@
+// fimo/vue/server — Vue adapter, server surface. The loaders are
+// framework-neutral (Vue needs no React): call them in server-side code
+// (frontmatter / load functions / useAsyncData) and render values with the
+// DOM attribute helpers so edit mode can select the elements.
+export * from '../wrapped/server.js';
+export { fimoLabelAttrs, fimoMediaAttrs } from '../wrapped/dom.js';

package/dist/runtime/wrapped/FimoFileLink.d.ts

@@ -0,0 +1,17 @@
+import { type ComponentPropsWithoutRef, type ReactNode } from 'react';
+type FimoFileLinkProps = Omit<ComponentPropsWithoutRef<'a'>, 'id'> & {
+    /** WrappedMedia entry key, e.g. `home.whitepaper`. Seeded at migration time. */
+    id: string;
+    children?: ReactNode;
+};
+/**
+ * Wraps a hardcoded file link (pdf, zip, ...) so the file becomes replaceable
+ * in Fimo. The original `href` stays in code as the fallback:
+ *
+ *   <FimoFileLink id="home.whitepaper" href="/whitepaper.pdf">
+ *     <FimoText id="home.whitepaper.cta">Download the whitepaper</FimoText>
+ *   </FimoFileLink>
+ */
+export declare function FimoFileLink({ id, href, children, ...props }: FimoFileLinkProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=FimoFileLink.d.ts.map

package/dist/runtime/wrapped/FimoFileLink.js

@@ -0,0 +1,19 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { FIMO_SOURCE } from '../primitives/lib/index.js';
+import { useWrappedMedia } from './WrappedContentContext.js';
+/**
+ * Wraps a hardcoded file link (pdf, zip, ...) so the file becomes replaceable
+ * in Fimo. The original `href` stays in code as the fallback:
+ *
+ *   <FimoFileLink id="home.whitepaper" href="/whitepaper.pdf">
+ *     <FimoText id="home.whitepaper.cta">Download the whitepaper</FimoText>
+ *   </FimoFileLink>
+ */
+export function FimoFileLink({ id, href, children, ...props }) {
+    const media = useWrappedMedia(id);
+    if (media) {
+        return (_jsx("a", { href: media.url, "data-fimo-source": media[FIMO_SOURCE], ...props, children: children }));
+    }
+    return (_jsx("a", { href: href, ...props, children: children }));
+}

package/dist/runtime/wrapped/FimoMediaImage.d.ts

@@ -0,0 +1,14 @@
+import { type ComponentPropsWithoutRef } from 'react';
+type FimoMediaImageProps = Omit<ComponentPropsWithoutRef<'img'>, 'id' | 'children'> & {
+    /** WrappedMedia entry key, e.g. `home.hero.image`. Seeded at migration time. */
+    id: string;
+};
+/**
+ * Wraps a hardcoded image so it becomes replaceable in Fimo. The original
+ * `src` stays in code as the fallback until the WrappedMedia entry resolves:
+ *
+ *   <FimoMediaImage id="home.hero.image" src="/images/dashboard.png" alt="Dashboard" width={1200} height={630} />
+ */
+export declare function FimoMediaImage({ id, src, alt, ...props }: FimoMediaImageProps): import("react/jsx-runtime").JSX.Element | null;
+export {};
+//# sourceMappingURL=FimoMediaImage.d.ts.map

package/dist/runtime/wrapped/FimoMediaImage.js

@@ -0,0 +1,20 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Image } from '../primitives/components/Image.js';
+import { useWrappedMedia } from './WrappedContentContext.js';
+/**
+ * Wraps a hardcoded image so it becomes replaceable in Fimo. The original
+ * `src` stays in code as the fallback until the WrappedMedia entry resolves:
+ *
+ *   <FimoMediaImage id="home.hero.image" src="/images/dashboard.png" alt="Dashboard" width={1200} height={630} />
+ */
+export function FimoMediaImage({ id, src, alt, ...props }) {
+    const media = useWrappedMedia(id);
+    if (media) {
+        return _jsx(Image, { value: media, alt: alt, ...props });
+    }
+    if (!src) {
+        return null;
+    }
+    return _jsx("img", { src: src, alt: alt, ...props });
+}

package/dist/runtime/wrapped/FimoMediaVideo.d.ts

@@ -0,0 +1,14 @@
+import { type ComponentPropsWithoutRef } from 'react';
+type FimoMediaVideoProps = Omit<ComponentPropsWithoutRef<'video'>, 'id' | 'children'> & {
+    /** WrappedMedia entry key, e.g. `home.demo.video`. Seeded at migration time. */
+    id: string;
+};
+/**
+ * Wraps a hardcoded video so it becomes replaceable in Fimo. The original
+ * `src` stays in code as the fallback until the WrappedMedia entry resolves:
+ *
+ *   <FimoMediaVideo id="home.demo.video" src="/demo.mp4" autoPlay muted loop />
+ */
+export declare function FimoMediaVideo({ id, src, autoPlay, loop, muted, playsInline, ...props }: FimoMediaVideoProps): import("react/jsx-runtime").JSX.Element | null;
+export {};
+//# sourceMappingURL=FimoMediaVideo.d.ts.map

package/dist/runtime/wrapped/FimoMediaVideo.js

@@ -0,0 +1,20 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Video } from '../primitives/components/Video.js';
+import { useWrappedMedia } from './WrappedContentContext.js';
+/**
+ * Wraps a hardcoded video so it becomes replaceable in Fimo. The original
+ * `src` stays in code as the fallback until the WrappedMedia entry resolves:
+ *
+ *   <FimoMediaVideo id="home.demo.video" src="/demo.mp4" autoPlay muted loop />
+ */
+export function FimoMediaVideo({ id, src, autoPlay, loop, muted, playsInline, ...props }) {
+    const media = useWrappedMedia(id);
+    if (media) {
+        return _jsx(Video, { value: media, autoPlay: autoPlay, loop: loop, muted: muted, playsInline: playsInline, ...props });
+    }
+    if (!src) {
+        return null;
+    }
+    return _jsx("video", { src: src, autoPlay: autoPlay, loop: loop, muted: muted, playsInline: playsInline, ...props });
+}

package/dist/runtime/wrapped/FimoRichTextBlock.d.ts

@@ -0,0 +1,23 @@
+import { type ReactNode } from 'react';
+import { type FimoRichTextComponents } from '../primitives/lib/index.js';
+interface FimoRichTextBlockProps {
+    /** WrappedRichText entry key, e.g. `home.hero.subtitle`. Seeded at migration time. */
+    id: string;
+    /** The original formatted markup — rendered when the entry is absent. */
+    children?: ReactNode;
+    components?: FimoRichTextComponents;
+    className?: string;
+}
+/**
+ * Wraps formatted text (bold, italic, underline, links) so it becomes
+ * editable with marks in Fimo. Seeding converts the original markup to
+ * TipTap JSON; the renderer emits the same tags back. The original JSX
+ * stays in code as the fallback:
+ *
+ *   <FimoRichTextBlock id="home.hero.subtitle">
+ *     <p>We help teams <strong>ship faster</strong> and <em>stay safe</em>.</p>
+ *   </FimoRichTextBlock>
+ */
+export declare function FimoRichTextBlock({ id, children, components, className }: FimoRichTextBlockProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=FimoRichTextBlock.d.ts.map

package/dist/runtime/wrapped/FimoRichTextBlock.js

@@ -0,0 +1,22 @@
+'use client';
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { RichText } from '../primitives/components/RichText.js';
+import { FimoRichText } from '../primitives/lib/index.js';
+import { useWrappedRichText } from './WrappedContentContext.js';
+/**
+ * Wraps formatted text (bold, italic, underline, links) so it becomes
+ * editable with marks in Fimo. Seeding converts the original markup to
+ * TipTap JSON; the renderer emits the same tags back. The original JSX
+ * stays in code as the fallback:
+ *
+ *   <FimoRichTextBlock id="home.hero.subtitle">
+ *     <p>We help teams <strong>ship faster</strong> and <em>stay safe</em>.</p>
+ *   </FimoRichTextBlock>
+ */
+export function FimoRichTextBlock({ id, children, components, className }) {
+    const entry = useWrappedRichText(id);
+    if (!entry) {
+        return _jsx(_Fragment, { children: children });
+    }
+    return (_jsx(RichText, { value: new FimoRichText(entry.content, entry.source), components: components, className: className }));
+}

package/dist/runtime/wrapped/FimoText.d.ts

@@ -0,0 +1,22 @@
+import { type ComponentPropsWithoutRef, type ElementType } from 'react';
+type FimoTextProps<T extends ElementType = 'span'> = {
+    /** Label key, e.g. `home.hero.title`. Seeded at migration time. */
+    id: string;
+    /** The original hardcoded string — rendered when the key has no value. */
+    children?: string;
+    as?: T;
+} & Omit<ComponentPropsWithoutRef<T>, 'id' | 'as' | 'children'>;
+/**
+ * Wraps a hardcoded string so it becomes editable in Fimo. The original
+ * string stays in code as the fallback:
+ *
+ *   <h1><FimoText id="home.hero.title">Ship your site in hours</FimoText></h1>
+ *
+ * For attribute strings use the two-argument label function instead:
+ *
+ *   const { t } = useLabels();
+ *   <input placeholder={String(t('home.newsletter.placeholder', 'Your work email'))} />
+ */
+export declare function FimoText<T extends ElementType = 'span'>({ id, children, as, ...props }: FimoTextProps<T>): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=FimoText.d.ts.map