includio-cms 0.5.2 → 0.5.3

package/dist/core/fields/formFieldSchemaToTs.js

@@ -1,27 +1,43 @@
 import { z } from 'zod';
 export function generateZodSchemaFromFormField(field) {
+    const errorMsg = field.errorMessage ? Object.values(field.errorMessage)[0] : undefined;
     switch (field.type) {
         case 'text': {
             let schema = z.string();
-            if (field.required)
-                schema = schema.min(1);
+            const minLen = field.minLength ?? (field.required ? 1 : undefined);
+            if (minLen) {
+                schema = schema.min(minLen, errorMsg || undefined);
+            }
+            if (field.maxLength) {
+                schema = schema.max(field.maxLength);
+            }
             return schema;
         }
         case 'email': {
             let schema = z.string();
-            if (field.required)
-                schema = schema.min(1).email();
+            if (field.required) {
+                schema = schema.min(1).email(errorMsg || undefined);
+            }
             return schema;
         }
         case 'textarea': {
             let schema = z.string();
-            if (field.required)
-                schema = schema.min(1);
+            const minLen = field.minLength ?? (field.required ? 1 : undefined);
+            if (minLen) {
+                schema = schema.min(minLen, errorMsg || undefined);
+            }
+            if (field.maxLength) {
+                schema = schema.max(field.maxLength);
+            }
             return schema;
         }
         case 'checkbox': {
             return field.required ? z.literal(true) : z.boolean();
         }
+        case 'select': {
+            const values = field.options.map((o) => o.value);
+            return z.enum(values);
+        }
         default:
             return z.any();
     }

package/dist/core/fields/urlUtils.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Check if URL is external (starts with http:// or https://).
+ */
+export declare function isExternalUrl(url: string): boolean;
+/**
+ * Build rel attribute string from individual tokens.
+ * Deduplicates and returns space-separated string or empty string.
+ */
+export declare function buildRel(tokens: string[]): string;
+/**
+ * Merge user-provided rel tokens with auto-generated ones.
+ * Returns space-separated string.
+ */
+export declare function mergeRel(userRel: string | undefined, autoTokens: string[]): string;

package/dist/core/fields/urlUtils.js

@@ -0,0 +1,21 @@
+/**
+ * Check if URL is external (starts with http:// or https://).
+ */
+export function isExternalUrl(url) {
+    return /^https?:\/\//i.test(url);
+}
+/**
+ * Build rel attribute string from individual tokens.
+ * Deduplicates and returns space-separated string or empty string.
+ */
+export function buildRel(tokens) {
+    return [...new Set(tokens.filter(Boolean))].join(' ');
+}
+/**
+ * Merge user-provided rel tokens with auto-generated ones.
+ * Returns space-separated string.
+ */
+export function mergeRel(userRel, autoTokens) {
+    const userTokens = userRel ? userRel.split(/\s+/).filter(Boolean) : [];
+    return buildRel([...autoTokens, ...userTokens]);
+}

package/dist/core/server/fields/populateEntry.js

@@ -1,13 +1,56 @@
+import { walkInlineBlockNodes } from '../../../admin/components/tiptap/structured-content-utils.js';
 import { translateObject } from '../entries/utils/getEntryTranslation.js';
 import { resolveMediaFields } from './resolveImageFields.js';
 import { resolveRelationFields } from './resolveRelationFields.js';
 import { resolveRichtextLinks } from './resolveRichtextLinks.js';
 import { resolveUrlFields } from './resolveUrlFields.js';
+function translateInlineBlockData(data, fields, language) {
+    for (const field of fields) {
+        const val = data[field.slug];
+        if (val == null)
+            continue;
+        switch (field.type) {
+            case 'content': {
+                const cf = field;
+                if (cf.inlineBlocks?.length &&
+                    val &&
+                    typeof val === 'object' &&
+                    'type' in val &&
+                    val.type === 'doc') {
+                    walkInlineBlockNodes(val, (node) => {
+                        if (node.attrs?.blockData && typeof node.attrs.blockData === 'object') {
+                            node.attrs.blockData = translateObject(node.attrs.blockData, language);
+                            const def = cf.inlineBlocks.find((b) => b.slug === node.attrs?.blockType);
+                            if (def) {
+                                translateInlineBlockData(node.attrs.blockData, def.fields, language);
+                            }
+                        }
+                    });
+                }
+                break;
+            }
+            case 'object':
+                if (val && typeof val === 'object' && 'data' in val)
+                    translateInlineBlockData(val.data, field.fields, language);
+                break;
+            case 'blocks':
+                if (Array.isArray(val)) {
+                    for (const item of val) {
+                        const def = field.of.find((d) => d.slug === item.slug);
+                        if (def)
+                            translateInlineBlockData(item.data, def.fields, language);
+                    }
+                }
+                break;
+        }
+    }
+}
 export async function populateEntryData(data, fields, language) {
     let populatedData = await resolveRelationFields(data, fields, language);
     populatedData = await resolveUrlFields(populatedData, fields, language);
     populatedData = await resolveMediaFields(populatedData, fields);
     populatedData = await resolveRichtextLinks(populatedData, fields, language);
     populatedData = translateObject(populatedData, language);
+    translateInlineBlockData(populatedData, fields, language);
     return populatedData;
 }

package/dist/core/server/fields/resolveImageFields.js

@@ -3,7 +3,7 @@ const PUBLIC_URL = env.PUBLIC_URL ?? '';
 import { getCMS } from '../../cms.js';
 import z from 'zod';
 import { getImageStyles } from './utils/imageStyles.js';
-import { extractMediaIds as extractMediaIdsFromDoc, walkMediaNodes, cloneDoc } from '../../../admin/components/tiptap/structured-content-utils.js';
+import { extractMediaIds as extractMediaIdsFromDoc, walkMediaNodes, walkInlineBlockNodes, cloneDoc } from '../../../admin/components/tiptap/structured-content-utils.js';
 export async function resolveMediaFields(data, fields) {
     const mediaIds = [];
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -52,11 +52,24 @@ export async function resolveMediaFields(data, fields) {
                     }
                     break;
                 case 'content': {
+                    const contentField = field;
                     // Content field is localized: { lang: StructuredContentDoc }
                     if (typeof val === 'object' && val !== null) {
                         for (const doc of Object.values(val)) {
                             if (doc && typeof doc === 'object' && doc.type === 'doc') {
+                                // Regular media nodes (figure/video/image)
                                 mediaIds.push(...extractMediaIdsFromDoc(doc));
+                                // Inline block fields (image/file/media inside blocks/objects)
+                                if (contentField.inlineBlocks?.length) {
+                                    walkInlineBlockNodes(doc, (node) => {
+                                        const bd = node.attrs?.blockData;
+                                        if (!bd || typeof bd !== 'object')
+                                            return;
+                                        const def = contentField.inlineBlocks.find((b) => b.slug === node.attrs?.blockType);
+                                        if (def)
+                                            collectIds(bd, def.fields);
+                                    });
+                                }
                             }
                         }
                     }
@@ -208,6 +221,7 @@ export async function resolveMediaFields(data, fields) {
                     break;
                 case 'content': {
                     // Content field is localized: { lang: StructuredContentDoc }
+                    const contentField = field;
                     if (typeof val === 'object' && val !== null) {
                         // eslint-disable-next-line @typescript-eslint/no-explicit-any
                         const resolved = {};
@@ -233,6 +247,24 @@ export async function resolveMediaFields(data, fields) {
                                         ...(mediaFile.type === 'image' ? { blurDataUrl: mediaFile.blurDataUrl } : {})
                                     };
                                 });
+                                // Resolve inline block fields
+                                if (contentField.inlineBlocks?.length) {
+                                    const promises = [];
+                                    walkInlineBlockNodes(cloned, (node) => {
+                                        const bd = node.attrs?.blockData;
+                                        if (!bd || typeof bd !== 'object')
+                                            return;
+                                        const def = contentField.inlineBlocks.find((b) => b.slug === node.attrs?.blockType);
+                                        if (!def)
+                                            return;
+                                        promises.push(resolveValues(bd, def.fields).then((resolvedBd) => {
+                                            node.attrs.blockData = resolvedBd;
+                                        }));
+                                    });
+                                    if (promises.length > 0) {
+                                        await Promise.all(promises);
+                                    }
+                                }
                                 resolved[lang] = cloned;
                             }
                             else {

package/dist/core/server/fields/resolveRelationFields.js

@@ -1,3 +1,4 @@
+import { walkInlineBlockNodes, cloneDoc } from '../../../admin/components/tiptap/structured-content-utils.js';
 import z from 'zod';
 export async function resolveRelationFields(data, fields, language) {
     const entriesIds = [];
@@ -37,6 +38,24 @@ export async function resolveRelationFields(data, fields, language) {
                         });
                     }
                     break;
+                case 'content': {
+                    const cf = field;
+                    if (typeof val === 'object' && val !== null && cf.inlineBlocks?.length) {
+                        for (const doc of Object.values(val)) {
+                            if (doc && typeof doc === 'object' && doc.type === 'doc') {
+                                walkInlineBlockNodes(doc, (node) => {
+                                    const bd = node.attrs?.blockData;
+                                    if (!bd || typeof bd !== 'object')
+                                        return;
+                                    const def = cf.inlineBlocks.find((b) => b.slug === node.attrs?.blockType);
+                                    if (def)
+                                        collectIds(bd, def.fields);
+                                });
+                            }
+                        }
+                    }
+                    break;
+                }
             }
         }
     };
@@ -93,6 +112,33 @@ export async function resolveRelationFields(data, fields, language) {
                         return item;
                     });
                     break;
+                case 'content': {
+                    const cf = field;
+                    if (typeof val === 'object' && val !== null && cf.inlineBlocks?.length) {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        const resolved = {};
+                        for (const [lang, doc] of Object.entries(val)) {
+                            if (doc && typeof doc === 'object' && doc.type === 'doc') {
+                                const cloned = cloneDoc(doc);
+                                walkInlineBlockNodes(cloned, (node) => {
+                                    const bd = node.attrs?.blockData;
+                                    if (!bd || typeof bd !== 'object')
+                                        return;
+                                    const def = cf.inlineBlocks.find((b) => b.slug === node.attrs?.blockType);
+                                    if (!def)
+                                        return;
+                                    node.attrs.blockData = resolveValues(bd, def.fields);
+                                });
+                                resolved[lang] = cloned;
+                            }
+                            else {
+                                resolved[lang] = doc;
+                            }
+                        }
+                        result[field.slug] = resolved;
+                    }
+                    break;
+                }
                 default:
                     result[field.slug] = val;
             }

package/dist/core/server/fields/resolveRichtextLinks.js

@@ -160,12 +160,26 @@ export async function resolveRichtextLinks(data, fields, language) {
                     break;
                 }
                 case 'content': {
+                    const contentField = field;
                     if (typeof val === 'object' && val !== null) {
                         // eslint-disable-next-line @typescript-eslint/no-explicit-any
                         const resolved = {};
                         for (const [lang, doc] of Object.entries(val)) {
                             if (doc && typeof doc === 'object' && doc.type === 'doc') {
-                                resolved[lang] = resolveContentDoc(doc, slugMap);
+                                const cloned = resolveContentDoc(doc, slugMap);
+                                // Resolve inline block fields
+                                if (contentField.inlineBlocks?.length) {
+                                    walkInlineBlockNodes(cloned, (node) => {
+                                        const bd = node.attrs?.blockData;
+                                        if (!bd || typeof bd !== 'object')
+                                            return;
+                                        const def = contentField.inlineBlocks.find((b) => b.slug === node.attrs?.blockType);
+                                        if (!def)
+                                            return;
+                                        node.attrs.blockData = resolveValues(bd, def.fields);
+                                    });
+                                }
+                                resolved[lang] = cloned;
                             }
                             else {
                                 resolved[lang] = doc;

package/dist/core/server/fields/resolveUrlFields.js

@@ -1,6 +1,18 @@
 import { urlFieldDataSchema, urlFieldDataWithRelationSchema } from '../../../schemas/field/url.js';
+import { walkInlineBlockNodes, cloneDoc } from '../../../admin/components/tiptap/structured-content-utils.js';
 import { getEntries } from '../entries/operations/get.js';
 import { getEntrySlugPath, getSlugFromEntryData } from './slugResolver.js';
+import { isExternalUrl, mergeRel } from '../../fields/urlUtils.js';
+function applyExternalAutoDetect(resolvedUrl, extras) {
+    const url = typeof resolvedUrl === 'string' ? resolvedUrl : '';
+    if (url && isExternalUrl(url)) {
+        extras.isExternal = true;
+        extras.rel = mergeRel(extras.rel, ['noopener', 'noreferrer']);
+        if (extras.newTab === undefined) {
+            extras.newTab = true;
+        }
+    }
+}
 export async function resolveUrlFields(data, fields, language) {
     const entriesIds = [];
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -38,6 +50,24 @@ export async function resolveUrlFields(data, fields, language) {
                         });
                     }
                     break;
+                case 'content': {
+                    const cf = field;
+                    if (typeof val === 'object' && val !== null && cf.inlineBlocks?.length) {
+                        for (const doc of Object.values(val)) {
+                            if (doc && typeof doc === 'object' && doc.type === 'doc') {
+                                walkInlineBlockNodes(doc, (node) => {
+                                    const bd = node.attrs?.blockData;
+                                    if (!bd || typeof bd !== 'object')
+                                        return;
+                                    const def = cf.inlineBlocks.find((b) => b.slug === node.attrs?.blockType);
+                                    if (def)
+                                        collectIds(bd, def.fields);
+                                });
+                            }
+                        }
+                    }
+                    break;
+                }
                 case 'array':
                     if (field.of === 'url' && Array.isArray(val)) {
                         for (const item of val) {
@@ -98,6 +128,9 @@ export async function resolveUrlFields(data, fields, language) {
                     if (parsed.newTab !== undefined) {
                         extras.newTab = parsed.newTab;
                     }
+                    if (parsed.rel) {
+                        extras.rel = parsed.rel;
+                    }
                     if (parsedValWithRelation.success) {
                         const slug = slugMap[parsedValWithRelation.data.id];
                         if (slug) {
@@ -108,6 +141,7 @@ export async function resolveUrlFields(data, fields, language) {
                     const resolvedUrl = language
                         ? parsed.url[language]
                         : parsed.url;
+                    applyExternalAutoDetect(resolvedUrl, extras);
                     result[field.slug] = { url: resolvedUrl, ...extras };
                     break;
                 }
@@ -132,6 +166,33 @@ export async function resolveUrlFields(data, fields, language) {
                         return item;
                     });
                     break;
+                case 'content': {
+                    const cf = field;
+                    if (typeof val === 'object' && val !== null && cf.inlineBlocks?.length) {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        const resolved = {};
+                        for (const [lang, doc] of Object.entries(val)) {
+                            if (doc && typeof doc === 'object' && doc.type === 'doc') {
+                                const cloned = cloneDoc(doc);
+                                walkInlineBlockNodes(cloned, (node) => {
+                                    const bd = node.attrs?.blockData;
+                                    if (!bd || typeof bd !== 'object')
+                                        return;
+                                    const def = cf.inlineBlocks.find((b) => b.slug === node.attrs?.blockType);
+                                    if (!def)
+                                        return;
+                                    node.attrs.blockData = resolveValues(bd, def.fields);
+                                });
+                                resolved[lang] = cloned;
+                            }
+                            else {
+                                resolved[lang] = doc;
+                            }
+                        }
+                        result[field.slug] = resolved;
+                    }
+                    break;
+                }
                 case 'array':
                     if (field.of === 'url' && Array.isArray(val)) {
                         // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -152,6 +213,9 @@ export async function resolveUrlFields(data, fields, language) {
                             if (parsed.newTab !== undefined) {
                                 extras.newTab = parsed.newTab;
                             }
+                            if (parsed.rel) {
+                                extras.rel = parsed.rel;
+                            }
                             if (parsedValWithRelation.success) {
                                 const slug = slugMap[parsedValWithRelation.data.id];
                                 if (slug) {
@@ -161,6 +225,7 @@ export async function resolveUrlFields(data, fields, language) {
                             const resolvedUrl = language
                                 ? parsed.url[language]
                                 : parsed.url;
+                            applyExternalAutoDetect(resolvedUrl, extras);
                             return { url: resolvedUrl, ...extras };
                         });
                     }

package/dist/core/server/generator/formFieldSchemaToString.js

@@ -1,24 +1,55 @@
+function getErrorMsg(field) {
+    if (field.errorMessage) {
+        const msg = Object.values(field.errorMessage)[0];
+        if (msg)
+            return JSON.stringify(msg);
+    }
+    return undefined;
+}
 export function generateZodSchemaFromFormFieldAsString(field) {
     let code = '';
     switch (field.type) {
-        case 'text':
+        case 'text': {
             code = 'z.string()';
-            if (field.required)
-                code += '.min(1)'; // Ensure non-empty string if required
+            const msg = getErrorMsg(field);
+            const minLen = field.minLength ?? (field.required ? 1 : undefined);
+            if (minLen) {
+                code += msg ? `.min(${minLen}, ${msg})` : `.min(${minLen})`;
+            }
+            if (field.maxLength) {
+                code += `.max(${field.maxLength})`;
+            }
             break;
-        case 'email':
+        }
+        case 'email': {
             code = 'z.string()';
-            if (field.required)
-                code += '.min(1).email()'; // Ensure non-empty and valid email if required
+            const msg = getErrorMsg(field);
+            if (field.required) {
+                code += '.min(1)';
+                code += msg ? `.email(${msg})` : '.email()';
+            }
             break;
-        case 'textarea':
+        }
+        case 'textarea': {
             code = 'z.string()';
-            if (field.required)
-                code += '.min(1)'; // Ensure non-empty string if required
+            const msg = getErrorMsg(field);
+            const minLen = field.minLength ?? (field.required ? 1 : undefined);
+            if (minLen) {
+                code += msg ? `.min(${minLen}, ${msg})` : `.min(${minLen})`;
+            }
+            if (field.maxLength) {
+                code += `.max(${field.maxLength})`;
+            }
             break;
+        }
         case 'checkbox':
             code = field.required ? 'z.literal(true)' : 'z.boolean()';
             break;
+        case 'select': {
+            const values = field.options.map((o) => JSON.stringify(o.value));
+            code = `z.enum([${values.join(', ')}])`;
+            break;
+        }
         default:
             code = 'z.any()';
     }

package/dist/core/server/generator/formFields.js

@@ -6,6 +6,8 @@ function getFormFieldTypeAsString(field) {
             return 'string';
         case 'checkbox':
             return 'boolean';
+        case 'select':
+            return field.options.map((o) => JSON.stringify(o.value)).join(' | ');
         default:
             return 'any';
     }

package/dist/core/server/generator/generator.js

@@ -55,7 +55,7 @@ function generateTypesStringForForms(records) {
         .join('\n')}
 	`;
     code += `
-		export type ${recordTypeString}Map = {
+		export type ${recordTypeString}EntryMap = {
 			${records
         .map((single) => {
         return `${single.slug}: ${toPascalCase(single.slug)}`;
@@ -168,9 +168,33 @@ function generateSchemas(config) {
     });
     writeFileSync(filePath, code);
 }
+function generateRemote(config) {
+    if (!config.forms || config.forms.length === 0)
+        return;
+    const cmsDir = join(process.cwd(), 'src/lib/cms/runtime');
+    const filePath = join(cmsDir, 'remote.ts');
+    let code = `// This file is auto-generated. Do not edit directly.\n\n`;
+    code += `import { command } from '$app/server';\n`;
+    code += `import { submitForm } from './api';\n`;
+    const schemaImports = config.forms
+        .map((form) => `${form.slug}FormSchema`)
+        .join(', ');
+    code += `import { ${schemaImports} } from './schemas';\n\n`;
+    config.forms.forEach((form) => {
+        const pascalSlug = toPascalCase(form.slug);
+        code += `export const submit${pascalSlug}Command = command(\n`;
+        code += `\t${form.slug}FormSchema,\n`;
+        code += `\tasync (data) => {\n`;
+        code += `\t\tawait submitForm('${form.slug}', data);\n`;
+        code += `\t}\n`;
+        code += `);\n\n`;
+    });
+    writeFileSync(filePath, code);
+}
 export function generateRuntime(config) {
     createCmsRuntimeDir();
     generateTypes(config);
     generateAPI(config);
     generateSchemas(config);
+    generateRemote(config);
 }

package/dist/schemas/field/url.d.ts

@@ -4,10 +4,12 @@ export declare const urlFieldDataSchema: z.ZodObject<{
     url: z.ZodRecord<z.ZodString, z.ZodString>;
     text: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     newTab: z.ZodOptional<z.ZodBoolean>;
+    rel: z.ZodOptional<z.ZodString>;
 }, z.z.core.$strip>;
 export declare const urlFieldDataWithRelationSchema: z.ZodObject<{
     id: z.ZodString;
     url: z.ZodRecord<z.ZodString, z.ZodString>;
     text: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     newTab: z.ZodOptional<z.ZodBoolean>;
+    rel: z.ZodOptional<z.ZodString>;
 }, z.z.core.$strip>;

package/dist/schemas/field/url.js

@@ -3,11 +3,13 @@ export const urlFieldDataSchema = z.object({
     id: z.string().optional(),
     url: z.record(z.string(), z.string()),
     text: z.record(z.string(), z.string()).optional(),
-    newTab: z.boolean().optional()
+    newTab: z.boolean().optional(),
+    rel: z.string().optional()
 });
 export const urlFieldDataWithRelationSchema = z.object({
     id: z.string().uuid(),
     url: z.record(z.string(), z.string()),
     text: z.record(z.string(), z.string()).optional(),
-    newTab: z.boolean().optional()
+    newTab: z.boolean().optional(),
+    rel: z.string().optional()
 });

package/dist/types/fields.d.ts

@@ -3,6 +3,11 @@ import type { ImageStyle, MediaFile } from './media.js';
 import type { Localized } from './languages.js';
 import type { StructuredContentDoc } from './structured-content.js';
 export type FieldType = 'text' | 'richtext' | 'content' | 'number' | 'boolean' | 'date' | 'datetime' | 'file' | 'image' | 'media' | 'select' | 'radio' | 'checkboxes' | 'relation' | 'object' | 'array' | 'blocks' | 'slug' | 'seo' | 'url';
+export interface FieldCondition {
+    field: string;
+    equals?: string | string[];
+    notEquals?: string | string[];
+}
 export interface BaseField {
     slug: string;
     label?: Localized;
@@ -10,6 +15,7 @@ export interface BaseField {
     description?: Localized;
     defaultValue?: any;
     localized?: boolean;
+    showWhen?: FieldCondition;
 }
 export interface TextField extends BaseField {
     type: 'text';
@@ -144,6 +150,7 @@ export interface ObjectField extends BaseField {
     thumbnail?: string;
 }
 export interface ObjectFieldData {
+    _id?: string;
     slug?: string;
     data: Record<string, unknown>;
 }
@@ -188,11 +195,13 @@ export interface UrlField extends BaseField {
     placeholder?: Localized;
     text?: boolean;
     newTab?: boolean;
+    rel?: boolean;
 }
 export type UrlFieldData = {
     id?: string;
     url: Record<string, string>;
     text?: Record<string, string>;
     newTab?: boolean;
+    rel?: string;
 };
 export type Field = TextField | RichtextField | ContentField | NumberField | BooleanField | DateField | DateTimeField | FileField | ImageField | MediaField | SelectField | RadioField | CheckboxesField | RelationField | ObjectField | ArrayField | BlocksField | SlugField | SeoField | UrlField;

package/dist/types/formFields.d.ts

@@ -1,16 +1,19 @@
 import type { Localized } from './languages.js';
-export type FormFieldType = 'text' | 'email' | 'textarea' | 'checkbox';
+export type FormFieldType = 'text' | 'email' | 'textarea' | 'checkbox' | 'select';
 export interface FormBaseField {
     slug: string;
     label?: Localized;
     required?: boolean;
     description?: Localized;
+    errorMessage?: Localized;
     defaultValue?: any;
     showInDataTable?: boolean;
 }
 export interface FormTextField extends FormBaseField {
     type: 'text';
     defaultValue?: string;
+    minLength?: number;
+    maxLength?: number;
 }
 export interface FormEmailField extends FormBaseField {
     type: 'email';
@@ -19,9 +22,19 @@ export interface FormEmailField extends FormBaseField {
 export interface FormTextareaField extends FormBaseField {
     type: 'textarea';
     defaultValue?: string;
+    minLength?: number;
+    maxLength?: number;
 }
 export interface FormCheckboxField extends FormBaseField {
     type: 'checkbox';
     defaultValue?: boolean;
 }
-export type FormField = FormTextField | FormEmailField | FormTextareaField | FormCheckboxField;
+export interface FormSelectField extends FormBaseField {
+    type: 'select';
+    options: {
+        value: string;
+        label?: Localized;
+    }[];
+    defaultValue?: string;
+}
+export type FormField = FormTextField | FormEmailField | FormTextareaField | FormCheckboxField | FormSelectField;

package/dist/types/index.d.ts

@@ -7,6 +7,7 @@ export { type ConfigBase } from './config.js';
 export { type CollectionConfig } from './collections.js';
 export { type SingleConfig } from './singles.js';
 export { type FormConfig, type FormSubmission } from './forms.js';
+export { type FormField, type FormFieldType, type FormBaseField, type FormTextField, type FormEmailField, type FormTextareaField, type FormCheckboxField, type FormSelectField } from './formFields.js';
 export { type CMSConfig } from './cms.js';
 export { type Language, type Localized } from './languages.js';
 export { type Layout, type LayoutNode, type LayoutPreset, type LayoutNodeType, type ColumnRatio, type SectionNode, type ColumnsNode, type CardNode, type AccordionNode, type StackNode } from './layout.js';