@nitrogenbuilder/connector-payload 1.1.0 → 1.2.0

package/dist/endpoints/templates.js

@@ -1,4 +1,5 @@
 import { getNitrogenSettings, buildDynamicData, buildResolvedPageResponse, buildResolvedListItemResponse, getDocumentPermalink, getDocumentRelativePermalink, getTemplateForType, requireAuth, } from './helpers.js';
+import { buildDynamicDataMeta, computeDocTranslationStatus, fetchLocaleAllDoc, getDefaultLocaleTitle, getLocalizationSettings, getPayloadLocalization, getRequestLanguage, resolveLocaleOptions, } from '../localization.js';
 function isContentTemplateCollection(collection) {
     return !!collection && collection !== 'header' && collection !== 'footer';
 }
@@ -25,6 +26,7 @@ export const templatesEndpoints = [
         handler: async (req) => {
             const { payload, routeParams } = req;
             const slug = routeParams?.slug;
+            const localeOptions = resolveLocaleOptions(payload, getRequestLanguage(req));
             try {
                 const [result, headerTemplate, footerTemplate] = await Promise.all([
                     payload.find({
@@ -32,6 +34,7 @@ export const templatesEndpoints = [
                         where: { slug: { equals: slug } },
                         limit: 1,
                         depth: 1,
+                        ...localeOptions,
                     }),
                     getTemplateForType(payload, 'header'),
                     getTemplateForType(payload, 'footer'),
@@ -50,6 +53,7 @@ export const templatesEndpoints = [
                             collection: associatedCollection,
                             limit: 1,
                             depth: 1,
+                            ...localeOptions,
                         });
                         if (associated.docs.length) {
                             associatedDoc = associated.docs[0];
@@ -61,9 +65,24 @@ export const templatesEndpoints = [
                     }
                 }
                 const response = await buildResolvedPageResponse(payload, doc, settings, dynamicData);
+                // When a language was requested, the top-level `title` must stay the
+                // default-locale one — the editor edits default-language field data
+                // only and PATCHes `title` back on save. The meta may describe the
+                // associated doc, but the round-tripped title is the template's own.
+                const templateAllDoc = localeOptions.locale
+                    ? await fetchLocaleAllDoc(payload, 'nitrogen-templates', doc.id)
+                    : undefined;
+                const dynamicDataMeta = associatedDoc
+                    ? await buildDynamicDataMeta(payload, associatedCollection, associatedDoc.id)
+                    : await buildDynamicDataMeta(payload, 'nitrogen-templates', doc.id, templateAllDoc);
+                const titleOverride = localeOptions.locale
+                    ? getDefaultLocaleTitle(payload, templateAllDoc ?? null)
+                    : null;
                 const previewTarget = getTemplatePreviewTarget(doc, settings, associatedCollection, associatedDoc);
                 return Response.json({
                     ...response,
+                    ...(titleOverride !== null ? { title: titleOverride } : {}),
+                    ...(dynamicDataMeta ? { dynamic_data_meta: dynamicDataMeta } : {}),
                     slug: previewTarget.slug,
                     permalink: previewTarget.permalink,
                     relative_permalink: previewTarget.relative_permalink,
@@ -87,6 +106,7 @@ export const templatesEndpoints = [
             const settings = await getNitrogenSettings(payload);
             const url = new URL(req.url || '', 'http://localhost');
             const templateType = url.searchParams.get('templateType');
+            const localeOptions = resolveLocaleOptions(payload, getRequestLanguage(req));
             const where = {
                 status: { equals: 'published' },
             };
@@ -98,6 +118,7 @@ export const templatesEndpoints = [
                 where,
                 limit: 0,
                 depth: 1,
+                ...localeOptions,
             });
             const items = await Promise.all(result.docs.map(async (doc) => {
                 const response = await buildResolvedListItemResponse(payload, doc, settings);
@@ -118,12 +139,14 @@ export const templatesEndpoints = [
         handler: async (req) => {
             const { payload, routeParams } = req;
             const id = routeParams?.id;
+            const localeOptions = resolveLocaleOptions(payload, getRequestLanguage(req));
             try {
                 const [doc, headerTemplate, footerTemplate] = await Promise.all([
                     payload.findByID({
                         collection: 'nitrogen-templates',
                         id,
                         depth: 1,
+                        ...localeOptions,
                     }),
                     getTemplateForType(payload, 'header'),
                     getTemplateForType(payload, 'footer'),
@@ -140,6 +163,7 @@ export const templatesEndpoints = [
                             collection: associatedCollection,
                             limit: 1,
                             depth: 1,
+                            ...localeOptions,
                         });
                         if (associated.docs.length) {
                             associatedDoc = associated.docs[0];
@@ -151,9 +175,22 @@ export const templatesEndpoints = [
                     }
                 }
                 const response = await buildResolvedPageResponse(payload, doc, settings, dynamicData);
+                // See GET slug/:slug — keep the round-tripped `title` at the default
+                // locale.
+                const templateAllDoc = localeOptions.locale
+                    ? await fetchLocaleAllDoc(payload, 'nitrogen-templates', doc.id)
+                    : undefined;
+                const dynamicDataMeta = associatedDoc
+                    ? await buildDynamicDataMeta(payload, associatedCollection, associatedDoc.id)
+                    : await buildDynamicDataMeta(payload, 'nitrogen-templates', doc.id, templateAllDoc);
+                const titleOverride = localeOptions.locale
+                    ? getDefaultLocaleTitle(payload, templateAllDoc ?? null)
+                    : null;
                 const previewTarget = getTemplatePreviewTarget(doc, settings, associatedCollection, associatedDoc);
                 return Response.json({
                     ...response,
+                    ...(titleOverride !== null ? { title: titleOverride } : {}),
+                    ...(dynamicDataMeta ? { dynamic_data_meta: dynamicDataMeta } : {}),
                     slug: previewTarget.slug,
                     permalink: previewTarget.permalink,
                     relative_permalink: previewTarget.relative_permalink,
@@ -168,6 +205,56 @@ export const templatesEndpoints = [
             }
         },
     },
+    // GET /api/nitrogen/v1/nitrogen-templates/:id/dynamic-data — Dynamic data
+    // (+ meta) for a template, optionally in a specific language (?lang=es).
+    {
+        path: '/nitrogen/v1/nitrogen-templates/:id/dynamic-data',
+        method: 'get',
+        handler: async (req) => {
+            const { payload, routeParams } = req;
+            const id = routeParams?.id;
+            const localeOptions = resolveLocaleOptions(payload, getRequestLanguage(req));
+            try {
+                const doc = (await payload.findByID({
+                    collection: 'nitrogen-templates',
+                    id,
+                    depth: 1,
+                    ...localeOptions,
+                }));
+                const settings = await getNitrogenSettings(payload);
+                let dynamicData = buildDynamicData(doc, settings);
+                let associatedDoc;
+                const associatedCollection = doc.associatedCollection;
+                if (isContentTemplateCollection(associatedCollection)) {
+                    try {
+                        const associated = await payload.find({
+                            collection: associatedCollection,
+                            limit: 1,
+                            depth: 1,
+                            ...localeOptions,
+                        });
+                        if (associated.docs.length) {
+                            associatedDoc = associated.docs[0];
+                            dynamicData = buildDynamicData(associatedDoc, settings);
+                        }
+                    }
+                    catch {
+                        // Collection may not exist — use template's own data
+                    }
+                }
+                const dynamicDataMeta = associatedDoc
+                    ? await buildDynamicDataMeta(payload, associatedCollection, associatedDoc.id)
+                    : await buildDynamicDataMeta(payload, 'nitrogen-templates', doc.id);
+                return Response.json({
+                    dynamic_data: dynamicData,
+                    ...(dynamicDataMeta ? { dynamic_data_meta: dynamicDataMeta } : {}),
+                });
+            }
+            catch {
+                return Response.json({ error: 'Not found' }, { status: 404 });
+            }
+        },
+    },
     // PATCH /api/nitrogen/v1/templates/:id — Update a template
     {
         path: '/nitrogen/v1/nitrogen-templates/:id',
@@ -206,10 +293,39 @@ export const templatesEndpoints = [
             if (Object.keys(updateData).length === 0) {
                 return Response.json({ error: 'No update data provided' }, { status: 400 });
             }
+            // Localization enabled → recompute per-language translation status from
+            // the saved module tree. Advisory only — never blocks the save.
+            if (updateData.nitrogenData !== undefined) {
+                try {
+                    const settings = await getNitrogenSettings(payload);
+                    const localization = getLocalizationSettings(settings);
+                    if (localization) {
+                        const translationStatus = await computeDocTranslationStatus({
+                            payload,
+                            collectionSlug: 'nitrogen-templates',
+                            docId: id,
+                            nitrogenData: updateData.nitrogenData,
+                            localization,
+                        });
+                        if (translationStatus) {
+                            updateData.nitrogenTranslationStatus = translationStatus;
+                        }
+                    }
+                }
+                catch {
+                    // Status is advisory — never block the save.
+                }
+            }
+            // The editor edits default-language field data only — pin the write to
+            // the default locale so it can never target a request-derived locale.
+            const payloadLocalization = getPayloadLocalization(payload);
             await payload.update({
                 collection: 'nitrogen-templates',
                 id,
                 data: updateData,
+                ...(payloadLocalization
+                    ? { locale: payloadLocalization.defaultLocale }
+                    : {}),
             });
             return Response.json({ success: true });
         },

package/dist/endpoints/translation-status.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Translation status route — lists per-language translation coverage for
+ * every Nitrogen-enabled document and template, for the editor's translation
+ * dashboard.
+ *
+ * The status is computed and stored (in `nitrogenTranslationStatus`) by the
+ * save handlers; this route reads the stored value and only computes on the
+ * fly for docs that have never been saved since localization was enabled.
+ */
+import type { Endpoint } from 'payload';
+export declare function createTranslationStatusEndpoints(collections: string[]): Endpoint[];

package/dist/endpoints/translation-status.js

@@ -0,0 +1,105 @@
+/**
+ * Translation status route — lists per-language translation coverage for
+ * every Nitrogen-enabled document and template, for the editor's translation
+ * dashboard.
+ *
+ * The status is computed and stored (in `nitrogenTranslationStatus`) by the
+ * save handlers; this route reads the stored value and only computes on the
+ * fly for docs that have never been saved since localization was enabled.
+ */
+import { getNitrogenSettings, requireAuth } from './helpers.js';
+import { findAllDocs } from '../inventory/indexing.js';
+import { computeDocTranslationStatus, getLocalizationSettings, getPayloadLocalization, loadTranslatablePropDefs, } from '../localization.js';
+function isStoredStatus(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+/**
+ * Docs fetched at locale 'all' carry localized fields as locale-keyed
+ * objects — read the default language's title in that case.
+ */
+function docTitle(doc, defaultLanguage) {
+    const title = doc.title;
+    if (typeof title === 'string')
+        return title;
+    if (title && typeof title === 'object' && !Array.isArray(title)) {
+        const record = title;
+        const value = record[defaultLanguage];
+        if (typeof value === 'string')
+            return value;
+        // No default-language title — fall back to the first stored one, matching
+        // the renderer's language-resolution fallback chain.
+        for (const candidate of Object.values(record)) {
+            if (typeof candidate === 'string' && candidate)
+                return candidate;
+        }
+    }
+    return '';
+}
+export function createTranslationStatusEndpoints(collections) {
+    return [
+        // GET /api/nitrogen/v1/translation-status — TranslationStatusEntry[] across
+        // configured collections + nitrogen-templates
+        {
+            path: '/nitrogen/v1/translation-status',
+            method: 'get',
+            handler: async (req) => {
+                const authError = requireAuth(req);
+                if (authError)
+                    return authError;
+                const { payload } = req;
+                const settings = await getNitrogenSettings(payload);
+                const localization = getLocalizationSettings(settings);
+                if (!localization) {
+                    return Response.json([]);
+                }
+                // One catalog load shared by every on-the-fly computation.
+                const propDefs = await loadTranslatablePropDefs(payload);
+                // With Payload-native localization, fetch docs at locale 'all' so
+                // field-level coverage can be read without per-doc re-fetches.
+                const locale = getPayloadLocalization(payload) ? 'all' : undefined;
+                const entries = [];
+                const allCollections = Array.from(new Set([...collections, 'nitrogen-templates']));
+                for (const collectionSlug of allCollections) {
+                    let docs;
+                    try {
+                        docs = await findAllDocs(payload, collectionSlug, { locale });
+                    }
+                    catch {
+                        // One bad collection shouldn't 500 the whole listing — skip it.
+                        continue;
+                    }
+                    const type = collectionSlug === 'nitrogen-templates' ? 'template' : 'page';
+                    for (const doc of docs) {
+                        let languages = null;
+                        if (isStoredStatus(doc.nitrogenTranslationStatus)) {
+                            languages = doc.nitrogenTranslationStatus;
+                        }
+                        else {
+                            try {
+                                languages = await computeDocTranslationStatus({
+                                    payload,
+                                    collectionSlug,
+                                    docId: doc.id,
+                                    nitrogenData: doc.nitrogenData,
+                                    localization,
+                                    propDefs,
+                                    localeAllDoc: locale ? doc : null,
+                                });
+                            }
+                            catch {
+                                languages = null;
+                            }
+                        }
+                        entries.push({
+                            id: doc.id,
+                            title: docTitle(doc, localization.defaultLanguage),
+                            type,
+                            languages: languages || {},
+                        });
+                    }
+                }
+                return Response.json(entries);
+            },
+        },
+    ];
+}

package/dist/frontend/NitrogenPageClient.d.ts

@@ -5,6 +5,11 @@ export interface NitrogenPageClientProps {
     dynamicData: Record<string, unknown>;
     isBuilder?: boolean;
     collection?: string;
+    /**
+     * Language to render translatable builder props in (a configured language
+     * code). Forwarded to NitrogenRenderer. Omit for the default language.
+     */
+    language?: string;
 }
 /**
  * Client component that renders Nitrogen pages using React.
@@ -12,5 +17,5 @@ export interface NitrogenPageClientProps {
  * Uses `useNitrogenData` hook for live preview updates in builder mode,
  * and `NitrogenRenderer` for React-based rendering of the component tree.
  */
-export declare function NitrogenPageClient({ pageId, pageData, dynamicData: initialDynamicData, isBuilder, collection, }: NitrogenPageClientProps): import("react/jsx-runtime").JSX.Element;
+export declare function NitrogenPageClient({ pageId, pageData, dynamicData: initialDynamicData, isBuilder, collection, language, }: NitrogenPageClientProps): import("react/jsx-runtime").JSX.Element;
 export default NitrogenPageClient;

package/dist/frontend/NitrogenPageClient.js

@@ -9,7 +9,7 @@ import { Nitrogen } from "@nitrogenbuilder/client-core";
  * Uses `useNitrogenData` hook for live preview updates in builder mode,
  * and `NitrogenRenderer` for React-based rendering of the component tree.
  */
-export function NitrogenPageClient({ pageId, pageData, dynamicData: initialDynamicData, isBuilder = false, collection, }) {
+export function NitrogenPageClient({ pageId, pageData, dynamicData: initialDynamicData, isBuilder = false, collection, language, }) {
     // Use the hook for live preview updates
     const page = useNitrogenData({
         type: "page",
@@ -50,6 +50,10 @@ export function NitrogenPageClient({ pageId, pageData, dynamicData: initialDynam
             }
         };
     }, [isBuilder]);
-    return (_jsx("div", { "data-nitrogen-location": "page", "data-page-id": pageId, "data-collection": collection, children: _jsx(NitrogenRenderer, { page: page?.data ?? [], dynamicData: page?.dynamicData ?? initialDynamicData, requestedData: {} }) }));
+    // The `language` prop is being added to NitrogenRenderer in the client-react
+    // package; spread it loosely so this compiles against both old and new
+    // renderer typings (older renderers simply ignore the extra prop).
+    const languageProp = language ? { language } : {};
+    return (_jsx("div", { "data-nitrogen-location": "page", "data-page-id": pageId, "data-collection": collection, "data-language": language, children: _jsx(NitrogenRenderer, { page: page?.data ?? [], dynamicData: page?.dynamicData ?? initialDynamicData, requestedData: {}, ...languageProp }) }));
 }
 export default NitrogenPageClient;

package/dist/frontend/NitrogenWrapper.d.ts

@@ -25,6 +25,13 @@ export interface NitrogenWrapperProps {
      * Regular page content to render when not in Nitrogen mode.
      */
     children: React.ReactNode;
+    /**
+     * Language to render the page in (a configured locale code, e.g. 'es').
+     * Dynamic data is rebuilt from the doc fetched at that locale, and the
+     * language is forwarded to the renderer so translatable builder props
+     * resolve to it. Omit for the default language.
+     */
+    language?: string;
 }
 /**
  * Server component that wraps your page content and automatically handles
@@ -45,5 +52,5 @@ export interface NitrogenWrapperProps {
  * }
  * ```
  */
-export declare function NitrogenWrapper({ page, searchParams, collection, config, children, }: NitrogenWrapperProps): Promise<import("react/jsx-runtime").JSX.Element>;
+export declare function NitrogenWrapper({ page, searchParams, collection, config, children, language, }: NitrogenWrapperProps): Promise<import("react/jsx-runtime").JSX.Element>;
 export default NitrogenWrapper;

package/dist/frontend/NitrogenWrapper.js

@@ -2,6 +2,7 @@ import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
 import { getPayload } from 'payload';
 import { NitrogenPageClient } from './NitrogenPageClient.js';
 import { buildDynamicData, getNitrogenSettings } from '../endpoints/helpers.js';
+import { resolveLocaleOptions } from '../localization.js';
 /**
  * Server component that wraps your page content and automatically handles
  * Nitrogen builder mode and Nitrogen-rendered pages.
@@ -21,7 +22,7 @@ import { buildDynamicData, getNitrogenSettings } from '../endpoints/helpers.js';
  * }
  * ```
  */
-export async function NitrogenWrapper({ page, searchParams, collection, config, children, }) {
+export async function NitrogenWrapper({ page, searchParams, collection, config, children, language, }) {
     const isBuilder = searchParams['nitrogen-builder'] !== undefined;
     const hasNitrogenData = Array.isArray(page.nitrogenData) && page.nitrogenData.length > 0;
     // If not in builder mode and no Nitrogen data, render regular content
@@ -31,7 +32,28 @@ export async function NitrogenWrapper({ page, searchParams, collection, config,
     // Fetch Nitrogen settings and build dynamic data
     const payload = await getPayload({ config });
     const settings = await getNitrogenSettings(payload);
-    const dynamicData = buildDynamicData(page, settings);
-    return (_jsx(NitrogenPageClient, { pageId: String(page.id), pageData: page.nitrogenData || [], dynamicData: dynamicData, isBuilder: isBuilder, collection: collection }));
+    // When a language is requested (and Payload localization is configured),
+    // re-fetch the doc at that locale so dynamic data carries the translated
+    // field values. Falls back to the passed-in page on any failure.
+    let sourceDoc = page;
+    const localeOptions = resolveLocaleOptions(payload, language);
+    if (localeOptions.locale) {
+        try {
+            const localized = await payload.findByID({
+                collection: collection,
+                id: page.id,
+                depth: 1,
+                ...localeOptions,
+            });
+            if (localized) {
+                sourceDoc = localized;
+            }
+        }
+        catch {
+            // Locale fetch is best-effort — keep the caller's doc.
+        }
+    }
+    const dynamicData = buildDynamicData(sourceDoc, settings);
+    return (_jsx(NitrogenPageClient, { pageId: String(page.id), pageData: page.nitrogenData || [], dynamicData: dynamicData, isBuilder: isBuilder, collection: collection, language: language }));
 }
 export default NitrogenWrapper;

package/dist/index.d.ts

@@ -34,6 +34,27 @@ export interface NitrogenConnectorPluginOptions {
      * `users`).
      */
     userCollection?: string;
+    /**
+     * Enables Payload-native localization for field data. When set (and the
+     * Payload config does not already configure `localization` itself), the
+     * plugin injects `localization: { locales, defaultLocale, fallback: true }`
+     * into the Payload config and marks eligible text fields (`title` on
+     * Nitrogen-enabled collections and on the plugin's own template collection)
+     * as `localized: true`. Localize your own custom fields yourself.
+     *
+     * IMPORTANT: the locales here must match the site languages configured in
+     * the Nitrogen settings (`nitrogenConfig.localization.languages`), and
+     * `defaultLocale` must match `defaultLanguage` — Payload stores the field
+     * translations, Nitrogen stores the builder-content translations, and the
+     * language codes are the join key.
+     *
+     * If your Payload config already has `localization` configured, that config
+     * is respected and this option does not override it.
+     */
+    localization?: {
+        locales: string[];
+        defaultLocale: string;
+    };
 }
 export declare const nitrogenConnectorPlugin: (options?: NitrogenConnectorPluginOptions) => any;
 export { NitrogenTemplates } from "./collections/NitrogenTemplates.js";
@@ -41,6 +62,7 @@ export { NitrogenSettings } from "./globals/NitrogenSettings.js";
 export { NitrogenEditButton } from "./components/NitrogenEditButton.js";
 export { NitrogenViewButton } from "./components/NitrogenViewButton.js";
 export { buildDynamicData, getNitrogenSettings } from "./endpoints/helpers.js";
+export { buildDynamicDataMeta, getRequestLanguage, resolveLocaleOptions, } from "./localization.js";
 export { createCollectionEndpoints } from "./endpoints/collection-endpoints.js";
 export { nitrogen } from "@nitrogenbuilder/client-core";
 export type { ComponentSettings, ComponentSettingsToProps, } from "@nitrogenbuilder/types";

package/dist/index.js

@@ -13,6 +13,7 @@ import { createCollectionEndpoints } from "./endpoints/collection-endpoints.js";
 import { createComponentInventoryEndpoints } from './endpoints/component-inventory.js';
 import { batchEndpoints } from "./endpoints/batch.js";
 import { sitemapEndpoints } from "./endpoints/sitemap.js";
+import { createTranslationStatusEndpoints } from "./endpoints/translation-status.js";
 import { createAgentAuthEndpoints } from "./endpoints/agent-auth.js";
 import { registerCollection } from "./collection-registry.js";
 import { deleteDocumentUsage, reindexDocumentUsage, syncComponentCatalog, } from './inventory/indexing.js';
@@ -38,12 +39,57 @@ const nitrogenRequiredFields = [
             },
         },
     },
+    {
+        name: "nitrogenTranslationStatus",
+        type: "json",
+        admin: {
+            hidden: true,
+            description: "Per-language translation coverage, computed by Nitrogen on save",
+        },
+    },
 ];
+/**
+ * Marks `title` text fields as `localized: true` (recursing into rows, tabs,
+ * groups, collapsibles). Fields that already declare `localized` explicitly
+ * are left untouched.
+ */
+function localizeTitleFields(fields) {
+    return fields.map((field) => {
+        const f = field;
+        if (f.type === "text" && f.name === "title" && f.localized === undefined) {
+            return { ...field, localized: true };
+        }
+        if (Array.isArray(f.fields)) {
+            return { ...field, fields: localizeTitleFields(f.fields) };
+        }
+        if (Array.isArray(f.tabs)) {
+            return {
+                ...field,
+                tabs: f.tabs.map((tab) => ({
+                    ...tab,
+                    fields: localizeTitleFields(tab.fields || []),
+                })),
+            };
+        }
+        return field;
+    });
+}
 export const nitrogenConnectorPlugin = (options = {}) => (incomingConfig) => {
     if (options.disabled) {
         return incomingConfig;
     }
     const config = { ...incomingConfig };
+    // Payload-native localization for field data. Only injected when the host
+    // config doesn't configure localization itself — an existing config is
+    // always respected.
+    if (options.localization && !incomingConfig.localization) {
+        config.localization = {
+            locales: options.localization.locales,
+            defaultLocale: options.localization.defaultLocale,
+            fallback: true,
+        };
+    }
+    const localizationActive = Boolean(config.localization);
     // The auth collection that owns MCP agent credentials. Prefer the explicit
     // option, else the first auth-enabled collection, else `users`.
     const userCollectionSlug = options.userCollection ||
@@ -83,10 +129,19 @@ export const nitrogenConnectorPlugin = (options = {}) => (incomingConfig) => {
             },
         };
     };
-    // Add Nitrogen templates collection
+    // Add Nitrogen templates collection. With localization active, template
+    // titles are localized (translated in the Payload admin's locale
+    // switcher); internal catalog/usage collections stay non-localized —
+    // their text fields are machine identifiers, not content.
+    const templatesCollection = localizationActive
+        ? {
+            ...NitrogenTemplates,
+            fields: localizeTitleFields(NitrogenTemplates.fields),
+        }
+        : NitrogenTemplates;
     config.collections = [
         ...(config.collections || []),
-        withInventoryHooks(NitrogenTemplates, 'nitrogen-templates'),
+        withInventoryHooks(templatesCollection, 'nitrogen-templates'),
         NitrogenComponentCatalog,
         NitrogenComponentUsage,
     ];
@@ -103,6 +158,7 @@ export const nitrogenConnectorPlugin = (options = {}) => (incomingConfig) => {
         ...menuEndpoints,
         ...batchEndpoints,
         ...sitemapEndpoints,
+        ...createTranslationStatusEndpoints(options.collections || []),
         ...createAgentAuthEndpoints(userCollectionSlug),
         ...createComponentInventoryEndpoints({
             collections: inventoryCollections,
@@ -191,6 +247,16 @@ export const nitrogenConnectorPlugin = (options = {}) => (incomingConfig) => {
                 fields: [...existing.fields, ...fieldsToAdd],
             };
         }
+        // With localization active, the collection's title becomes localized so
+        // it can be translated via the Payload admin's native locale switcher.
+        // (Users localize their own custom fields themselves.)
+        if (localizationActive) {
+            const current = config.collections[existingIndex];
+            config.collections[existingIndex] = {
+                ...current,
+                fields: localizeTitleFields(current.fields),
+            };
+        }
         // Inject NitrogenEditButton admin component
         const col = config.collections[existingIndex];
         const adminConfig = col.admin || {};
@@ -301,6 +367,7 @@ export { NitrogenEditButton } from "./components/NitrogenEditButton.js";
 export { NitrogenViewButton } from "./components/NitrogenViewButton.js";
 // Helper exports for consumers building custom frontend routes
 export { buildDynamicData, getNitrogenSettings } from "./endpoints/helpers.js";
+export { buildDynamicDataMeta, getRequestLanguage, resolveLocaleOptions, } from "./localization.js";
 // Collection endpoint factory for consumers who need custom endpoint generation
 export { createCollectionEndpoints } from "./endpoints/collection-endpoints.js";
 // Re-export @nitrogenbuilder packages for convenience

package/dist/inventory/indexing.d.ts

@@ -6,12 +6,7 @@ export declare const NITROGEN_COMPONENT_CATALOG_COLLECTION = "nitrogen-component
 export declare const NITROGEN_COMPONENT_USAGE_COLLECTION = "nitrogen-component-usage";
 type ComponentUsageRecord = {
     componentName: string;
-    depth: number;
     moduleId: string;
-    modulePath: string;
-    parentComponentName?: string;
-    parentModuleId?: string;
-    parentModulePath?: string;
 };
 type ReindexResult = {
     catalogCount: number;
@@ -21,6 +16,8 @@ type ReindexResult = {
 export declare function extractComponentUsageRecords(modules: unknown): ComponentUsageRecord[];
 export declare function findAllDocs<T extends object>(payload: Payload, collection: string, options?: {
     limit?: number;
+    /** e.g. 'all' to fetch every locale's value for localized fields */
+    locale?: string;
     select?: Record<string, true>;
     where?: Where;
 }, req?: PayloadRequest): Promise<T[]>;