@nccirtu/tablefy 0.8.3 → 0.9.0

package/dist/columns/forms/components/field-renderer.d.ts

@@ -0,0 +1,12 @@
+import { ReactNode } from "react";
+import { BuiltField } from "../types/form";
+export interface FieldRendererProps<TData extends Record<string, any>> {
+    field: BuiltField<TData>;
+    value: any;
+    error?: string;
+    disabled?: boolean;
+    data: TData;
+    onChange: (value: any) => void;
+    onBlur?: () => void;
+}
+export declare function FieldRenderer<TData extends Record<string, any>>({ field, value, error, disabled, data, onChange, onBlur, }: FieldRendererProps<TData>): ReactNode;

package/dist/columns/forms/components/form-actions.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode } from "react";
+import { FormActionConfig } from "../types/actions";
+export interface FormActionsProps<TData extends Record<string, any>> {
+    actions: FormActionConfig<TData>[];
+    position?: "start" | "end" | "between" | "center";
+    data: TData;
+    processing?: boolean;
+}
+export declare function FormActions<TData extends Record<string, any>>({ actions, position, data, processing, }: FormActionsProps<TData>): ReactNode;

package/dist/columns/forms/components/form-renderer.d.ts

@@ -0,0 +1,14 @@
+import { ReactNode } from "react";
+import { FormBuildResult } from "../types/form";
+export interface FormRendererProps<TData extends Record<string, any>> {
+    schema: FormBuildResult<TData>;
+    data: TData;
+    errors: Partial<Record<keyof TData, string>>;
+    onChange: (field: keyof TData, value: any) => void;
+    onSubmit: () => void;
+    processing?: boolean;
+    className?: string;
+    disabled?: boolean;
+    onBlur?: (field: string) => void;
+}
+export declare function FormRenderer<TData extends Record<string, any>>({ schema, data, errors, onChange, onSubmit, processing, className, disabled, onBlur, }: FormRendererProps<TData>): ReactNode;

package/dist/columns/forms/components/grid-layout.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from "react";
+export interface GridLayoutProps {
+    columns?: number;
+    children: ReactNode;
+    className?: string;
+}
+export declare function GridLayout({ columns, children, className, }: GridLayoutProps): ReactNode;

package/dist/columns/forms/components/index.d.ts

@@ -0,0 +1,9 @@
+export { FormRenderer } from "./form-renderer";
+export type { FormRendererProps } from "./form-renderer";
+export { FieldRenderer } from "./field-renderer";
+export type { FieldRendererProps } from "./field-renderer";
+export { GridLayout } from "./grid-layout";
+export { FormActions } from "./form-actions";
+export { SectionRenderer } from "./section-renderer";
+export { TabRenderer } from "./tab-renderer";
+export { WizardRenderer } from "./wizard-renderer";

package/dist/columns/forms/components/section-renderer.d.ts

@@ -0,0 +1,14 @@
+import { ReactNode } from "react";
+import { SectionConfig } from "../types/layout";
+import { BuiltField } from "../types/form";
+export interface SectionRendererProps<TData extends Record<string, any>> {
+    section: SectionConfig<TData>;
+    fields: BuiltField<TData>[];
+    data: TData;
+    errors: Partial<Record<keyof TData, string>>;
+    onChange: (field: keyof TData, value: any) => void;
+    onBlur?: (field: string) => void;
+    isFieldVisible: (field: BuiltField<TData>) => boolean;
+    isFieldDisabled: (field: BuiltField<TData>) => boolean;
+}
+export declare function SectionRenderer<TData extends Record<string, any>>({ section, fields, data, errors, onChange, onBlur, isFieldVisible, isFieldDisabled, }: SectionRendererProps<TData>): ReactNode;

package/dist/columns/forms/components/tab-renderer.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from "react";
+import { TabConfig } from "../types/layout";
+import { BuiltField } from "../types/form";
+export interface TabRendererProps<TData extends Record<string, any>> {
+    tabs: TabConfig<TData>[];
+    fields: BuiltField<TData>[];
+    data: TData;
+    errors: Partial<Record<keyof TData, string>>;
+    onChange: (field: keyof TData, value: any) => void;
+    onBlur?: (field: string) => void;
+    isFieldVisible: (field: BuiltField<TData>) => boolean;
+    isFieldDisabled: (field: BuiltField<TData>) => boolean;
+    columns?: number;
+}
+export declare function TabRenderer<TData extends Record<string, any>>({ tabs, fields, data, errors, onChange, onBlur, isFieldVisible, isFieldDisabled, columns, }: TabRendererProps<TData>): ReactNode;

package/dist/columns/forms/components/wizard-renderer.d.ts

@@ -0,0 +1,17 @@
+import { ReactNode } from "react";
+import { WizardStepConfig } from "../types/layout";
+import { BuiltField } from "../types/form";
+export interface WizardRendererProps<TData extends Record<string, any>> {
+    steps: WizardStepConfig<TData>[];
+    fields: BuiltField<TData>[];
+    data: TData;
+    errors: Partial<Record<keyof TData, string>>;
+    onChange: (field: keyof TData, value: any) => void;
+    onBlur?: (field: string) => void;
+    isFieldVisible: (field: BuiltField<TData>) => boolean;
+    isFieldDisabled: (field: BuiltField<TData>) => boolean;
+    columns?: number;
+    onSubmit: () => void;
+    processing?: boolean;
+}
+export declare function WizardRenderer<TData extends Record<string, any>>({ steps, fields, data, errors, onChange, onBlur, isFieldVisible, isFieldDisabled, columns, onSubmit, processing, }: WizardRendererProps<TData>): ReactNode;

package/dist/columns/forms/fields/base-field.d.ts

@@ -0,0 +1,24 @@
+import { ReactNode } from "react";
+import { BaseFieldConfig, ValidationRule } from "../types/field";
+import { FieldType, FieldRenderProps, BuiltField } from "../types/form";
+export declare abstract class BaseField<TData extends Record<string, any>, TConfig extends BaseFieldConfig<TData>> {
+    protected config: TConfig;
+    constructor(name: string);
+    label(label: string): this;
+    placeholder(placeholder: string): this;
+    helperText(text: string): this;
+    required(required?: boolean): this;
+    disabled(disabled?: boolean | ((data: TData) => boolean)): this;
+    readOnly(readOnly?: boolean): this;
+    hidden(hidden?: boolean | ((data: TData) => boolean)): this;
+    default(value: any): this;
+    columnSpan(span: number): this;
+    className(className: string): this;
+    rules(rules: ValidationRule[]): this;
+    zodSchema(schema: any): this;
+    dependsOn<K extends string & keyof TData>(field: K, condition: (value: TData[K], data: TData) => boolean, effect?: "show" | "hide" | "enable" | "disable" | "setValue", effectValue?: any): this;
+    reactive(reactive?: boolean): this;
+    abstract readonly fieldType: FieldType;
+    abstract renderField(props: FieldRenderProps<TData>): ReactNode;
+    build(): BuiltField<TData>;
+}

package/dist/columns/forms/fields/checkbox-group.d.ts

@@ -0,0 +1,12 @@
+import { ReactNode } from "react";
+import { BaseField } from "./base-field";
+import { CheckboxGroupConfig, SelectOption } from "../types/field";
+import { FieldType, FieldRenderProps } from "../types/form";
+export declare class CheckboxGroup<TData extends Record<string, any>> extends BaseField<TData, CheckboxGroupConfig<TData>> {
+    readonly fieldType: FieldType;
+    constructor(name: string);
+    static make<TData extends Record<string, any>>(name: string & keyof TData | string): CheckboxGroup<TData>;
+    options(options: SelectOption[]): this;
+    columns(columns: number): this;
+    renderField({ value, onChange, error, disabled, }: FieldRenderProps<TData>): ReactNode;
+}

package/dist/columns/forms/fields/checkbox.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode } from "react";
+import { BaseField } from "./base-field";
+import { CheckboxConfig } from "../types/field";
+import { FieldType, FieldRenderProps } from "../types/form";
+export declare class Checkbox<TData extends Record<string, any>> extends BaseField<TData, CheckboxConfig<TData>> {
+    readonly fieldType: FieldType;
+    static make<TData extends Record<string, any>>(name: string & keyof TData | string): Checkbox<TData>;
+    renderField({ value, onChange, error, disabled, }: FieldRenderProps<TData>): ReactNode;
+}

package/dist/columns/forms/fields/date-picker.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from "react";
+import { BaseField } from "./base-field";
+import { DatePickerConfig } from "../types/field";
+import { FieldType, FieldRenderProps } from "../types/form";
+export declare class DatePicker<TData extends Record<string, any>> extends BaseField<TData, DatePickerConfig<TData>> {
+    readonly fieldType: FieldType;
+    constructor(name: string);
+    static make<TData extends Record<string, any>>(name: string & keyof TData | string): DatePicker<TData>;
+    minDate(date: Date | ((data: TData) => Date)): this;
+    maxDate(date: Date | ((data: TData) => Date)): this;
+    format(format: string): this;
+    includeTime(includeTime?: boolean): this;
+    locale(locale: string): this;
+    renderField({ value, onChange, error, disabled, data, }: FieldRenderProps<TData>): ReactNode;
+}

package/dist/columns/forms/fields/file-upload.d.ts

@@ -0,0 +1,17 @@
+import { ReactNode } from "react";
+import { BaseField } from "./base-field";
+import { FileUploadConfig } from "../types/field";
+import { FieldType, FieldRenderProps } from "../types/form";
+export declare class FileUpload<TData extends Record<string, any>> extends BaseField<TData, FileUploadConfig<TData>> {
+    readonly fieldType: FieldType;
+    constructor(name: string);
+    static make<TData extends Record<string, any>>(name: string & keyof TData | string): FileUpload<TData>;
+    accept(accept: string): this;
+    maxSize(bytes: number): this;
+    multiple(multiple?: boolean): this;
+    maxFiles(max: number): this;
+    preview(preview?: boolean): this;
+    image(): this;
+    pdf(): this;
+    renderField({ value, onChange, error, disabled, }: FieldRenderProps<TData>): ReactNode;
+}

package/dist/columns/forms/fields/hidden.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode } from "react";
+import { BaseField } from "./base-field";
+import { HiddenConfig } from "../types/field";
+import { FieldType, FieldRenderProps } from "../types/form";
+export declare class Hidden<TData extends Record<string, any>> extends BaseField<TData, HiddenConfig<TData>> {
+    readonly fieldType: FieldType;
+    static make<TData extends Record<string, any>>(name: string & keyof TData | string): Hidden<TData>;
+    renderField({ value }: FieldRenderProps<TData>): ReactNode;
+}

package/dist/columns/forms/fields/index.d.ts

@@ -0,0 +1,12 @@
+export { BaseField } from "./base-field";
+export { TextInput } from "./text-input";
+export { Textarea } from "./textarea";
+export { Select } from "./select";
+export { Checkbox } from "./checkbox";
+export { Toggle } from "./toggle";
+export { RadioGroup } from "./radio-group";
+export { DatePicker } from "./date-picker";
+export { Hidden } from "./hidden";
+export { FileUpload } from "./file-upload";
+export { CheckboxGroup } from "./checkbox-group";
+export { Repeater } from "./repeater";

package/dist/columns/forms/fields/radio-group.d.ts

@@ -0,0 +1,14 @@
+import { ReactNode } from "react";
+import { BaseField } from "./base-field";
+import { RadioGroupConfig, SelectOption } from "../types/field";
+import { FieldType, FieldRenderProps } from "../types/form";
+export declare class RadioGroup<TData extends Record<string, any>> extends BaseField<TData, RadioGroupConfig<TData>> {
+    readonly fieldType: FieldType;
+    constructor(name: string);
+    static make<TData extends Record<string, any>>(name: string & keyof TData | string): RadioGroup<TData>;
+    options(options: SelectOption[]): this;
+    orientation(orientation: "horizontal" | "vertical"): this;
+    horizontal(): this;
+    vertical(): this;
+    renderField({ value, onChange, error, disabled, }: FieldRenderProps<TData>): ReactNode;
+}

package/dist/columns/forms/fields/repeater.d.ts

@@ -0,0 +1,21 @@
+import { ReactNode } from "react";
+import { BaseField } from "./base-field";
+import { RepeaterConfig } from "../types/field";
+import { FieldType, FieldRenderProps, BuiltField } from "../types/form";
+type FieldBuilder<TData extends Record<string, any>> = {
+    build(): BuiltField<TData>;
+};
+export declare class Repeater<TData extends Record<string, any>> extends BaseField<TData, RepeaterConfig<TData>> {
+    readonly fieldType: FieldType;
+    private fieldBuilders;
+    constructor(name: string);
+    static make<TData extends Record<string, any>>(name: string & keyof TData | string): Repeater<TData>;
+    fields(...builders: FieldBuilder<any>[]): this;
+    minItems(min: number): this;
+    maxItems(max: number): this;
+    addLabel(label: string): this;
+    collapsible(collapsible?: boolean): this;
+    orderable(orderable?: boolean): this;
+    renderField({ value, onChange, error, disabled, data, }: FieldRenderProps<TData>): ReactNode;
+}
+export {};

package/dist/columns/forms/fields/select.d.ts

@@ -0,0 +1,16 @@
+import { ReactNode } from "react";
+import { BaseField } from "./base-field";
+import { SelectConfig, SelectOption } from "../types/field";
+import { FieldType, FieldRenderProps } from "../types/form";
+export declare class Select<TData extends Record<string, any>> extends BaseField<TData, SelectConfig<TData>> {
+    readonly fieldType: FieldType;
+    constructor(name: string);
+    static make<TData extends Record<string, any>>(name: string & keyof TData | string): Select<TData>;
+    options(options: SelectOption[] | ((data: TData) => SelectOption[])): this;
+    multiple(multiple?: boolean): this;
+    searchable(searchable?: boolean): this;
+    clearable(clearable?: boolean): this;
+    maxItems(max: number): this;
+    loadOptions(fn: (query: string) => Promise<SelectOption[]>): this;
+    renderField({ value, onChange, error, disabled, data, }: FieldRenderProps<TData>): ReactNode;
+}

package/dist/columns/forms/fields/text-input.d.ts

@@ -0,0 +1,20 @@
+import { ReactNode } from "react";
+import { BaseField } from "./base-field";
+import { TextInputConfig } from "../types/field";
+import { FieldType, FieldRenderProps } from "../types/form";
+export declare class TextInput<TData extends Record<string, any>> extends BaseField<TData, TextInputConfig<TData>> {
+    readonly fieldType: FieldType;
+    static make<TData extends Record<string, any>>(name: string & keyof TData | string): TextInput<TData>;
+    type(type: "text" | "email" | "password" | "number" | "url" | "tel"): this;
+    email(): this;
+    password(): this;
+    number(): this;
+    url(): this;
+    tel(): this;
+    minLength(min: number): this;
+    maxLength(max: number): this;
+    prefix(prefix: string | ReactNode): this;
+    suffix(suffix: string | ReactNode): this;
+    autocomplete(value: string): this;
+    renderField({ value, onChange, onBlur, error, disabled, }: FieldRenderProps<TData>): ReactNode;
+}

package/dist/columns/forms/fields/textarea.d.ts

@@ -0,0 +1,14 @@
+import { ReactNode } from "react";
+import { BaseField } from "./base-field";
+import { TextareaConfig } from "../types/field";
+import { FieldType, FieldRenderProps } from "../types/form";
+export declare class Textarea<TData extends Record<string, any>> extends BaseField<TData, TextareaConfig<TData>> {
+    readonly fieldType: FieldType;
+    constructor(name: string);
+    static make<TData extends Record<string, any>>(name: string & keyof TData | string): Textarea<TData>;
+    rows(rows: number): this;
+    minLength(min: number): this;
+    maxLength(max: number): this;
+    autoResize(autoResize?: boolean): this;
+    renderField({ value, onChange, onBlur, error, disabled, }: FieldRenderProps<TData>): ReactNode;
+}

package/dist/columns/forms/fields/toggle.d.ts

@@ -0,0 +1,11 @@
+import { ReactNode } from "react";
+import { BaseField } from "./base-field";
+import { ToggleConfig } from "../types/field";
+import { FieldType, FieldRenderProps } from "../types/form";
+export declare class Toggle<TData extends Record<string, any>> extends BaseField<TData, ToggleConfig<TData>> {
+    readonly fieldType: FieldType;
+    static make<TData extends Record<string, any>>(name: string & keyof TData | string): Toggle<TData>;
+    onLabel(label: string): this;
+    offLabel(label: string): this;
+    renderField({ value, onChange, error, disabled, }: FieldRenderProps<TData>): ReactNode;
+}

package/dist/columns/forms/index.d.ts

@@ -0,0 +1,26 @@
+export { FormSchema } from "./builders/form-schema";
+export { ActionsBuilder } from "./builders/actions-builder";
+export { SectionBuilder } from "./builders/section-builder";
+export { TabBuilder } from "./builders/tab-builder";
+export { WizardStep } from "./builders/wizard-builder";
+export { BaseField } from "./fields/base-field";
+export { TextInput } from "./fields/text-input";
+export { Textarea } from "./fields/textarea";
+export { Select } from "./fields/select";
+export { Checkbox } from "./fields/checkbox";
+export { Toggle } from "./fields/toggle";
+export { RadioGroup } from "./fields/radio-group";
+export { DatePicker } from "./fields/date-picker";
+export { Hidden } from "./fields/hidden";
+export { FileUpload } from "./fields/file-upload";
+export { CheckboxGroup } from "./fields/checkbox-group";
+export { Repeater } from "./fields/repeater";
+export { FormRenderer } from "./components/form-renderer";
+export type { FormRendererProps } from "./components/form-renderer";
+export { FieldRenderer } from "./components/field-renderer";
+export { GridLayout } from "./components/grid-layout";
+export { FormActions } from "./components/form-actions";
+export { SectionRenderer } from "./components/section-renderer";
+export { TabRenderer } from "./components/tab-renderer";
+export { WizardRenderer } from "./components/wizard-renderer";
+export type { BaseFieldConfig, ValidationRule, DependencyConfig, TextInputConfig, TextareaConfig, SelectOption, SelectConfig, CheckboxConfig, CheckboxGroupConfig, ToggleConfig, RadioGroupConfig, DatePickerConfig, FileUploadConfig, RepeaterConfig, HiddenConfig, FieldType, FieldRenderProps, BuiltField, FormSchemaConfig, FormBuildResult, SectionConfig, TabConfig, WizardStepConfig, FormActionConfig, } from "./types";

package/dist/columns/forms/types/actions.d.ts

@@ -0,0 +1,11 @@
+import { ReactNode } from "react";
+export interface FormActionConfig<TData extends Record<string, any> = Record<string, any>> {
+    type: "submit" | "cancel" | "custom";
+    label: string;
+    variant?: "default" | "secondary" | "outline" | "ghost" | "destructive";
+    disabled?: boolean | ((data: TData, processing: boolean) => boolean);
+    loading?: boolean;
+    icon?: ReactNode;
+    onClick?: () => void;
+    href?: string;
+}

package/dist/columns/forms/types/field.d.ts

@@ -0,0 +1,98 @@
+import { ReactNode } from "react";
+export interface BaseFieldConfig<TData extends Record<string, any>> {
+    name: string;
+    label?: string;
+    placeholder?: string;
+    helperText?: string;
+    required?: boolean;
+    disabled?: boolean | ((data: TData) => boolean);
+    readOnly?: boolean;
+    hidden?: boolean | ((data: TData) => boolean);
+    defaultValue?: any;
+    columnSpan?: number;
+    className?: string;
+    rules?: ValidationRule[];
+    zodSchema?: any;
+    dependsOn?: DependencyConfig<TData>[];
+    reactive?: boolean;
+}
+export interface ValidationRule {
+    type: string;
+    value?: any;
+    message?: string;
+}
+export interface DependencyConfig<TData> {
+    field: string & keyof TData;
+    condition: (value: any, data: TData) => boolean;
+    effect: "show" | "hide" | "enable" | "disable" | "setValue";
+    effectValue?: any;
+}
+export interface TextInputConfig<TData extends Record<string, any>> extends BaseFieldConfig<TData> {
+    type?: "text" | "email" | "password" | "number" | "url" | "tel";
+    minLength?: number;
+    maxLength?: number;
+    prefix?: string | ReactNode;
+    suffix?: string | ReactNode;
+    mask?: string;
+    autocomplete?: string;
+}
+export interface TextareaConfig<TData extends Record<string, any>> extends BaseFieldConfig<TData> {
+    rows?: number;
+    minLength?: number;
+    maxLength?: number;
+    autoResize?: boolean;
+}
+export interface SelectOption {
+    label: string;
+    value: string;
+    disabled?: boolean;
+    group?: string;
+    description?: string;
+    icon?: ReactNode;
+}
+export interface SelectConfig<TData extends Record<string, any>> extends BaseFieldConfig<TData> {
+    options: SelectOption[] | ((data: TData) => SelectOption[]);
+    multiple?: boolean;
+    searchable?: boolean;
+    clearable?: boolean;
+    maxItems?: number;
+    loadOptions?: (query: string) => Promise<SelectOption[]>;
+}
+export interface CheckboxConfig<TData extends Record<string, any>> extends BaseFieldConfig<TData> {
+}
+export interface CheckboxGroupConfig<TData extends Record<string, any>> extends BaseFieldConfig<TData> {
+    options: SelectOption[];
+    columns?: number;
+}
+export interface ToggleConfig<TData extends Record<string, any>> extends BaseFieldConfig<TData> {
+    onLabel?: string;
+    offLabel?: string;
+}
+export interface RadioGroupConfig<TData extends Record<string, any>> extends BaseFieldConfig<TData> {
+    options: SelectOption[];
+    orientation?: "horizontal" | "vertical";
+}
+export interface DatePickerConfig<TData extends Record<string, any>> extends BaseFieldConfig<TData> {
+    minDate?: Date | ((data: TData) => Date);
+    maxDate?: Date | ((data: TData) => Date);
+    format?: string;
+    includeTime?: boolean;
+    locale?: string;
+}
+export interface FileUploadConfig<TData extends Record<string, any>> extends BaseFieldConfig<TData> {
+    accept?: string;
+    maxSize?: number;
+    multiple?: boolean;
+    maxFiles?: number;
+    preview?: boolean;
+}
+export interface RepeaterConfig<TData extends Record<string, any>> extends BaseFieldConfig<TData> {
+    fields: any[];
+    minItems?: number;
+    maxItems?: number;
+    addLabel?: string;
+    collapsible?: boolean;
+    orderable?: boolean;
+}
+export interface HiddenConfig<TData extends Record<string, any>> extends BaseFieldConfig<TData> {
+}

package/dist/columns/forms/types/form.d.ts

@@ -0,0 +1,37 @@
+import { ReactNode } from "react";
+import { BaseFieldConfig } from "./field";
+import { SectionConfig, TabConfig, WizardStepConfig } from "./layout";
+import { FormActionConfig } from "./actions";
+export type FieldType = "text" | "textarea" | "select" | "multi-select" | "checkbox" | "checkbox-group" | "toggle" | "radio-group" | "date-picker" | "date-time-picker" | "file-upload" | "repeater" | "hidden";
+export interface FieldRenderProps<TData extends Record<string, any> = Record<string, any>> {
+    value: any;
+    onChange: (value: any) => void;
+    onBlur?: () => void;
+    error?: string;
+    disabled?: boolean;
+    data: TData;
+}
+export interface BuiltField<TData extends Record<string, any> = Record<string, any>> {
+    name: string;
+    type: FieldType;
+    config: BaseFieldConfig<TData> & Record<string, any>;
+    render: (props: FieldRenderProps<TData>) => ReactNode;
+}
+export interface FormSchemaConfig<TData extends Record<string, any>> {
+    title?: string | ((data: TData) => string);
+    description?: string | ((data: TData) => string);
+    columns?: number;
+    bordered?: boolean;
+    spacing?: "compact" | "normal" | "relaxed";
+    fields: BuiltField<TData>[];
+    sections?: SectionConfig<TData>[];
+    tabs?: TabConfig<TData>[];
+    wizardSteps?: WizardStepConfig<TData>[];
+    actions?: FormActionConfig<TData>[];
+    actionsPosition?: "start" | "end" | "between" | "center";
+    disabled?: boolean | ((data: TData) => boolean);
+}
+export interface FormBuildResult<TData extends Record<string, any>> {
+    fields: BuiltField<TData>[];
+    config: FormSchemaConfig<TData>;
+}

package/dist/columns/forms/types/index.d.ts

@@ -0,0 +1,4 @@
+export type { BaseFieldConfig, ValidationRule, DependencyConfig, TextInputConfig, TextareaConfig, SelectOption, SelectConfig, CheckboxConfig, CheckboxGroupConfig, ToggleConfig, RadioGroupConfig, DatePickerConfig, FileUploadConfig, RepeaterConfig, HiddenConfig, } from "./field";
+export type { FieldType, FieldRenderProps, BuiltField, FormSchemaConfig, FormBuildResult, } from "./form";
+export type { SectionConfig, TabConfig, WizardStepConfig, } from "./layout";
+export type { FormActionConfig } from "./actions";

package/dist/columns/forms/types/layout.d.ts

@@ -0,0 +1,31 @@
+import { ReactNode } from "react";
+export interface SectionConfig<TData extends Record<string, any>> {
+    id: string;
+    title: string;
+    description?: string;
+    fields: string[];
+    columns?: number;
+    collapsible?: boolean;
+    collapsed?: boolean;
+    icon?: ReactNode;
+    hidden?: (data: TData) => boolean;
+}
+export interface TabConfig<TData extends Record<string, any>> {
+    id: string;
+    label: string;
+    icon?: ReactNode;
+    fields?: string[];
+    sections?: SectionConfig<TData>[];
+    badge?: string | number | ((data: TData) => string | number);
+    disabled?: (data: TData) => boolean;
+}
+export interface WizardStepConfig<TData extends Record<string, any>> {
+    id: string;
+    label: string;
+    description?: string;
+    icon?: ReactNode;
+    fields?: string[];
+    sections?: SectionConfig<TData>[];
+    canProceed?: (data: TData) => boolean;
+    beforeNext?: (data: TData) => Promise<boolean> | boolean;
+}

package/dist/columns/index.d.ts

@@ -21,3 +21,5 @@ export type { EnumOption } from "./columns/enum-column";
 export { ConfirmProvider, confirm } from "./confirm";
 export type { ConfirmOptions } from "./confirm";
 export type { DataTableConfig, EmptyStateConfig, FilterConfig, HeaderAction, PaginationConfig, SearchConfig, } from "./types";
+export { FormSchema, ActionsBuilder, SectionBuilder, TabBuilder, WizardStep, TextInput, Textarea, Select, Checkbox, Toggle, RadioGroup, DatePicker, Hidden, FileUpload, CheckboxGroup, Repeater, FormRenderer, } from "./forms";
+export type { FormSchemaConfig, FormBuildResult, FormRendererProps, BuiltField, FieldType, FieldRenderProps, BaseFieldConfig, SelectOption as FormSelectOption, FormActionConfig, SectionConfig, TabConfig, WizardStepConfig, } from "./forms";

package/dist/columns/index.esm.js

@@ -241,8 +241,18 @@ class BadgeColumn extends BaseColumn {
         this.config.variants = variants;
         return this;
     }
+    // Dynamische Variante basierend auf Row-Daten
+    variantFn(fn) {
+        this.config.variantFn = fn;
+        return this;
+    }
+    // Dynamische className basierend auf Row-Daten
+    classNameFn(fn) {
+        this.config.classNameFn = fn;
+        return this;
+    }
     build() {
-        const { accessor, label, sortable, variants } = this.config;
+        const { accessor, label, sortable, variants, variantFn, classNameFn } = this.config;
         return {
             accessorKey: accessor,
             header: ({ column }) => {
@@ -252,18 +262,31 @@ class BadgeColumn extends BaseColumn {
                 }
                 return (jsxs(Button, { variant: "table_header", size: "table_header", onClick: () => column.toggleSorting(column.getIsSorted() === "asc"), className: cn("text-muted-foreground font-medium", this.getAlignmentClass(), this.config.headerClassName), children: [displayLabel, jsx(ArrowUpDown, { className: "ml-2 h-4 w-4" })] }));
             },
-            cell: ({ getValue }) => {
-                const value = String(getValue());
-                const variantConfig = variants?.[value];
-                if (!variantConfig) {
-                    return (jsx(Badge, { variant: "outline", className: this.config.cellClassName, children: value }));
+            cell: ({ getValue, row }) => {
+                const value = getValue();
+                const stringValue = String(value);
+                // Priority 1: Dynamic variantFn (highest priority)
+                if (variantFn) {
+                    const dynamicConfig = variantFn(value, row.original);
+                    return (jsxs(Badge, { variant: dynamicConfig.variant === "success" ||
+                            dynamicConfig.variant === "warning" ||
+                            dynamicConfig.variant === "info" ||
+                            dynamicConfig.variant === "muted"
+                            ? "default"
+                            : dynamicConfig.variant || "default", className: cn(dynamicConfig.className, classNameFn?.(value, row.original), this.config.cellClassName), children: [dynamicConfig.icon, dynamicConfig.label || stringValue] }));
+                }
+                // Priority 2: Static variants lookup
+                const variantConfig = variants?.[stringValue];
+                if (variantConfig) {
+                    return (jsxs(Badge, { variant: variantConfig.variant === "success" ||
+                            variantConfig.variant === "warning" ||
+                            variantConfig.variant === "info" ||
+                            variantConfig.variant === "muted"
+                            ? "default"
+                            : variantConfig.variant || "default", className: cn(variantConfig.className, classNameFn?.(value, row.original), this.config.cellClassName), children: [variantConfig.icon, variantConfig.label || stringValue] }));
                 }
-                return (jsxs(Badge, { variant: variantConfig.variant === "success" ||
-                        variantConfig.variant === "warning" ||
-                        variantConfig.variant === "info" ||
-                        variantConfig.variant === "muted"
-                        ? "default"
-                        : variantConfig.variant || "default", className: cn(variantConfig.className, this.config.cellClassName), children: [variantConfig.icon, variantConfig.label || value] }));
+                // Priority 3: Default badge with optional dynamic className
+                return (jsx(Badge, { variant: "outline", className: cn(classNameFn?.(value, row.original), this.config.cellClassName), children: stringValue }));
             },
         };
     }