@focus-reactive/payload-plugin-translator 0.5.1 → 0.6.0

package/dist/client/widgets/translate-field-control/ui/TranslateFieldControl.js

@@ -0,0 +1,204 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { toast, useConfig, useDocumentInfo, useField, useForm, useFormFields, useLocale } from "@payloadcms/ui";
+import { useState } from "react";
+import { useTranslateField } from "../../../entities/translation/api/mutations/useTranslateField";
+import { LanguageTranslateIcon } from "../../../shared/lib/assets/icons/LanguageTranslateIcon";
+import { ReloadIcon } from "../../../shared/lib/assets/icons/ReloadIcon";
+import { SendIcon } from "../../../shared/lib/assets/icons/SendIcon";
+import { useLocaleOptions } from "../../../shared/lib/payload/hooks/useLocaleOptions";
+import { useToggle } from "../../../shared/lib/utils/react/useToggle";
+import Button from "../../../shared/ui/Button";
+import Popup from "../../../shared/ui/Popup";
+import Select from "../../../shared/ui/Select";
+import Tooltip from "../../../shared/ui/Tooltip";
+import styles from "./styles.module.scss";
+/**
+ * Per-field Translate control, injected into the field's `admin.components.beforeInput`.
+ * The trigger is an icon button; clicking it opens a compact popup that reuses the plugin's
+ * recognizable `source → target` direction pattern (as on the document/collection level):
+ * a small **source** locale `Select`, an arrow, then the **current** locale (the target).
+ *
+ * **Direction.** The target is *always* the locale the user is editing (`useLocale()`) — never
+ * derived from the picker; only the **source** is chosen. This is the reverse of the
+ * document/collection level (translate *from* the current locale *to* a chosen target): here we
+ * pull content *into* where the user stands. Deliberate, and field-level only for now.
+ *
+ * The source is an explicit locale (no "auto-detect": the field reads the chosen locale's *saved*
+ * value, so it needs a saved document — the control is **hidden entirely while creating** a new
+ * one). It defaults to Payload's configured `defaultLocale` when
+ * that isn't the current locale, otherwise the user picks. On success the result is written back
+ * (see {@link writeFieldValue}) and an **Undo** restores the previous value. Field `value` + `path`
+ * come from `useField()` via the field path context (`beforeInput` renders inside it — no `path`
+ * prop).
+ *
+ * **Write-back** is one path for every supported field type: a form `UPDATE` bumping both `value`
+ * and `initialValue`. A Lexical (`richText`) editor owns its state and only re-reads on
+ * `initialValue` change, so it re-mounts with the new content; `text` / `textarea` inputs just
+ * re-render from `value`. So no per-type flag is needed.
+ */ const TranslateFieldControl = ()=>{
+    const { value, path } = useField();
+    const locale = useLocale();
+    const { collectionSlug, id } = useDocumentInfo();
+    const { config } = useConfig();
+    const { setModified } = useForm();
+    const dispatchFields = useFormFields(([, dispatch])=>dispatch);
+    const localeOptions = useLocaleOptions();
+    const { mutateAsync, isPending } = useTranslateField();
+    // `config.localization` is `false | {…}`, so the truthy check is load-bearing (not just a nil guard).
+    const defaultLocale = config.localization ? config.localization.defaultLocale : undefined;
+    const [isOpen, popup] = useToggle();
+    const [sourceLng, setSourceLng] = useState(()=>defaultLocale && defaultLocale !== locale.code ? defaultLocale : "");
+    // `null` = no undo available; an object wraps the value so a legitimately `undefined` field value
+    // (a real pre-translation state) stays distinguishable from "nothing to undo".
+    const [undo, setUndo] = useState(null);
+    // fieldLevel is off while creating a document: from-locale reads the *saved* document's value,
+    // which doesn't exist yet — so the control is hidden entirely on a new/unsaved doc. (Re-enable
+    // once translating the unsaved value in place is supported.) All hooks above run unconditionally.
+    if (id === undefined || id === null) return null;
+    // Source options: every locale except the one being edited (it's the fixed target).
+    const sourceLocaleOptions = localeOptions.filter((option)=>option.value !== locale.code);
+    const canTranslate = sourceLng !== "" && !isPending;
+    // One write path for every supported field type: a form UPDATE bumping value AND initialValue.
+    // A Lexical (richText) editor re-mounts on the initialValue change so it shows the new content;
+    // text/textarea inputs just re-render from value. setModified keeps the form dirty/savable, since
+    // value === initialValue would otherwise read as unchanged.
+    const writeFieldValue = (next)=>{
+        dispatchFields({
+            type: "UPDATE",
+            path,
+            value: next,
+            initialValue: next
+        });
+        setModified(true);
+    };
+    const handleTranslate = async ()=>{
+        if (!(collectionSlug && canTranslate)) return;
+        const previous = value;
+        try {
+            const { data } = await mutateAsync({
+                collectionSlug,
+                fieldPath: path,
+                targetLng: locale.code,
+                sourceLng,
+                docId: id
+            });
+            if (data.status === "translated") {
+                setUndo({
+                    value: previous
+                });
+                writeFieldValue(data.value);
+                toast.success("Field translated");
+                return;
+            }
+            const notify = data.notice.level === "warning" ? toast.warning : toast.info;
+            notify(data.notice.message);
+        } catch (error) {
+            toast.error(error instanceof Error ? error.message : "Translation failed");
+        }
+    };
+    const handleUndo = ()=>{
+        if (!undo) return;
+        writeFieldValue(undo.value);
+        setUndo(null);
+    };
+    return /*#__PURE__*/ _jsx(Popup, {
+        $align: "center",
+        $side: "right",
+        open: isOpen,
+        onOpenChange: popup.setValue,
+        // Don't auto-focus the first button on open — it's a Tooltip trigger, and Radix tooltips
+        // open on focus, so autofocus would flash the Translate button's tooltip immediately.
+        onOpenAutoFocus: (event)=>event.preventDefault(),
+        $trigger: /*#__PURE__*/ _jsx("div", {
+            className: styles.trigger,
+            children: /*#__PURE__*/ _jsx(Tooltip, {
+                content: "Translate field",
+                children: /*#__PURE__*/ _jsx(Button, {
+                    type: "button",
+                    $variant: "light",
+                    $size: "sm",
+                    $isIconButton: true,
+                    $isLoading: isPending && !isOpen,
+                    "aria-label": "Translate field",
+                    onClick: popup.setTrue,
+                    children: /*#__PURE__*/ _jsx(LanguageTranslateIcon, {})
+                })
+            })
+        }),
+        children: /*#__PURE__*/ _jsx("div", {
+            className: styles.popup,
+            children: /*#__PURE__*/ _jsxs("div", {
+                className: styles.row,
+                children: [
+                    /*#__PURE__*/ _jsxs("div", {
+                        "aria-label": `Translation direction: from ${sourceLng || "a source locale"} into ${locale.code}`,
+                        className: styles.direction,
+                        role: "group",
+                        children: [
+                            /*#__PURE__*/ _jsxs(Select, {
+                                $fullWidth: false,
+                                $size: "sm",
+                                "aria-label": "Source locale",
+                                value: sourceLng,
+                                onChange: (event)=>setSourceLng(event.target.value),
+                                disabled: isPending,
+                                children: [
+                                    sourceLng === "" && /*#__PURE__*/ _jsx(Select.SelectOption, {
+                                        value: "",
+                                        disabled: true,
+                                        children: "—"
+                                    }),
+                                    sourceLocaleOptions.map((option)=>/*#__PURE__*/ _jsx(Select.SelectOption, {
+                                            value: option.value,
+                                            children: option.value.toLowerCase()
+                                        }, option.value))
+                                ]
+                            }),
+                            /*#__PURE__*/ _jsx("span", {
+                                "aria-hidden": "true",
+                                className: styles.arrow,
+                                children: "→"
+                            }),
+                            /*#__PURE__*/ _jsx("span", {
+                                "aria-label": `Target locale: ${locale.code} (the locale you're editing)`,
+                                className: styles.current,
+                                children: locale.code.toLowerCase()
+                            })
+                        ]
+                    }),
+                    /*#__PURE__*/ _jsx(Tooltip, {
+                        content: "Translate",
+                        children: /*#__PURE__*/ _jsx(Button, {
+                            type: "button",
+                            $variant: "filled",
+                            $size: "sm",
+                            $isIconButton: true,
+                            $isLoading: isPending,
+                            disabled: !canTranslate,
+                            "aria-label": `Translate from ${sourceLng || "the selected locale"} into ${locale.code}`,
+                            onClick: handleTranslate,
+                            children: /*#__PURE__*/ _jsx(SendIcon, {})
+                        })
+                    }),
+                    undo && /*#__PURE__*/ _jsx(Tooltip, {
+                        content: "Undo translation",
+                        children: /*#__PURE__*/ _jsx(Button, {
+                            type: "button",
+                            $variant: "light",
+                            $size: "sm",
+                            $isIconButton: true,
+                            "aria-label": "Undo translation",
+                            disabled: isPending,
+                            onClick: handleUndo,
+                            children: /*#__PURE__*/ _jsx(ReloadIcon, {})
+                        })
+                    })
+                ]
+            })
+        })
+    });
+};
+export default TranslateFieldControl;
+
+//# sourceMappingURL=TranslateFieldControl.js.map

package/dist/client/widgets/translate-field-control/ui/styles.module.scss

@@ -0,0 +1,48 @@
+.popup {
+  display: flex;
+  flex-direction: column;
+  gap: 0.375rem;
+}
+
+.row {
+  display: flex;
+  align-items: center;
+  gap: 0.375rem;
+}
+
+/* The from → to direction group; lays the source select, arrow and target chip out inline. */
+.direction {
+  display: flex;
+  align-items: center;
+  gap: 0.375rem;
+}
+
+.arrow {
+  display: flex;
+  align-items: center;
+  color: var(--theme-elevation-400);
+}
+
+/* The fixed target locale — framed like the source Select (same border/radius/height/font) for
+   a consistent two-box "source → target" look, but with a muted bg to read as read-only. */
+.current {
+  display: inline-flex;
+  align-items: center;
+  box-sizing: border-box;
+  height: 24px;
+  padding-inline: 0.5rem;
+  border: 1px solid var(--theme-elevation-150);
+  border-radius: var(--style-radius-s);
+  background: var(--theme-elevation-50);
+  font-size: 0.875rem;
+  font-weight: 500;
+  color: var(--theme-elevation-800);
+}
+
+.trigger {
+  /* inline-flex so the wrapper hugs the icon button — a block/flex div stretches full width,
+     which drags the popover anchor across the field. */
+  display: inline-flex;
+  width: fit-content;
+  margin-bottom: 0.25rem;
+}

package/dist/field-actions.d.ts

@@ -0,0 +1,25 @@
+import type { Field } from "payload";
+import type { RawPayloadComponentExport } from "./client/shared/types/PayloadComponentExport";
+/**
+ * Strategy for placing a per-field control into a field's admin config — the seam
+ * between *what* to render (a control component) and *where* it goes (positioning).
+ *
+ * Today the only implementation is {@link beforeInputPositioner}, built on Payload's
+ * native `admin.components.beforeInput` slot. A future field-slots plugin can supply its
+ * own positioner (e.g. placing the trigger in the field label, next to the locale) by
+ * implementing this same interface — the control component and the wiring in
+ * `withFieldTranslation` stay untouched. This is the connector we expose later; for now
+ * it lives internal, with the default below as the built-in fallback.
+ *
+ * @template T - The concrete field type, preserved through positioning.
+ * @param field - The field to attach the control to.
+ * @param control - Import-map reference to the control component.
+ * @returns The field with the control positioned.
+ */
+export type FieldControlPositioner = <T extends Field>(field: T, control: RawPayloadComponentExport) => T;
+/**
+ * Default positioner: append the control to the field's `admin.components.beforeInput`,
+ * rendering it just above the input. `beforeInput` is an array slot, so we append —
+ * preserving any components already declared on the field.
+ */
+export declare const beforeInputPositioner: FieldControlPositioner;

package/dist/field-actions.js

@@ -0,0 +1,23 @@
+/**
+ * Default positioner: append the control to the field's `admin.components.beforeInput`,
+ * rendering it just above the input. `beforeInput` is an array slot, so we append —
+ * preserving any components already declared on the field.
+ */ export const beforeInputPositioner = (field, control)=>{
+    const withAdmin = field;
+    const existing = withAdmin.admin?.components?.beforeInput ?? [];
+    return {
+        ...field,
+        admin: {
+            ...withAdmin.admin,
+            components: {
+                ...withAdmin.admin?.components,
+                beforeInput: [
+                    ...existing,
+                    control
+                ]
+            }
+        }
+    };
+};
+
+//# sourceMappingURL=field-actions.js.map

package/dist/field-config.d.ts

@@ -1,46 +1,46 @@
-import type { Field } from 'payload';
-import type { FieldTranslationConfig } from './server/shared/field-config';
+import type { Field, RichTextField, TextareaField, TextField } from "payload";
+import type { FieldTranslationConfig } from "./server/shared/field-config";
 export type { FieldTranslationConfig };
+/**
+ * Field types eligible for the per-field translate control — the same text-bearing
+ * leaves the server's `TranslatableField` handles. `richText` writes back by re-mounting
+ * the Lexical editor (see the control); `text` / `textarea` write straight to form state.
+ */
+type FieldControlCandidate = TextField | TextareaField | RichTextField;
 /**
  * @deprecated Use `FieldTranslationConfig` instead
  */
 export type { FieldTranslationConfig as TranslateKitFieldConfig };
 /**
- * Apply translation configuration to a Payload field.
+ * Configure a Payload field for translation.
  *
- * Use this helper to configure how fields should be handled during translation.
+ * - **Add a translate control** — wrap a `text` / `textarea` field with no second
+ *   argument. A per-field Translate control is positioned on the field (today, just
+ *   above the input). Requires `fieldLevel()` in the plugin's `levels` to register the
+ *   endpoint. Control-injection behavior is `@since 0.6.0`; field exclusion predates it.
+ * - **Exclude from translation** — pass `{ exclude: true }` (any field type). The field
+ *   value is never sent to the translation provider and no control is added.
  *
  * @param field - The Payload field to configure
- * @param config - Translation configuration options
- * @returns The field with translation configuration applied
+ * @param config - Pass `{ exclude: true }` to exclude; omit to add a control
+ * @returns A new field with the configuration applied (the input is not mutated)
  *
  * @example
  * ```ts
  * import { withFieldTranslation } from '@focus-reactive/payload-plugin-translator'
  *
- * // Exclude a field from translation
- * withFieldTranslation(
- *   { name: 'sku', type: 'text', localized: true },
- *   { exclude: true }
- * )
- * ```
+ * // Add a per-field translate control
+ * withFieldTranslation({ name: 'title', type: 'text', localized: true })
  *
- * @example
- * ```ts
- * // In a collection definition
- * const Products: CollectionConfig = {
- *   slug: 'products',
- *   fields: [
- *     { name: 'title', type: 'text', localized: true },
- *     withFieldTranslation(
- *       { name: 'sku', type: 'text', localized: true },
- *       { exclude: true }
- *     ),
- *   ],
- * }
+ * // Exclude a field from translation
+ * withFieldTranslation({ name: 'sku', type: 'text', localized: true }, { exclude: true })
  * ```
  */
-export declare function withFieldTranslation<T extends Field>(field: T, config: FieldTranslationConfig): T;
+export declare function withFieldTranslation<T extends Field>(field: T, ...rest: T extends FieldControlCandidate ? [config?: {
+    exclude?: boolean;
+}] : [config: {
+    exclude: true;
+}]): T;
 /**
  * @deprecated Use `withFieldTranslation` instead
  */

package/dist/field-config.js

@@ -1,46 +1,23 @@
-import { TRANSLATE_KIT_CUSTOM_KEY } from './server/shared/field-config';
+import { TRANSLATE_KIT_CUSTOM_KEY } from "./server/shared/field-config";
+import { TranslateFieldControlExport } from "./client/widgets/translate-field-control/ui/TranslateFieldControl.export";
+import { beforeInputPositioner } from "./field-actions";
 /**
- * Apply translation configuration to a Payload field.
- *
- * Use this helper to configure how fields should be handled during translation.
- *
- * @param field - The Payload field to configure
- * @param config - Translation configuration options
- * @returns The field with translation configuration applied
- *
- * @example
- * ```ts
- * import { withFieldTranslation } from '@focus-reactive/payload-plugin-translator'
- *
- * // Exclude a field from translation
- * withFieldTranslation(
- *   { name: 'sku', type: 'text', localized: true },
- *   { exclude: true }
- * )
- * ```
- *
- * @example
- * ```ts
- * // In a collection definition
- * const Products: CollectionConfig = {
- *   slug: 'products',
- *   fields: [
- *     { name: 'title', type: 'text', localized: true },
- *     withFieldTranslation(
- *       { name: 'sku', type: 'text', localized: true },
- *       { exclude: true }
- *     ),
- *   ],
- * }
- * ```
- */ export function withFieldTranslation(field, config) {
-    return {
+ * Where the translate control is placed. The single swap point: when a dedicated
+ * field-slots plugin lands, point this at its positioner (or take one as config) and
+ * the control moves — e.g. into the field label — without touching anything else.
+ * @see FieldControlPositioner
+ */ const activeFieldControlPositioner = beforeInputPositioner;
+export function withFieldTranslation(field, config) {
+    const configured = {
         ...field,
         custom: {
             ...field.custom ?? {},
-            [TRANSLATE_KIT_CUSTOM_KEY]: config
+            [TRANSLATE_KIT_CUSTOM_KEY]: config ?? {}
         }
     };
+    // No `exclude` = control intent: position the control via the active positioner.
+    // `exclude: true` = no control (the field is left out of translation entirely).
+    return config?.exclude ? configured : activeFieldControlPositioner(configured, new TranslateFieldControlExport());
 }
 /**
  * @deprecated Use `withFieldTranslation` instead

package/dist/index.d.ts

@@ -5,7 +5,7 @@ export { createOpenAIProvider } from "./server/modules/translation-providers";
 export type { TranslationProvider, TranslationInput, TranslationOutput, OpenAIProviderConfig, DryRunConfig } from "./server/modules/translation-providers";
 export { createPayloadJobsRunner, createSyncRunner } from "./server/modules/task-runner";
 export type { TaskRunnerProvider, PayloadJobsRunnerOptions } from "./server/modules/task-runner";
-export { documentLevel, collectionLevel } from "./server/modules/translation-levels";
+export { documentLevel, collectionLevel, fieldLevel } from "./server/modules/translation-levels";
 export type { TranslationLevel } from "./server/modules/translation-levels";
 export { withFieldTranslation } from "./field-config";
 export type { FieldTranslationConfig } from "./field-config";

package/dist/index.js

@@ -5,7 +5,7 @@ export { createOpenAIProvider } from "./server/modules/translation-providers";
 // Task runners
 export { createPayloadJobsRunner, createSyncRunner } from "./server/modules/task-runner";
 // Translation levels
-export { documentLevel, collectionLevel } from "./server/modules/translation-levels";
+export { documentLevel, collectionLevel, fieldLevel } from "./server/modules/translation-levels";
 // Field config
 export { withFieldTranslation } from "./field-config";
 // Deprecated exports (for backwards compatibility)

package/dist/plugin.d.ts

@@ -35,7 +35,7 @@ export type TranslatorPluginConfig = {
     basePath?: string;
     /**
      * Which translation surfaces to enable, as level factories — `documentLevel()`,
-     * `collectionLevel()` (and, from a later phase, `fieldLevel()`). Omit for the
+     * `collectionLevel()`, `fieldLevel()`. Omit for the
      * default `[documentLevel(), collectionLevel()]`, which is exactly today's behaviour.
      * Each level should appear at most once: endpoints are deduplicated, but admin
      * components are not, so a duplicated level renders a duplicated control.

package/dist/plugin.js

@@ -54,7 +54,9 @@ import { normalizePath } from "./server/shared";
                 collections,
                 basePath,
                 access,
-                taskRunnerFactory
+                taskRunnerFactory,
+                schemaMap,
+                translationProvider
             });
             for (const level of activeLevels)level.extend(builder);
             // Plugin-level contributions, routed through the same single config-writer:

package/dist/server/features/translate-field/handler.d.ts

@@ -0,0 +1,17 @@
+import type { PayloadRequest } from "payload";
+import type { FieldTranslationConfig } from "./model";
+/**
+ * Synchronous single-field translation: read the field's value from the saved document in the
+ * chosen source locale, resolve the declared field path to its schema subtree, run
+ * `translateContent`, and return the translated value. No persistence — the result is written to
+ * form state by the caller.
+ *
+ * From-locale only: `source_lng` + `doc_id` are required (validated by the schema), so there is
+ * always exactly one DB read. Reserves HTTP errors for genuine errors — "nothing to translate"
+ * and "couldn't resolve the block" come back as a 200 `noop` with a notice.
+ */
+export declare class TranslateFieldHandler {
+    private readonly config;
+    constructor(config: FieldTranslationConfig);
+    handle(req: PayloadRequest): Promise<Response>;
+}

package/dist/server/features/translate-field/handler.js

@@ -0,0 +1,85 @@
+import { getByPath, ServerResponse } from "../../shared";
+import { translateContent } from "../../modules/translation-pipeline";
+import { FieldTranslationInputSchema, MAX_FIELD_VALUE_BYTES } from "./model";
+import { resolveFieldSubtree } from "./resolveFieldSubtree";
+const byteLength = (value)=>new TextEncoder().encode(JSON.stringify(value) ?? "").length;
+const noop = (value, level, message)=>({
+        status: "noop",
+        value,
+        notice: {
+            level,
+            message
+        }
+    });
+/**
+ * Synchronous single-field translation: read the field's value from the saved document in the
+ * chosen source locale, resolve the declared field path to its schema subtree, run
+ * `translateContent`, and return the translated value. No persistence — the result is written to
+ * form state by the caller.
+ *
+ * From-locale only: `source_lng` + `doc_id` are required (validated by the schema), so there is
+ * always exactly one DB read. Reserves HTTP errors for genuine errors — "nothing to translate"
+ * and "couldn't resolve the block" come back as a 200 `noop` with a notice.
+ */ export class TranslateFieldHandler {
+    config;
+    constructor(config){
+        this.config = config;
+    }
+    async handle(req) {
+        const parsed = FieldTranslationInputSchema.safeParse(await req.json?.());
+        if (parsed.error) return ServerResponse.validationError(parsed.error.issues);
+        const { collection_slug, field_path, target_lng, source_lng, doc_id } = parsed.data;
+        const fields = this.config.schemaMap.get(collection_slug);
+        if (!fields) return ServerResponse.badRequest(`Collection "${collection_slug}" is not available for translation`);
+        // Read the source value from the saved document in `source_lng` (fallbackLocale: false so an
+        // empty source reads as empty → noop, not a fallback). The doc also lets the resolver
+        // disambiguate `blocks` — their `blockType` lives in the data.
+        const sourceDoc = await req.payload.findByID({
+            collection: collection_slug,
+            id: doc_id,
+            locale: source_lng,
+            fallbackLocale: false,
+            depth: 0
+        });
+        const sourceValue = getByPath(sourceDoc, field_path);
+        // Guard the *translated* payload (held synchronously through the provider call), not the
+        // request body, which now carries no field value.
+        if (byteLength(sourceValue) > MAX_FIELD_VALUE_BYTES) {
+            return ServerResponse.custom(`Field value exceeds the ${MAX_FIELD_VALUE_BYTES}-byte limit`, 413);
+        }
+        const resolution = resolveFieldSubtree(fields, field_path, sourceValue, sourceDoc);
+        if (resolution.status === "not-found") {
+            return ServerResponse.badRequest(`Field path "${field_path}" was not found in collection "${collection_slug}"`);
+        }
+        if (resolution.status === "inside-blocks") {
+            return ServerResponse.success(noop(sourceValue, "info", "Couldn't resolve the block for this field in the source document"));
+        }
+        if (resolution.status === "localized-list-ancestor") {
+            // Inside a localized blocks/array: its order/content is independent per locale, so the path
+            // index can't be matched to the source locale. Translate the whole document instead.
+            return ServerResponse.success(noop(sourceValue, "warning", "This field is inside a localized block — translate the whole document instead, so blocks stay aligned across locales"));
+        }
+        if (resolution.status === "not-translatable") {
+            return ServerResponse.success(noop(sourceValue, "info", "Nothing to translate in this field"));
+        }
+        // No `strategy`/`targetData`: a per-field translate is an explicit "translate this field now",
+        // so `translateContent` always overwrites (its default). skip_existing has no meaning here.
+        const translated = await translateContent({
+            schema: resolution.schema,
+            sourceData: resolution.sourceData,
+            sourceLng: source_lng,
+            targetLng: target_lng,
+            translationProvider: this.config.translationProvider
+        });
+        if (!translated) {
+            return ServerResponse.success(noop(sourceValue, "info", "Nothing to translate in this field"));
+        }
+        const result = {
+            status: "translated",
+            value: translated[resolution.fieldName]
+        };
+        return ServerResponse.success(result);
+    }
+}
+
+//# sourceMappingURL=handler.js.map

package/dist/server/features/translate-field/index.d.ts

@@ -0,0 +1,6 @@
+export { createFieldRoute } from "./route";
+export type { CreateFieldRouteArgs } from "./route";
+export { TranslateFieldHandler } from "./handler";
+export { resolveFieldSubtree } from "./resolveFieldSubtree";
+export type { FieldSubtreeResolution } from "./resolveFieldSubtree";
+export type { FieldTranslationConfig, FieldTranslationInput, FieldTranslationNotice, FieldTranslationResult } from "./model";

package/dist/server/features/translate-field/index.js

@@ -0,0 +1,5 @@
+export { createFieldRoute } from "./route";
+export { TranslateFieldHandler } from "./handler";
+export { resolveFieldSubtree } from "./resolveFieldSubtree";
+
+//# sourceMappingURL=index.js.map