fimo 0.7.0-experimental.1 → 0.7.0-experimental.10

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

@@ -0,0 +1,28 @@
+import React from 'react';
+import { FIMO_SOURCE, FimoMedia, type FimoRichTextContent } from '../primitives/lib/index.js';
+export interface WrappedMediaEntry {
+    url: string;
+    alt?: string;
+    name?: string;
+    mime?: string;
+    width?: number;
+    height?: number;
+    /** data-fimo-source path, e.g. `WrappedMedia.<entryId>.image` */
+    source: string;
+}
+export interface WrappedRichTextEntry {
+    content: FimoRichTextContent;
+    /** data-fimo-source path, e.g. `WrappedRichText.<entryId>.body` */
+    source: string;
+}
+export interface WrappedContentValue {
+    media: Record<string, WrappedMediaEntry>;
+    richText: Record<string, WrappedRichTextEntry>;
+}
+export declare function WrappedContentProvider({ media, richText, children, }: Partial<WrappedContentValue> & {
+    children?: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useWrappedMedia(id: string): FimoMedia | null;
+export declare function useWrappedRichText(id: string): WrappedRichTextEntry | null;
+export { FIMO_SOURCE };
+//# sourceMappingURL=WrappedContentContext.d.ts.map

package/dist/runtime/wrapped/WrappedContentContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WrappedContentContext.d.ts","sourceRoot":"","sources":["../../../src/runtime/wrapped/WrappedContentContext.tsx"],"names":[],"mappings":"AACA,OAAO,KAA6C,MAAM,OAAO,CAAC;AAElE,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,KAAK,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAE9F,MAAM,WAAW,iBAAiB;IAChC,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iEAAiE;IACjE,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,mBAAmB,CAAC;IAC7B,mEAAmE;IACnE,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;IACzC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;CAChD;AAMD,wBAAgB,sBAAsB,CAAC,EACrC,KAAK,EACL,QAAQ,EACR,QAAQ,GACT,EAAE,OAAO,CAAC,mBAAmB,CAAC,GAAG;IAAE,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;CAAE,2CAG/D;AAED,wBAAgB,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAiB5D;AAED,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,MAAM,GAAG,oBAAoB,GAAG,IAAI,CAG1E;AAED,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/runtime/wrapped/WrappedContentContext.js

@@ -0,0 +1,30 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useMemo } from 'react';
+import { FIMO_SOURCE, FimoMedia } from '../primitives/lib/index.js';
+const emptyValue = { media: {}, richText: {} };
+const WrappedContentContext = createContext(emptyValue);
+export function WrappedContentProvider({ media, richText, children, }) {
+    const value = useMemo(() => ({ media: media ?? {}, richText: richText ?? {} }), [media, richText]);
+    return _jsx(WrappedContentContext.Provider, { value: value, children: children });
+}
+export function useWrappedMedia(id) {
+    const { media } = useContext(WrappedContentContext);
+    const entry = media[id];
+    if (!entry) {
+        return null;
+    }
+    return new FimoMedia({
+        url: entry.url,
+        alt: entry.alt ?? '',
+        name: entry.name ?? id,
+        mime: entry.mime ?? '',
+        width: entry.width,
+        height: entry.height,
+    }, entry.source);
+}
+export function useWrappedRichText(id) {
+    const { richText } = useContext(WrappedContentContext);
+    return richText[id] ?? null;
+}
+export { FIMO_SOURCE };

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

@@ -0,0 +1,33 @@
+import React from 'react';
+import type { FimoConfig } from '../shared/fimo-config.types.js';
+import { type WrappedMediaEntry, type WrappedRichTextEntry } from './WrappedContentContext.js';
+export interface WrappedLabels {
+    dictionaries: Record<string, Record<string, string>>;
+    defaultLocale: string;
+    locales?: string[];
+    updatedAt?: string | null;
+    signature: string;
+}
+/** Framework navigation adapter: the ONLY thing an adapter must supply. */
+export interface WrappedNavigation {
+    pathname: string | null;
+    navigate: (to: string) => void;
+}
+export interface WrappedProvidersProps {
+    config: FimoConfig;
+    labels?: WrappedLabels;
+    media?: Record<string, WrappedMediaEntry>;
+    richText?: Record<string, WrappedRichTextEntry>;
+    locale?: string;
+    navigation: WrappedNavigation;
+    children?: React.ReactNode;
+}
+/**
+ * Framework-neutral providers for WRAPPED (adopted) apps. Adapters
+ * (fimo/next, fimo/remix, ...) supply only the navigation hooks; everything
+ * else — label hydration, locale resolution, preview bridge, error boundary —
+ * is shared. Content arrives as serializable props from the wrapped server
+ * loaders.
+ */
+export declare function WrappedProviders({ config, labels, media, richText, locale, navigation, children }: WrappedProvidersProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=WrappedProviders.d.ts.map

package/dist/runtime/wrapped/WrappedProviders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WrappedProviders.d.ts","sourceRoot":"","sources":["../../../src/runtime/wrapped/WrappedProviders.tsx"],"names":[],"mappings":"AAEA,OAAO,KAA8D,MAAM,OAAO,CAAC;AAUnF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AACjE,OAAO,EAA0B,KAAK,iBAAiB,EAAE,KAAK,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAEvH,MAAM,WAAW,aAAa;IAC5B,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACrD,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,2EAA2E;AAC3E,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,QAAQ,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;CAChC;AAED,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,UAAU,CAAC;IACnB,MAAM,CAAC,EAAE,aAAa,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;IAC1C,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;IAChD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,iBAAiB,CAAC;IAC9B,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;CAC5B;AA+DD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,EAAE,qBAAqB,2CAqDxH"}

package/dist/runtime/wrapped/WrappedProviders.js

@@ -0,0 +1,101 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { Suspense, useCallback, useEffect, useMemo, useState } from 'react';
+import { ErrorBoundary } from 'react-error-boundary';
+import { DataSourcesProvider } from '../content/DataSourcesProvider.js';
+import { AppErrorBoundary, onError } from '../core/AppErrorBoundary.js';
+import { FimoLocaleProvider } from '../i18n/FimoLocaleContext.js';
+import { getFimoTextDirection, resolveFimoLocale, toHtmlLang } from '../i18n/locale.js';
+import { ScreenshotProvider } from '../iframe/ScreenshotProvider.js';
+import { hydrateLabels } from '../primitives/labels-store.js';
+import { getDisplayRoutes } from '../shared/display-routes.js';
+import { WrappedContentProvider } from './WrappedContentContext.js';
+function toLabelState(labels) {
+    return {
+        dictionaries: labels.dictionaries,
+        defaultLocale: labels.defaultLocale,
+        signature: labels.signature,
+        updatedAt: labels.updatedAt ?? null,
+    };
+}
+function PreviewBridge({ config, navigation }) {
+    const { pathname, navigate } = navigation;
+    const localeResolution = useMemo(() => resolveFimoLocale({ pathname: pathname ?? undefined }, config), [pathname, config]);
+    const sendRoutes = useCallback(() => {
+        window.parent.postMessage({ type: 'nav/routes', payload: { routes: getDisplayRoutes(config) } }, '*');
+    }, [config]);
+    const sendLocationChange = useCallback(() => {
+        window.parent.postMessage({
+            type: 'nav/locationChange',
+            payload: {
+                path: pathname,
+                routePath: localeResolution.routePath,
+                locale: localeResolution.locale,
+            },
+        }, '*');
+    }, [pathname, localeResolution.locale, localeResolution.routePath]);
+    useEffect(sendRoutes, [sendRoutes]);
+    useEffect(sendLocationChange, [sendLocationChange]);
+    useEffect(() => {
+        const handleMessage = (event) => {
+            const type = event.data?.type;
+            const payload = event.data?.payload;
+            switch (type) {
+                case 'nav/navigate':
+                    if (payload?.to) {
+                        navigate(payload.to);
+                    }
+                    return;
+                case 'nav/read-routes':
+                    sendRoutes();
+                    sendLocationChange();
+                    return;
+            }
+        };
+        window.addEventListener('message', handleMessage);
+        return () => {
+            window.removeEventListener('message', handleMessage);
+        };
+    }, [navigate, sendRoutes, sendLocationChange]);
+    return null;
+}
+/**
+ * Framework-neutral providers for WRAPPED (adopted) apps. Adapters
+ * (fimo/next, fimo/remix, ...) supply only the navigation hooks; everything
+ * else — label hydration, locale resolution, preview bridge, error boundary —
+ * is shared. Content arrives as serializable props from the wrapped server
+ * loaders.
+ */
+export function WrappedProviders({ config, labels, media, richText, locale, navigation, children }) {
+    // Wrapped apps have no QueryClientProvider of their own; ScreenshotProvider
+    // (and future data-refresh machinery) need one, so the adapter owns it.
+    const [queryClient] = useState(() => new QueryClient());
+    useState(() => {
+        if (labels) {
+            hydrateLabels(toLabelState(labels));
+        }
+        return null;
+    });
+    useEffect(() => {
+        if (labels) {
+            hydrateLabels(toLabelState(labels));
+        }
+    }, [labels]);
+    const pathname = navigation.pathname;
+    const localeResolution = useMemo(() => resolveFimoLocale({ pathname: pathname ?? undefined }, config), [pathname, config]);
+    const activeLocale = locale ?? localeResolution.locale;
+    const activeDir = getFimoTextDirection(activeLocale);
+    useEffect(() => {
+        if (typeof document === 'undefined') {
+            return;
+        }
+        document.documentElement.lang = toHtmlLang(activeLocale);
+        document.documentElement.dir = activeDir;
+    }, [activeDir, activeLocale]);
+    return (_jsx(ErrorBoundary, { FallbackComponent: AppErrorBoundary, onError: onError, children: _jsx(QueryClientProvider, { client: queryClient, children: _jsx(FimoLocaleProvider, { value: {
+                    ...localeResolution,
+                    locale: activeLocale,
+                    dir: activeDir,
+                }, children: _jsx(WrappedContentProvider, { media: media, richText: richText, children: _jsx(DataSourcesProvider, { children: _jsxs(ScreenshotProvider, { children: [_jsx(PreviewBridge, { config: config, navigation: navigation }), _jsx(Suspense, { children: children })] }) }) }) }) }) }));
+}

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

@@ -0,0 +1,4 @@
+export declare const FIMO_SOURCE_ATTR = "data-fimo-source";
+export declare function fimoLabelAttrs(key: string, locale?: string): Record<string, string>;
+export declare function fimoMediaAttrs(source: string): Record<string, string>;
+//# sourceMappingURL=dom.d.ts.map

package/dist/runtime/wrapped/dom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dom.d.ts","sourceRoot":"","sources":["../../../src/runtime/wrapped/dom.ts"],"names":[],"mappings":"AAgBA,eAAO,MAAM,gBAAgB,qBAAqB,CAAC;AAEnD,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,SAAO,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAEjF;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAErE"}

package/dist/runtime/wrapped/dom.js

@@ -0,0 +1,23 @@
+// Framework-agnostic DOM contract for wrapped content in NON-React
+// frameworks (Astro templates, Vue SFCs, Svelte components). The edit-mode
+// preview client selects elements by these attributes; rendering the value +
+// attributes is all a template needs:
+//
+//   Astro:  <h1 {...fimoLabelAttrs('home.title')}>{t('home.title', 'Hello')}</h1>
+//   Vue:    <h1 v-bind="fimoLabelAttrs('home.title')">{{ t('home.title', 'Hello') }}</h1>
+//   Svelte: <h1 {...fimoLabelAttrs('home.title')}>{tv}</h1>
+//
+// Values come from the server loaders (loadFimoT / loadWrappedMedia) — after
+// an edit, the page refetches on reload; live DOM patching is handled by the
+// preview client via these same attributes.
+// NOTE: this must be the literal DOM attribute the preview client queries
+// (`document.querySelectorAll('[data-fimo-source]')`) — NOT the FIMO_SOURCE
+// Symbol from the React primitives: a symbol key vanishes in a template
+// attribute spread and in JSON, silently breaking editability.
+export const FIMO_SOURCE_ATTR = 'data-fimo-source';
+export function fimoLabelAttrs(key, locale = 'en') {
+    return { [FIMO_SOURCE_ATTR]: `__labels.${locale}.${key}.value` };
+}
+export function fimoMediaAttrs(source) {
+    return { [FIMO_SOURCE_ATTR]: source };
+}

package/dist/runtime/wrapped/dom.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=dom.test.d.ts.map

package/dist/runtime/wrapped/dom.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dom.test.d.ts","sourceRoot":"","sources":["../../../src/runtime/wrapped/dom.test.ts"],"names":[],"mappings":""}

package/dist/runtime/wrapped/dom.test.js

@@ -0,0 +1,16 @@
+import { describe, expect, it } from 'vitest';
+import { fimoLabelAttrs, fimoMediaAttrs } from './dom.js';
+describe('wrapped DOM attrs', () => {
+    it('emits the literal data-fimo-source attribute (a symbol key would vanish in template spreads)', () => {
+        expect(fimoLabelAttrs('home.hero.title')).toEqual({
+            'data-fimo-source': '__labels.en.home.hero.title.value',
+        });
+        expect(fimoLabelAttrs('home.hero.title', 'fr')).toEqual({
+            'data-fimo-source': '__labels.fr.home.hero.title.value',
+        });
+        expect(fimoMediaAttrs('hero.image')).toEqual({ 'data-fimo-source': 'hero.image' });
+    });
+    it('survives JSON serialization (the shape template engines actually consume)', () => {
+        expect(JSON.parse(JSON.stringify(fimoLabelAttrs('k')))).not.toEqual({});
+    });
+});

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

@@ -0,0 +1,77 @@
+import type { FimoNextLabels } from '../next/FimoNextProviders.js';
+import type { FimoConfig } from '../shared/fimo-config.types.js';
+import type { WrappedMediaEntry, WrappedRichTextEntry } from './WrappedContentContext.js';
+export interface FimoServerOptions {
+    /** Project root (where fimo-config.json and .env live). Defaults to cwd. */
+    rootDir?: string;
+    /** Tenant API base URL. Defaults to NEXT_PUBLIC_FIMO_API_URL / VITE_API_URL. */
+    apiUrl?: string;
+}
+export declare function loadFimoConfig(rootDir?: string): FimoConfig;
+export declare function loadFimoLabels(options?: FimoServerOptions): Promise<FimoNextLabels>;
+/**
+ * Server-component label accessor: `useLabels()` is client-only, and forcing
+ * a client wrapper for one aria-label in a server component is not a
+ * migration, it is collateral damage. Load once per request scope and read
+ * synchronously: `const t = await loadFimoT(); <a aria-label={t('footer.github', 'GitHub')} …`.
+ */
+export declare function loadFimoT(options?: FimoServerOptions & {
+    locale?: string;
+}): Promise<(key: string, fallback: string) => string>;
+export interface FimoEntry {
+    id: string;
+    data: Record<string, unknown>;
+}
+/**
+ * Fetch published entries of a content type from the public tenant API.
+ * Returns [] when the API is unreachable so the wrapped site keeps rendering
+ * its fallbacks.
+ */
+export declare function fetchEntries(typeName: string, options?: FimoServerOptions & {
+    /** The public API returns newest-first; rendering wants source order.
+     *  Default 'oldest' restores insertion order for migrated collections. */
+    order?: 'oldest' | 'newest';
+    /** Query filter forwarded to the public API (e.g. { slug: { $in: [...] } }). */
+    where?: Record<string, unknown>;
+    /** Row cap forwarded to the public API. */
+    limit?: number;
+}): Promise<FimoEntry[]>;
+/**
+ * Load the WrappedMedia entries (key → media) seeded by the wrap migration.
+ * Each entry has a `key` (the FimoMediaImage/Video/FileLink id) and an
+ * asset-typed `image` field.
+ */
+export declare function loadWrappedMedia(options?: FimoServerOptions): Promise<Record<string, WrappedMediaEntry>>;
+/**
+ * Load the WrappedRichText entries (key → TipTap JSON) seeded by the wrap
+ * migration for formatted text (bold/italic/underline/links).
+ */
+export declare function loadWrappedRichText(options?: FimoServerOptions): Promise<Record<string, WrappedRichTextEntry>>;
+/**
+ * Overlay a wrap-migrated collection onto its retained source rows: fetch the
+ * Fimo entries matching the source rows' keys, merge field-by-field with the
+ * type-matched rule above, and return plain data rows in SOURCE order. The
+ * page keeps its original render logic and its original fallback — edits made
+ * in Fimo show up, everything else stays byte-identical.
+ */
+export declare function wrapCollection<T extends Record<string, unknown>>(typeName: string, sourceRows: readonly T[], options?: FimoServerOptions & {
+    keyField?: string;
+}): Promise<T[]>;
+/**
+ * Load a locale's messages from Fimo for an EXISTING i18n runtime (next-intl,
+ * i18next). Wrap-mode i18n ingestion seeds the app's message store into Fimo
+ * labels (flat dot-keys); this fetches them back and un-flattens them into the
+ * nested shape the app's own i18n loader expects — so the app keeps its
+ * `useTranslations`/`t()` unchanged, now editable from Fimo Studio.
+ *
+ * Deep-merge over the shipped messages (pass them as `fallback`) so any key
+ * not yet in Fimo falls back to the static file instead of showing a missing
+ * key. Wire it in the app's message loader, e.g. next-intl `i18n/request.ts`:
+ *
+ *   const messages = await loadFimoMessages(locale, { fallback: staticMessages });
+ *   return { locale, messages };
+ */
+export declare function loadFimoMessages(locale: string, options?: FimoServerOptions & {
+    fallback?: Record<string, unknown>;
+}): Promise<Record<string, unknown>>;
+//# sourceMappingURL=server.d.ts.map

package/dist/runtime/wrapped/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../src/runtime/wrapped/server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAMnE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAUjE,OAAO,KAAK,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAE1F,MAAM,WAAW,iBAAiB;IAChC,4EAA4E;IAC5E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gFAAgF;IAChF,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wBAAgB,cAAc,CAAC,OAAO,GAAE,MAAsB,GAAG,UAAU,CAE1E;AAED,wBAAsB,cAAc,CAAC,OAAO,GAAE,iBAAsB,GAAG,OAAO,CAAC,cAAc,CAAC,CAI7F;AAED;;;;;GAKG;AACH,wBAAsB,SAAS,CAC7B,OAAO,GAAE,iBAAiB,GAAG;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAO,GACpD,OAAO,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAC,CAQpD;AAED,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B;AAUD;;;;GAIG;AACH,wBAAsB,YAAY,CAChC,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,iBAAiB,GAAG;IAC3B;8EAC0E;IAC1E,KAAK,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAC5B,gFAAgF;IAChF,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,2CAA2C;IAC3C,KAAK,CAAC,EAAE,MAAM,CAAC;CACX,GACL,OAAO,CAAC,SAAS,EAAE,CAAC,CA+BtB;AAUD;;;;GAIG;AACH,wBAAsB,gBAAgB,CAAC,OAAO,GAAE,iBAAsB,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC,CA2BlH;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,CACvC,OAAO,GAAE,iBAAsB,GAC9B,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC,CAiB/C;AAqCD;;;;;;GAMG;AACH,wBAAsB,cAAc,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpE,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,SAAS,CAAC,EAAE,EACxB,OAAO,GAAE,iBAAiB,GAAG;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAO,GACtD,OAAO,CAAC,CAAC,EAAE,CAAC,CAoCd;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,iBAAiB,GAAG;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAO,GACvE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAelC"}

package/dist/runtime/wrapped/server.js

@@ -0,0 +1,237 @@
+// Server-only loaders for WRAPPED (adopted) apps — framework-neutral.
+// Content resolves at request time from the public tenant API (no Vite
+// virtual modules, no build plugin). Framework adapters re-export these:
+// fimo/next/server today, fimo/astro tomorrow — same loaders, same shapes.
+import { getConfigServer } from '../shared/fimo-config.server.js';
+import { deepMergeMessages, unflattenMessages } from '../shared/i18n-messages.js';
+import { fetchLabelDictionary, fetchWithTimeout, labelSignature, loadLabelBundle, readProjectEnv, resolveTenantApiUrl, } from '../shared/labels-fetch.server.js';
+export function loadFimoConfig(rootDir = process.cwd()) {
+    return getConfigServer(rootDir);
+}
+export async function loadFimoLabels(options = {}) {
+    const rootDir = options.rootDir ?? process.cwd();
+    const bundle = await loadLabelBundle(rootDir);
+    return { ...bundle, signature: labelSignature(bundle) };
+}
+/**
+ * Server-component label accessor: `useLabels()` is client-only, and forcing
+ * a client wrapper for one aria-label in a server component is not a
+ * migration, it is collateral damage. Load once per request scope and read
+ * synchronously: `const t = await loadFimoT(); <a aria-label={t('footer.github', 'GitHub')} …`.
+ */
+export async function loadFimoT(options = {}) {
+    const labels = await loadFimoLabels(options);
+    const locale = options.locale ?? labels.defaultLocale;
+    const dictionary = labels.dictionaries[locale] ?? labels.dictionaries[labels.defaultLocale] ?? {};
+    return (key, fallback) => {
+        const value = dictionary[key];
+        return typeof value === 'string' && value.length > 0 ? value : fallback;
+    };
+}
+async function resolveApiUrl(options) {
+    if (options.apiUrl) {
+        return options.apiUrl;
+    }
+    const env = await readProjectEnv(options.rootDir ?? process.cwd());
+    return resolveTenantApiUrl(env);
+}
+/**
+ * Fetch published entries of a content type from the public tenant API.
+ * Returns [] when the API is unreachable so the wrapped site keeps rendering
+ * its fallbacks.
+ */
+export async function fetchEntries(typeName, options = {}) {
+    const apiUrl = await resolveApiUrl(options);
+    if (!apiUrl) {
+        return [];
+    }
+    try {
+        const url = new URL(`/entries/${typeName}`, apiUrl);
+        if (options.where) {
+            url.searchParams.set('where', JSON.stringify(options.where));
+        }
+        if (options.limit) {
+            url.searchParams.set('limit', String(options.limit));
+        }
+        const response = await fetchWithTimeout(url, 4000);
+        if (!response.ok) {
+            return [];
+        }
+        const body = (await response.json());
+        const rows = Array.isArray(body.data) ? body.data : [];
+        const entries = rows
+            .filter((row) => Boolean(row) && typeof row === 'object')
+            .map((row) => ({
+            id: String(row.id ?? row.documentId ?? ''),
+            data: (row.data && typeof row.data === 'object' ? row.data : row),
+        }))
+            .filter((row) => row.id.length > 0);
+        return (options.order ?? 'oldest') === 'oldest' ? entries.reverse() : entries;
+    }
+    catch {
+        return [];
+    }
+}
+function readString(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function readNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+/**
+ * Load the WrappedMedia entries (key → media) seeded by the wrap migration.
+ * Each entry has a `key` (the FimoMediaImage/Video/FileLink id) and an
+ * asset-typed `image` field.
+ */
+export async function loadWrappedMedia(options = {}) {
+    const entries = await fetchEntries('WrappedMedia', options);
+    const map = {};
+    for (const entry of entries) {
+        const key = readString(entry.data.key) ?? readString(entry.data.slug);
+        const asset = entry.data.image;
+        if (!key || !asset || typeof asset !== 'object') {
+            continue;
+        }
+        const assetRecord = asset;
+        const url = readString(assetRecord.url);
+        if (!url) {
+            continue;
+        }
+        map[key] = {
+            url,
+            alt: readString(assetRecord.alt) ?? readString(entry.data.alt),
+            name: readString(assetRecord.name),
+            mime: readString(assetRecord.mime) ?? readString(assetRecord.mimeType),
+            width: readNumber(assetRecord.width),
+            height: readNumber(assetRecord.height),
+            source: `WrappedMedia.${entry.id}.image`,
+        };
+    }
+    return map;
+}
+/**
+ * Load the WrappedRichText entries (key → TipTap JSON) seeded by the wrap
+ * migration for formatted text (bold/italic/underline/links).
+ */
+export async function loadWrappedRichText(options = {}) {
+    const entries = await fetchEntries('WrappedRichText', options);
+    const map = {};
+    for (const entry of entries) {
+        const key = readString(entry.data.key) ?? readString(entry.data.slug);
+        const body = entry.data.body;
+        if (!key || !body || typeof body !== 'object') {
+            continue;
+        }
+        map[key] = {
+            content: body,
+            source: `WrappedRichText.${entry.id}.body`,
+        };
+    }
+    return map;
+}
+/** Key fields tried, in order, to align a source row with its Fimo entry. */
+const COLLECTION_KEY_FIELDS = ['slug', 'id', 'key', 'name', 'title', 'question'];
+/** Fimo entries fetched per collection: covers rendered windows and small
+ *  collections entirely; rows beyond it keep rendering their source values. */
+const COLLECTION_FETCH_CAP = 100;
+function collectionKeyField(rows) {
+    for (const field of COLLECTION_KEY_FIELDS) {
+        if (rows.every((row) => typeof row[field] === 'string' && row[field].length > 0)) {
+            return field;
+        }
+    }
+    return null;
+}
+/** A Fimo value replaces its source value only when the SHAPES agree, so a
+ *  page that rendered strings keeps rendering strings: media envelopes,
+ *  richtext docs, reference handles, and nulls all fall back to the source
+ *  value instead of leaking objects into JSX. */
+function preferTypeMatched(fimoValue, sourceValue) {
+    if (fimoValue === null || fimoValue === undefined) {
+        return sourceValue;
+    }
+    if (Array.isArray(sourceValue)) {
+        if (!Array.isArray(fimoValue)) {
+            return sourceValue;
+        }
+        return fimoValue.every((element) => typeof element === typeof (sourceValue[0] ?? '') && typeof element !== 'object')
+            ? fimoValue
+            : sourceValue;
+    }
+    return typeof fimoValue === typeof sourceValue && typeof fimoValue !== 'object' ? fimoValue : sourceValue;
+}
+/**
+ * Overlay a wrap-migrated collection onto its retained source rows: fetch the
+ * Fimo entries matching the source rows' keys, merge field-by-field with the
+ * type-matched rule above, and return plain data rows in SOURCE order. The
+ * page keeps its original render logic and its original fallback — edits made
+ * in Fimo show up, everything else stays byte-identical.
+ */
+export async function wrapCollection(typeName, sourceRows, options = {}) {
+    const rows = sourceRows;
+    if (rows.length === 0) {
+        return [];
+    }
+    const keyField = options.keyField ?? collectionKeyField(rows);
+    if (!keyField) {
+        return sourceRows;
+    }
+    const keys = rows.slice(0, COLLECTION_FETCH_CAP).map((row) => row[keyField]);
+    const entries = await fetchEntries(typeName, {
+        ...options,
+        where: { [keyField]: { $in: keys } },
+        limit: keys.length,
+    });
+    if (entries.length === 0) {
+        return sourceRows;
+    }
+    const byKey = new Map();
+    for (const entry of entries) {
+        const key = entry.data[keyField];
+        if (typeof key === 'string' && !byKey.has(key)) {
+            byKey.set(key, entry.data);
+        }
+    }
+    return rows.map((row) => {
+        const fimoRow = byKey.get(row[keyField]);
+        if (!fimoRow) {
+            return row;
+        }
+        const merged = { ...row };
+        for (const field of Object.keys(row)) {
+            merged[field] = preferTypeMatched(fimoRow[field], row[field]);
+        }
+        return merged;
+    });
+}
+/**
+ * Load a locale's messages from Fimo for an EXISTING i18n runtime (next-intl,
+ * i18next). Wrap-mode i18n ingestion seeds the app's message store into Fimo
+ * labels (flat dot-keys); this fetches them back and un-flattens them into the
+ * nested shape the app's own i18n loader expects — so the app keeps its
+ * `useTranslations`/`t()` unchanged, now editable from Fimo Studio.
+ *
+ * Deep-merge over the shipped messages (pass them as `fallback`) so any key
+ * not yet in Fimo falls back to the static file instead of showing a missing
+ * key. Wire it in the app's message loader, e.g. next-intl `i18n/request.ts`:
+ *
+ *   const messages = await loadFimoMessages(locale, { fallback: staticMessages });
+ *   return { locale, messages };
+ */
+export async function loadFimoMessages(locale, options = {}) {
+    const fallback = options.fallback ?? {};
+    const apiUrl = await resolveApiUrl(options);
+    if (!apiUrl) {
+        return fallback;
+    }
+    try {
+        const { labels } = await fetchLabelDictionary(apiUrl, locale);
+        if (Object.keys(labels).length === 0) {
+            return fallback;
+        }
+        return deepMergeMessages(fallback, unflattenMessages(labels));
+    }
+    catch {
+        return fallback;
+    }
+}

package/dist/runtime/wrapped/server.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=server.test.d.ts.map

package/dist/runtime/wrapped/server.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.test.d.ts","sourceRoot":"","sources":["../../../src/runtime/wrapped/server.test.ts"],"names":[],"mappings":""}