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

package/dist/client/shared/ui/Button/Button.d.ts

@@ -1,9 +1,9 @@
-import type { ComponentPropsWithRef, ReactNode } from 'react';
-type ButtonProps = ComponentPropsWithRef<'button'> & {
+import type { ComponentPropsWithRef, ReactNode } from "react";
+type ButtonProps = ComponentPropsWithRef<"button"> & {
     $fullWidth?: boolean;
-    $variant?: 'outlined' | 'filled' | 'unstyled' | 'transparent' | 'light';
+    $variant?: "outlined" | "filled" | "unstyled" | "transparent" | "light";
     $startContent?: ReactNode;
-    $size?: 'sm' | 'md' | 'lg';
+    $size?: "sm" | "md" | "lg";
     $isLoading?: boolean;
     $isIconButton?: boolean;
 };

package/dist/client/shared/ui/Button/Button.js

@@ -1,31 +1,31 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import classNames from 'classnames';
-import { forwardRef } from 'react';
-import Loading from '../Loading';
-import styles from './styles.module.scss';
+import classNames from "classnames";
+import { forwardRef } from "react";
+import Loading from "../Loading";
+import styles from "./styles.module.scss";
 const sizes = {
     sm: {
-        height: '24px',
-        paddingInline: '0.25rem'
+        height: "24px",
+        paddingInline: "0.25rem"
     },
     md: {
-        height: '32px',
-        paddingInline: '0.5rem'
+        height: "32px",
+        paddingInline: "0.5rem"
     },
     lg: {
-        height: '40px',
-        paddingInline: '0.75rem'
+        height: "40px",
+        paddingInline: "0.75rem"
     }
 };
-const Button = /*#__PURE__*/ forwardRef(function Button({ className = '', children, $fullWidth, style, $startContent, $variant, $isLoading, $size = 'md', $isIconButton, ...props }, ref) {
+const Button = /*#__PURE__*/ forwardRef(function Button({ className = "", children, $fullWidth, style, $startContent, $variant, $isLoading, $size = "md", $isIconButton, ...props }, ref) {
     const _style = {
-        '--button-width': $fullWidth ? '100%' : 'auto',
-        '--height': sizes[$size].height,
-        '--padding-inline': $isIconButton ? '0' : sizes[$size].paddingInline,
-        '--width': $isIconButton ? sizes[$size].height : 'auto',
+        "--button-width": $fullWidth ? "100%" : "auto",
+        "--height": sizes[$size].height,
+        "--padding-inline": $isIconButton ? "0" : sizes[$size].paddingInline,
+        "--width": $isIconButton ? sizes[$size].height : "auto",
         ...style
     };
-    const buttonClassName = $variant === 'unstyled' ? classNames(styles['unstyled'], className, $isIconButton && styles['icon-button']) : classNames(styles['button'], className, $variant ? styles[$variant] : undefined, $isIconButton && styles['icon-button']);
+    const buttonClassName = $variant === "unstyled" ? classNames(styles["unstyled"], className, $isIconButton && styles["icon-button"]) : classNames(styles["button"], className, $variant ? styles[$variant] : undefined, $isIconButton && styles["icon-button"]);
     return /*#__PURE__*/ _jsxs("button", {
         ...props,
         style: _style,
@@ -33,11 +33,11 @@ const Button = /*#__PURE__*/ forwardRef(function Button({ className = '', childr
         className: buttonClassName,
         children: [
             $startContent && /*#__PURE__*/ _jsx("div", {
-                className: styles['start-content'],
+                className: styles["start-content"],
                 children: $startContent
             }),
             $isLoading ? /*#__PURE__*/ _jsx(Loading, {
-                size: $isIconButton ? 'small' : 'medium'
+                size: $isIconButton ? "small" : "medium"
             }) : children
         ]
     });

package/dist/client/shared/ui/Button/styles.module.scss

@@ -7,7 +7,7 @@
   justify-content: center;
   align-items: center;
   text-decoration: none;
-  transition: background 0.1sease-in-out, opacity 0.2sease-in-out, border-color 0.2sease-in-out;
+  transition: background 0.1s ease-in-out, opacity 0.2s ease-in-out, border-color 0.2s ease-in-out;
   background: none;
   padding-block: 0.25rem;
   padding-inline: var(--padding-inline);

package/dist/client/shared/ui/Popup/Popup.d.ts

@@ -1,10 +1,16 @@
-import type { PropsWithChildren, ReactElement } from 'react';
+import type { PropsWithChildren, ReactElement } from "react";
 type PopupProps = PropsWithChildren<{
     $trigger: ReactElement;
-    $align?: 'center' | 'end' | 'start';
-    $side?: 'top' | 'right' | 'bottom' | 'left';
+    $align?: "center" | "end" | "start";
+    $side?: "top" | "right" | "bottom" | "left";
     open: boolean;
     onOpenChange: (open: boolean) => void;
+    /**
+     * Forwarded to Radix `Popover.Content`. Call `event.preventDefault()` to stop the popover
+     * from auto-focusing its first focusable child on open — useful when that child is a
+     * tooltip trigger (Radix tooltips open on focus, so autofocus would flash the tooltip).
+     */
+    onOpenAutoFocus?: (event: Event) => void;
 }>;
-declare function Popup({ open, children, onOpenChange, $trigger, $align, $side }: PopupProps): import("react/jsx-runtime").JSX.Element;
+declare function Popup({ open, children, onOpenChange, $trigger, $align, $side, onOpenAutoFocus }: PopupProps): import("react/jsx-runtime").JSX.Element;
 export default Popup;

package/dist/client/shared/ui/Popup/Popup.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import * as Popover from '@radix-ui/react-popover';
-import style from './styles.module.scss';
-function Popup({ open, children, onOpenChange, $trigger, $align, $side }) {
+import * as Popover from "@radix-ui/react-popover";
+import style from "./styles.module.scss";
+function Popup({ open, children, onOpenChange, $trigger, $align, $side, onOpenAutoFocus }) {
     return /*#__PURE__*/ _jsxs(Popover.Root, {
         open: open,
         onOpenChange: onOpenChange,
@@ -16,6 +16,7 @@ function Popup({ open, children, onOpenChange, $trigger, $align, $side }) {
                     side: $side,
                     align: $align,
                     className: style.popover,
+                    onOpenAutoFocus: onOpenAutoFocus,
                     children: children
                 })
             })

package/dist/client/shared/ui/Select/Select.d.ts

@@ -1,13 +1,15 @@
-import type { ComponentPropsWithoutRef, ComponentPropsWithRef } from 'react';
-type SelectProps = ComponentPropsWithRef<'select'> & {
+import type { ComponentPropsWithoutRef, ComponentPropsWithRef } from "react";
+type SelectProps = ComponentPropsWithRef<"select"> & {
     emptyOption?: boolean;
     hasError?: boolean;
-    $size?: 'sm' | 'md' | 'lg';
-    'aria-describedby'?: string;
-    'aria-invalid'?: boolean;
+    $size?: "sm" | "md" | "lg";
+    /** Stretch to fill the container (default). Set `false` to size to content — useful inline. */
+    $fullWidth?: boolean;
+    "aria-describedby"?: string;
+    "aria-invalid"?: boolean;
 };
-type SelectOptionProps = ComponentPropsWithoutRef<'option'>;
-type SelectEmptyOptionProps = Omit<SelectOptionProps, 'value' | 'disabled' | 'hidden'>;
+type SelectOptionProps = ComponentPropsWithoutRef<"option">;
+type SelectEmptyOptionProps = Omit<SelectOptionProps, "value" | "disabled" | "hidden">;
 declare const SelectOption: ({ children, ...props }: SelectOptionProps) => import("react/jsx-runtime").JSX.Element;
 declare const SelectEmptyOption: ({ children, ...props }: SelectEmptyOptionProps) => import("react/jsx-runtime").JSX.Element;
 declare const Select: import("react").ForwardRefExoticComponent<Omit<SelectProps, "ref"> & import("react").RefAttributes<HTMLSelectElement>>;

package/dist/client/shared/ui/Select/Select.js

@@ -1,22 +1,22 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import classNames from 'classnames';
-import { forwardRef } from 'react';
-import styles from './styles.module.scss';
+import classNames from "classnames";
+import { forwardRef } from "react";
+import styles from "./styles.module.scss";
 const sizes = {
     sm: {
-        height: '24px',
-        paddingInline: '0.25rem',
-        fontSize: '0.875rem'
+        height: "24px",
+        paddingInline: "0.25rem",
+        fontSize: "0.875rem"
     },
     md: {
-        height: '32px',
-        paddingInline: '0.5rem',
-        fontSize: '1rem'
+        height: "32px",
+        paddingInline: "0.5rem",
+        fontSize: "1rem"
     },
     lg: {
-        height: '40px',
-        paddingInline: '0.75rem',
-        fontSize: '1rem'
+        height: "40px",
+        paddingInline: "0.75rem",
+        fontSize: "1rem"
     }
 };
 const SelectOption = ({ children, ...props })=>/*#__PURE__*/ _jsx("option", {
@@ -28,15 +28,16 @@ const SelectEmptyOption = ({ children, ...props })=>/*#__PURE__*/ _jsx("option",
         ...props,
         children: children
     });
-const Select = /*#__PURE__*/ forwardRef(function Select({ children, className = '', hasError = false, $size = 'lg', style, 'aria-invalid': ariaInvalid, ...props }, ref) {
+const Select = /*#__PURE__*/ forwardRef(function Select({ children, className = "", hasError = false, $size = "lg", $fullWidth = true, style, "aria-invalid": ariaInvalid, ...props }, ref) {
     const _style = {
-        '--height': sizes[$size].height,
-        '--padding-inline': sizes[$size].paddingInline,
-        '--font-size': sizes[$size].fontSize,
+        "--height": sizes[$size].height,
+        "--padding-inline": sizes[$size].paddingInline,
+        "--font-size": sizes[$size].fontSize,
         ...style
     };
     const selectClassName = classNames(styles.select, styles[`size-${$size}`], {
-        [styles.selectError]: hasError
+        [styles.selectError]: hasError,
+        [styles.auto]: !$fullWidth
     }, className);
     return /*#__PURE__*/ _jsx("select", {
         ref: ref,

package/dist/client/shared/ui/Select/styles.module.scss

@@ -31,6 +31,11 @@
   }
 }
 
+/* Opt out of full width (`$fullWidth={false}`) — size to content, e.g. inline in a row. */
+.auto {
+  width: auto;
+}
+
 /* Size-specific styles if needed */
 .size-sm {
   background-size: 12px 12px;

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

@@ -0,0 +1,31 @@
+import type { Field } from "payload";
+/**
+ * Outcome of mapping a declared field path to a translatable subtree.
+ *
+ * - `resolved` — the path lands on a translatable leaf; `schema` + `sourceData`
+ *   are ready for `translateContent`, and `fieldName` is the key to unwrap the result.
+ * - `not-found` — the path resolves to no field at all (a typo) → caller returns 400.
+ * - `not-translatable` — resolves to a field that isn't a text-like leaf → caller no-ops.
+ * - `inside-blocks` — the path descends through a polymorphic `blocks` field, which
+ *   can't be resolved from the path alone (the blockType lives in the data) → caller no-ops.
+ */
+export type FieldSubtreeResolution = {
+    status: "resolved";
+    schema: Field[];
+    sourceData: Record<string, unknown>;
+    fieldName: string;
+} | {
+    status: "not-found";
+} | {
+    status: "not-translatable";
+} | {
+    status: "inside-blocks";
+};
+/**
+ * Map a declared `fieldPath` to the `{ schema, sourceData }` pair `translateContent` expects.
+ * Walks the schema by field name (via the shared {@link findFieldByPath}), dropping array indices
+ * (a field's config is shared across array items). Descends transparently through presentational
+ * containers (row, collapsible, unnamed tabs) and through named group/array/tab containers. A path
+ * that descends through a `blocks` field returns `inside-blocks`.
+ */
+export declare function resolveFieldSubtree(rootFields: Field[], fieldPath: string, value: unknown): FieldSubtreeResolution;

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

@@ -0,0 +1,45 @@
+import { isTranslatableField } from "../../shared";
+import { findFieldByPath } from "../../shared/field-traversal";
+const isIndexSegment = (segment)=>/^\d+$/u.test(segment);
+/**
+ * Map a declared `fieldPath` to the `{ schema, sourceData }` pair `translateContent` expects.
+ * Walks the schema by field name (via the shared {@link findFieldByPath}), dropping array indices
+ * (a field's config is shared across array items). Descends transparently through presentational
+ * containers (row, collapsible, unnamed tabs) and through named group/array/tab containers. A path
+ * that descends through a `blocks` field returns `inside-blocks`.
+ */ export function resolveFieldSubtree(rootFields, fieldPath, value) {
+    const segments = fieldPath.split(".").map((segment)=>segment.trim()).filter((segment)=>segment.length > 0 && !isIndexSegment(segment));
+    if (segments.length === 0) return {
+        status: "not-found"
+    };
+    const result = findFieldByPath(rootFields, segments);
+    switch(result.status){
+        case "leaf":
+            return isTranslatableField(result.field) ? {
+                status: "resolved",
+                schema: [
+                    result.field
+                ],
+                sourceData: {
+                    [result.field.name]: value
+                },
+                fieldName: result.field.name
+            } : {
+                status: "not-translatable"
+            };
+        case "container":
+            return {
+                status: "not-translatable"
+            };
+        case "inside-blocks":
+            return {
+                status: "inside-blocks"
+            };
+        case "not-found":
+            return {
+                status: "not-found"
+            };
+    }
+}
+
+//# sourceMappingURL=resolveFieldSubtree.js.map

package/dist/server/modules/translation-pipeline/stages/data-reconciler/DataReconciler.d.ts

@@ -1,11 +1,7 @@
-import type { Field } from 'payload';
+import type { Field } from "payload";
 /**
- * Deep merges source and target data with target priority.
- * Creates full document shape needed for Payload validation.
- *
- * Logic:
- * - If targetValue exists and is not empty → use targetValue
- * - Otherwise → use sourceValue
+ * Deep-merges source and target data with target priority, producing the full document shape
+ * Payload validation needs. Built on the shared {@link walkFields} engine.
  *
  * Stage 1 of the translation pipeline.
  */
@@ -14,12 +10,10 @@ export declare class DataReconciler {
     constructor(schema: Field[]);
     /**
      * Reconciles source and target data into a complete document shape.
-     * The result contains all fields needed for Payload validation.
      *
      * @param sourceData - Source locale document data
      * @param targetData - Target locale document data (may be empty/partial)
      * @returns Complete document shape with reconciled field values
      */
     reconcile(sourceData: Record<string, unknown>, targetData: Record<string, unknown>): Record<string, unknown>;
-    private reconcileFields;
 }

package/dist/server/modules/translation-pipeline/stages/data-reconciler/DataReconciler.js

@@ -1,12 +1,70 @@
-import { fieldAffectsData, fieldIsArrayType, fieldIsBlockType, fieldIsGroupType, tabHasName } from 'payload/shared';
-import { hasFields, isBlockItem, isTabsField, isEmpty, isObject } from '../../../../shared';
+import { isEmpty, isObject } from "../../../../shared";
+import { resolveBlockFields, walkFields } from "../../../../shared/field-traversal";
+const asObject = (value)=>isObject(value) ? value : {};
 /**
- * Deep merges source and target data with target priority.
- * Creates full document shape needed for Payload validation.
- *
- * Logic:
- * - If targetValue exists and is not empty → use targetValue
- * - Otherwise → use sourceValue
+ * Reconcile walker: produces the full document shape from source + target, with target
+ * priority (source fills empty target slots). Iteration is driven by `source`; a field with
+ * no source value is dropped, `id` is stripped from array/block elements (Postgres rejects it
+ * on update), `blockType` is preserved, and non-object array items / unknown blocks pass
+ * through unchanged.
+ */ const reconcileWalker = {
+    enterObject (field, cursor) {
+        const sourceValue = cursor.source[field.name];
+        if (!isObject(sourceValue)) return "skip"; // undefined / non-object source → drop the field
+        return {
+            source: sourceValue,
+            target: asObject(cursor.target[field.name])
+        };
+    },
+    enterList (field, cursor) {
+        const sourceValue = cursor.source[field.name];
+        if (!Array.isArray(sourceValue)) return "skip";
+        const targetValue = cursor.target[field.name];
+        const targetArr = Array.isArray(targetValue) ? targetValue : [];
+        const children = [];
+        sourceValue.forEach((item, index)=>{
+            if (!isObject(item)) return; // non-object element → passthrough (rebuilt in combine)
+            const fields = field.type === "blocks" ? resolveBlockFields(field, item) : field.fields;
+            if (!fields) return; // unknown blockType → passthrough
+            children.push({
+                cursor: {
+                    source: item,
+                    target: asObject(targetArr[index])
+                },
+                fields,
+                key: index
+            });
+        });
+        return children;
+    },
+    leaf (field, cursor) {
+        const sourceValue = cursor.source[field.name];
+        if (sourceValue === undefined) return undefined; // no source value → field dropped
+        const targetValue = cursor.target[field.name];
+        return isEmpty(targetValue) ? sourceValue : targetValue; // target priority, fallback to source
+    },
+    combine (container, children, cursor) {
+        if (container.kind === "list") {
+            // Rebuild the full array: reconciled objects where present (by index), raw source items otherwise.
+            const sourceArr = cursor.source[container.key] ?? [];
+            const byIndex = new Map(children.map((child)=>[
+                    child.key,
+                    child.out
+                ]));
+            return sourceArr.map((item, index)=>byIndex.has(index) ? byIndex.get(index) : item);
+        }
+        const result = {};
+        for (const child of children)result[child.key] = child.out;
+        // Block elements keep their blockType; id is intentionally stripped (Postgres rejects it on update).
+        if (container.kind === "element" && container.field.type === "blocks") {
+            result.blockType = cursor.source.blockType;
+        }
+        return result;
+    }
+};
+/**
+ * Deep-merges source and target data with target priority, producing the full document shape
+ * Payload validation needs. Built on the shared {@link walkFields} engine.
  *
  * Stage 1 of the translation pipeline.
  */ export class DataReconciler {
@@ -16,81 +74,16 @@ import { hasFields, isBlockItem, isTabsField, isEmpty, isObject } from '../../..
     }
     /**
    * Reconciles source and target data into a complete document shape.
-   * The result contains all fields needed for Payload validation.
    *
    * @param sourceData - Source locale document data
    * @param targetData - Target locale document data (may be empty/partial)
    * @returns Complete document shape with reconciled field values
    */ reconcile(sourceData, targetData) {
-        return this.reconcileFields(this.schema, sourceData, targetData ?? {});
-    }
-    reconcileFields(fields, source, target) {
-        const result = {};
-        for (const field of fields){
-            if (isTabsField(field)) {
-                for (const tab of field.tabs){
-                    if (hasFields(tab)) {
-                        if (tabHasName(tab)) {
-                            const tabSource = source[tab.name];
-                            const tabTarget = target[tab.name];
-                            if (isObject(tabSource)) {
-                                result[tab.name] = this.reconcileFields(tab.fields, tabSource, isObject(tabTarget) ? tabTarget : {});
-                            }
-                        } else {
-                            Object.assign(result, this.reconcileFields(tab.fields, source, target));
-                        }
-                    }
-                }
-                continue;
-            }
-            if (!fieldAffectsData(field)) {
-                if (hasFields(field)) Object.assign(result, this.reconcileFields(field.fields, source, target));
-                continue;
-            }
-            const sourceValue = source[field.name];
-            const targetValue = target[field.name];
-            // Skip undefined source values
-            if (sourceValue === undefined) continue;
-            // Group - recursively reconcile
-            if (fieldIsGroupType(field) && isObject(sourceValue)) {
-                const targetGroup = isObject(targetValue) ? targetValue : {};
-                result[field.name] = this.reconcileFields(field.fields, sourceValue, targetGroup);
-                continue;
-            }
-            // Array - recursively reconcile each item (without id - Postgres rejects it)
-            if (fieldIsArrayType(field) && Array.isArray(sourceValue)) {
-                const targetArray = Array.isArray(targetValue) ? targetValue : [];
-                result[field.name] = sourceValue.map((sourceItem, index)=>{
-                    if (isObject(sourceItem)) {
-                        const targetItem = isObject(targetArray[index]) ? targetArray[index] : {};
-                        return this.reconcileFields(field.fields, sourceItem, targetItem);
-                    }
-                    return sourceItem;
-                });
-                continue;
-            }
-            // Blocks - recursively reconcile each block (without id - Postgres rejects it)
-            if (fieldIsBlockType(field) && Array.isArray(sourceValue)) {
-                const targetArray = Array.isArray(targetValue) ? targetValue : [];
-                result[field.name] = sourceValue.map((sourceItem, index)=>{
-                    if (isBlockItem(sourceItem)) {
-                        const block = field.blocks.find((b)=>b.slug === sourceItem.blockType);
-                        if (block) {
-                            const targetItem = isObject(targetArray[index]) ? targetArray[index] : {};
-                            return {
-                                ...this.reconcileFields(block.fields, sourceItem, targetItem),
-                                blockType: sourceItem.blockType
-                            };
-                        }
-                    }
-                    return sourceItem;
-                });
-                continue;
-            }
-            // Deep merge: target priority, fallback to source
-            result[field.name] = isEmpty(targetValue) ? sourceValue : targetValue;
-        }
-        return result;
+        const root = {
+            source: sourceData,
+            target: targetData ?? {}
+        };
+        return walkFields(this.schema, root, reconcileWalker) ?? {};
     }
 }
 

package/dist/server/modules/translation-pipeline/stages/field-collector/FieldChunkCollector.d.ts

@@ -1,18 +1,15 @@
-import type { Field } from 'payload';
-import type { FieldChunk } from '../../types';
-import type { TranslationStrategy } from '../../strategies';
+import type { Field } from "payload";
+import type { TranslationStrategy } from "../../strategies";
+import type { FieldChunk } from "../../types";
 /**
- * Collects FieldChunks by traversing schema and data in parallel.
- * Each chunk contains a reference to the parent data object for later mutation.
+ * Collects FieldChunks by walking schema + data with the shared {@link walkFields} engine.
+ * Iteration is driven by `filteredData`; each translatable, localized, non-excluded leaf that
+ * the strategy approves is written with its source value and pushed as a chunk carrying a
+ * mutable reference to its parent object (for later write-back). Collect-only — `combine` is a
+ * no-op; results accumulate in a closure.
  *
- * Applies all filtering logic:
- * - isTranslatableField
- * - isLocalizedField
- * - strategy.shouldTranslate(sourceValue, targetValue)
- * - !isFieldExcludedFromTranslation
- *
- * IMPORTANT: Expects ORIGINAL collection schemas (before Payload sanitization).
- * Original schemas preserve `localized: true` on nested fields.
+ * IMPORTANT: Expects ORIGINAL collection schemas (before Payload sanitization). Original
+ * schemas preserve `localized: true` on nested fields.
  */
 export declare class FieldChunkCollector {
     private readonly schema;
@@ -20,15 +17,7 @@ export declare class FieldChunkCollector {
     private readonly sourceData;
     private readonly targetData;
     private readonly strategy;
-    private chunks;
     constructor(schema: Field[], filteredData: Record<string, unknown>, sourceData: Record<string, unknown>, targetData: Record<string, unknown>, strategy: TranslationStrategy);
-    /**
-     * Collects translatable field chunks that need translation.
-     */
+    /** Collects translatable field chunks that need translation. */
     collect(): FieldChunk[];
-    /**
-     * Traverses fields recursively, collecting translatable fields that need translation.
-     * Uses strategy.shouldTranslate() to determine if field needs translation.
-     */
-    private traverseFields;
 }