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

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

@@ -0,0 +1,191 @@
+import type { ArrayField, BlocksField, Field, FieldAffectingData, NamedGroupField, NamedTab, TabAsField, TabsField } from "payload";
+/**
+ * A data-affecting field the engine routes to `leaf`: a scalar/relational leaf, never a
+ * container (`group`/`array`/`blocks`) and never a `TabAsField`. Narrowing `FieldAffectingData`
+ * down to these members is what guarantees `name: string` — the raw union does NOT, because
+ * an unnamed `TabAsField` carries `name?: string`.
+ *
+ * @public
+ */
+export type LeafField = Exclude<FieldAffectingData, ArrayField | BlocksField | NamedGroupField | TabAsField>;
+/**
+ * Structural classification of a single Payload field — the one place that encodes
+ * how Payload field types map onto data boundaries (the dispatch order
+ * `tabs → transparent → group → array → blocks → leaf`).
+ *
+ * Consumed by {@link FieldWalker}/`walkFields` (the exhaustive, data-parallel walks)
+ * and by path-navigation; the four hand-rolled traversals collapse onto it so the
+ * dispatch lives in exactly one place.
+ *
+ * - `transparent` — presentational container that does NOT open a data boundary
+ *   (row, collapsible, unnamed group). Its `fields` live in the SAME data scope as
+ *   the parent.
+ * - `presentational` — a `ui` leaf: no data, no subfields.
+ * - `group`/`array`/`blocks` — open a data boundary at `name`.
+ * - `leaf` — a data-affecting field with no subfields.
+ *
+ * @see {@link classifyField} — produces this; {@link walkFields} — consumes it.
+ * @public
+ */
+export type FieldStructure = {
+    kind: "tabs";
+    field: TabsField;
+} | {
+    kind: "transparent";
+    fields: Field[];
+} | {
+    kind: "presentational";
+} | {
+    kind: "group";
+    name: string;
+    fields: Field[];
+    field: NamedGroupField;
+} | {
+    kind: "array";
+    name: string;
+    fields: Field[];
+    field: ArrayField;
+} | {
+    kind: "blocks";
+    name: string;
+    field: BlocksField;
+} | {
+    kind: "leaf";
+    name: string;
+    field: LeafField;
+};
+/**
+ * A tab flattened by `tabScopes`. A named tab opens a data boundary, so its `NamedTab`
+ * is surfaced (the walker passes it to `enterObject`, and `tab.name` is the data key).
+ * An unnamed tab flattens into the parent data scope, so only its `fields` are needed.
+ *
+ * @see {@link tabScopes}
+ * @public
+ */
+export type TabScope = {
+    named: true;
+    tab: NamedTab;
+} | {
+    named: false;
+    fields: Field[];
+};
+/**
+ * Control signal a walker callback can return instead of descending.
+ * - `skip` — do not descend this branch; continue with siblings.
+ * - `stop` — halt the whole walk (used for path-style navigation / early-exit).
+ *
+ * @public
+ */
+export type WalkSignal = "skip" | "stop";
+/**
+ * One child to recurse under an array/blocks boundary. The caller derives these from its own
+ * data (it alone knows how many elements there are and their shape) and returns them from
+ * {@link FieldWalker.enterList}.
+ *
+ * @template Cursor - The walker's data-position type (see {@link FieldWalker}).
+ * @public
+ */
+export interface ChildCursor<Cursor extends object> {
+    cursor: Cursor;
+    /** Child fields to walk under this item. For `blocks`, the resolved `block.fields`. */
+    fields: Field[];
+    /** Index/key this child sits at; surfaced back to `combine`. */
+    key: string | number;
+}
+/**
+ * The container the engine asks the walker to assemble, bottom-up.
+ *
+ * - `root` — the top-level field list (`field` is `null`).
+ * - `object` — a `group` or a named tab.
+ * - `list` — an `array` or `blocks` collection (children are its elements, keyed by index).
+ * - `element` — a single element of a list (children are its fields). `field` is the
+ *   parent list field; distinguish array vs blocks via `field.type`.
+ *
+ * @see {@link FieldWalker.combine}
+ * @public
+ */
+export type ContainerInfo = {
+    kind: "root";
+    field: null;
+} | {
+    kind: "object";
+    field: NamedGroupField | NamedTab;
+    key: string;
+} | {
+    kind: "list";
+    field: ArrayField | BlocksField;
+    key: string;
+} | {
+    kind: "element";
+    field: ArrayField | BlocksField;
+    key: string | number;
+};
+/**
+ * A child's assembled output, tagged with the key it sat at within its parent. Passed to
+ * {@link FieldWalker.combine} as the `children` list.
+ *
+ * @template Out - The walker's per-node output type (see {@link FieldWalker}).
+ * @public
+ */
+export interface ChildOutput<Out> {
+    key: string | number;
+    out: Out;
+}
+/**
+ * Behaviour a caller plugs into {@link walkFields}. The engine owns structural dispatch and
+ * recursion over the **schema**; the caller owns the **data** via the opaque `Cursor`
+ * (1..n parallel data trees plus any path live there) and decides what to produce.
+ *
+ * Shapes this is designed to subsume (one engine, many callers):
+ * - build-tree (filter / reconcile) — reconstruct values in `combine`.
+ * - collect + mutate (field-chunk collector) — push/mutate in `leaf`, `combine` is a no-op.
+ * - navigate + early-exit (path resolver) — `enter*` returns `'skip'`/`'stop'`.
+ *
+ * @template Cursor - The data position threaded through the walk. The engine never reads it;
+ * it only passes it to your callbacks and stores the cursors you return. Constrained to
+ * `object` so a cursor can never collide with a {@link WalkSignal} string (`'skip'`/`'stop'`).
+ * @template Out - What you produce per leaf and assemble per container. Use `void` for a
+ * collect-only walk (accumulate in a closure, return `undefined` from `combine`).
+ *
+ * @example
+ * A collect-only walker that records the path of every localized leaf:
+ * ```ts
+ * type Cursor = { data: Record<string, unknown>; path: string[] };
+ * const found: string[] = [];
+ *
+ * const walker: FieldWalker<Cursor, void> = {
+ *   enterObject: (field, c) =>
+ *     isRecord(c.data[field.name])
+ *       ? { data: c.data[field.name], path: [...c.path, field.name] }
+ *       : "skip",
+ *   enterList: (field, c) => toItemCursors(field, c),
+ *   leaf: (field, c) => {
+ *     if (field.localized) found.push([...c.path, field.name].join("."));
+ *     return undefined;
+ *   },
+ *   combine: () => undefined, // collect-only: nothing to assemble
+ * };
+ * ```
+ *
+ * @see {@link walkFields}
+ * @public
+ */
+export interface FieldWalker<Cursor extends object, Out> {
+    /** Enter a single-object boundary (named `group` or named tab). Return the child cursor, or a signal. */
+    enterObject(field: NamedGroupField | NamedTab, cursor: Cursor): Cursor | WalkSignal;
+    /** Enter an `array`/`blocks` boundary. Return one {@link ChildCursor} per element, or a signal. */
+    enterList(field: ArrayField | BlocksField, cursor: Cursor): ChildCursor<Cursor>[] | WalkSignal;
+    /**
+     * Visit a data-affecting leaf. `field` is a {@link LeafField} — the engine has already
+     * resolved it via the `fieldAffectsData` guard and excluded containers/tabs, so `field.name`
+     * is always present and callers never touch the raw `Field` union. Return its output, or
+     * `undefined` to drop it.
+     */
+    leaf(field: LeafField, cursor: Cursor): Out | undefined;
+    /**
+     * Assemble a container from its children's outputs (called bottom-up). Build-tree
+     * callers reconstruct here; collectors return `undefined`. Return `undefined` to drop
+     * the container from its parent (e.g. an empty object after filtering).
+     */
+    combine(container: ContainerInfo, children: ChildOutput<Out>[], cursor: Cursor): Out | undefined;
+}

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

@@ -0,0 +1,41 @@
+/**
+ * Behaviour a caller plugs into {@link walkFields}. The engine owns structural dispatch and
+ * recursion over the **schema**; the caller owns the **data** via the opaque `Cursor`
+ * (1..n parallel data trees plus any path live there) and decides what to produce.
+ *
+ * Shapes this is designed to subsume (one engine, many callers):
+ * - build-tree (filter / reconcile) — reconstruct values in `combine`.
+ * - collect + mutate (field-chunk collector) — push/mutate in `leaf`, `combine` is a no-op.
+ * - navigate + early-exit (path resolver) — `enter*` returns `'skip'`/`'stop'`.
+ *
+ * @template Cursor - The data position threaded through the walk. The engine never reads it;
+ * it only passes it to your callbacks and stores the cursors you return. Constrained to
+ * `object` so a cursor can never collide with a {@link WalkSignal} string (`'skip'`/`'stop'`).
+ * @template Out - What you produce per leaf and assemble per container. Use `void` for a
+ * collect-only walk (accumulate in a closure, return `undefined` from `combine`).
+ *
+ * @example
+ * A collect-only walker that records the path of every localized leaf:
+ * ```ts
+ * type Cursor = { data: Record<string, unknown>; path: string[] };
+ * const found: string[] = [];
+ *
+ * const walker: FieldWalker<Cursor, void> = {
+ *   enterObject: (field, c) =>
+ *     isRecord(c.data[field.name])
+ *       ? { data: c.data[field.name], path: [...c.path, field.name] }
+ *       : "skip",
+ *   enterList: (field, c) => toItemCursors(field, c),
+ *   leaf: (field, c) => {
+ *     if (field.localized) found.push([...c.path, field.name].join("."));
+ *     return undefined;
+ *   },
+ *   combine: () => undefined, // collect-only: nothing to assemble
+ * };
+ * ```
+ *
+ * @see {@link walkFields}
+ * @public
+ */ export { };
+
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1,51 @@
+import type { Field } from "payload";
+import type { FieldWalker } from "./types";
+/**
+ * Depth-first walk of a Payload field **schema**, driving a caller-supplied
+ * {@link FieldWalker}. The single traversal engine this package's data operations build on
+ * (filtering, reconciling, collecting, navigating).
+ *
+ * The engine owns structural dispatch (via {@link classifyField} / {@link tabScopes}) and the
+ * recursion; the caller owns the **data** through the opaque `Cursor` and decides what to
+ * produce. The engine never reads the cursor — so the caller can thread one, two, or more
+ * parallel data trees (plus a path) inside it. Containers are assembled bottom-up via
+ * `combine`, after their children.
+ *
+ * @template Cursor - The caller's data position threaded through the walk (e.g. the current
+ * data object, a `{ source, target }` pair, plus a path). Constrained to `object` so a cursor
+ * can never collide with a {@link WalkSignal} string (`'skip'`/`'stop'`).
+ * @template Out - What the walker produces per node and assembles per container (e.g. a
+ * rebuilt data subtree, or `void` for a collect-only walk).
+ *
+ * @param fields - The schema to walk (a collection/global/group `fields` array).
+ * @param root - The initial `Cursor` paired with the top-level `fields`.
+ * @param walker - The behavior to drive: `enterObject` / `enterList` derive child cursors (or
+ * return a {@link WalkSignal} to `'skip'` a branch or `'stop'` the whole walk), `leaf`
+ * produces a value per data-affecting leaf, and `combine` assembles each container from its
+ * children.
+ * @returns The root `combine` output. `undefined` if the walk was halted by `'stop'` before the
+ * root assembled, OR if the root `combine` itself returned `undefined` (e.g. a collect-only
+ * walker). To distinguish "stopped" from "empty result", track it via the cursor, not this value.
+ *
+ * @example
+ * Keep only localized leaves and rebuild the data tree (a "filter" walk):
+ * ```ts
+ * type Cursor = { data: Record<string, unknown> };
+ *
+ * const filtered = walkFields<Cursor, unknown>(schema, { data }, {
+ *   enterObject: (field, c) =>
+ *     isRecord(c.data[field.name]) ? { data: c.data[field.name] } : "skip",
+ *   enterList: (field, c) => toItemCursors(field, c), // one ChildCursor per element
+ *   leaf: (field, c) => (field.localized ? c.data[field.name] : undefined),
+ *   combine: (container, children) => {
+ *     if (children.length === 0) return undefined; // drop empty containers
+ *     if (container.kind === "list") return children.map((ch) => ch.out);
+ *     return Object.fromEntries(children.map((ch) => [ch.key, ch.out]));
+ *   },
+ * });
+ * ```
+ *
+ * @see {@link FieldWalker} for the full visitor contract and the caller shapes it subsumes.
+ * @public
+ */
+export declare function walkFields<Cursor extends object, Out>(fields: Field[], root: Cursor, walker: FieldWalker<Cursor, Out>): Out | undefined;

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

@@ -0,0 +1,164 @@
+import { classifyField, tabScopes } from "./kernel";
+/**
+ * Internal engine backing {@link walkFields}. Methods return `true` to mean "stop requested —
+ * unwind and halt the entire walk". A class is used (over nested functions) because the three
+ * steps are mutually recursive; methods can reference each other without use-before-define
+ * ordering.
+ *
+ * @internal
+ */ class FieldTreeWalker {
+    walker;
+    constructor(walker){
+        this.walker = walker;
+    }
+    run(fields, root) {
+        const out = [];
+        if (this.level(fields, root, out)) return undefined;
+        return this.walker.combine({
+            kind: "root",
+            field: null
+        }, out, root);
+    }
+    /** Walk one data level (root, a group/tab body, or a list element), pushing child outputs into `out`. */ level(fields, cursor, out) {
+        for (const field of fields){
+            const structure = classifyField(field);
+            switch(structure.kind){
+                case "presentational":
+                    break;
+                case "transparent":
+                    if (this.level(structure.fields, cursor, out)) return true;
+                    break;
+                case "tabs":
+                    for (const scope of tabScopes(structure.field)){
+                        if (scope.named) {
+                            if (this.object(scope.tab, scope.tab.name, scope.tab.fields, cursor, out)) return true;
+                        } else if (this.level(scope.fields, cursor, out)) {
+                            return true;
+                        }
+                    }
+                    break;
+                case "group":
+                    if (this.object(structure.field, structure.name, structure.fields, cursor, out)) return true;
+                    break;
+                case "array":
+                case "blocks":
+                    if (this.list(structure.field, structure.name, cursor, out)) return true;
+                    break;
+                case "leaf":
+                    {
+                        const leafOut = this.walker.leaf(structure.field, cursor);
+                        if (leafOut !== undefined) out.push({
+                            key: structure.name,
+                            out: leafOut
+                        });
+                        break;
+                    }
+                default:
+                    {
+                        // Exhaustiveness guard: if a new FieldStructure kind is added, this errors at compile time.
+                        const exhaustive = structure;
+                        throw new Error(`unhandled field structure: ${String(exhaustive)}`);
+                    }
+            }
+        }
+        return false;
+    }
+    /** Descend a single-object boundary (named group or named tab) and assemble it. */ object(field, key, childFields, cursor, out) {
+        const result = this.walker.enterObject(field, cursor);
+        if (result === "stop") return true;
+        if (result === "skip") return false;
+        const childOut = [];
+        if (this.level(childFields, result, childOut)) return true;
+        const assembled = this.walker.combine({
+            kind: "object",
+            field,
+            key
+        }, childOut, result);
+        if (assembled !== undefined) out.push({
+            key,
+            out: assembled
+        });
+        return false;
+    }
+    /** Descend an array/blocks boundary, assembling each element then the list itself. */ list(field, key, cursor, out) {
+        const result = this.walker.enterList(field, cursor);
+        if (result === "stop") return true;
+        if (result === "skip") return false;
+        const elements = [];
+        for (const child of result){
+            const childOut = [];
+            if (this.level(child.fields, child.cursor, childOut)) return true;
+            const elementOut = this.walker.combine({
+                kind: "element",
+                field,
+                key: child.key
+            }, childOut, child.cursor);
+            if (elementOut !== undefined) elements.push({
+                key: child.key,
+                out: elementOut
+            });
+        }
+        const listOut = this.walker.combine({
+            kind: "list",
+            field,
+            key
+        }, elements, cursor);
+        if (listOut !== undefined) out.push({
+            key,
+            out: listOut
+        });
+        return false;
+    }
+}
+/**
+ * Depth-first walk of a Payload field **schema**, driving a caller-supplied
+ * {@link FieldWalker}. The single traversal engine this package's data operations build on
+ * (filtering, reconciling, collecting, navigating).
+ *
+ * The engine owns structural dispatch (via {@link classifyField} / {@link tabScopes}) and the
+ * recursion; the caller owns the **data** through the opaque `Cursor` and decides what to
+ * produce. The engine never reads the cursor — so the caller can thread one, two, or more
+ * parallel data trees (plus a path) inside it. Containers are assembled bottom-up via
+ * `combine`, after their children.
+ *
+ * @template Cursor - The caller's data position threaded through the walk (e.g. the current
+ * data object, a `{ source, target }` pair, plus a path). Constrained to `object` so a cursor
+ * can never collide with a {@link WalkSignal} string (`'skip'`/`'stop'`).
+ * @template Out - What the walker produces per node and assembles per container (e.g. a
+ * rebuilt data subtree, or `void` for a collect-only walk).
+ *
+ * @param fields - The schema to walk (a collection/global/group `fields` array).
+ * @param root - The initial `Cursor` paired with the top-level `fields`.
+ * @param walker - The behavior to drive: `enterObject` / `enterList` derive child cursors (or
+ * return a {@link WalkSignal} to `'skip'` a branch or `'stop'` the whole walk), `leaf`
+ * produces a value per data-affecting leaf, and `combine` assembles each container from its
+ * children.
+ * @returns The root `combine` output. `undefined` if the walk was halted by `'stop'` before the
+ * root assembled, OR if the root `combine` itself returned `undefined` (e.g. a collect-only
+ * walker). To distinguish "stopped" from "empty result", track it via the cursor, not this value.
+ *
+ * @example
+ * Keep only localized leaves and rebuild the data tree (a "filter" walk):
+ * ```ts
+ * type Cursor = { data: Record<string, unknown> };
+ *
+ * const filtered = walkFields<Cursor, unknown>(schema, { data }, {
+ *   enterObject: (field, c) =>
+ *     isRecord(c.data[field.name]) ? { data: c.data[field.name] } : "skip",
+ *   enterList: (field, c) => toItemCursors(field, c), // one ChildCursor per element
+ *   leaf: (field, c) => (field.localized ? c.data[field.name] : undefined),
+ *   combine: (container, children) => {
+ *     if (children.length === 0) return undefined; // drop empty containers
+ *     if (container.kind === "list") return children.map((ch) => ch.out);
+ *     return Object.fromEntries(children.map((ch) => [ch.key, ch.out]));
+ *   },
+ * });
+ * ```
+ *
+ * @see {@link FieldWalker} for the full visitor contract and the caller shapes it subsumes.
+ * @public
+ */ export function walkFields(fields, root, walker) {
+    return new FieldTreeWalker(walker).run(fields, root);
+}
+
+//# sourceMappingURL=walkFields.js.map

package/dist/server/shared/utils/filterLocalizedFields.d.ts

@@ -1,7 +1,7 @@
-import type { Field } from 'payload';
+import type { Field } from "payload";
 /**
- * Filters data to keep only translatable localized fields.
- * For container fields (group, array, blocks) recursively filters nested data.
+ * Filters data to keep only translatable localized fields, recursively for container fields
+ * (group, array, blocks, named tabs). Built on the shared {@link walkFields} engine.
  *
  * @param schema - Payload field schema (original, not sanitized)
  * @param data - Document data to filter

package/dist/server/shared/utils/filterLocalizedFields.js

@@ -1,72 +1,61 @@
-import { fieldAffectsData, fieldIsArrayType, fieldIsBlockType, fieldIsGroupType } from 'payload/shared';
-import { hasFields, isBlockItem, isLocalizedField, isTabsField, isTranslatableField } from '../guards';
-import { isObject } from './isObject';
-import { isEmpty } from './isEmpty';
+import { resolveBlockFields, walkFields } from "../field-traversal";
+import { isLocalizedField, isTranslatableField } from "../guards";
+import { isObject } from "./isObject";
 /**
- * Filters data to keep only translatable localized fields.
- * For container fields (group, array, blocks) recursively filters nested data.
+ * Filter walker: keeps only translatable, localized leaves, rebuilding the surrounding
+ * object/array/blocks structure and dropping any container left empty. `id` (array/block
+ * elements) and `blockType` (block elements) are preserved since they aren't schema fields.
+ */ const filterWalker = {
+    enterObject (field, cursor) {
+        const value = cursor.data[field.name];
+        return isObject(value) ? {
+            data: value
+        } : "skip";
+    },
+    enterList (field, cursor) {
+        const value = cursor.data[field.name];
+        if (!Array.isArray(value)) return "skip";
+        const children = [];
+        value.forEach((item, index)=>{
+            if (!isObject(item)) return; // drop non-object elements
+            const fields = field.type === "blocks" ? resolveBlockFields(field, item) : field.fields;
+            if (fields) children.push({
+                cursor: {
+                    data: item
+                },
+                fields,
+                key: index
+            }); // unknown blockType → fields null → drop
+        });
+        return children;
+    },
+    leaf (field, cursor) {
+        return isTranslatableField(field) && isLocalizedField(field) ? cursor.data[field.name] : undefined;
+    },
+    combine (container, children, cursor) {
+        if (children.length === 0) return undefined; // drop empty containers/lists
+        if (container.kind === "list") return children.map((child)=>child.out);
+        const result = {};
+        for (const child of children)result[child.key] = child.out;
+        if (container.kind === "element") {
+            const item = cursor.data;
+            if (item.id !== undefined) result.id = item.id;
+            if (container.field.type === "blocks") result.blockType = item.blockType;
+        }
+        return result;
+    }
+};
+/**
+ * Filters data to keep only translatable localized fields, recursively for container fields
+ * (group, array, blocks, named tabs). Built on the shared {@link walkFields} engine.
  *
  * @param schema - Payload field schema (original, not sanitized)
  * @param data - Document data to filter
  * @returns Filtered data containing only translatable localized fields
  */ export function filterLocalizedFields(schema, data) {
-    const result = {};
-    for (const field of schema){
-        if (isTabsField(field)) {
-            for (const tab of field.tabs){
-                if (hasFields(tab)) Object.assign(result, filterLocalizedFields(tab.fields, data));
-            }
-            continue;
-        }
-        if (!fieldAffectsData(field)) {
-            if (hasFields(field)) Object.assign(result, filterLocalizedFields(field.fields, data));
-            continue;
-        }
-        const value = data[field.name];
-        if (value === undefined) continue;
-        if (fieldIsGroupType(field) && isObject(value)) {
-            const filtered = filterLocalizedFields(field.fields, value);
-            if (!isEmpty(filtered)) result[field.name] = filtered;
-            continue;
-        }
-        if (fieldIsArrayType(field) && Array.isArray(value)) {
-            const filteredArray = value.map((item)=>{
-                if (isObject(item)) {
-                    const filtered = filterLocalizedFields(field.fields, item);
-                    if (!isEmpty(filtered)) return {
-                        ...filtered,
-                        id: item.id
-                    };
-                }
-                return null;
-            }).filter(Boolean);
-            if (!isEmpty(filteredArray)) result[field.name] = filteredArray;
-            continue;
-        }
-        if (fieldIsBlockType(field) && Array.isArray(value)) {
-            const filteredBlocks = value.map((item)=>{
-                if (isBlockItem(item)) {
-                    const block = field.blocks.find((b)=>b.slug === item.blockType);
-                    if (block) {
-                        const filtered = filterLocalizedFields(block.fields, item);
-                        if (!isEmpty(filtered)) return {
-                            ...filtered,
-                            blockType: item.blockType,
-                            id: item.id
-                        };
-                    }
-                }
-                return null;
-            }).filter(Boolean);
-            if (!isEmpty(filteredBlocks)) result[field.name] = filteredBlocks;
-            continue;
-        }
-        if (isTranslatableField(field) && isLocalizedField(field)) {
-            result[field.name] = value;
-            continue;
-        }
-    }
-    return result;
+    return walkFields(schema, {
+        data
+    }, filterWalker) ?? {};
 }
 
 //# sourceMappingURL=filterLocalizedFields.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@focus-reactive/payload-plugin-translator",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "Translation plugin for Payload CMS 3.x. Automatically translate your localized content using any translation provider.",
   "type": "module",
   "license": "MIT",
@@ -55,7 +55,7 @@
     "lint:fix": "ultracite fix",
     "test": "vitest run",
     "test:watch": "vitest",
-    "check-types": "tsgo --noEmit"
+    "check-types": "tsgo --noEmit -p tsconfig.check.json"
   },
   "peerDependencies": {
     "@payloadcms/richtext-lexical": "^3.76.0",