@focus-reactive/payload-plugin-translator 0.9.1 → 0.9.2

package/dist/core/kernel/field-traversal/index.d.ts

@@ -2,6 +2,7 @@ export { findFieldByPath } from "./findFieldByPath";
 export type { FieldPathResult } from "./findFieldByPath";
 export { hasFields, isBlockItem, isTabsField } from "./guards";
 export { classifyField, matchElementById, resolveBlockFields, tabScopes } from "./kernel";
+export { projectFieldsToFieldLike } from "./projectFieldLike";
 export { fieldAffectsData, fieldIsArrayType, fieldIsBlockType, fieldIsGroupType, tabHasName, } from "./predicates";
 export type { ArrayFieldLike, BlockLike, BlocksFieldLike, ChildCursor, ChildOutput, ContainerInfo, FieldLike, FieldStructure, FieldWalker, GroupFieldLike, LeafField, LeafFieldLike, TabLike, TabScope, TabsFieldLike, WalkSignal, } from "./types";
 export { walkFields } from "./walkFields";

package/dist/core/kernel/field-traversal/index.js

@@ -1,6 +1,7 @@
 export { findFieldByPath } from "./findFieldByPath";
 export { hasFields, isBlockItem, isTabsField } from "./guards";
 export { classifyField, matchElementById, resolveBlockFields, tabScopes } from "./kernel";
+export { projectFieldsToFieldLike } from "./projectFieldLike";
 export { fieldAffectsData, fieldIsArrayType, fieldIsBlockType, fieldIsGroupType, tabHasName } from "./predicates";
 export { walkFields } from "./walkFields";
 

package/dist/core/kernel/field-traversal/projectFieldLike.d.ts

@@ -0,0 +1,32 @@
+import type { FieldLike } from "./types";
+/**
+ * Deep-project a field schema into an independent {@link FieldLike} tree, copying ONLY the properties
+ * this layer reads. Replaces the `JSON.parse(JSON.stringify(fields))` clone the plugin used to snapshot
+ * a collection's schema before Payload's sanitizer mutates the originals.
+ *
+ * Why a bespoke projection rather than a structural clone:
+ * - **Independence is mandatory, not cosmetic.** Payload's `sanitizeFields` does `delete field.localized`
+ *   **in place** on any field nested under a localized ancestor (group/array/named tab). The pipeline
+ *   reads per-field `localized`, so a shared reference would silently lose it and the field would stop
+ *   being translated. Every field/container here is a NEW object, and `localized` is copied by value at
+ *   projection time (before sanitize runs), so the snapshot is preserved.
+ * - **`structuredClone` can't be used.** Field definitions embed Lexical editor configs containing async
+ *   functions, which `structuredClone` throws on. The old JSON round-trip "worked" only by silently
+ *   dropping every function; this projection drops them explicitly by copying a typed whitelist.
+ *
+ * The contract is exactly what the traversal/pipeline consumes: `type` (classify), `name`/`localized`
+ * (leaf data + translation gate), `custom` (only `custom.translateKit.exclude` is read), and the
+ * container members `fields` (group/array/row/collapsible/unnamed-group), `blocks` (with the
+ * load-bearing `block.slug` used for block-type dispatch), and `tabs` (named + unnamed). Every field is
+ * kept 1:1 (including presentational `ui`/`row`/`collapsible`) so downstream classification is unchanged;
+ * only the property set is narrowed.
+ *
+ * `custom` is copied by reference: it is a passthrough bag Payload does not mutate during sanitize (only
+ * `localized` is deleted, which we snapshot by value), and deep-copying it would re-introduce the
+ * `structuredClone`-on-functions problem this projection exists to avoid.
+ *
+ * @param fields - The source field list (Payload's `Field[]` is structurally assignable to `FieldLike[]`).
+ * @returns A new, independent `FieldLike[]` unaffected by later mutation of the source objects.
+ * @since 0.9.1
+ */
+export declare function projectFieldsToFieldLike(fields: FieldLike[]): FieldLike[];

package/dist/core/kernel/field-traversal/projectFieldLike.js

@@ -0,0 +1,60 @@
+function projectField(field) {
+    const out = {
+        type: field.type
+    };
+    if (field.name !== undefined) out.name = field.name;
+    if (field.localized !== undefined) out.localized = field.localized;
+    if (field.custom !== undefined) out.custom = field.custom;
+    if (field.fields) out.fields = field.fields.map(projectField);
+    if (field.blocks) {
+        out.blocks = field.blocks.map((block)=>({
+                slug: block.slug,
+                fields: block.fields.map(projectField)
+            }));
+    }
+    if (field.tabs) {
+        out.tabs = field.tabs.map((tab)=>{
+            const projected = {
+                fields: tab.fields.map(projectField)
+            };
+            if (tab.name !== undefined) projected.name = tab.name;
+            if (tab.localized !== undefined) projected.localized = tab.localized;
+            return projected;
+        });
+    }
+    return out;
+}
+/**
+ * Deep-project a field schema into an independent {@link FieldLike} tree, copying ONLY the properties
+ * this layer reads. Replaces the `JSON.parse(JSON.stringify(fields))` clone the plugin used to snapshot
+ * a collection's schema before Payload's sanitizer mutates the originals.
+ *
+ * Why a bespoke projection rather than a structural clone:
+ * - **Independence is mandatory, not cosmetic.** Payload's `sanitizeFields` does `delete field.localized`
+ *   **in place** on any field nested under a localized ancestor (group/array/named tab). The pipeline
+ *   reads per-field `localized`, so a shared reference would silently lose it and the field would stop
+ *   being translated. Every field/container here is a NEW object, and `localized` is copied by value at
+ *   projection time (before sanitize runs), so the snapshot is preserved.
+ * - **`structuredClone` can't be used.** Field definitions embed Lexical editor configs containing async
+ *   functions, which `structuredClone` throws on. The old JSON round-trip "worked" only by silently
+ *   dropping every function; this projection drops them explicitly by copying a typed whitelist.
+ *
+ * The contract is exactly what the traversal/pipeline consumes: `type` (classify), `name`/`localized`
+ * (leaf data + translation gate), `custom` (only `custom.translateKit.exclude` is read), and the
+ * container members `fields` (group/array/row/collapsible/unnamed-group), `blocks` (with the
+ * load-bearing `block.slug` used for block-type dispatch), and `tabs` (named + unnamed). Every field is
+ * kept 1:1 (including presentational `ui`/`row`/`collapsible`) so downstream classification is unchanged;
+ * only the property set is narrowed.
+ *
+ * `custom` is copied by reference: it is a passthrough bag Payload does not mutate during sanitize (only
+ * `localized` is deleted, which we snapshot by value), and deep-copying it would re-introduce the
+ * `structuredClone`-on-functions problem this projection exists to avoid.
+ *
+ * @param fields - The source field list (Payload's `Field[]` is structurally assignable to `FieldLike[]`).
+ * @returns A new, independent `FieldLike[]` unaffected by later mutation of the source objects.
+ * @since 0.9.1
+ */ export function projectFieldsToFieldLike(fields) {
+    return fields.map(projectField);
+}
+
+//# sourceMappingURL=projectFieldLike.js.map

package/dist/plugin.js

@@ -1,6 +1,7 @@
 import { CacheProviderExport } from "./client/app/cache/CacheProvider.export";
 import { configureAutoTranslate } from "./server/modules/auto-translate";
 import { configureProvenance } from "./server/modules/provenance";
+import { projectFieldsToFieldLike } from "./core/kernel/field-traversal";
 import { wireTranslateRunner } from "./server/features/translate-document";
 import { documentLevel, collectionLevel } from "./composition/levels";
 import { PluginConfigBuilder } from "./server/modules/translation-levels/PluginConfigBuilder";
@@ -13,17 +14,15 @@ import { normalizePath } from "./server/shared";
     init() {
         return async (config)=>{
             const { access, translationProvider, runner, collections, levels, provenance, lifecycle, basePath: rawBasePath = "/translate" } = this.pluginConfig;
-            // Build schema map from deep-cloned collections.
-            // Deep clone is required because Payload mutates the original collection objects, removing
-            // `localized: true` from nested fields during sanitization. JSON round-trip (not
-            // structuredClone) because Lexical editor configs contain async functions structuredClone
-            // cannot handle.
-            // TODO: Consider introducing a FieldLike interface with only the properties used by the
-            // pipeline (name, type, localized, fields, blocks, tabs, custom) to make the contract explicit
-            // and avoid reliance on JSON round-trip.
+            // Snapshot each collection's schema as an independent FieldLike tree BEFORE Payload's sanitizer
+            // mutates the originals (it deletes `localized` from fields nested under a localized ancestor).
+            // `projectFieldsToFieldLike` deep-copies only the properties the pipeline reads — an explicit,
+            // typed contract, replacing the old JSON round-trip (which "worked" only by silently dropping the
+            // Lexical editor's async functions that structuredClone chokes on). Payload's `Field[]` is
+            // structurally assignable to `FieldLike[]`, so the projection happens right here at the boundary.
             const schemaMap = new Map(collections.map((col)=>[
                     col.slug,
-                    JSON.parse(JSON.stringify(col.fields))
+                    projectFieldsToFieldLike(col.fields)
                 ]));
             const collectionSlugs = new Set(schemaMap.keys());
             const basePath = normalizePath(rawBasePath);

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

@@ -1,4 +1,4 @@
-import type { Field } from "payload";
+import type { FieldLike } from "../../../core/kernel/field-traversal";
 /**
  * Outcome of mapping a declared field path to a translatable subtree.
  *
@@ -14,7 +14,7 @@ import type { Field } from "payload";
  */
 export type FieldSubtreeResolution = {
     status: "resolved";
-    schema: Field[];
+    schema: FieldLike[];
     sourceData: Record<string, unknown>;
     fieldName: string;
 } | {
@@ -36,4 +36,4 @@ export type FieldSubtreeResolution = {
  * the element's `blockType` in `doc` picks the block schema. Without `doc`, a path through a
  * `blocks` field returns `inside-blocks`.
  */
-export declare function resolveFieldSubtree(rootFields: Field[], fieldPath: string, value: unknown, doc?: unknown): FieldSubtreeResolution;
+export declare function resolveFieldSubtree(rootFields: FieldLike[], fieldPath: string, value: unknown, doc?: unknown): FieldSubtreeResolution;

package/dist/types/CollectionSchemaMap.d.ts

@@ -1,6 +1,9 @@
-import type { CollectionSlug, Field } from "payload";
+import type { CollectionSlug } from "payload";
+import type { FieldLike } from "../core/kernel/field-traversal";
 /**
- * Map of collection slug to original field schema.
- * Used to access original schemas before Payload sanitization.
+ * Map of collection slug to its projected field schema — an independent {@link FieldLike} snapshot
+ * taken (via `projectFieldsToFieldLike`) before Payload's sanitizer mutates the originals, so nested
+ * `localized` flags survive. Typed as `FieldLike[]` (not Payload's `Field[]`) because every consumer
+ * reads it structurally as `FieldLike`; the projection is the boundary that makes that explicit.
  */
-export type CollectionSchemaMap = Map<CollectionSlug, Field[]>;
+export type CollectionSchemaMap = Map<CollectionSlug, FieldLike[]>;

package/dist/types/CollectionSchemaMap.js

@@ -1,6 +1,8 @@
 /**
- * Map of collection slug to original field schema.
- * Used to access original schemas before Payload sanitization.
+ * Map of collection slug to its projected field schema — an independent {@link FieldLike} snapshot
+ * taken (via `projectFieldsToFieldLike`) before Payload's sanitizer mutates the originals, so nested
+ * `localized` flags survive. Typed as `FieldLike[]` (not Payload's `Field[]`) because every consumer
+ * reads it structurally as `FieldLike`; the projection is the boundary that makes that explicit.
  */ export { };
 
 //# sourceMappingURL=CollectionSchemaMap.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@focus-reactive/payload-plugin-translator",
-  "version": "0.9.1",
+  "version": "0.9.2",
   "description": "Translation plugin for Payload CMS 3.x. Automatically translate your localized content using any translation provider.",
   "type": "module",
   "license": "MIT",