@pdg/react-form 1.0.166 → 1.1.1

package/dist/@private/@types/date_time.d.ts

@@ -1,6 +1,6 @@
 import { Dayjs } from 'dayjs';
-export type FormAvailableDateType = 'year' | 'month' | 'day' | 'hour' | 'minute' | 'second';
-export interface FormAvailableDateItem {
+export type PFormAvailableDateType = 'year' | 'month' | 'day' | 'hour' | 'minute' | 'second';
+export interface PFormAvailableDateItem {
     date: Dayjs;
     year: number;
     month: number;
@@ -9,4 +9,4 @@ export interface FormAvailableDateItem {
     minute: number;
     second: number;
 }
-export type FormAvailableDate = [FormAvailableDateItem | null, FormAvailableDateItem | null];
+export type PFormAvailableDate = [PFormAvailableDateItem | null, PFormAvailableDateItem | null];

package/dist/@private/PrivateDatePicker/PrivateDatePicker.types.d.ts

@@ -1,11 +1,11 @@
 import { ReactNode } from 'react';
 import { DesktopDatePickerProps } from '@mui/x-date-pickers';
-import { CommonSxProps, FormDateType, FormDateValueItemCommands, FormTimeType, FormValueItemBaseCommands, FormValueItemProps } from '../../@types';
+import { PCommonSxProps, PFormDateType, PFormDateValueItemCommands, PFormTimeType, PFormValueItemBaseCommands, PFormValueItemProps } from '../../@types';
 import { Dayjs } from 'dayjs';
 export type PrivateDatePickerValue = Dayjs | null;
-export interface PrivateDatePickerProps extends CommonSxProps, Partial<Omit<DesktopDatePickerProps<Dayjs>, 'children' | 'name' | 'className' | 'style' | 'sx' | 'value' | 'inputFormat' | 'views' | 'onChange'>>, FormValueItemProps<PrivateDatePickerValue, false> {
-    type: FormDateType;
-    time?: FormTimeType;
+export interface PrivateDatePickerProps extends PCommonSxProps, Partial<Omit<DesktopDatePickerProps<Dayjs>, 'children' | 'name' | 'className' | 'style' | 'sx' | 'value' | 'inputFormat' | 'views' | 'onChange'>>, PFormValueItemProps<PrivateDatePickerValue, false> {
+    type: PFormDateType;
+    time?: PFormTimeType;
     hours?: number[];
     minutes?: number[];
     seconds?: number[];
@@ -22,5 +22,5 @@ export interface PrivateDatePickerProps extends CommonSxProps, Partial<Omit<Desk
     enableKeyboardInput?: boolean;
     hidden?: boolean;
 }
-export interface PrivateDatePickerCommands extends FormValueItemBaseCommands<PrivateDatePickerValue, false>, FormDateValueItemCommands {
+export interface PrivateDatePickerCommands extends PFormValueItemBaseCommands<PrivateDatePickerValue, false>, PFormDateValueItemCommands {
 }

package/dist/@private/PrivateDateTimePicker/PrivateDateTimePicker.types.d.ts

@@ -1,11 +1,11 @@
 import { ReactNode } from 'react';
 import { DesktopDateTimePickerProps } from '@mui/x-date-pickers';
-import { CommonSxProps, FormDateType, FormDateValueItemCommands, FormTimeType, FormValueItemBaseCommands, FormValueItemProps } from '../../@types';
+import { PCommonSxProps, PFormDateType, PFormDateValueItemCommands, PFormTimeType, PFormValueItemBaseCommands, PFormValueItemProps } from '../../@types';
 import { Dayjs } from 'dayjs';
 export type PrivateDateTimePickerValue = Dayjs | null;
-export interface PrivateDateTimePickerProps extends CommonSxProps, Partial<Omit<DesktopDateTimePickerProps<Dayjs>, 'children' | 'className' | 'name' | 'style' | 'sx' | 'value' | 'inputFormat' | 'views' | 'onChange' | 'openTo' | 'view' | 'viewRenderers' | 'components' | 'componentsProps' | 'slots' | 'slotProps'>>, FormValueItemProps<PrivateDateTimePickerValue, false> {
-    type: FormDateType;
-    time?: FormTimeType;
+export interface PrivateDateTimePickerProps extends PCommonSxProps, Partial<Omit<DesktopDateTimePickerProps<Dayjs>, 'children' | 'className' | 'name' | 'style' | 'sx' | 'value' | 'inputFormat' | 'views' | 'onChange' | 'openTo' | 'view' | 'viewRenderers' | 'components' | 'componentsProps' | 'slots' | 'slotProps'>>, PFormValueItemProps<PrivateDateTimePickerValue, false> {
+    type: PFormDateType;
+    time?: PFormTimeType;
     hours?: number[];
     minutes?: number[];
     seconds?: number[];
@@ -22,5 +22,5 @@ export interface PrivateDateTimePickerProps extends CommonSxProps, Partial<Omit<
     enableKeyboardInput?: boolean;
     hidden?: boolean;
 }
-export interface PrivateDateTimePickerCommands extends FormValueItemBaseCommands<PrivateDateTimePickerValue, false>, FormDateValueItemCommands {
+export interface PrivateDateTimePickerCommands extends PFormValueItemBaseCommands<PrivateDateTimePickerValue, false>, PFormDateValueItemCommands {
 }

package/dist/@private/PrivateInputDatePicker/PrivateInputDatePicker.types.d.ts

@@ -2,10 +2,10 @@ import React, { ReactNode } from 'react';
 import { Dayjs } from 'dayjs';
 import { TextFieldProps } from '@mui/material';
 import { DateValidationError } from '@mui/x-date-pickers';
-import { CommonSxProps, FormValueItemProps } from '../../@types';
+import { PCommonSxProps, PFormValueItemProps } from '../../@types';
 import { DesktopDatePickerProps } from '@mui/x-date-pickers';
 export type PrivateInputDatePickerValue = Dayjs | null;
-export interface PrivateInputDatePickerProps extends CommonSxProps, Pick<DesktopDatePickerProps<Dayjs>, 'name' | 'disablePast' | 'disableFuture' | 'shouldDisableYear' | 'shouldDisableMonth' | 'shouldDisableDate'>, Pick<FormValueItemProps<PrivateInputDatePickerValue>, 'variant' | 'size' | 'color' | 'focused' | 'fullWidth' | 'readOnly' | 'label' | 'labelIcon' | 'error'> {
+export interface PrivateInputDatePickerProps extends PCommonSxProps, Pick<DesktopDatePickerProps<Dayjs>, 'name' | 'disablePast' | 'disableFuture' | 'shouldDisableYear' | 'shouldDisableMonth' | 'shouldDisableDate'>, Pick<PFormValueItemProps<PrivateInputDatePickerValue>, 'variant' | 'size' | 'color' | 'focused' | 'fullWidth' | 'readOnly' | 'label' | 'labelIcon' | 'error'> {
     className?: string;
     value: PrivateInputDatePickerValue;
     disabled?: boolean;

package/dist/@private/PrivateMonthSelect/PrivateMonthSelect.types.d.ts

@@ -1,9 +1,9 @@
-import { FormAvailableDate } from '../@types';
+import { PFormAvailableDate } from '../@types';
 export interface PrivateMonthSelectProps {
     year: number;
     selectYear: number | null;
     selectMonth: number | null;
     activeMonth: number;
-    availableDate: FormAvailableDate;
+    availableDate: PFormAvailableDate;
     onSelect(month: number): void;
 }

package/dist/@private/PrivateStaticDatePicker/PrivateStaticDatePicker.types.d.ts

@@ -1,12 +1,12 @@
 import { StaticDatePickerProps } from '@mui/x-date-pickers';
 import { Dayjs } from 'dayjs';
-import { FormAvailableDate } from '../@types';
-import { FormDateType, FormTimeType } from '../../@types';
+import { PFormAvailableDate } from '../@types';
+import { PFormDateType, PFormTimeType } from '../../@types';
 export type PrivateStaticDatePickerUnit = 'date' | 'action_date' | 'hour' | 'minute' | 'second';
 export interface PrivateStaticDatePickerProps extends Omit<StaticDatePickerProps<Dayjs>, 'displayStaticWrapperAs' | 'renderInput' | 'onChange'> {
-    type: FormDateType;
-    time?: FormTimeType;
-    availableDate?: FormAvailableDate;
+    type: PFormDateType;
+    time?: PFormTimeType;
+    availableDate?: PFormAvailableDate;
     hours?: number[];
     minutes?: number[];
     seconds?: number[];

package/dist/@private/PrivateStaticDateTimePicker/PrivateStaticDateTimePicker.types.d.ts

@@ -1,12 +1,12 @@
 import { StaticDateTimePickerProps } from '@mui/x-date-pickers';
 import { Dayjs } from 'dayjs';
-import { FormAvailableDate } from '../@types';
-import { FormDateType, FormTimeType } from '../../@types';
+import { PFormAvailableDate } from '../@types';
+import { PFormDateType, PFormTimeType } from '../../@types';
 export type PrivateStaticDateTimePickerUnit = 'date' | 'action_date' | 'hour' | 'minute' | 'second';
 export interface PrivateStaticDateTimePickerProps extends Omit<StaticDateTimePickerProps<Dayjs>, 'displayStaticWrapperAs' | 'renderInput' | 'onChange'> {
-    type: FormDateType;
-    time?: FormTimeType;
-    availableDate?: FormAvailableDate;
+    type: PFormDateType;
+    time?: PFormTimeType;
+    availableDate?: PFormAvailableDate;
     hours?: number[];
     minutes?: number[];
     seconds?: number[];

package/dist/@private/PrivateTimeSection/PrivateTimeSection.types.d.ts

@@ -1,14 +1,14 @@
 import React from 'react';
 import { PrivateTimeSelectCommands } from '../PrivateTimeSelect';
 import { Dayjs } from 'dayjs';
-import { FormTimeType } from '../../@types';
+import { PFormTimeType } from '../../@types';
 import { PrivateStaticDateTimePickerUnit } from '../PrivateStaticDateTimePicker';
-import { FormAvailableDate } from '../@types';
+import { PFormAvailableDate } from '../@types';
 export interface PrivateTimeSectionProps {
-    time: FormTimeType;
+    time: PFormTimeType;
     width: number;
     cols: 1 | 2 | 3;
-    availableDate: FormAvailableDate;
+    availableDate: PFormAvailableDate;
     hourSelectRef: React.RefObject<PrivateTimeSelectCommands | null>;
     minuteSelectRef: React.RefObject<PrivateTimeSelectCommands | null>;
     secondSelectRef: React.RefObject<PrivateTimeSelectCommands | null>;

package/dist/@private/PrivateYearSelect/PrivateYearSelect.types.d.ts

@@ -1,7 +1,7 @@
-import { FormAvailableDate } from '../@types';
+import { PFormAvailableDate } from '../@types';
 export interface PrivateYearSelectProps {
     selectYear: number | null;
     activeYear: number;
-    availableDate: FormAvailableDate;
+    availableDate: PFormAvailableDate;
     onSelect(year: number): void;
 }

package/dist/@types/date_time.d.ts

@@ -1,2 +1,2 @@
-export type FormDateType = 'date' | 'date_time' | 'time';
-export type FormTimeType = 'hour' | 'minute' | 'second';
+export type PFormDateType = 'date' | 'date_time' | 'time';
+export type PFormTimeType = 'hour' | 'minute' | 'second';

package/dist/@types/types.d.ts

@@ -1,35 +1,35 @@
 import { CSSProperties, ReactNode } from 'react';
 import { SxProps } from '@mui/system';
 import { Theme } from '@mui/material/styles';
-import { FormContextValue } from '../FormContext';
+import { PFormContextValue } from '../PFormContext';
 export type PartialPick<T, K extends keyof T> = Partial<Pick<T, K>>;
 export type PartialOmit<T, K extends keyof T> = Partial<Omit<T, K>>;
-export interface CommonProps {
+export interface PCommonProps {
     children?: ReactNode;
     className?: string;
     style?: CSSProperties;
 }
-export interface CommonSxProps extends CommonProps {
+export interface PCommonSxProps extends PCommonProps {
     sx?: SxProps<Theme>;
 }
-export type FormYearMonthValue = {
+export type PFormYearMonthValue = {
     year: number | '';
     month: number | '';
 };
-export type FormValue = string | number | boolean | FormYearMonthValue;
-export interface FormValueMap {
-    [key: string]: FormValue;
+export type PFormValue = string | number | boolean | PFormYearMonthValue;
+export interface PFormValueMap {
+    [key: string]: PFormValue;
 }
-export type FormValueItemData = Record<string, any>;
-export interface FormValueItemBaseCommands<T, AllowUndefinedValue extends boolean, V = AllowUndefinedValue extends true ? T | undefined : T> {
-    getType(): 'default' | 'FormCheckbox' | 'FormToggleButtonGroup' | 'FormRadioGroup' | 'FormRating' | 'FormTextEditor' | 'FormAutocomplete' | 'FormDatePicker' | 'FormDateTimePicker' | 'FormTimePicker' | 'FormDateRangePicker' | 'FormMonthPicker' | 'FormMonthRangePicker' | 'FormYearPicker' | 'FormYearRangePicker' | 'FormFile' | 'FormSwitch';
+export type PFormValueItemData = Record<string, any>;
+export interface PFormValueItemBaseCommands<T, AllowUndefinedValue extends boolean, V = AllowUndefinedValue extends true ? T | undefined : T> {
+    getType(): 'default' | 'PFormCheckbox' | 'PFormToggleButtonGroup' | 'PFormRadioGroup' | 'PFormRating' | 'PFormTextEditor' | 'PFormAutocomplete' | 'PFormDatePicker' | 'PFormDateTimePicker' | 'PFormTimePicker' | 'PFormDateRangePicker' | 'PFormMonthPicker' | 'PFormMonthRangePicker' | 'PFormYearPicker' | 'PFormYearRangePicker' | 'PFormFile' | 'PFormSwitch';
     getName(): string;
     getReset(): V;
     reset(): void;
     getValue(): V;
     setValue(value: V): void;
-    getData(): FormValueItemData | undefined;
-    setData(data?: FormValueItemData): void;
+    getData(): PFormValueItemData | undefined;
+    setData(data?: PFormValueItemData): void;
     isExceptValue(): boolean;
     isDisabled(): boolean;
     setDisabled(disabled: boolean): void;
@@ -40,55 +40,55 @@ export interface FormValueItemBaseCommands<T, AllowUndefinedValue extends boolea
     validate(): boolean;
     setError(error: boolean, errorText: ReactNode | undefined): void;
 }
-export interface FormArrayValueItemCommands {
+export interface PFormArrayValueItemCommands {
     isFormValueSort(): boolean;
     getFormValueSeparator(): string;
 }
-export interface FormItemsValueItemCommands<T> {
+export interface PFormItemsValueItemCommands<T> {
     getItems(): T[] | undefined;
     setItems(items: T[] | undefined): void;
 }
-export interface FormCheckValueItemCommands<T> {
+export interface PFormCheckValueItemCommands<T> {
     getChecked(): boolean;
     setChecked(checked: boolean, notFireOnChange?: boolean): void;
     getUncheckedValue(): T;
     setUncheckedValue(uncheckedValue: T): void;
 }
-export interface FormMultipleValueItemCommands {
+export interface PFormMultipleValueItemCommands {
     isMultiple(): boolean;
 }
-export interface FormLoadingValueItemCommands {
+export interface PFormLoadingValueItemCommands {
     getLoading(): boolean;
     setLoading(loading: boolean): void;
 }
-export interface FormDateValueItemCommands {
+export interface PFormDateValueItemCommands {
     getFormValueFormat(): string;
 }
-export interface FormRangeValueItemCommands<T> {
+export interface PFormRangeValueItemCommands<T> {
     getFromValue(): T | null;
     setFromValue(value: T | null): void;
     getToValue(): T | null;
     setToValue(value: T | null): void;
 }
-export interface FormRangeValueItemNameCommands {
+export interface PFormRangeValueItemNameCommands {
     getFormValueFromNameSuffix(): string;
     getFormValueToNameSuffix(): string;
     getFormValueFromName(): string;
     getFormValueToName(): string;
 }
-export interface FormYearMonthValueItemCommands {
+export interface PFormYearMonthValueItemCommands {
     getYear(): number | null;
     setYear(year: number | null): void;
     getMonth(): number | null;
     setMonth(month: number | null): void;
 }
-export interface FormYearMonthValueItemNameCommands {
+export interface PFormYearMonthValueItemNameCommands {
     getFormValueYearNameSuffix(): string;
     getFormValueMonthNameSuffix(): string;
     getFormValueYearName(): string;
     getFormValueMonthName(): string;
 }
-export interface FormYearMonthRangeValueItemCommands {
+export interface PFormYearMonthRangeValueItemCommands {
     getFromYear(): number | null;
     setFromYear(year: number | null): void;
     getFromMonth(): number | null;
@@ -98,7 +98,7 @@ export interface FormYearMonthRangeValueItemCommands {
     getToMonth(): number | null;
     setToMonth(month: number | null): void;
 }
-export interface FormYearMonthRangeValueItemNameCommands {
+export interface PFormYearMonthRangeValueItemNameCommands {
     getFormValueFromYearNameSuffix(): string;
     getFormValueFromMonthNameSuffix(): string;
     getFormValueToYearNameSuffix(): string;
@@ -108,12 +108,12 @@ export interface FormYearMonthRangeValueItemNameCommands {
     getFormValueToYearName(): string;
     getFormValueToMonthName(): string;
 }
-export interface FormValueItemCommands<T, AllowUndefinedValue extends boolean = true, ItemType = any> extends FormValueItemBaseCommands<T, AllowUndefinedValue>, Partial<FormArrayValueItemCommands>, Partial<FormItemsValueItemCommands<ItemType>>, Partial<FormCheckValueItemCommands<T>>, Partial<FormMultipleValueItemCommands>, Partial<FormLoadingValueItemCommands>, Partial<FormDateValueItemCommands>, Partial<FormRangeValueItemCommands<T>>, Partial<FormRangeValueItemNameCommands>, Partial<FormYearMonthValueItemCommands>, Partial<FormYearMonthValueItemNameCommands>, Partial<FormYearMonthRangeValueItemCommands>, Partial<FormYearMonthRangeValueItemNameCommands> {
+export interface PFormValueItemCommands<T, AllowUndefinedValue extends boolean = true, ItemType = any> extends PFormValueItemBaseCommands<T, AllowUndefinedValue>, Partial<PFormArrayValueItemCommands>, Partial<PFormItemsValueItemCommands<ItemType>>, Partial<PFormCheckValueItemCommands<T>>, Partial<PFormMultipleValueItemCommands>, Partial<PFormLoadingValueItemCommands>, Partial<PFormDateValueItemCommands>, Partial<PFormRangeValueItemCommands<T>>, Partial<PFormRangeValueItemNameCommands>, Partial<PFormYearMonthValueItemCommands>, Partial<PFormYearMonthValueItemNameCommands>, Partial<PFormYearMonthRangeValueItemCommands>, Partial<PFormYearMonthRangeValueItemNameCommands> {
 }
-export interface FormValueItemCommandsMap<T, AllowUndefinedValue extends boolean = true, ItemType = any> {
-    [key: string]: FormValueItemCommands<T, AllowUndefinedValue, ItemType> | undefined;
+export interface PFormValueItemCommandsMap<T, AllowUndefinedValue extends boolean = true, ItemType = any> {
+    [key: string]: PFormValueItemCommands<T, AllowUndefinedValue, ItemType> | undefined;
 }
-export interface FormValueItemProps<T, AllowUndefinedValue extends boolean = true, V = AllowUndefinedValue extends true ? T | undefined : T> extends PartialPick<FormContextValue<T>, 'variant' | 'size' | 'color' | 'focused'> {
+export interface PFormValueItemProps<T, AllowUndefinedValue extends boolean = true, V = AllowUndefinedValue extends true ? T | undefined : T> extends PartialPick<PFormContextValue<T>, 'variant' | 'size' | 'color' | 'focused'> {
     name: string;
     value?: T;
     labelIcon?: string;
@@ -126,7 +126,7 @@ export interface FormValueItemProps<T, AllowUndefinedValue extends boolean = tru
     hidden?: boolean;
     exceptValue?: boolean;
     helperText?: ReactNode;
-    data?: FormValueItemData;
+    data?: PFormValueItemData;
     onChange?(value: V): void;
     onValidate?(value: V): true | string;
 }

package/dist/PForm/PForm.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { PFormProps as Props, PFormCommands } from './PForm.types';
+declare const PForm: React.ForwardRefExoticComponent<Props & React.RefAttributes<PFormCommands>>;
+export default PForm;

package/dist/{Form/Form.types.d.ts → PForm/PForm.types.d.ts}

@@ -1,34 +1,34 @@
 import { ReactNode } from 'react';
 import { FormControlProps, GridProps, InputLabelProps } from '@mui/material';
-import { PartialPick, CommonSxProps, FormValue, FormValueMap, FormValueItemCommands, FormValueItemBaseCommands } from '../@types';
-export interface FormInvalidItemInfo {
+import { PartialPick, PCommonSxProps, PFormValue, PFormValueMap, PFormValueItemCommands, PFormValueItemBaseCommands } from '../@types';
+export interface PFormInvalidItemInfo {
     name: string;
-    commands: FormValueItemCommands<any>;
+    commands: PFormValueItemCommands<any>;
 }
-export type FormInvalidItems = FormInvalidItemInfo[];
-export interface FormProps extends CommonSxProps, PartialPick<FormControlProps, 'variant' | 'size' | 'color' | 'focused'>, PartialPick<GridProps, 'spacing'> {
+export type PFormInvalidItems = PFormInvalidItemInfo[];
+export interface PFormProps extends PCommonSxProps, PartialPick<FormControlProps, 'variant' | 'size' | 'color' | 'focused'>, PartialPick<GridProps, 'spacing'> {
     labelShrink?: InputLabelProps['shrink'];
     fullWidth?: boolean;
     fullHeight?: boolean;
     formColGap?: number;
     disabled?: boolean;
     submitWhenReturnKey?: boolean;
-    onSubmit?(data: FormValueMap): void;
-    onInvalid?(invalidItems: FormInvalidItems): void;
+    onSubmit?(data: PFormValueMap): void;
+    onInvalid?(invalidItems: PFormInvalidItems): void;
     onValueChange?(name: string, value: any): void;
     onValueChangeByUser?(name: string, value: any): void;
 }
-export interface FormCommands {
+export interface PFormCommands {
     submit(): void;
-    getAllFormValue(): FormValueMap;
+    getAllFormValue(): PFormValueMap;
     resetAll(): void;
-    getItem<T extends FormValueItemBaseCommands<any, true> = FormValueItemCommands<any>>(name: string): T | undefined;
+    getItem<T extends PFormValueItemBaseCommands<any, true> = PFormValueItemCommands<any>>(name: string): T | undefined;
     exists(name: string): boolean;
     getReset(name: string): any;
-    getFormReset(name: string, subKey?: string): FormValue;
+    getFormReset(name: string, subKey?: string): PFormValue;
     reset(name: string): void;
     getValue(name: string): any;
-    getFormValue(name: string, subKey?: string): FormValue;
+    getFormValue(name: string, subKey?: string): PFormValue;
     setValue(name: string, value: any): void;
     isExceptValue(name: string): boolean;
     isDisabled(name: string): boolean;

package/dist/PForm/index.d.ts

@@ -0,0 +1,4 @@
+import PForm from './PForm';
+export default PForm;
+export { PForm };
+export * from './PForm.types';

package/dist/{FormCommon/FormButton/FormButton.d.ts → PFormCommon/PFormButton/PFormButton.d.ts}

@@ -1,4 +1,4 @@
 import React from 'react';
-import { FormButtonProps as Props } from './FormButton.types';
+import { PFormButtonProps as Props } from './PFormButton.types';
 declare const _default: React.NamedExoticComponent<Props & React.RefAttributes<HTMLButtonElement>>;
 export default _default;

package/dist/PFormCommon/PFormButton/PFormButton.types.d.ts

@@ -0,0 +1,6 @@
+import { PartialPick } from '../../@types';
+import { PFormContextValue } from '../../PFormContext';
+import { PButtonProps } from '@pdg/react-component';
+export interface PFormButtonProps extends PartialPick<PFormContextValue, 'color' | 'size'>, Omit<PButtonProps, 'color' | 'size'> {
+    type?: 'button' | 'submit';
+}

package/dist/PFormCommon/PFormButton/index.d.ts

@@ -0,0 +1,4 @@
+import PFormButton from './PFormButton';
+export default PFormButton;
+export { PFormButton };
+export * from './PFormButton.types';

package/dist/{FormCommon/FormLabel/FormLabel.d.ts → PFormCommon/PFormLabel/PFormLabel.d.ts}

@@ -1,4 +1,4 @@
 import React from 'react';
-import { FormLabelProps as Props } from './FormLabel.types';
+import { PFormLabelProps as Props } from './PFormLabel.types';
 declare const _default: React.NamedExoticComponent<Omit<Props, "ref"> & React.RefAttributes<HTMLLabelElement>>;
 export default _default;

package/dist/PFormCommon/PFormLabel/PFormLabel.types.d.ts

@@ -0,0 +1,7 @@
+import { InputLabelProps } from '@mui/material';
+import { PartialPick, PartialOmit } from '../../@types';
+import { PFormProps } from '../../PForm';
+export interface PFormLabelProps extends PartialOmit<InputLabelProps, 'size'>, PartialPick<PFormProps, 'size'> {
+    icon?: string;
+    warning?: boolean;
+}

package/dist/PFormCommon/PFormLabel/index.d.ts

@@ -0,0 +1,4 @@
+import PFormLabel from './PFormLabel';
+export default PFormLabel;
+export { PFormLabel };
+export * from './PFormLabel.types';

package/dist/PFormCommon/index.d.ts

@@ -0,0 +1,2 @@
+export * from './PFormButton';
+export * from './PFormLabel';

package/dist/PFormContext/PFormContext.d.ts

@@ -0,0 +1,3 @@
+import { PFormContextValue } from './PFormContext.types';
+declare const PFormContext: import("react").Context<PFormContextValue<any, true>>;
+export default PFormContext;

package/dist/{FormContext/FormContext.types.d.ts → PFormContext/PFormContext.types.d.ts}

@@ -1,17 +1,17 @@
-import { PartialPick, FormValueItemCommands } from '../@types';
-import { FormProps } from '../Form/Form.types';
-export interface FormContextValue<T = any, AllowUndefinedValue extends boolean = true> extends PartialPick<FormProps, 'variant' | 'size' | 'color' | 'spacing' | 'formColGap' | 'focused' | 'labelShrink' | 'fullWidth'> {
+import { PartialPick, PFormValueItemCommands } from '../@types';
+import { PFormProps } from '../PForm/PForm.types';
+export interface PFormContextValue<T = any, AllowUndefinedValue extends boolean = true> extends PartialPick<PFormProps, 'variant' | 'size' | 'color' | 'spacing' | 'formColGap' | 'focused' | 'labelShrink' | 'fullWidth'> {
     id: string;
     fullHeight?: boolean;
     disabled?: boolean;
     submitWhenReturnKey?: boolean;
-    onAddValueItem(id: string, commands: FormValueItemCommands<T, AllowUndefinedValue>): void;
+    onAddValueItem(id: string, commands: PFormValueItemCommands<T, AllowUndefinedValue>): void;
     onRemoveValueItem(id: string): void;
     onValueChange(name: string, value: T): void;
     onValueChangeByUser(name: string, value: T): void;
     onRequestSubmit(name: string, value: T): void;
     onRequestSearchSubmit(name: string, value: T): void;
-    /** FormRow */
+    /** PFormRow */
     formColAutoXs?: number;
     formColWidth?: number;
     onAddFormCol?(id: string, xs: number | undefined): void;
@@ -21,4 +21,4 @@ export interface FormContextValue<T = any, AllowUndefinedValue extends boolean =
     formColWithLabel?: boolean;
     formColWithHelperText?: boolean;
 }
-export declare const FormContextDefaultValue: FormContextValue;
+export declare const PFormContextDefaultValue: PFormContextValue;

package/dist/PFormContext/index.d.ts

@@ -0,0 +1,5 @@
+import PFormContext from './PFormContext';
+export default PFormContext;
+export { PFormContext };
+export * from './PFormContext.types';
+export { default as useFormState } from './useFormState';

package/dist/PFormContext/useFormState.d.ts

@@ -0,0 +1,2 @@
+import { PFormContextValue } from './PFormContext.types';
+export default function useFormState<T, AllowUndefinedValue extends boolean = true>(): PFormContextValue<T, AllowUndefinedValue>;

package/dist/PFormContextProvider/PFormContextProvider.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { PFormContextProviderProps as Props } from './PFormContextProvider.types';
+declare const PFormContextProvider: React.FC<Props>;
+export default PFormContextProvider;

package/dist/PFormContextProvider/PFormContextProvider.types.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode } from 'react';
+import { PFormContextValue } from '../PFormContext';
+export interface PFormContextProviderProps {
+    value: PFormContextValue;
+    children: ReactNode;
+}

package/dist/PFormContextProvider/index.d.ts

@@ -0,0 +1,4 @@
+import PFormContextProvider from './PFormContextProvider';
+export default PFormContextProvider;
+export { PFormContextProvider };
+export * from './PFormContextProvider.types';

package/dist/PFormItemCustom/PFormAutocomplete/PFormAutocomplete.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { PFormAutocompleteProps, PFormAutocompleteCommands, PFormAutocompleteSingleValue } from './PFormAutocomplete.types';
+declare const PFormAutocomplete: (<T extends PFormAutocompleteSingleValue, Multiple extends boolean | undefined>(props: PFormAutocompleteProps<T, Multiple> & React.RefAttributes<PFormAutocompleteCommands<T, Multiple>>) => React.ReactElement | null) & Pick<React.ForwardRefExoticComponent<any>, "displayName" | "propTypes" | "$$typeof">;
+export default PFormAutocomplete;

package/dist/PFormItemCustom/PFormAutocomplete/PFormAutocomplete.types.d.ts

@@ -0,0 +1,40 @@
+import React, { ReactNode } from 'react';
+import { PCommonSxProps, PFormMultipleValueItemCommands } from '../../@types';
+import { PFormArrayValueItemCommands, PFormItemsValueItemCommands, PFormLoadingValueItemCommands, PFormValueItemBaseCommands, PFormValueItemProps } from '../../@types';
+import { PFormTextFieldProps } from '../../PFormItemTextFieldBase';
+export type PFormAutocompleteSingleValue = string | number | boolean;
+export interface PFormAutocompleteItem<T extends PFormAutocompleteSingleValue> {
+    label: ReactNode;
+    value: T;
+    disabled?: boolean;
+    [key: string]: any;
+}
+export type PFormAutocompleteItems<T extends PFormAutocompleteSingleValue> = PFormAutocompleteItem<T>[];
+export type PFormAutocompleteValue<T extends PFormAutocompleteSingleValue, Multiple extends boolean | undefined> = ([Multiple] extends [true] ? T[] : T) | undefined;
+export type PFormAutocompleteComponentValue<T extends PFormAutocompleteSingleValue, Multiple extends boolean | undefined> = ([Multiple] extends [true] ? PFormAutocompleteItem<T>[] : PFormAutocompleteItem<T>) | null;
+export interface PFormAutocompleteProps<T extends PFormAutocompleteSingleValue, Multiple extends boolean | undefined = undefined> extends PCommonSxProps, Omit<PFormValueItemProps<PFormAutocompleteValue<T, Multiple>>, 'value'>, Pick<PFormTextFieldProps<T>, 'required' | 'focused' | 'labelShrink' | 'onFocus' | 'onBlur'> {
+    value?: PFormAutocompleteValue<T, Multiple>;
+    items?: PFormAutocompleteItems<T>;
+    multiple?: Multiple;
+    formValueSeparator?: string;
+    formValueSort?: boolean;
+    loading?: boolean;
+    loadingText?: React.ReactNode;
+    placeholder?: string;
+    disablePortal?: boolean;
+    noOptionsText?: string;
+    limitTags?: number;
+    getLimitTagsText?: (more: number) => ReactNode;
+    openOnFocus?: boolean;
+    disableClearable?: boolean;
+    async?: boolean;
+    onLoadItems?: (inputValue?: string) => Promise<PFormAutocompleteItems<T>>;
+    onAsyncLoadValueItem?: (value: PFormAutocompleteValue<T, Multiple>) => Promise<PFormAutocompleteComponentValue<T, Multiple>>;
+    onRenderItem?: (item: PFormAutocompleteItem<T>) => ReactNode;
+    onRenderTag?: (item: PFormAutocompleteItem<T>) => ReactNode;
+    onValue?: (value: PFormAutocompleteValue<T, Multiple>) => PFormAutocompleteValue<T, Multiple>;
+    onAddItem?: (item: PFormAutocompleteItem<T>) => boolean | Promise<boolean>;
+    getOptionDisabled?: (item: PFormAutocompleteItem<T>) => boolean;
+}
+export interface PFormAutocompleteCommands<T extends PFormAutocompleteSingleValue, Multiple extends boolean | undefined = undefined> extends PFormValueItemBaseCommands<PFormAutocompleteValue<T, Multiple>, true>, PFormArrayValueItemCommands, PFormItemsValueItemCommands<PFormAutocompleteItem<T>>, PFormMultipleValueItemCommands, PFormLoadingValueItemCommands {
+}

package/dist/PFormItemCustom/PFormAutocomplete/index.d.ts

@@ -0,0 +1,4 @@
+import PFormAutocomplete from './PFormAutocomplete';
+export default PFormAutocomplete;
+export { PFormAutocomplete };
+export * from './PFormAutocomplete.types';

package/dist/PFormItemCustom/PFormCheckbox/PFormCheckbox.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { PFormCheckboxProps as Props, PFormCheckboxCommands } from './PFormCheckbox.types';
+declare const PFormCheckbox: React.ForwardRefExoticComponent<Omit<Props, "ref"> & React.RefAttributes<PFormCheckboxCommands>>;
+export default PFormCheckbox;

package/dist/PFormItemCustom/PFormCheckbox/PFormCheckbox.types.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode, RefObject } from 'react';
+import { ButtonBaseActions, CheckboxProps } from '@mui/material';
+import { PCommonSxProps, PFormCheckValueItemCommands, PFormValueItemBaseCommands, PFormValueItemProps } from '../../@types';
+export type PFormCheckboxValue = string | number | boolean;
+export interface PFormCheckboxCommands extends Omit<PFormValueItemBaseCommands<PFormCheckboxValue, false>, 'getReset'>, PFormCheckValueItemCommands<PFormCheckboxValue> {
+    getReset(): boolean;
+}
+export interface PFormCheckboxProps extends PCommonSxProps, Omit<CheckboxProps, 'size' | 'color' | 'name' | 'inputRef' | 'action' | 'required' | 'onChange'>, Omit<PFormValueItemProps<PFormCheckboxValue, false>, 'value' | 'onChange'> {
+    value?: PFormCheckboxValue;
+    uncheckedValue?: PFormCheckboxValue;
+    text?: ReactNode;
+    inputRef?: RefObject<HTMLInputElement>;
+    action?: RefObject<ButtonBaseActions>;
+    onChange?(checked: boolean): void;
+}

package/dist/PFormItemCustom/PFormCheckbox/index.d.ts

@@ -0,0 +1,4 @@
+import PFormCheckbox from './PFormCheckbox';
+export default PFormCheckbox;
+export { PFormCheckbox };
+export * from './PFormCheckbox.types';

package/dist/PFormItemCustom/PFormDatePicker/PFormDatePicker.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { PFormDatePickerProps as Props, PFormDatePickerCommands } from './PFormDatePicker.types';
+declare const PFormDatePicker: React.ForwardRefExoticComponent<Props & React.RefAttributes<PFormDatePickerCommands>>;
+export default PFormDatePicker;

package/dist/PFormItemCustom/PFormDatePicker/PFormDatePicker.types.d.ts

@@ -0,0 +1,6 @@
+import { PrivateDatePickerValue, PrivateDatePickerProps, PrivateDatePickerCommands } from '../../@private';
+export type PFormDatePickerValue = PrivateDatePickerValue;
+export interface PFormDatePickerProps extends Omit<PrivateDatePickerProps, 'type' | 'time' | 'hours' | 'minutes' | 'seconds' | 'minuteInterval' | 'secondInterval'> {
+}
+export interface PFormDatePickerCommands extends PrivateDatePickerCommands {
+}

package/dist/PFormItemCustom/PFormDatePicker/index.d.ts

@@ -0,0 +1,4 @@
+import PFormDatePicker from './PFormDatePicker';
+export default PFormDatePicker;
+export { PFormDatePicker };
+export * from './PFormDatePicker.types';

package/dist/PFormItemCustom/PFormDateRangePicker/PFormDateRangePicker.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { PFormDateRangePickerProps as Props, PFormDateRangePickerCommands } from './PFormDateRangePicker.types';
+declare const PFormDateRangePicker: React.ForwardRefExoticComponent<Props & React.RefAttributes<PFormDateRangePickerCommands>>;
+export default PFormDateRangePicker;