@mvriu5/payload-ai 1.6.3 → 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/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/{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 { };

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

@@ -0,0 +1,13 @@
+import type { FieldConfig } from "../schema/normalize.js";
+export declare const getFieldOptionValues: (field: FieldConfig) => string[];
+export declare const inferOptionValueFromText: ({ field, requireFieldMention, text, }: {
+    field: FieldConfig;
+    requireFieldMention?: boolean;
+    text?: string;
+}) => string | undefined;
+export declare const getDefaultFieldValue: ({ field, inferenceText, label, titleFieldName, }: {
+    field: FieldConfig;
+    inferenceText?: string;
+    label: string;
+    titleFieldName?: string;
+}) => {} | null | undefined;

package/dist/features/proposals/optionInference.js

@@ -0,0 +1,46 @@
+import { getOptionValue, getSafeProposalLabel } from "../../utils/data.js";
+const isTitleLikeField = (field, titleFieldName)=>{
+    const normalizedName = field.name?.toLowerCase();
+    return Boolean(field.name && (field.name === titleFieldName || normalizedName === "title" || normalizedName === "name" || normalizedName === "label" || normalizedName === "headline"));
+};
+export const getFieldOptionValues = (field)=>(field.options || []).map((option)=>getOptionValue(option)).filter((option)=>Boolean(option));
+const escapeRegExp = (value)=>value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const getFieldNameVariants = (fieldName)=>{
+    if (!fieldName) return [];
+    const spacedName = fieldName.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").toLowerCase();
+    return Array.from(new Set([
+        fieldName.toLowerCase(),
+        spacedName
+    ])).filter(Boolean);
+};
+export const inferOptionValueFromText = ({ field, requireFieldMention = false, text })=>{
+    const normalizedText = text?.trim().toLowerCase();
+    if (!normalizedText) return undefined;
+    if (requireFieldMention && !getFieldNameVariants(field.name).some((variant)=>new RegExp(`\\b${escapeRegExp(variant)}\\b`, "i").test(normalizedText))) {
+        return undefined;
+    }
+    return getFieldOptionValues(field).sort((left, right)=>right.length - left.length).find((optionValue)=>new RegExp(`\\b${escapeRegExp(optionValue.toLowerCase())}\\b`, "i").test(normalizedText));
+};
+export const getDefaultFieldValue = ({ field, inferenceText, label, titleFieldName })=>{
+    if (field.name === "_status") return "draft";
+    if (field.type === "checkbox") return false;
+    if (field.type === "select" || field.type === "radio") {
+        const inferredOptionValue = inferOptionValueFromText({
+            field,
+            requireFieldMention: true,
+            text: inferenceText || label
+        });
+        if (inferredOptionValue !== undefined) return inferredOptionValue;
+        if (field.defaultValue !== undefined) return field.defaultValue;
+        return getOptionValue(field.options?.[0]);
+    }
+    if (field.defaultValue !== undefined) return field.defaultValue;
+    if ([
+        "email",
+        "text",
+        "textarea"
+    ].includes(field.type || "") && isTitleLikeField(field, titleFieldName)) {
+        return getSafeProposalLabel(label);
+    }
+    return undefined;
+};

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

@@ -0,0 +1,6 @@
+import { type FieldConfig } from "../schema/normalize.js";
+import type { NormalizationState } from "./normalizationTypes.js";
+export declare const prepareSingleLocaleData: ({ data, fields, ...state }: NormalizationState & {
+    data: Record<string, unknown>;
+    fields: readonly FieldConfig[];
+}) => Record<string, unknown>;