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

package/dist/server/shared/field-traversal/findFieldByPath.js

@@ -1,19 +1,29 @@
-import { classifyField, tabScopes } from "./kernel";
+import { classifyField, resolveBlockFields, tabScopes } from "./kernel";
+const isIndexSegment = (segment)=>/^\d+$/u.test(segment);
+/** Safely read `key` off an object/array; `undefined` for non-objects (arrays index by string key). */ const childData = (data, key)=>data != null && typeof data === "object" ? data[key] : undefined;
 /**
  * Navigate a field schema by a path of segment NAMES, descending one matching branch at a time
  * with early-exit (targeted navigation, not an exhaustive walk). Presentational containers
  * (`row`/`collapsible`/unnamed `group`) and unnamed tabs are transparent — searched in the same
- * path scope. Built on {@link classifyField} / {@link tabScopes} so the structural dispatch lives
- * in one place.
+ * path scope. Built on {@link classifyField} / {@link tabScopes} / {@link resolveBlockFields} so
+ * the structural dispatch lives in one place.
  *
- * The caller supplies already-prepared name segments (split, trimmed, with array indices dropped —
- * a field's config is shared across array items, so indices never appear in the schema).
+ * **Array indices and `blocks`.** Array element configs are shared, so a numeric segment after an
+ * array name selects the data item but not the schema (the schema continues into `array.fields`).
+ * A `blocks` field is polymorphic — which block (and thus which fields) sits at an index lives in
+ * the *data*, not the schema. So to descend through `blocks` the caller must pass the document
+ * `data` and keep the element index in the path: this function reads `data[name][index].blockType`
+ * and resolves the matching block via {@link resolveBlockFields}. Without `data` (or with a
+ * non-indexed path), descending through `blocks` returns `inside-blocks`.
  *
  * @param fields - The schema level to search.
- * @param segments - Remaining path segments (names) to match, head-first.
+ * @param segments - Remaining path segments to match, head-first. Keep array/block element indices
+ *   in the path when navigating with `data`.
+ * @param data - The document (sub)tree aligned with `fields`, used only to disambiguate `blocks`.
+ *   Omit for schema-only navigation.
  * @returns A {@link FieldPathResult}.
  * @public
- */ export function findFieldByPath(fields, segments) {
+ */ export function findFieldByPath(fields, segments, data) {
     const [head, ...rest] = segments;
     if (head === undefined) return {
         status: "not-found"
@@ -28,10 +38,10 @@ import { classifyField, tabScopes } from "./kernel";
                             if (scope.tab.name === head) {
                                 return rest.length === 0 ? {
                                     status: "container"
-                                } : findFieldByPath(scope.tab.fields, rest);
+                                } : findFieldByPath(scope.tab.fields, rest, childData(data, head));
                             }
                         } else {
-                            const found = findFieldByPath(scope.fields, segments); // unnamed tab → same path scope
+                            const found = findFieldByPath(scope.fields, segments, data); // unnamed tab → same path + data scope
                             if (found.status !== "not-found") return found;
                         }
                     }
@@ -39,28 +49,63 @@ import { classifyField, tabScopes } from "./kernel";
                 }
             case "transparent":
                 {
-                    const found = findFieldByPath(structure.fields, segments); // row/collapsible/unnamed group → same scope
+                    const found = findFieldByPath(structure.fields, segments, data); // row/collapsible/unnamed group → same scope
                     if (found.status !== "not-found") return found;
                     break;
                 }
             case "presentational":
                 break;
             case "group":
-            case "array":
                 {
                     if (structure.name !== head) break;
                     return rest.length === 0 ? {
                         status: "container"
-                    } : findFieldByPath(structure.fields, rest);
+                    } : findFieldByPath(structure.fields, rest, childData(data, head));
+                }
+            case "array":
+                {
+                    if (structure.name !== head) break;
+                    if (rest.length === 0) return {
+                        status: "container"
+                    };
+                    // A localized array is an independent per-locale structure — its element index is not a
+                    // stable identity across locales, so refuse to navigate THROUGH it by path.
+                    if (structure.field.localized) return {
+                        status: "localized-list-ancestor"
+                    };
+                    // A numeric segment selects the data element; the schema is shared across elements.
+                    const [next, ...tail] = rest;
+                    if (isIndexSegment(next)) {
+                        return tail.length === 0 ? {
+                            status: "container"
+                        } : findFieldByPath(structure.fields, tail, childData(childData(data, head), next));
+                    }
+                    return findFieldByPath(structure.fields, rest, childData(data, head));
                 }
             case "blocks":
                 {
                     if (structure.name !== head) break;
-                    return rest.length === 0 ? {
+                    if (rest.length === 0) return {
                         status: "container"
-                    } : {
+                    };
+                    // A localized blocks field is an independent per-locale structure — its element index is
+                    // not a stable identity across locales, so refuse to navigate THROUGH it by path.
+                    if (structure.field.localized) return {
+                        status: "localized-list-ancestor"
+                    };
+                    // Polymorphic: need the element index + its data to pick the block schema by `blockType`.
+                    const [next, ...tail] = rest;
+                    if (!isIndexSegment(next)) return {
+                        status: "inside-blocks"
+                    };
+                    const item = childData(childData(data, head), next);
+                    const blockFields = resolveBlockFields(structure.field, item);
+                    if (!blockFields) return {
                         status: "inside-blocks"
                     };
+                    return tail.length === 0 ? {
+                        status: "container"
+                    } : findFieldByPath(blockFields, tail, item);
                 }
             case "leaf":
                 {

package/dist/server/shared/field-traversal/index.d.ts

@@ -1,5 +1,5 @@
 export { findFieldByPath } from "./findFieldByPath";
 export type { FieldPathResult } from "./findFieldByPath";
-export { classifyField, resolveBlockFields, tabScopes } from "./kernel";
+export { classifyField, matchElementById, resolveBlockFields, tabScopes } from "./kernel";
 export type { ChildCursor, ChildOutput, ContainerInfo, FieldStructure, FieldWalker, LeafField, TabScope, WalkSignal } from "./types";
 export { walkFields } from "./walkFields";

package/dist/server/shared/field-traversal/index.js

@@ -1,5 +1,5 @@
 export { findFieldByPath } from "./findFieldByPath";
-export { classifyField, resolveBlockFields, tabScopes } from "./kernel";
+export { classifyField, matchElementById, resolveBlockFields, tabScopes } from "./kernel";
 export { walkFields } from "./walkFields";
 
 //# sourceMappingURL=index.js.map

package/dist/server/shared/field-traversal/kernel.d.ts

@@ -83,3 +83,25 @@ export declare function tabScopes(field: TabsField): TabScope[];
  * @public
  */
 export declare function resolveBlockFields(field: BlocksField, item: unknown): Field[] | null;
+/**
+ * Find the element of a parallel data array that corresponds to `refItem` by `id` — not by
+ * position.
+ *
+ * Localized `blocks`/`array` fields are stored independently per locale, so the locales can be
+ * reordered or differ entirely; pairing two parallel trees by position then cross-contaminates
+ * unrelated elements ("blocks don't line up across locales"). Matching by `id` is correct in both
+ * regimes: a non-localized field is one shared row with the same `id` across locales (so id-match
+ * equals the old positional match), while independent localized content has diverging ids (no
+ * match → the caller falls back to `refItem`'s own values, never another element's). For blocks the
+ * `blockType` must also match, so an id collision across types can't graft mismatched fields.
+ *
+ * Shared by the translation pipeline's two multi-tree walkers — reconcile and collect — to pair
+ * their `target` array against the source/reference element currently being visited.
+ *
+ * @param arr - The array to search (e.g. the target-locale elements).
+ * @param refItem - The element being matched, carrying the canonical `id` (and `blockType`).
+ * @param isBlocks - Whether the field is a `blocks` field (then `blockType` must also match).
+ * @returns The matched element, or `{}` when there is no counterpart (or `refItem` carries no `id`).
+ * @public
+ */
+export declare function matchElementById(arr: unknown[], refItem: Record<string, unknown>, isBlocks: boolean): Record<string, unknown>;

package/dist/server/shared/field-traversal/kernel.js

@@ -1,5 +1,6 @@
 import { fieldAffectsData, fieldIsArrayType, fieldIsBlockType, fieldIsGroupType, tabHasName } from "payload/shared";
 import { hasFields, isBlockItem, isTabsField } from "../guards";
+import { isObject } from "../utils";
 /**
  * Classify a single Payload {@link Field} into a discriminated {@link FieldStructure} — the
  * one place that encodes how Payload field types map onto data boundaries.
@@ -141,5 +142,31 @@ import { hasFields, isBlockItem, isTabsField } from "../guards";
     const block = field.blocks.find((candidate)=>candidate.slug === item.blockType);
     return block ? block.fields : null;
 }
+/**
+ * Find the element of a parallel data array that corresponds to `refItem` by `id` — not by
+ * position.
+ *
+ * Localized `blocks`/`array` fields are stored independently per locale, so the locales can be
+ * reordered or differ entirely; pairing two parallel trees by position then cross-contaminates
+ * unrelated elements ("blocks don't line up across locales"). Matching by `id` is correct in both
+ * regimes: a non-localized field is one shared row with the same `id` across locales (so id-match
+ * equals the old positional match), while independent localized content has diverging ids (no
+ * match → the caller falls back to `refItem`'s own values, never another element's). For blocks the
+ * `blockType` must also match, so an id collision across types can't graft mismatched fields.
+ *
+ * Shared by the translation pipeline's two multi-tree walkers — reconcile and collect — to pair
+ * their `target` array against the source/reference element currently being visited.
+ *
+ * @param arr - The array to search (e.g. the target-locale elements).
+ * @param refItem - The element being matched, carrying the canonical `id` (and `blockType`).
+ * @param isBlocks - Whether the field is a `blocks` field (then `blockType` must also match).
+ * @returns The matched element, or `{}` when there is no counterpart (or `refItem` carries no `id`).
+ * @public
+ */ export function matchElementById(arr, refItem, isBlocks) {
+    const id = refItem.id;
+    if (id === undefined || id === null) return {};
+    const match = arr.find((candidate)=>isObject(candidate) && candidate.id === id && (!isBlocks || candidate.blockType === refItem.blockType));
+    return isObject(match) ? match : {};
+}
 
 //# sourceMappingURL=kernel.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@focus-reactive/payload-plugin-translator",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "Translation plugin for Payload CMS 3.x. Automatically translate your localized content using any translation provider.",
   "type": "module",
   "license": "MIT",
@@ -50,7 +50,7 @@
     "build:types": "tsc --emitDeclarationOnly --declaration --outDir dist",
     "copyfiles": "copyfiles -u 1 \"src/**/*.scss\" dist",
     "clean": "rm -rf dist",
-    "dev": "bun run build:swc -- --watch",
+    "dev": "bun run build:swc -- --watch --copy-files",
     "lint": "ultracite check",
     "lint:fix": "ultracite fix",
     "test": "vitest run",