nextjs-cms 0.0.1 → 0.5.1

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

@@ -0,0 +1,131 @@
+import type { BaseFieldConfig } from './field';
+import { Field } from './field';
+import { entityKind } from '../helpers';
+import * as z from 'zod';
+declare const configSchema: z.ZodObject<{
+    /**
+     * A destination table where the values will be saved
+     * When this is set, the value of the field will only be saved in the destination table as one row per each value
+     */
+    destinationDb: z.ZodOptional<z.ZodObject<{
+        table: z.ZodString;
+        itemIdentifier: z.ZodString;
+        selectIdentifier: z.ZodString;
+    }, z.core.$strict>>;
+    autoCompletion: z.ZodOptional<z.ZodObject<{
+        table: z.ZodString;
+        column: z.ZodString;
+    }, z.core.$strict>>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    /**
+     * Whether to sanitize the value before saving it to the database.
+     * If true, the value will be escaped to prevent XSS attacks.
+     * If false, the value will be saved as is (raw input).
+     * @default false
+     */
+    sanitize: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+type Config = z.infer<typeof configSchema>;
+export declare class TagsField extends Field<'tags', Config> {
+    static readonly [entityKind]: string;
+    readonly destinationDb?: {
+        table: string;
+        itemIdentifier: string;
+        selectIdentifier: string;
+    };
+    readonly placeholder: string;
+    readonly sanitize: boolean;
+    constructor(config: BaseFieldConfig<Config>);
+    getValue(): any;
+    exportForClient(): {
+        placeholder: string;
+        sanitize: boolean;
+        type: "tags";
+        name: string;
+        label: string;
+        required: boolean;
+        conditionalFields: import("../types").ConditionalField[];
+        readonly: boolean;
+        defaultValue: any;
+        value: any;
+    };
+    checkRequired(): void;
+    prepareForSubmission(): Promise<void>;
+}
+export type TagsFieldClientConfig = ReturnType<TagsField['exportForClient']>;
+declare const optionsSchema: z.ZodObject<{
+    /**
+     * A destination table where the values will be saved
+     * When this is set, the value of the field will only be saved in the destination table as one row per each value
+     */
+    destinationDb: z.ZodOptional<z.ZodObject<{
+        table: z.ZodString;
+        itemIdentifier: z.ZodString;
+        selectIdentifier: z.ZodString;
+    }, z.core.$strict>>;
+    autoCompletion: z.ZodOptional<z.ZodObject<{
+        table: z.ZodString;
+        column: z.ZodString;
+    }, z.core.$strict>>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    /**
+     * Whether to sanitize the value before saving it to the database.
+     * If true, the value will be escaped to prevent XSS attacks.
+     * If false, the value will be saved as is (raw input).
+     * @default false
+     */
+    sanitize: z.ZodOptional<z.ZodBoolean>;
+    name: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    defaultValue: z.ZodOptional<z.ZodAny>;
+    order: z.ZodOptional<z.ZodNumber>;
+    conditionalRules: z.ZodOptional<z.ZodArray<z.ZodCustom<import("../types").ConditionalRule, import("../types").ConditionalRule>>>;
+    adminGenerated: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodLiteral<false>, z.ZodLiteral<"readonly">]>>;
+}, z.core.$strict>;
+declare const tagsFieldConfigSchema: z.ZodObject<{
+    type: z.ZodLiteral<"tags">;
+    build: z.ZodFunction<z.core.$ZodFunctionArgs, z.ZodCustom<TagsField, TagsField>>;
+    /**
+     * A destination table where the values will be saved
+     * When this is set, the value of the field will only be saved in the destination table as one row per each value
+     */
+    destinationDb: z.ZodOptional<z.ZodObject<{
+        table: z.ZodString;
+        itemIdentifier: z.ZodString;
+        selectIdentifier: z.ZodString;
+    }, z.core.$strict>>;
+    autoCompletion: z.ZodOptional<z.ZodObject<{
+        table: z.ZodString;
+        column: z.ZodString;
+    }, z.core.$strict>>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    /**
+     * Whether to sanitize the value before saving it to the database.
+     * If true, the value will be escaped to prevent XSS attacks.
+     * If false, the value will be saved as is (raw input).
+     * @default false
+     */
+    sanitize: z.ZodOptional<z.ZodBoolean>;
+    name: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    defaultValue: z.ZodOptional<z.ZodAny>;
+    order: z.ZodOptional<z.ZodNumber>;
+    conditionalRules: z.ZodOptional<z.ZodArray<z.ZodCustom<import("../types").ConditionalRule, import("../types").ConditionalRule>>>;
+    adminGenerated: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodLiteral<false>, z.ZodLiteral<"readonly">]>>;
+}, z.core.$strict>;
+/**
+ * Tags field configuration type
+ * This is a plain object that can be serialized and used anywhere
+ * The build() method allows creating a TagsField instance when needed
+ */
+export type TagsFieldConfig = z.infer<typeof tagsFieldConfigSchema>;
+/**
+ * Helper function to create a tags field configuration
+ * Returns a config object with a build() method that can be serialized and used anywhere
+ * @param field
+ */
+export declare function tagsField(field: z.infer<typeof optionsSchema>): TagsFieldConfig;
+export {};
+//# sourceMappingURL=tags.d.ts.map

package/dist/core/fields/tags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tags.d.ts","sourceRoot":"","sources":["../../../src/core/fields/tags.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAC9C,OAAO,EAAE,KAAK,EAAyB,MAAM,SAAS,CAAA;AACtD,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AACvC,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAGxB,QAAA,MAAM,YAAY;IACd;;;OAGG;;;;;;;;;;;IAiBH;;;;;OAKG;;kBAEL,CAAA;AAEF,KAAK,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AAE1C,qBAAa,SAAU,SAAQ,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC;IAChD,gBAAyB,CAAC,UAAU,CAAC,EAAE,MAAM,CAAc;IAC3D,SAAkB,aAAa,CAAC,EAAE;QAC9B,KAAK,EAAE,MAAM,CAAA;QACb,cAAc,EAAE,MAAM,CAAA;QACtB,gBAAgB,EAAE,MAAM,CAAA;KAC3B,CAAA;IACD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;gBAEd,MAAM,EAAE,eAAe,CAAC,MAAM,CAAC;IAO3C,QAAQ;IAIQ,eAAe;;;;;;;;;;;;IAQ/B,aAAa;IAMP,oBAAoB,IAAI,OAAO,CAAC,IAAI,CAAC;CAa9C;AAED,MAAM,MAAM,qBAAqB,GAAG,UAAU,CAAC,SAAS,CAAC,iBAAiB,CAAC,CAAC,CAAA;AAE5E,QAAA,MAAM,aAAa;IAnFf;;;OAGG;;;;;;;;;;;IAiBH;;;;;OAKG;;;;;;;;;kBA6DL,CAAA;AAEF,QAAA,MAAM,qBAAqB;;;IAxFvB;;;OAGG;;;;;;;;;;;IAiBH;;;;;OAKG;;;;;;;;;kBAmEL,CAAA;AAEF;;;;GAIG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,GAAG,eAAe,CAmB/E"}

package/dist/core/fields/tags.js

@@ -0,0 +1,105 @@
+import { Field, baseFieldConfigSchema } from './field';
+import { entityKind } from '../helpers';
+import * as z from 'zod';
+import { escapeHTML } from '../security/dom';
+const configSchema = z.strictObject({
+    /**
+     * A destination table where the values will be saved
+     * When this is set, the value of the field will only be saved in the destination table as one row per each value
+     */
+    destinationDb: z
+        .strictObject({
+        table: z.string().describe('The destination table name'),
+        itemIdentifier: z.string().describe('The identifier of the item that has this tags field as a field'),
+        selectIdentifier: z.string().describe('An identifier name for the value of the values in the tags field'),
+    })
+        .optional()
+        .describe('Destination table configuration'),
+    autoCompletion: z
+        .strictObject({
+        table: z.string().describe('The table where the auto completion values are stored'),
+        column: z.string().describe('The column where the values are stored'),
+    })
+        .optional()
+        .describe('Auto completion configuration'),
+    placeholder: z.string().optional().describe('The placeholder text for the field'),
+    /**
+     * Whether to sanitize the value before saving it to the database.
+     * If true, the value will be escaped to prevent XSS attacks.
+     * If false, the value will be saved as is (raw input).
+     * @default false
+     */
+    sanitize: z.boolean().optional().describe('Sanitize the value before saving'),
+});
+export class TagsField extends Field {
+    static [entityKind] = 'TagsField';
+    destinationDb;
+    placeholder;
+    sanitize;
+    constructor(config) {
+        super(config, 'tags');
+        this.destinationDb = config.destinationDb;
+        this.placeholder = config.placeholder || '';
+        this.sanitize = config.sanitize ?? false;
+    }
+    getValue() {
+        return this.value;
+    }
+    exportForClient() {
+        return {
+            ...super.exportForClient(),
+            placeholder: this.placeholder,
+            sanitize: this.sanitize,
+        };
+    }
+    checkRequired() {
+        if (this.required && (!this.value || this.value.length === 0)) {
+            throw new Error(`Field ${this.label} is required`);
+        }
+    }
+    async prepareForSubmission() {
+        if (this.value) {
+            if (!Array.isArray(this.value)) {
+                throw new Error(`Field ${this.label} must be an array of tags`);
+            }
+            if (this.value.some((tag) => typeof tag !== 'string')) {
+                throw new Error(`Field ${this.label} must contain only string tags`);
+            }
+            if (this.sanitize) {
+                this.value = this.value.map((tag) => escapeHTML(tag) || tag);
+            }
+        }
+    }
+}
+const optionsSchema = z.strictObject({
+    ...baseFieldConfigSchema.shape,
+    ...configSchema.shape,
+});
+const tagsFieldConfigSchema = z.strictObject({
+    ...optionsSchema.shape,
+    type: z.literal('tags').describe('The type of the field'),
+    build: z.function().output(z.instanceof(TagsField)).describe('Build a TagsField instance from this config'),
+});
+/**
+ * Helper function to create a tags field configuration
+ * Returns a config object with a build() method that can be serialized and used anywhere
+ * @param field
+ */
+export function tagsField(field) {
+    /**
+     * Validate the field config
+     */
+    const result = optionsSchema.safeParse(field);
+    if (!result.success) {
+        throw new Error(`[Field: ${field.name}]: ${z.prettifyError(result.error)}`);
+    }
+    const config = {
+        ...field,
+        type: 'tags',
+        build() {
+            // Use the original field config directly (it doesn't have build() method)
+            return new TagsField(field);
+        },
+    };
+    return config;
+}

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

@@ -0,0 +1,136 @@
+import type { BaseFieldConfig } from './field';
+import { Field } from './field';
+import { entityKind } from '../helpers';
+import * as z from 'zod';
+declare const configSchema: z.ZodObject<{
+    placeholder: z.ZodOptional<z.ZodString>;
+    minLength: z.ZodOptional<z.ZodNumber>;
+    maxLength: z.ZodOptional<z.ZodNumber>;
+    /**
+     * The default value of the field.
+     * If set, the field will be pre-populated with this value when the form is loaded.
+     * If `adminGenerated` is not true, the field will be included when submitting the form with this value.
+     */
+    defaultValue: z.ZodOptional<z.ZodString>;
+    /**
+     * Whether to sanitize the value before saving it to the database.
+     * If true, the value will be escaped to prevent XSS attacks.
+     * If false, the value will be saved as is (raw input).
+     * @default false
+     */
+    sanitize: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+type Config = z.infer<typeof configSchema>;
+export declare class TextField extends Field<'text', Config> {
+    static readonly [entityKind]: string;
+    readonly maxLength: number | undefined;
+    readonly minLength: number | undefined;
+    readonly placeholder: string | undefined;
+    private readonly _defaultValue;
+    value: string | undefined;
+    readonly sanitize: boolean;
+    constructor(config: BaseFieldConfig<Config>);
+    /**
+     * Sanitize the value
+     */
+    private sanitizeValue;
+    exportForClient(): {
+        maxLength: number | undefined;
+        minLength: number | undefined;
+        placeholder: string | undefined;
+        sanitize: boolean;
+        type: "text";
+        name: string;
+        label: string;
+        required: boolean;
+        conditionalFields: import("../types").ConditionalField[];
+        readonly: boolean;
+        defaultValue: any;
+        value: any;
+    };
+    /**
+     * Get the value of the field
+     */
+    getValue(): string | undefined;
+    checkRequired(): void;
+    hasSqlNameAndValue(): boolean;
+    /**
+     * Prepare the field for submission
+     */
+    prepareForSubmission(): Promise<void>;
+}
+export type TextFieldClientConfig = ReturnType<TextField['exportForClient']>;
+declare const optionsSchema: z.ZodObject<{
+    placeholder: z.ZodOptional<z.ZodString>;
+    minLength: z.ZodOptional<z.ZodNumber>;
+    maxLength: z.ZodOptional<z.ZodNumber>;
+    /**
+     * The default value of the field.
+     * If set, the field will be pre-populated with this value when the form is loaded.
+     * If `adminGenerated` is not true, the field will be included when submitting the form with this value.
+     */
+    defaultValue: z.ZodOptional<z.ZodString>;
+    /**
+     * Whether to sanitize the value before saving it to the database.
+     * If true, the value will be escaped to prevent XSS attacks.
+     * If false, the value will be saved as is (raw input).
+     * @default false
+     */
+    sanitize: z.ZodOptional<z.ZodBoolean>;
+    name: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    order: z.ZodOptional<z.ZodNumber>;
+    conditionalRules: z.ZodOptional<z.ZodArray<z.ZodCustom<import("../types").ConditionalRule, import("../types").ConditionalRule>>>;
+    adminGenerated: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodLiteral<false>, z.ZodLiteral<"readonly">]>>;
+}, z.core.$strict>;
+declare const textFieldConfigSchema: z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    build: z.ZodFunction<z.core.$ZodFunctionArgs, z.ZodCustom<TextField, TextField>>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    minLength: z.ZodOptional<z.ZodNumber>;
+    maxLength: z.ZodOptional<z.ZodNumber>;
+    /**
+     * The default value of the field.
+     * If set, the field will be pre-populated with this value when the form is loaded.
+     * If `adminGenerated` is not true, the field will be included when submitting the form with this value.
+     */
+    defaultValue: z.ZodOptional<z.ZodString>;
+    /**
+     * Whether to sanitize the value before saving it to the database.
+     * If true, the value will be escaped to prevent XSS attacks.
+     * If false, the value will be saved as is (raw input).
+     * @default false
+     */
+    sanitize: z.ZodOptional<z.ZodBoolean>;
+    name: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    order: z.ZodOptional<z.ZodNumber>;
+    conditionalRules: z.ZodOptional<z.ZodArray<z.ZodCustom<import("../types").ConditionalRule, import("../types").ConditionalRule>>>;
+    adminGenerated: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodLiteral<false>, z.ZodLiteral<"readonly">]>>;
+}, z.core.$strict>;
+/**
+ * Text field configuration type
+ * This is a plain object that can be serialized and used anywhere
+ * The build() method allows creating a TextField instance when needed
+ */
+export type TextFieldConfig = z.infer<typeof textFieldConfigSchema>;
+/**
+ * Helper function to create a text field configuration
+ * Returns a config object with a build() method that can be serialized and used anywhere
+ *
+ * @example
+ * ```typescript
+ * const fieldConfig = textField({ name: 'title', label: 'Title', required: true, order: 1 })
+ * // Use as config (serializable)
+ * const config = JSON.stringify(fieldConfig) // methods are ignored during serialization
+ * // Build instance when needed
+ * const fieldInstance = fieldConfig.build()
+ * ```
+ *
+ * @param field
+ */
+export declare function textField(field: z.infer<typeof optionsSchema>): TextFieldConfig;
+export {};
+//# sourceMappingURL=text.d.ts.map

package/dist/core/fields/text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../../src/core/fields/text.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAC9C,OAAO,EAAE,KAAK,EAAyB,MAAM,SAAS,CAAA;AACtD,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AACvC,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAGxB,QAAA,MAAM,YAAY;;;;IAId;;;;OAIG;;IAEH;;;;;OAKG;;kBAEL,CAAA;AAEF,KAAK,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AAE1C,qBAAa,SAAU,SAAQ,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC;IAChD,gBAAyB,CAAC,UAAU,CAAC,EAAE,MAAM,CAAc;IAC3D,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAA;IACtC,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAA;IACtC,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,CAAA;IACxC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAoB;IACzC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAA;IAClC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;gBAEd,MAAM,EAAE,eAAe,CAAC,MAAM,CAAC;IAU3C;;OAEG;IACH,OAAO,CAAC,aAAa;IAgBL,eAAe;;;;;;;;;;;;;;IAU/B;;OAEG;IACH,QAAQ,IAAI,MAAM,GAAG,SAAS;IAI9B,aAAa;IAWJ,kBAAkB,IAAI,OAAO;IAOtC;;OAEG;IACG,oBAAoB;CAyB7B;AAED,MAAM,MAAM,qBAAqB,GAAG,UAAU,CAAC,SAAS,CAAC,iBAAiB,CAAC,CAAC,CAAA;AAE5E,QAAA,MAAM,aAAa;;;;IA1Hf;;;;OAIG;;IAEH;;;;;OAKG;;;;;;;;kBAkHL,CAAA;AAEF,QAAA,MAAM,qBAAqB;;;;;;IA/HvB;;;;OAIG;;IAEH;;;;;OAKG;;;;;;;;kBAwHL,CAAA;AAEF;;;;GAIG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,GAAG,eAAe,CAmB/E"}

package/dist/core/fields/text.js

@@ -0,0 +1,157 @@
+import { Field, baseFieldConfigSchema } from './field';
+import { entityKind } from '../helpers';
+import * as z from 'zod';
+import { escapeHTML } from '../security/dom';
+const configSchema = z.strictObject({
+    placeholder: z.string().optional().describe('The placeholder text for the field'),
+    minLength: z.number().optional().describe('The minimum length of the field value'),
+    maxLength: z.number().optional().describe('The maximum length of the field value'),
+    /**
+     * The default value of the field.
+     * If set, the field will be pre-populated with this value when the form is loaded.
+     * If `adminGenerated` is not true, the field will be included when submitting the form with this value.
+     */
+    defaultValue: z.string().optional().describe('The default value of the field'),
+    /**
+     * Whether to sanitize the value before saving it to the database.
+     * If true, the value will be escaped to prevent XSS attacks.
+     * If false, the value will be saved as is (raw input).
+     * @default false
+     */
+    sanitize: z.boolean().optional().describe('Sanitize the value before saving'),
+});
+export class TextField extends Field {
+    static [entityKind] = 'TextField';
+    maxLength;
+    minLength;
+    placeholder;
+    _defaultValue;
+    value;
+    sanitize;
+    constructor(config) {
+        super(config, 'text');
+        this.maxLength = config.maxLength;
+        this.minLength = config.minLength;
+        this.placeholder = config.placeholder;
+        this.value = config.defaultValue;
+        this._defaultValue = config.defaultValue;
+        this.sanitize = config.sanitize ?? false;
+    }
+    /**
+     * Sanitize the value
+     */
+    sanitizeValue() {
+        /**
+         * Check if the value is not undefined
+         */
+        if (this.value !== undefined && this.sanitize) {
+            /**
+             * Sanitize the value
+             */
+            this.value = escapeHTML(this.value);
+        }
+    }
+    /*public override async postSubmit(): Promise<void> {
+        return
+    }*/
+    exportForClient() {
+        return {
+            ...super.exportForClient(),
+            maxLength: this.maxLength,
+            minLength: this.minLength,
+            placeholder: this.placeholder,
+            sanitize: this.sanitize,
+        };
+    }
+    /**
+     * Get the value of the field
+     */
+    getValue() {
+        return this.value;
+    }
+    checkRequired() {
+        /**
+         * Check if the field is required
+         */
+        if (this.required) {
+            if (!this.value || this.value.trim().length === 0) {
+                throw new Error(`Field ${this.label} is required`);
+            }
+        }
+    }
+    hasSqlNameAndValue() {
+        /**
+         * Include the field in the SQL if it is admin-generated, or not admin-generated but has a default value
+         */
+        return this.adminGenerated === true || this._defaultValue !== undefined;
+    }
+    /**
+     * Prepare the field for submission
+     */
+    async prepareForSubmission() {
+        /**
+         * Sanitize the value
+         */
+        this.sanitizeValue();
+        if (this.value) {
+            /**
+             * Check minimum length
+             */
+            if (this.minLength) {
+                if (this.minLength > this.value.length) {
+                    throw new Error(`Field ${this.label} must be at least ${this.minLength} characters long`);
+                }
+            }
+            /**
+             * Check maximum length
+             */
+            if (this.maxLength) {
+                if (this.maxLength < this.value.length) {
+                    throw new Error(`Field ${this.label} must be at most ${this.maxLength} characters long`);
+                }
+            }
+        }
+    }
+}
+const optionsSchema = z.strictObject({
+    ...baseFieldConfigSchema.shape,
+    ...configSchema.shape,
+});
+const textFieldConfigSchema = z.strictObject({
+    ...optionsSchema.shape,
+    type: z.literal('text').describe('The type of the field'),
+    build: z.function().output(z.instanceof(TextField)).describe('Build a TextField instance from this config'),
+});
+/**
+ * Helper function to create a text field configuration
+ * Returns a config object with a build() method that can be serialized and used anywhere
+ *
+ * @example
+ * ```typescript
+ * const fieldConfig = textField({ name: 'title', label: 'Title', required: true, order: 1 })
+ * // Use as config (serializable)
+ * const config = JSON.stringify(fieldConfig) // methods are ignored during serialization
+ * // Build instance when needed
+ * const fieldInstance = fieldConfig.build()
+ * ```
+ *
+ * @param field
+ */
+export function textField(field) {
+    /**
+     * Validate the field config
+     */
+    const result = optionsSchema.safeParse(field);
+    if (!result.success) {
+        throw new Error(`[Field: ${field.name}]: ${z.prettifyError(result.error)}`);
+    }
+    const config = {
+        ...field,
+        type: 'text',
+        build() {
+            // Use the original field config directly (it doesn't have build() method)
+            return new TextField(field);
+        },
+    };
+    return config;
+}

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

@@ -0,0 +1,107 @@
+import type { BaseFieldConfig } from './field';
+import { Field } from './field';
+import { entityKind } from '../helpers';
+import * as z from 'zod';
+declare const configSchema: z.ZodObject<{
+    placeholder: z.ZodOptional<z.ZodString>;
+    minLength: z.ZodOptional<z.ZodNumber>;
+    maxLength: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Whether to sanitize the value before saving it to the database.
+     * If true, the value will be escaped to prevent XSS attacks.
+     * If false, the value will be saved as is (raw input).
+     * @default false
+     */
+    sanitize: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+type Config = z.infer<typeof configSchema>;
+export declare class TextAreaField extends Field<'textarea', Config> {
+    static readonly [entityKind]: string;
+    readonly maxLength: number | undefined;
+    readonly minLength: number | undefined;
+    readonly placeholder: string | undefined;
+    readonly sanitize: boolean;
+    constructor(config: BaseFieldConfig<Config>);
+    exportForClient(): {
+        maxLength: number | undefined;
+        minLength: number | undefined;
+        placeholder: string | undefined;
+        sanitize: boolean;
+        type: "textarea";
+        name: string;
+        label: string;
+        required: boolean;
+        conditionalFields: import("../types").ConditionalField[];
+        readonly: boolean;
+        defaultValue: any;
+        value: any;
+    };
+    /**
+     * Sanitize the value
+     */
+    private sanitizeValue;
+    /**
+     * Get the value of the field
+     */
+    getValue(): string | undefined;
+    checkRequired(): void;
+    /**
+     * Prepare the field for submission
+     */
+    prepareForSubmission(): Promise<void>;
+}
+export type TextAreaFieldClientConfig = ReturnType<TextAreaField['exportForClient']>;
+declare const optionsSchema: z.ZodObject<{
+    placeholder: z.ZodOptional<z.ZodString>;
+    minLength: z.ZodOptional<z.ZodNumber>;
+    maxLength: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Whether to sanitize the value before saving it to the database.
+     * If true, the value will be escaped to prevent XSS attacks.
+     * If false, the value will be saved as is (raw input).
+     * @default false
+     */
+    sanitize: z.ZodOptional<z.ZodBoolean>;
+    name: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    defaultValue: z.ZodOptional<z.ZodAny>;
+    order: z.ZodOptional<z.ZodNumber>;
+    conditionalRules: z.ZodOptional<z.ZodArray<z.ZodCustom<import("../types").ConditionalRule, import("../types").ConditionalRule>>>;
+    adminGenerated: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodLiteral<false>, z.ZodLiteral<"readonly">]>>;
+}, z.core.$strict>;
+declare const textAreaFieldConfigSchema: z.ZodObject<{
+    type: z.ZodLiteral<"textarea">;
+    build: z.ZodFunction<z.core.$ZodFunctionArgs, z.ZodCustom<TextAreaField, TextAreaField>>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    minLength: z.ZodOptional<z.ZodNumber>;
+    maxLength: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Whether to sanitize the value before saving it to the database.
+     * If true, the value will be escaped to prevent XSS attacks.
+     * If false, the value will be saved as is (raw input).
+     * @default false
+     */
+    sanitize: z.ZodOptional<z.ZodBoolean>;
+    name: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    defaultValue: z.ZodOptional<z.ZodAny>;
+    order: z.ZodOptional<z.ZodNumber>;
+    conditionalRules: z.ZodOptional<z.ZodArray<z.ZodCustom<import("../types").ConditionalRule, import("../types").ConditionalRule>>>;
+    adminGenerated: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodLiteral<false>, z.ZodLiteral<"readonly">]>>;
+}, z.core.$strict>;
+/**
+ * TextArea field configuration type
+ * This is a plain object that can be serialized and used anywhere
+ * The build() method allows creating a TextAreaField instance when needed
+ */
+export type TextAreaFieldConfig = z.infer<typeof textAreaFieldConfigSchema>;
+/**
+ * Helper function to create a textarea field configuration
+ * Returns a config object with a build() method that can be serialized and used anywhere
+ * @param field
+ */
+export declare function textAreaField(field: z.infer<typeof optionsSchema>): TextAreaFieldConfig;
+export {};
+//# sourceMappingURL=textArea.d.ts.map

package/dist/core/fields/textArea.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"textArea.d.ts","sourceRoot":"","sources":["../../../src/core/fields/textArea.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAC9C,OAAO,EAAE,KAAK,EAAyB,MAAM,SAAS,CAAA;AACtD,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AACvC,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAGxB,QAAA,MAAM,YAAY;;;;IAId;;;;;OAKG;;kBAEL,CAAA;AAEF,KAAK,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AAE1C,qBAAa,aAAc,SAAQ,KAAK,CAAC,UAAU,EAAE,MAAM,CAAC;IACxD,gBAAyB,CAAC,UAAU,CAAC,EAAE,MAAM,CAAkB;IAC/D,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAA;IACtC,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAA;IACtC,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,CAAA;IACxC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;gBAEd,MAAM,EAAE,eAAe,CAAC,MAAM,CAAC;IAQ3B,eAAe;;;;;;;;;;;;;;IAU/B;;OAEG;IACH,OAAO,CAAC,aAAa;IAYrB;;OAEG;IACH,QAAQ,IAAI,MAAM,GAAG,SAAS;IAI9B,aAAa;IAWb;;OAEG;IACG,oBAAoB;CAuB7B;AAED,MAAM,MAAM,yBAAyB,GAAG,UAAU,CAAC,aAAa,CAAC,iBAAiB,CAAC,CAAC,CAAA;AAEpF,QAAA,MAAM,aAAa;;;;IAnGf;;;;;OAKG;;;;;;;;;kBAiGL,CAAA;AAEF,QAAA,MAAM,yBAAyB;;;;;;IAxG3B;;;;;OAKG;;;;;;;;;kBAuGL,CAAA;AAEF;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE3E;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,GAAG,mBAAmB,CAmBvF"}