dinocollab-core 1.0.1 → 1.0.3

package/dist/types/api-context/global-modal.d.ts

@@ -0,0 +1,37 @@
+import React, { Component } from 'react';
+import { SxProps } from '@mui/material';
+export interface GlobalModalState {
+    sx?: SxProps;
+    sxWrap?: SxProps;
+    /** @default true */
+    backdropActivated?: boolean;
+    onClose?: (reason?: TModalReason) => void;
+    renderContent?: () => React.ReactNode;
+}
+export type TModalReason = 'backdropClick' | 'escapeKeyDown';
+interface GlobalModalProps {
+}
+export type TShowModal = (value: GlobalModalState) => void;
+export type TCloseModal = (event?: {}, reason?: TModalReason) => void;
+export interface IGlobalModalContext {
+    show: TShowModal;
+    close: TCloseModal;
+}
+export declare const GlobalModalContext: React.Context<IGlobalModalContext>;
+export interface IMapGlobalModal {
+    context: IGlobalModalContext;
+}
+export declare const MapGlobalModalContext: (context: (state: IGlobalModalContext) => React.ReactNode) => import("react/jsx-runtime").JSX.Element;
+declare class GlobalModal extends Component<React.PropsWithChildren<GlobalModalProps>, GlobalModalState> implements IGlobalModalContext {
+    constructor(props: any);
+    show: TShowModal;
+    close: TCloseModal;
+    render(): import("react/jsx-runtime").JSX.Element;
+    renderContent: () => React.ReactNode;
+}
+export default GlobalModal;
+export interface IApiGlobalModalContextProps {
+    contextGlobalModal: IGlobalModalContext;
+}
+export declare const withApiGlobalModalContext: <P extends IApiGlobalModalContextProps>(Component: React.ComponentType<P>) => (props: Omit<P, "contextGlobalModal">) => import("react/jsx-runtime").JSX.Element;
+export declare const withApiGlobalModalConsumerContext: <P extends IApiGlobalModalContextProps>(Component: React.ComponentType<P>) => (props: Omit<P, "contextGlobalModal">) => import("react/jsx-runtime").JSX.Element;

package/dist/types/api-context/index.d.ts

@@ -0,0 +1,9 @@
+export { default as ApiPopover } from './popover';
+export * from './popover';
+export { default as AlertGlobal } from './alert-global';
+export * from './alert-global';
+export { default as DrawerGlobal } from './drawer-global';
+export { default as GlobalModal } from './global-modal';
+export * from './global-modal';
+export { default as PopoverGlobal } from './popover-global';
+export * from './popover-global';

package/dist/types/api-context/popover-global.d.ts

@@ -0,0 +1,37 @@
+import React, { Component, PropsWithChildren } from 'react';
+import { PopoverProps, PopoverVirtualElement } from '@mui/material';
+export interface PopoverGlobalState {
+    anchorEl?: Element | (() => Element) | PopoverVirtualElement | (() => PopoverVirtualElement) | null;
+    popoverProps?: Omit<PopoverProps, 'open'>;
+    content: React.ReactNode;
+}
+export type OpenPopover = (value: PopoverGlobalState) => void;
+export type ClosePopover = (reason?: 'backdropClick' | 'escapeKeyDown') => void;
+export interface PopoverGlobalContext {
+    open: OpenPopover;
+    close: ClosePopover;
+}
+export declare const PopoverGlobalApi: PopoverGlobalContext;
+export declare const PopoverGlobalContext: React.Context<PopoverGlobalContext>;
+export declare const MapPopoverGlobalContext: (context: (state: PopoverGlobalContext) => React.ReactNode) => import("react/jsx-runtime").JSX.Element;
+interface IProps extends PropsWithChildren {
+}
+export declare class PopoverGlobalProvider extends Component<IProps, PopoverGlobalState> {
+    constructor(props: any);
+    componentDidMount(): void;
+    render(): import("react/jsx-runtime").JSX.Element;
+    openPopover: OpenPopover;
+    timer: any;
+    closePopover: ClosePopover;
+}
+export interface IPopoverGlobalContextProps {
+    contextPopover: PopoverGlobalContext;
+}
+export declare const withPopoverGlobalContext: <P extends IPopoverGlobalContextProps>(Component: React.ComponentType<P>) => (props: Omit<P, "contextPopover">) => import("react/jsx-runtime").JSX.Element;
+declare const PopoverGlobal: {
+    Provider: typeof PopoverGlobalProvider;
+    Api: PopoverGlobalContext;
+    Context: React.Context<PopoverGlobalContext>;
+    mapContext: (context: (state: PopoverGlobalContext) => React.ReactNode) => import("react/jsx-runtime").JSX.Element;
+};
+export default PopoverGlobal;

package/dist/types/api-context/popover.d.ts

@@ -0,0 +1,32 @@
+import React, { Component } from 'react';
+import { PopoverProps, PopoverVirtualElement } from '@mui/material';
+export interface IPopoverOptions {
+    anchorEl?: Element | (() => Element) | PopoverVirtualElement | (() => PopoverVirtualElement) | null;
+    popoverProps?: Omit<PopoverProps, 'open'>;
+    content: React.ReactNode;
+}
+export type TShowPopover = (option: IPopoverOptions) => void;
+export type TClosePopover = (reason?: 'backdropClick' | 'escapeKeyDown') => void;
+export interface IApiPopoverContext {
+    showPopover: TShowPopover;
+    closePopover: TClosePopover;
+}
+export declare const ApiPopoverContext: React.Context<IApiPopoverContext>;
+export declare const MapApiPopoverContext: (context: (state: IApiPopoverContext) => React.ReactNode) => import("react/jsx-runtime").JSX.Element;
+interface IProps {
+}
+interface IState extends IPopoverOptions {
+}
+type TProps = React.PropsWithChildren<IProps>;
+declare class ApiPopover extends Component<TProps, IState> implements IApiPopoverContext {
+    constructor(props: any);
+    render(): import("react/jsx-runtime").JSX.Element;
+    showPopover: (option: IPopoverOptions) => void;
+    timer: any;
+    closePopover: TClosePopover;
+}
+export default ApiPopover;
+export interface IApiPopoverContextProps {
+    contextPopover: IApiPopoverContext;
+}
+export declare const withApiPopoverContext: <P extends IApiPopoverContextProps>(Component: React.ComponentType<P>) => (props: Omit<P, "contextPopover">) => import("react/jsx-runtime").JSX.Element;

package/dist/types/api-context/ui.units.d.ts

@@ -0,0 +1,2 @@
+import { FC } from 'react';
+export declare const ContentDefault: FC;

package/dist/types/components/breadcrumbs.d.ts

@@ -0,0 +1,13 @@
+import React, { FC } from 'react';
+import { TypographyProps } from '@mui/material';
+export interface IBreadcrumbConfig {
+    label: string;
+    url?: string;
+    propsGetter?: () => TypographyProps;
+    onClick?: (event: React.MouseEvent<HTMLDivElement, MouseEvent>) => void;
+}
+export interface IBreadcrumbsProps {
+    value?: IBreadcrumbConfig[];
+}
+declare const Breadcrumbs: FC<IBreadcrumbsProps>;
+export default Breadcrumbs;

package/dist/types/components/copy-to-clipboard.d.ts

@@ -0,0 +1,26 @@
+import { Component, ComponentType } from 'react';
+import { ButtonProps, TooltipProps } from '@mui/material';
+export interface ICopyToClipboardProps {
+    value: string;
+    slots?: {
+        tooltipProps?: Partial<TooltipProps>;
+        button?: ComponentType<{
+            onClick: () => void;
+            copied?: boolean;
+        }>;
+        buttonProps?: ButtonProps;
+    };
+}
+export interface ICopyToClipboardState {
+    showTooltip: boolean;
+    copied: boolean;
+}
+declare class CopyToClipboard extends Component<ICopyToClipboardProps, ICopyToClipboardState> {
+    constructor(props: ICopyToClipboardProps);
+    render(): import("react/jsx-runtime").JSX.Element;
+    renderIcon: () => import("react/jsx-runtime").JSX.Element;
+    handleClickCopy: () => void;
+    private debounceTime;
+    private onCopy;
+}
+export default CopyToClipboard;

package/dist/types/components/help-tooltip.d.ts

@@ -0,0 +1,15 @@
+import React, { FC, PropsWithChildren, ReactNode } from 'react';
+import { SxProps, Theme } from '@mui/material';
+export interface IHelpTooltipProps {
+    title: string;
+    small?: boolean;
+    sxIcon?: SxProps<Theme>;
+}
+declare const HelpTooltip: FC<PropsWithChildren<IHelpTooltipProps>>;
+export default HelpTooltip;
+export interface IHelpTooltipWrapProps {
+    content: ReactNode;
+    title: string;
+    children: React.ReactNode;
+}
+export declare const HelpTooltipWrap: FC<IHelpTooltipWrapProps>;

package/dist/types/components/image-with-fallback.d.ts

@@ -0,0 +1,13 @@
+import React, { FC, ReactNode } from 'react';
+export interface IImageWithFallbackPropsOwner {
+    src?: string;
+    alt?: string;
+    fallbackSrc: string;
+    loading?: ReactNode;
+    debounceDelay?: number;
+}
+export type IImageProps = Omit<React.ImgHTMLAttributes<HTMLImageElement>, keyof IImageWithFallbackPropsOwner>;
+export interface IImageWithFallbackProps extends IImageProps, IImageWithFallbackPropsOwner {
+}
+declare const ImageWithFallback: FC<IImageWithFallbackProps>;
+export default ImageWithFallback;

package/dist/types/components/index.d.ts

@@ -0,0 +1,11 @@
+export { default as Breadcrumbs } from './breadcrumbs';
+export * from './breadcrumbs';
+export { default as CopyToClipboard } from './copy-to-clipboard';
+export * from './copy-to-clipboard';
+export { default as ImageWithFallback } from './image-with-fallback';
+export * from './image-with-fallback';
+export { default as HelpTooltip } from './help-tooltip';
+export * from './help-tooltip';
+export { default as TextEditorPreview } from './text-editor.preview';
+export { default as TextEditor } from './text-editor';
+export * from './text-editor';

package/dist/types/components/input-debounce-timer.d.ts

@@ -0,0 +1,9 @@
+import { FC } from 'react';
+export interface IInputDebounceTimerProps {
+    value?: string;
+    onChange?: (value: string) => void;
+    placeholder?: string;
+    disabledTimer?: boolean;
+}
+declare const InputDebounceTimer: FC<IInputDebounceTimerProps>;
+export default InputDebounceTimer;

package/dist/types/components/loading-buttons.d.ts

@@ -0,0 +1,6 @@
+import { FC } from 'react';
+import { ButtonProps } from '@mui/material';
+export interface LoadingButtonProps extends ButtonProps {
+    loading?: boolean;
+}
+export declare const LoadingButton: FC<LoadingButtonProps>;

package/dist/types/components/text-editor.d.ts

@@ -0,0 +1,26 @@
+import { Component } from 'react';
+import { SxProps, Theme } from '@mui/material';
+import 'react-quill/dist/quill.snow.css';
+export declare const textEditorClasses: {
+    root: string;
+    fullscreen: string;
+};
+export interface ITextEditorProps {
+    id?: string;
+    name: string;
+    sx?: SxProps<Theme>;
+    readOnly?: boolean;
+    defautValue?: string;
+    error?: boolean;
+    onBlur?: () => void;
+}
+export interface ITextEditorState {
+    value: string;
+}
+declare class TextEditor extends Component<ITextEditorProps, ITextEditorState> {
+    constructor(props: ITextEditorProps);
+    handleChange: (value: string) => void;
+    id: number;
+    render(): import("react/jsx-runtime").JSX.Element;
+}
+export default TextEditor;

package/dist/types/components/text-editor.preview.d.ts

@@ -0,0 +1,5 @@
+import { FC } from 'react';
+declare const TextEditorPreview: FC<{
+    children: string;
+}>;
+export default TextEditorPreview;

package/dist/types/form/create.autocomplete.chips.d.ts

@@ -0,0 +1,16 @@
+import { ComponentType } from 'react';
+import { IFormInputBase } from './types';
+export interface IAutocompleteChipParams {
+    optionItems?: string[];
+    limitTags?: number;
+    separator?: string;
+    saveLocalStorageByKey?: string;
+}
+export interface IAutocompleteChipProps<T> extends IFormInputBase<T, IAutocompleteChipParams> {
+}
+export interface IAutocompleteChipState {
+    value: string[];
+    options: string[];
+}
+declare function CreateAutocompleteChip<T>(params?: IAutocompleteChipParams): ComponentType<IAutocompleteChipProps<T>>;
+export default CreateAutocompleteChip;

package/dist/types/form/create.date-expired.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import { TextFieldProps } from '@mui/material';
+import { IFormInputBase } from './types';
+export interface IDateExpiredSlots<T> {
+    /** @default string */
+    type?: 'number' | 'string';
+    textFieldProps?: Partial<TextFieldProps>;
+    switchChecked?: boolean;
+    switchCheckedGetter?: (value: any, model?: Partial<T>) => boolean;
+}
+export interface IDateExpiredProps<T> extends IFormInputBase<T> {
+    slots?: IDateExpiredSlots<T>;
+}
+export interface IDateExpiredState {
+    numberOfDays: number;
+    switchChecked: boolean;
+}
+declare function CreateDateExpired<T>(params?: IDateExpiredSlots<T>): React.ComponentType<IDateExpiredProps<T>>;
+export default CreateDateExpired;

package/dist/types/form/create.date-picker.d.ts

@@ -0,0 +1,19 @@
+import React, { ComponentType } from 'react';
+import { Dayjs } from 'dayjs';
+import { DatePickerProps } from '@mui/x-date-pickers';
+import { IFormInputBase } from './types';
+export interface IDatePickerSlots {
+    defaultValue?: string;
+    minDate?: Dayjs;
+    minDateOffset?: number;
+    datePickerProps?: DatePickerProps<Dayjs>;
+}
+export interface IDatePickerProps<T> extends IFormInputBase<T> {
+    format?: string;
+    slots?: Omit<IDatePickerSlots, 'defaultValue'>;
+}
+export interface IDatePickerState {
+    value: Dayjs | null;
+}
+declare const CreateDatePicker: <T extends Object>(params?: IDatePickerSlots) => React.ComponentType<IDatePickerProps<T>>;
+export default CreateDatePicker;

package/dist/types/form/create.form-base.d.ts

@@ -0,0 +1,30 @@
+import React, { ComponentType, PropsWithChildren } from 'react';
+import { SxProps, Theme } from '@mui/material';
+import { IFormBase } from './types';
+import FormValidator, { IPartialError } from './validator';
+export interface FormBaseParam<TModel> {
+    validate?: FormValidator<Partial<TModel>>;
+}
+export interface FormBaseProps<TModel> extends PropsWithChildren {
+    sx?: SxProps<Theme>;
+    validate?: FormValidator<Partial<TModel>>;
+    onSubmit: (data: Partial<TModel>, e: React.FormEvent<HTMLFormElement>) => Promise<void>;
+}
+export interface FormBaseState<TModel> extends Pick<IFormBase<TModel>, 'messageErrors'> {
+    modelState?: Partial<TModel>;
+}
+export interface IFormContextBase<TModel> {
+    modelState?: Partial<TModel>;
+    messageErrors: IPartialError<TModel>;
+    onBlur: (keyName: keyof TModel) => void;
+    setError: (keyName: keyof TModel, message: string) => void;
+    clearErrorAll: (keyName: keyof TModel) => void;
+}
+export interface FormBaseResult<TModel> {
+    Form: ComponentType<FormBaseProps<TModel>>;
+    Validator?: FormValidator<Partial<TModel>>;
+    Context: React.Context<IFormContextBase<TModel>>;
+    contextMapping: (params: (context: IFormContextBase<TModel>) => JSX.Element) => JSX.Element;
+}
+declare const CreateFormBase: <TModel>(param?: FormBaseParam<TModel> | undefined) => FormBaseResult<TModel>;
+export default CreateFormBase;

package/dist/types/form/create.form-comfirm.d.ts

@@ -0,0 +1,20 @@
+import React, { ComponentType } from 'react';
+export interface IFormComfirmParam<T> {
+    title?: string;
+    content: (value?: T) => JSX.Element;
+    colors?: {
+        yes?: 'inherit' | 'error' | 'primary' | 'secondary' | 'success' | 'info' | 'warning';
+        no?: 'inherit' | 'error' | 'primary' | 'secondary' | 'success' | 'info' | 'warning';
+    };
+}
+export interface IFormComfirmProps<T> {
+    data?: T;
+    title?: string;
+    onSubmit: (value?: T) => Promise<void>;
+    onCancel?: () => void;
+}
+export interface IFormComfirmState {
+    loading?: boolean;
+}
+declare const CreateFormComfirm: <T = any>(param?: IFormComfirmParam<T> | undefined) => React.ComponentType<React.PropsWithChildren<IFormComfirmProps<T>>>;
+export default CreateFormComfirm;

package/dist/types/form/create.form-grid-layout.d.ts

@@ -0,0 +1,44 @@
+import React, { ComponentType } from 'react';
+import { BoxProps, RegularBreakpoints, SxProps, Theme } from '@mui/material';
+import { IFormBase, IFormInputBase } from './types';
+import FormValidator from './validator';
+export interface IFormGridLayoutConfig<T> {
+    key: keyof T;
+    label?: string;
+    placeholder?: string;
+    reponsives?: RegularBreakpoints;
+    defaultValue?: any;
+    inputElement?: React.ComponentType<IFormInputBase<T>>;
+}
+export type SubmitMappingEvent<T> = (value: Partial<T>, oldValue?: T) => Partial<T>;
+export interface IFormGridLayoutSlots<T> {
+    action?: React.ComponentType<IFormBase<T>>;
+    actionBefore?: JSX.Element;
+    contentBefore?: JSX.Element;
+    contentAfter?: JSX.Element;
+    inputVisibility?: Partial<Record<keyof T, boolean>>;
+    inputDisabled?: Partial<Record<keyof T, boolean>>;
+    closeState?: {
+        Success?: boolean;
+        Fail?: boolean;
+    };
+    contentProps?: BoxProps;
+}
+export interface IFormGridLayoutParams<T> extends IFormGridLayoutSlots<T> {
+    configs: IFormGridLayoutConfig<T>[];
+    validate: FormValidator<Partial<T>>;
+    submitMapping?: SubmitMappingEvent<T>;
+}
+export interface IFormGridLayoutProps<T> {
+    data?: T;
+    onSubmit: (value: Partial<T>, signal?: AbortSignal) => Promise<void>;
+    onError?: (error: any) => void;
+    onClose?: () => void;
+    sx?: SxProps<Theme>;
+    slots?: IFormGridLayoutSlots<T>;
+}
+export interface IFormGridLayoutState {
+    loadding?: boolean;
+}
+declare const CreateFormGridLayout: <T>(params: IFormGridLayoutParams<T>) => React.ComponentType<IFormGridLayoutProps<T>>;
+export default CreateFormGridLayout;

package/dist/types/form/create.form-grid-layout.units.d.ts

@@ -0,0 +1,8 @@
+import React, { ReactNode } from 'react';
+import { IFormBase } from './types';
+export declare const ContentWrap: StyledComponent<ComponentProps, SpecificComponentProps, JSXProps>;
+export interface IFormBottomBarProps<T> extends IFormBase<T> {
+    before?: ReactNode;
+}
+export declare function CreateFormBottomBar<T>(): React.FC<IFormBottomBarProps<T>>;
+export declare const FormBottomBarWrap: StyledComponent<ComponentProps, SpecificComponentProps, JSXProps>;

package/dist/types/form/create.input.d.ts

@@ -0,0 +1,29 @@
+import React, { ComponentType } from 'react';
+import { TextFieldProps } from '@mui/material';
+import { IFormInputBase } from './types';
+import { IImageWithFallbackPropsOwner } from '../components';
+export interface InputBaseImage<T> extends Partial<IImageWithFallbackPropsOwner> {
+    srcValue?: (value: any, model?: Partial<T>) => string;
+    element?: React.ComponentType<{
+        value: any;
+        model?: Partial<T>;
+    }>;
+    mirror?: boolean;
+}
+export interface IInputSlots<T> {
+    maxLength?: number;
+    textFieldProps?: TextFieldProps;
+    pastenable?: boolean;
+    imageLeft?: InputBaseImage<T>;
+    imageRight?: InputBaseImage<T>;
+}
+export interface IInputProps<T> extends IFormInputBase<T> {
+    slots?: IInputSlots<T>;
+}
+export interface IInputState {
+    value?: string;
+}
+export interface IInputParams<T> extends IInputSlots<T> {
+}
+declare const CreateInput: <T>(params?: IInputParams<T> | undefined) => React.ComponentType<IInputProps<T>>;
+export default CreateInput;

package/dist/types/form/create.input.file.d.ts

@@ -0,0 +1,16 @@
+import { ComponentType } from 'react';
+import { TextFieldProps } from '@mui/material';
+import { IFormInputBase } from './types';
+export interface IInputFileProps<T> extends IFormInputBase<T> {
+    accept?: string;
+    multiple?: boolean;
+    textFieldProps?: TextFieldProps;
+}
+export interface IInputFileState {
+}
+export interface IInputFileParams {
+    accept?: string;
+    multiple?: boolean;
+}
+declare function CreateInputFile<T>(params?: IInputFileParams): ComponentType<IFormInputBase<T>>;
+export default CreateInputFile;

package/dist/types/form/create.select-simple.d.ts

@@ -0,0 +1,24 @@
+import { ComponentType } from 'react';
+import { SelectProps } from '@mui/material';
+import { IFormInputBase } from './types';
+export interface ISelectSimpleOption<T extends string = string> {
+    name: string;
+    value: T;
+}
+export interface ISelectSimpleSlots {
+    selectProps?: Omit<SelectProps, 'variant'>;
+}
+export interface ISelectSimpleProps<T> extends Partial<IFormInputBase<T>> {
+    options?: ISelectSimpleOption[];
+    onChange?: (value: ISelectSimpleOption) => void;
+    slots?: ISelectSimpleSlots;
+    fullWidth?: boolean;
+}
+export interface ISelectSimpleState {
+    value?: string;
+}
+export interface ISelectSimpleParams extends ISelectSimpleSlots {
+    options?: ISelectSimpleOption[];
+}
+declare function CreateSelectSimple<T>(args?: ISelectSimpleParams): ComponentType<ISelectSimpleProps<T>>;
+export default CreateSelectSimple;

package/dist/types/form/create.select-with-api.d.ts

@@ -0,0 +1,29 @@
+import React, { ComponentType } from 'react';
+import { TextFieldProps } from '@mui/material';
+import { IFormInputBase } from './types';
+export interface ISelectWithApiOption<TOther = any> {
+    Id: string;
+    Name?: string;
+    Other?: TOther;
+}
+export interface ISelectWithApiPropsSlots {
+    textFieldProps: TextFieldProps;
+}
+export type ISelectWithApiFetchData<O extends ISelectWithApiOption> = (value?: string, signal?: AbortSignal) => Promise<O[]>;
+export interface ISelectWithApiProps<T, O extends ISelectWithApiOption> extends IFormInputBase<T>, ISelectWithApiParams<O> {
+    onChange?: (value: O | null) => void;
+    existedIds?: string[];
+    slots?: ISelectWithApiPropsSlots;
+}
+export interface ISelectWithApiState<O extends ISelectWithApiOption> {
+    options: O[];
+    statusText?: string;
+    optionSelected: O | null;
+    inputValue: string;
+    loading?: boolean;
+}
+export interface ISelectWithApiParams<O extends ISelectWithApiOption> {
+    fetchData?: ISelectWithApiFetchData<O>;
+}
+declare const CreateSelectWithApi: <T, O extends ISelectWithApiOption<any> = ISelectWithApiOption<any>>(params?: ISelectWithApiParams<O> | undefined) => React.ComponentType<ISelectWithApiProps<T, O>>;
+export default CreateSelectWithApi;

package/dist/types/form/create.text-editor.d.ts

@@ -0,0 +1,42 @@
+import React from 'react';
+import { IFormInputBase } from './types';
+export interface ITextEditorParams {
+    id: string;
+    title: string;
+}
+export interface ITextEditorProps<T> extends IFormInputBase<T> {
+}
+export interface ITextEditorState {
+    isFullscreen: boolean;
+}
+declare function CreateTextEditor<T>(params: ITextEditorParams): {
+    new (props: ITextEditorProps<T>): {
+        contentRef: React.RefObject<HTMLDivElement | null>;
+        componentDidMount(): void;
+        componentWillUnmount(): void;
+        handleFullscreenChange: () => void;
+        handleFullscreenToggle: () => void;
+        getWrapClasses: () => string;
+        render(): import("react/jsx-runtime").JSX.Element;
+        context: unknown;
+        setState<K extends "isFullscreen">(state: ITextEditorState | ((prevState: Readonly<ITextEditorState>, props: Readonly<ITextEditorProps<T>>) => ITextEditorState | Pick<ITextEditorState, K> | null) | Pick<ITextEditorState, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<ITextEditorProps<T>>;
+        state: Readonly<ITextEditorState>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        shouldComponentUpdate?(nextProps: Readonly<ITextEditorProps<T>>, nextState: Readonly<ITextEditorState>, nextContext: any): boolean;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<ITextEditorProps<T>>, prevState: Readonly<ITextEditorState>): any;
+        componentDidUpdate?(prevProps: Readonly<ITextEditorProps<T>>, prevState: Readonly<ITextEditorState>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<ITextEditorProps<T>>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<ITextEditorProps<T>>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<ITextEditorProps<T>>, nextState: Readonly<ITextEditorState>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<ITextEditorProps<T>>, nextState: Readonly<ITextEditorState>, nextContext: any): void;
+    };
+    contextType?: React.Context<any> | undefined;
+};
+export default CreateTextEditor;

package/dist/types/form/dino-form.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="react" />
+import FormValidator from './validator';
+import CreateInputFile from './create.input.file';
+import CreateTextEditor from './create.text-editor';
+import CreateDateExpired from './create.date-expired';
+import CreateSelectSimple from './create.select-simple';
+import CreateAutocompleteChip from './create.autocomplete.chips';
+declare class DinoFormBase {
+    ModalWrap: import("react").FC<import("./modal-wrapper").IFormModalWrapperProps>;
+    BottomBarWrap: StyledComponent<ComponentProps, SpecificComponentProps, JSXProps>;
+    FormValidator: typeof FormValidator;
+    validator: <T>(configs: import("./validator").IFormValidatorConfig<T>) => FormValidator<T>;
+    createFormBase: <TModel>(param?: import("./create.form-base").FormBaseParam<TModel> | undefined) => import("./create.form-base").FormBaseResult<TModel>;
+    createFormComfirm: <T = any>(param?: import("./create.form-comfirm").IFormComfirmParam<T> | undefined) => import("react").ComponentType<import("react").PropsWithChildren<import("./create.form-comfirm").IFormComfirmProps<T>>>;
+    createFormGridLayout: <T>(params: import("./create.form-grid-layout").IFormGridLayoutParams<T>) => import("react").ComponentType<import("./create.form-grid-layout").IFormGridLayoutProps<T>>;
+    createDateExpired: typeof CreateDateExpired;
+    createDatePicker: <T extends Object>(params?: import("./create.date-picker").IDatePickerSlots | undefined) => import("react").ComponentType<import("./create.date-picker").IDatePickerProps<T>>;
+    createAutocompleteChip: typeof CreateAutocompleteChip;
+    createInput: <T>(params?: import("./create.input").IInputParams<T> | undefined) => import("react").ComponentType<import("./create.input").IInputProps<T>>;
+    createInputFile: typeof CreateInputFile;
+    createSelectSimple: typeof CreateSelectSimple;
+    createSelectWithApi: <T, O extends import("./create.select-with-api").ISelectWithApiOption<any> = import("./create.select-with-api").ISelectWithApiOption<any>>(params?: import("./create.select-with-api").ISelectWithApiParams<O> | undefined) => import("react").ComponentType<import("./create.select-with-api").ISelectWithApiProps<T, O>>;
+    createTextEditor: typeof CreateTextEditor;
+}
+declare const DinoForm: DinoFormBase;
+export default DinoForm;

package/dist/types/form/helper.d.ts

@@ -0,0 +1,14 @@
+import { AxiosError } from 'axios';
+import FormValidator, { IModelError, IPartialError } from './validator';
+export declare const getErrorMessage: <TModel>(MessageErrors: IPartialError<TModel> | undefined, key?: keyof TModel | undefined) => IModelError;
+type IModelBase = {
+    [key: string]: any;
+};
+export declare const convertFormDataToJson: <TModel>(form: FormData) => Partial<TModel>;
+export declare const SingleValidate: <TModel, TPartial = TModel>(key: keyof TModel, modelState: TPartial, MessageErrors: IPartialError<TModel>, Validator: FormValidator<TPartial>) => {
+    [key: string]: any;
+} | null;
+export declare const getErrorFromResponse: <TModel>(error: AxiosError, ModelRender: TModel) => IPartialError<TModel> | undefined;
+export declare const clearFieldEmpty: <TModel>(model: Extract<TModel, IModelBase>) => void;
+export declare const validateMerge: <TModel>(...validateor: (FormValidator<TModel> | undefined)[]) => FormValidator<TModel>;
+export {};

package/dist/types/form/index.d.ts

@@ -0,0 +1,7 @@
+export * from './types';
+export { default as FormValidator } from './validator';
+export * from './validator';
+export { default as DinoForm } from './dino-form';
+export { getErrorMessage, convertFormDataToJson } from './helper';
+export type { ISelectWithApiOption } from './create.select-with-api';
+export type { InputBaseImage } from './create.input';

package/dist/types/form/modal-wrapper.d.ts

@@ -0,0 +1,14 @@
+import { FC, PropsWithChildren } from 'react';
+import { Breakpoint, SxProps, Theme } from '@mui/material';
+export interface IFormModalWrapperProps extends PropsWithChildren {
+    title: string;
+    size?: Breakpoint;
+    fullHeight?: boolean;
+    onCloseClick?: () => void;
+    slots?: {
+        sxTopbarProps?: SxProps<Theme>;
+        beforeTitle?: JSX.Element;
+    };
+}
+declare const FormModalWrapper: FC<IFormModalWrapperProps>;
+export default FormModalWrapper;