@mvriu5/payload-ai 1.6.2 → 1.6.4

package/dist/components/action-toast/ActionToast.d.ts

@@ -1,17 +1,4 @@
-export type ActionProposal = {
-    _aiSignature?: {
-        expiresAt: string;
-        value: string;
-    };
-    action: "create" | "delete" | "update" | "updateGlobal";
-    collection?: string;
-    data?: Record<string, unknown>;
-    id?: string;
-    label: string;
-    locale?: string;
-    localizedData?: Record<string, Record<string, unknown>>;
-    slug?: string;
-};
+import type { ActionProposal } from "../../features/proposals/types.js";
 type ActionToastProps = {
     apiRoute: string;
     description?: string;

package/dist/components/action-toast/ActionToast.js

@@ -2,7 +2,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Button, CheckIcon, SwapIcon } from "@payloadcms/ui";
 import { formatAdminURL } from "payload/shared";
 import { useState } from "react";
-import { redactSensitiveData } from "../../ai/sensitiveData.js";
+import { redactSensitiveData } from "../../features/sensitiveData.js";
 import { DiffDialog } from "../diff-dialog/DiffDialog.js";
 import { TextShimmer } from "../text-shimmer/TextShimmer.js";
 import styles from "./ActionToast.module.css";

package/dist/components/ai-input/AIInput.js

@@ -3,7 +3,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 import { Button, ChevronIcon, useAuth, useConfig, useDocumentForm, useDocumentInfo, useLocale } from "@payloadcms/ui";
 import { formatAdminURL } from "payload/shared";
 import { useEffect, useRef, useState } from "react";
-import { mergeData } from "../../payload/shared.js";
+import { mergeData } from "../../utils/data.js";
 import { ActionToast } from "../action-toast/ActionToast.js";
 import { useAIChatStream } from "../hooks/useAIChatStream.js";
 import { useAISettings } from "../hooks/useAISettings.js";

package/dist/components/audit-log-list/AuditLogList.d.ts

@@ -1,5 +1,4 @@
-import type { ActionProposal } from "../action-toast/ActionToast.js";
-import { type ProposalDiff } from "../diff-dialog/DiffDialog.js";
+import type { ActionProposal, ActionProposalReference, ProposalDiff } from "../../features/proposals/types.js";
 export type AppliedChange = {
     action?: ActionProposal["action"] | null;
     additions: number;
@@ -22,7 +21,7 @@ export type AppliedChange = {
 export type ActiveDiff = {
     change: AppliedChange | null;
     diff: ProposalDiff;
-    proposal: ActionProposal;
+    proposal: ActionProposalReference;
 };
 declare const AuditLogList: () => import("react").JSX.Element;
 export default AuditLogList;

package/dist/components/diff-dialog/DiffDialog.d.ts

@@ -1,14 +1,10 @@
-import type { ActionProposal } from "../action-toast/ActionToast.js";
+import type { ActionProposalReference, ProposalDiff } from "../../features/proposals/types.js";
 import type { AppliedChange } from "../audit-log-list/AuditLogList.js";
-export type ProposalDiff = {
-    after: unknown;
-    before: unknown;
-};
 type DiffDialogProps = {
     change?: AppliedChange;
     diff: ProposalDiff;
     onClose: () => void;
-    proposal: ActionProposal;
+    proposal: ActionProposalReference;
     tokenUsage?: {
         inputTokens?: number;
         outputTokens?: number;

package/dist/components/diff-dialog/DiffDialog.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { useEffect, useRef, useState } from "react";
-import { getJSONLineKey } from "../../payload/shared.js";
+import { getJSONLineKey } from "../../utils/data.js";
 import styles from "./DiffDialog.module.css";
 import { Button } from "@payloadcms/ui";
 const formatDiffValue = (value)=>{

package/dist/components/generate-field/GenerateField.js

@@ -55,6 +55,7 @@ const GenerateField = ({ field, generationFieldKey, generationFieldType, path, r
                 scope.type,
                 scope.slug,
                 generationFieldKey,
+                path,
                 locale.code,
                 context
             ]);
@@ -63,6 +64,7 @@ const GenerateField = ({ field, generationFieldKey, generationFieldType, path, r
                 body: {
                     context,
                     fieldKey: generationFieldKey,
+                    fieldPath: path,
                     locale: locale.code,
                     scope
                 },

package/dist/components/hooks/useAIChatStream.d.ts

@@ -1,5 +1,5 @@
 import { RefObject } from "react";
-import type { ActionProposal } from "../action-toast/ActionToast.js";
+import type { ActionProposal } from "../../features/proposals/types.js";
 import type { Mention } from "./useMentions.js";
 export type TokenUsage = {
     inputTokens?: number;

package/dist/components/hooks/useAISettings.d.ts

@@ -1,4 +1,4 @@
-import type { AIProviderProfile } from "../../ai/providerOptions.js";
+import type { AIProviderProfile } from "../../features/providers/options.js";
 interface UseAISettingsOptions {
     adminUserSlug?: string;
     apiRoute: string;

package/dist/components/hooks/useAISettings.js

@@ -1,7 +1,7 @@
 "use client";
 import { formatAdminURL } from "payload/shared";
 import { useEffect, useState } from "react";
-import { isAbortError } from "../../payload/shared.js";
+import { isAbortError } from "../../utils/data.js";
 const managedSelectionKey = "payload-ai:selected-managed-model";
 const getStoredModelKey = (provider)=>`payload-ai:selected-model:${provider}`;
 const getStoredModel = (provider)=>{

package/dist/components/hooks/useDocumentMentionSuggestions.js

@@ -1,7 +1,7 @@
 "use client";
 import { formatAdminURL } from "payload/shared";
 import { useEffect, useState } from "react";
-import { isAbortError } from "../../payload/shared.js";
+import { isAbortError } from "../../utils/data.js";
 const fetchDocumentMentionSuggestions = async ({ apiRoute, collectionSlug, query, signal })=>{
     const res = await fetch(formatAdminURL({
         apiRoute,

package/dist/components/hooks/useMentions.js

@@ -1,6 +1,6 @@
 "use client";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { getSerializableLabel, isInternalCollection } from "../../payload/shared.js";
+import { getSerializableLabel, isInternalCollection } from "../../utils/data.js";
 import { createBadgePrefix, getTextNodeAtOffset, replaceTextRangeWithBadge } from "../ai-input/badge.js";
 import { useDocumentMentionSuggestions } from "../hooks/useDocumentMentionSuggestions.js";
 const isMentionBoundary = (character)=>{

package/dist/components/hooks/usePluginConfig.d.ts

@@ -1,4 +1,4 @@
-import { type AIProviderProfile } from "../../ai/providerOptions.js";
+import { type AIProviderProfile } from "../../features/providers/options.js";
 type MediaConfig = {
     acceptedMimeTypes?: string[];
     collectionSlug: string;
@@ -22,11 +22,11 @@ export declare const usePluginConfig: (config: {
     aiModelConfig: {
         defaults: Record<"claude" | "google" | "mistral" | "openai" | "openrouter", string>;
         providers: {
-            claude: import("../../ai/providerOptions.js").AIProviderModelOption[];
-            google: import("../../ai/providerOptions.js").AIProviderModelOption[];
-            mistral: import("../../ai/providerOptions.js").AIProviderModelOption[];
-            openai: import("../../ai/providerOptions.js").AIProviderModelOption[];
-            openrouter: import("../../ai/providerOptions.js").AIProviderModelOption[];
+            claude: import("../../features/providers/options.js").AIProviderModelOption[];
+            google: import("../../features/providers/options.js").AIProviderModelOption[];
+            mistral: import("../../features/providers/options.js").AIProviderModelOption[];
+            openai: import("../../features/providers/options.js").AIProviderModelOption[];
+            openrouter: import("../../features/providers/options.js").AIProviderModelOption[];
         };
     };
     defaultLocale: string | undefined;

package/dist/components/hooks/usePluginConfig.js

@@ -1,5 +1,5 @@
 import { useMemo } from "react";
-import { getLegacyAIProviderProfiles, getResolvedAIModelConfig } from "../../ai/providerOptions.js";
+import { getLegacyAIProviderProfiles, getResolvedAIModelConfig } from "../../features/providers/options.js";
 export const usePluginConfig = (config)=>{
     const pluginConfig = config.admin?.custom?.payloadAiPlugin;
     const aiModelConfig = useMemo(()=>getResolvedAIModelConfig(pluginConfig?.models), [

package/dist/{payload → features}/collectionPermissions.js

@@ -1,4 +1,4 @@
-import { isInternalCollection } from "./shared.js";
+import { isInternalCollection } from "../utils/data.js";
 const allActions = [
     "create",
     "delete",

package/dist/{payload/textFieldGeneration.d.ts → features/content/fieldGeneration.d.ts}

@@ -3,6 +3,10 @@ type GeneratableField = Extract<Field, {
     type: "json" | "richText" | "text" | "textarea";
 }>;
 export type TextGenerationFieldContext = {
+    block?: {
+        label: string;
+        slug: string;
+    };
     description?: string;
     fieldType: GeneratableField["type"];
     hasMany: boolean;

package/dist/{payload/textFieldGeneration.js → features/content/fieldGeneration.js}

@@ -1,11 +1,18 @@
 const generateFieldComponent = "@mvriu5/payload-ai/client#GenerateField";
+const getTranslatedLabel = (label, fallback)=>{
+    if (typeof label === "string") return label;
+    if (label && typeof label === "object") {
+        const translatedLabel = Object.values(label).find((value)=>typeof value === "string");
+        if (typeof translatedLabel === "string") return translatedLabel;
+    }
+    return fallback;
+};
 const getLabel = (field)=>{
-    if (typeof field.label === "string") return field.label;
     if (field.label && typeof field.label === "object") {
         const label = Object.values(field.label).find((value)=>typeof value === "string");
         if (typeof label === "string") return label;
     }
-    return field.name;
+    return getTranslatedLabel(field.label, field.name);
 };
 const getDescription = (field)=>{
     const description = field.admin?.description;
@@ -31,11 +38,12 @@ const addGenerateComponent = (field, key)=>{
         }
     ];
 };
-const visitFields = ({ fields, parentKey, result })=>{
+const visitFields = ({ block, fields, parentKey, result })=>{
     for (const field of fields){
         if (field.type === "tabs") {
             for (const tab of field.tabs){
                 visitFields({
+                    block,
                     fields: tab.fields,
                     parentKey: "name" in tab ? `${parentKey}.${tab.name}` : parentKey,
                     result
@@ -47,6 +55,10 @@ const visitFields = ({ fields, parentKey, result })=>{
             for (const block of field.blocks){
                 if (typeof block !== "object") continue;
                 visitFields({
+                    block: {
+                        label: getTranslatedLabel(block.labels?.singular, block.slug),
+                        slug: block.slug
+                    },
                     fields: block.fields,
                     parentKey: `${parentKey}.${field.name}.${block.slug}`,
                     result
@@ -57,6 +69,7 @@ const visitFields = ({ fields, parentKey, result })=>{
         if ("fields" in field && Array.isArray(field.fields)) {
             const nextParent = "name" in field && field.name ? `${parentKey}.${field.name}` : parentKey;
             visitFields({
+                block,
                 fields: field.fields,
                 parentKey: nextParent,
                 result
@@ -73,6 +86,9 @@ const visitFields = ({ fields, parentKey, result })=>{
         if (generatableField.admin?.hidden) continue;
         addGenerateComponent(generatableField, key);
         result.push({
+            ...block ? {
+                block
+            } : {},
             description: getDescription(generatableField),
             fieldType: generatableField.type,
             hasMany: "hasMany" in generatableField ? Boolean(generatableField.hasMany) : false,

package/dist/{ai → features}/promptCaching.d.ts

@@ -1,10 +1,10 @@
 import type { SystemModelMessage } from "ai";
-import type { AIProvider } from "./providerOptions.js";
+import type { AIProvider } from "./providers/options.js";
 type PromptCacheContext = {
     cacheable: Record<string, unknown>[];
     dynamic: Record<string, unknown>[];
 };
-type PromptCacheProviderOptions = NonNullable<SystemModelMessage["providerOptions"]>;
+export type PromptCacheProviderOptions = NonNullable<SystemModelMessage["providerOptions"]>;
 export declare const splitPromptCacheContext: (mentionContext: Record<string, unknown>[]) => PromptCacheContext;
 export declare const createCachedSystemMessages: ({ cacheableContext, cacheableInstructions, dynamicInstructions, enabled, provider, staticInstructions, }: {
     cacheableContext: Record<string, unknown>[];

package/dist/features/proposals/containerNormalization.d.ts

@@ -0,0 +1,8 @@
+import type { NormalizeFieldValueArgs } from "./normalizationTypes.js";
+export declare const containerNormalizers: {
+    array: ({ field, normalizeRecord, path, value, ...state }: NormalizeFieldValueArgs) => (Record<string, unknown> | undefined)[] | undefined;
+    blocks: ({ field, normalizeRecord, path, value, ...state }: NormalizeFieldValueArgs) => ({
+        blockType: string;
+    } | undefined)[] | undefined;
+    group: ({ field, normalizeRecord, path, value, ...state }: NormalizeFieldValueArgs) => Record<string, unknown> | undefined;
+};

package/dist/features/proposals/containerNormalization.js

@@ -0,0 +1,112 @@
+import { isRecord } from "../../utils/data.js";
+const normalizeGroup = ({ field, normalizeRecord, path, value, ...state })=>{
+    if (!isRecord(value)) {
+        state.issues.push({
+            code: "invalid_container",
+            message: "Group fields must be objects.",
+            path
+        });
+        return undefined;
+    }
+    return normalizeRecord({
+        ...state,
+        allowSafeFallback: false,
+        enforceRequiredChildren: state.mode === "create" || state.enforceRequiredChildren,
+        fields: field.fields || [],
+        path,
+        value
+    });
+};
+const getArrayItemLabelField = (field)=>{
+    const childFields = (field.fields || []).filter((childField)=>Boolean(childField.name));
+    return childFields.find((childField)=>childField.name === "label") || childFields.find((childField)=>childField.name === "title") || childFields.find((childField)=>childField.name === "name") || childFields.find((childField)=>childField.name === "value") || childFields[0];
+};
+const normalizeArray = ({ field, normalizeRecord, path, value, ...state })=>{
+    if (!Array.isArray(value)) {
+        state.issues.push({
+            code: "invalid_array",
+            message: "Array fields must use an array value.",
+            path
+        });
+        return undefined;
+    }
+    const itemLabelField = getArrayItemLabelField(field);
+    return value.map((item, index)=>{
+        const itemPath = `${path}.${index}`;
+        if (!isRecord(item) && !itemLabelField) {
+            state.issues.push({
+                code: "invalid_array",
+                message: "Array items must be objects for this field.",
+                path: itemPath
+            });
+            return undefined;
+        }
+        return normalizeRecord({
+            ...state,
+            allowSafeFallback: false,
+            enforceRequiredChildren: true,
+            fields: field.fields || [],
+            path: itemPath,
+            value: isRecord(item) ? item : {
+                [itemLabelField.name]: item
+            }
+        });
+    });
+};
+const getBlockType = (item)=>typeof item.blockType === "string" ? item.blockType : typeof item.type === "string" ? item.type : typeof item.slug === "string" ? item.slug : null;
+const normalizeBlocks = ({ field, normalizeRecord, path, value, ...state })=>{
+    if (!Array.isArray(value)) {
+        state.issues.push({
+            code: "invalid_blocks",
+            message: "Blocks fields must use an array value.",
+            path
+        });
+        return undefined;
+    }
+    return value.map((item, index)=>{
+        const itemPath = `${path}.${index}`;
+        if (!isRecord(item)) {
+            state.issues.push({
+                code: "invalid_blocks",
+                message: "Each block entry must be an object.",
+                path: itemPath
+            });
+            return undefined;
+        }
+        const blockType = getBlockType(item);
+        if (!blockType) {
+            state.issues.push({
+                code: "invalid_block_type",
+                message: "Each block entry must include blockType.",
+                path: itemPath
+            });
+            return undefined;
+        }
+        const block = field.blocks?.find((candidate)=>candidate.slug === blockType);
+        if (!block) {
+            state.issues.push({
+                code: "invalid_block_type",
+                message: `Unknown block type "${blockType}".`,
+                path: `${itemPath}.blockType`
+            });
+            return undefined;
+        }
+        const { blockType: _blockType, slug: _slug, type: _type, ...blockData } = item;
+        return {
+            ...normalizeRecord({
+                ...state,
+                allowSafeFallback: false,
+                enforceRequiredChildren: true,
+                fields: block.fields || [],
+                path: itemPath,
+                value: blockData
+            }),
+            blockType
+        };
+    });
+};
+export const containerNormalizers = {
+    array: normalizeArray,
+    blocks: normalizeBlocks,
+    group: normalizeGroup
+};

package/dist/{payload/proposalData.d.ts → features/proposals/data.d.ts}

@@ -1,11 +1,7 @@
-import { type LocalizedDataInput } from "./shared.js";
-import { type CollectionConfig, type FieldConfig } from "./normalizeData.js";
-type ProposalMode = "create" | "update";
-export type ProposalValidationIssue = {
-    code: "empty_localized_data" | "invalid_array" | "invalid_block_type" | "invalid_blocks" | "invalid_checkbox" | "invalid_container" | "invalid_date" | "invalid_option" | "invalid_relationship" | "missing_required_field" | "non_localized_field_in_secondary_locale" | "unknown_field";
-    message: string;
-    path: string;
-};
+import type { LocalizedDataInput } from "./types.js";
+import { type CollectionConfig, type FieldConfig } from "../schema/normalize.js";
+import type { ProposalMode, ProposalValidationIssue } from "./normalizationTypes.js";
+export type { ProposalValidationIssue } from "./normalizationTypes.js";
 export type PreparedProposalData = {
     coercedFields: string[];
     data?: Record<string, unknown>;
@@ -20,7 +16,7 @@ type PrepareProposalDataArgs = {
     localizedData?: LocalizedDataInput;
     mode: ProposalMode;
 };
-export declare const prepareProposalWriteData: ({ collectionConfig, data, inferenceText, label, localizedData, mode }: PrepareProposalDataArgs) => PreparedProposalData;
+export declare const prepareProposalWriteData: ({ collectionConfig, data, inferenceText, label, localizedData, mode, }: PrepareProposalDataArgs) => PreparedProposalData;
 export declare const applyLocalizedRequiredFallbackToPreparedData: ({ fallbackSource, fields, preparedData, }: {
     fallbackSource: Record<string, unknown>;
     fields: readonly FieldConfig[];
@@ -28,4 +24,3 @@ export declare const applyLocalizedRequiredFallbackToPreparedData: ({ fallbackSo
 }) => {
     [x: string]: unknown;
 };
-export {};

package/dist/features/proposals/data.js

@@ -0,0 +1,113 @@
+import { isRecord } from "../../utils/data.js";
+import { getSchemaFields, normalizeAuthData } from "../schema/normalize.js";
+import { prepareSingleLocaleData } from "./recordNormalization.js";
+export const prepareProposalWriteData = ({ collectionConfig, data, inferenceText, label, localizedData, mode })=>{
+    const schemaFields = getSchemaFields(collectionConfig);
+    const titleFieldName = typeof collectionConfig?.admin?.useAsTitle === "string" ? collectionConfig.admin.useAsTitle : undefined;
+    const issues = [];
+    const coercedFields = [];
+    if (localizedData) {
+        const localeEntries = Object.entries(localizedData);
+        if (localeEntries.length === 0) {
+            issues.push({
+                code: "empty_localized_data",
+                message: "localizedData must contain at least one locale entry.",
+                path: "localizedData"
+            });
+            return {
+                coercedFields,
+                issues,
+                localizedData: {}
+            };
+        }
+        const normalizedLocalizedData = {};
+        for (const [locale, localeValue] of localeEntries){
+            if (!isRecord(localeValue)) {
+                issues.push({
+                    code: "invalid_container",
+                    message: "Each locale entry must be an object.",
+                    path: `localizedData.${locale}`
+                });
+                continue;
+            }
+            normalizedLocalizedData[locale] = prepareSingleLocaleData({
+                coercedFields,
+                data: localeValue,
+                fields: schemaFields,
+                inferenceText,
+                issues,
+                label,
+                mode,
+                titleFieldName
+            });
+        }
+        const [firstLocale] = localeEntries[0] || [];
+        if (firstLocale) {
+            for (const field of schemaFields.filter((candidate)=>Boolean(candidate.name))){
+                if (field.localized) continue;
+                for (const [locale, localeValue] of Object.entries(normalizedLocalizedData)){
+                    if (locale === firstLocale || localeValue[field.name] === undefined) continue;
+                    issues.push({
+                        code: "non_localized_field_in_secondary_locale",
+                        message: "Non-localized fields may only be set in the first locale entry.",
+                        path: `localizedData.${locale}.${field.name}`
+                    });
+                }
+            }
+        }
+        return {
+            coercedFields,
+            issues,
+            localizedData: Object.fromEntries(Object.entries(normalizedLocalizedData).map(([locale, localeValue])=>[
+                    locale,
+                    normalizeAuthData(collectionConfig, {
+                        coercedFields: [],
+                        data: localeValue,
+                        droppedFields: []
+                    }).data
+                ]))
+        };
+    }
+    const normalizedData = prepareSingleLocaleData({
+        coercedFields,
+        data: data || {},
+        fields: schemaFields,
+        inferenceText,
+        issues,
+        label,
+        mode,
+        titleFieldName
+    });
+    const authNormalized = normalizeAuthData(collectionConfig, {
+        coercedFields: [],
+        data: normalizedData,
+        droppedFields: []
+    });
+    coercedFields.push(...authNormalized.coercedFields);
+    return {
+        coercedFields,
+        data: authNormalized.data,
+        issues
+    };
+};
+export const applyLocalizedRequiredFallbackToPreparedData = ({ fallbackSource, fields, preparedData })=>{
+    const mergedData = {
+        ...preparedData
+    };
+    for (const field of fields.filter((candidate)=>Boolean(candidate.name))){
+        if (field.localized && field.required && mergedData[field.name] === undefined && fallbackSource[field.name] !== undefined) {
+            mergedData[field.name] = fallbackSource[field.name];
+            continue;
+        }
+        if (field.type === "group" && field.fields?.length && isRecord(fallbackSource[field.name])) {
+            const currentValue = isRecord(mergedData[field.name]) ? mergedData[field.name] : {};
+            const nestedValue = applyLocalizedRequiredFallbackToPreparedData({
+                fallbackSource: fallbackSource[field.name],
+                fields: field.fields,
+                preparedData: currentValue
+            });
+            if (Object.keys(nestedValue).length > 0) mergedData[field.name] = nestedValue;
+        }
+    }
+    return mergedData;
+};

package/dist/features/proposals/fieldNormalization.d.ts

@@ -0,0 +1,2 @@
+import type { NormalizeFieldValueArgs } from "./normalizationTypes.js";
+export declare const normalizeFieldValue: (args: NormalizeFieldValueArgs) => unknown;

package/dist/features/proposals/fieldNormalization.js

@@ -0,0 +1,69 @@
+import { createLexicalText } from "../schema/normalize.js";
+import { containerNormalizers } from "./containerNormalization.js";
+import { getFieldOptionValues, inferOptionValueFromText } from "./optionInference.js";
+import { normalizeRelationshipValue } from "./relationshipNormalization.js";
+const normalizeCheckbox = ({ issues, path, value })=>{
+    if (typeof value === "boolean") return value;
+    if (value === "true") return true;
+    if (value === "false") return false;
+    issues.push({
+        code: "invalid_checkbox",
+        message: "Checkbox fields must use true or false.",
+        path
+    });
+    return undefined;
+};
+const normalizeOption = ({ coercedFields, field, inferenceText, issues, label, path, value })=>{
+    const optionValues = getFieldOptionValues(field);
+    const stringValue = value === null ? "" : String(value);
+    const inferredOptionValue = inferOptionValueFromText({
+        field,
+        requireFieldMention: true,
+        text: inferenceText || label
+    });
+    if (inferredOptionValue && optionValues.includes(inferredOptionValue)) {
+        if (stringValue !== inferredOptionValue) coercedFields.push(path);
+        return inferredOptionValue;
+    }
+    if (stringValue && optionValues.includes(stringValue)) return stringValue;
+    issues.push({
+        code: "invalid_option",
+        message: `Field must use one of: ${optionValues.join(", ")}.`,
+        path
+    });
+    return undefined;
+};
+const normalizeText = ({ value })=>value === null ? value : String(value);
+const normalizeDate = ({ issues, path, value })=>{
+    const date = new Date(String(value));
+    if (!Number.isNaN(date.getTime())) return date.toISOString();
+    issues.push({
+        code: "invalid_date",
+        message: "Date fields must use a valid date value.",
+        path
+    });
+    return undefined;
+};
+const normalizeRelationship = ({ field, issues, path, value })=>normalizeRelationshipValue({
+        field,
+        issues,
+        path,
+        value
+    });
+const fieldNormalizers = {
+    ...containerNormalizers,
+    checkbox: normalizeCheckbox,
+    date: normalizeDate,
+    email: normalizeText,
+    radio: normalizeOption,
+    relationship: normalizeRelationship,
+    richText: ({ value })=>createLexicalText(value),
+    select: normalizeOption,
+    text: normalizeText,
+    textarea: normalizeText,
+    upload: normalizeRelationship
+};
+export const normalizeFieldValue = (args)=>{
+    const normalizer = args.field.type ? fieldNormalizers[args.field.type] : undefined;
+    return normalizer ? normalizer(args) : args.value;
+};

package/dist/features/proposals/normalizationTypes.d.ts

@@ -0,0 +1,31 @@
+import type { FieldConfig } from "../schema/normalize.js";
+export type ProposalMode = "create" | "update";
+export type ProposalValidationIssue = {
+    code: "empty_localized_data" | "invalid_array" | "invalid_block_type" | "invalid_blocks" | "invalid_checkbox" | "invalid_container" | "invalid_date" | "invalid_option" | "invalid_relationship" | "missing_required_field" | "non_localized_field_in_secondary_locale" | "unknown_field";
+    message: string;
+    path: string;
+};
+export type NormalizationState = {
+    coercedFields: string[];
+    inferenceText?: string;
+    issues: ProposalValidationIssue[];
+    label: string;
+    mode: ProposalMode;
+    titleFieldName?: string;
+};
+export type NormalizeRecordArgs = NormalizationState & {
+    allowSafeFallback: boolean;
+    enforceRequiredChildren: boolean;
+    fields: readonly FieldConfig[];
+    path: string;
+    value: Record<string, unknown>;
+};
+type NormalizeRecord = (args: NormalizeRecordArgs) => Record<string, unknown>;
+export type NormalizeFieldValueArgs = NormalizationState & {
+    enforceRequiredChildren: boolean;
+    field: FieldConfig;
+    normalizeRecord: NormalizeRecord;
+    path: string;
+    value: unknown;
+};
+export {};

package/dist/features/proposals/normalizationTypes.js

@@ -0,0 +1 @@
+export { };