adminizer 4.6.0 → 4.7.0-build.221

package/helpers/inertiaAddHelper.d.ts

@@ -1,4 +1,4 @@
-import { Entity, PropsField } from "../interfaces/types";
+import { ModelResource, PropsField } from "../interfaces/types";
 import { Actions } from "./inertiaActionsHelper";
 import { Fields, Field } from "./fieldsHelper";
 import { AbstractControls, ControlType } from "../lib/controls/AbstractControls";
@@ -22,422 +22,11 @@ interface FieldProps extends Record<string | number | symbol, unknown> {
     };
     postLink: string;
     model: string;
-    historyTableMessages: Record<string, string>;
 }
-export default function inertiaAddHelper(req: ReqType, entity: Entity, fields: Fields, record?: Record<string, string | boolean | number | string[]>, view?: boolean): FieldProps;
+export default function inertiaAddHelper(req: ReqType, modelResource: ModelResource, fields: Fields, record?: Record<string, string | boolean | number | string[]>, view?: boolean): FieldProps;
 export declare function getControlsOptions(fieldConfig: Field["config"], req: ReqType, type: ControlType, defaultControlName: string): {
     name: string;
-    config: {
-        el?: HTMLElement;
-        height?: string;
-        minHeight?: string;
-        initialValue?: string;
-        previewStyle?: import("@toast-ui/editor/types/editor").PreviewStyle;
-        initialEditType?: import("@toast-ui/editor/types/editor").EditorType;
-        events?: import("@toast-ui/editor/types/editor").EventMap;
-        hooks?: import("@toast-ui/editor/types/editor").HookMap;
-        language?: string;
-        useCommandShortcut?: boolean;
-        usageStatistics?: boolean;
-        toolbarItems?: (string | import("@toast-ui/editor/types/ui").ToolbarItemOptions)[][];
-        hideModeSwitch?: boolean;
-        plugins?: import("@toast-ui/editor/types/editor").EditorPlugin[];
-        extendedAutolinks?: import("@toast-ui/editor/types/editor").ExtendedAutolinks;
-        placeholder?: string;
-        linkAttributes?: import("@toast-ui/editor/types/editor").LinkAttributes;
-        customHTMLRenderer?: import("@toast-ui/editor/types/editor").CustomHTMLRenderer;
-        customMarkdownRenderer?: import("@toast-ui/editor/types/convertor").ToMdConvertorMap;
-        referenceDefinition?: boolean;
-        customHTMLSanitizer?: import("@toast-ui/editor/types/editor").Sanitizer;
-        previewHighlight?: boolean;
-        frontMatter?: boolean;
-        widgetRules?: import("@toast-ui/editor/types/editor").WidgetRule[];
-        theme?: string;
-        autofocus?: boolean;
-        viewer?: boolean;
-    } | {
-        items: string[];
-    } | {
-        [x: string]: string | number | boolean | object | string[] | Record<string, unknown>;
-    } | {
-        activeHeaderClassName?: string;
-        allowEmpty?: boolean;
-        allowHtml?: boolean;
-        allowInsertColumn?: boolean;
-        allowInsertRow?: boolean;
-        allowInvalid?: boolean;
-        allowRemoveColumn?: boolean;
-        allowRemoveRow?: boolean;
-        ariaTags?: boolean;
-        autoColumnSize?: import("handsontable/plugins/autoColumnSize").Settings;
-        autoRowSize?: import("handsontable/plugins/autoRowSize").Settings;
-        autoWrapCol?: boolean;
-        autoWrapRow?: boolean;
-        bindRowsWithHeaders?: import("handsontable/plugins/bindRowsWithHeaders").Settings;
-        cell?: import("handsontable/settings").CellSettings[];
-        cells?: (this: import("handsontable/settings").CellProperties, row: number, column: number, prop: string | number) => import("handsontable/settings").CellMeta;
-        checkedTemplate?: boolean | string | number;
-        className?: string | string[];
-        colHeaders?: boolean | string[] | ((index: number) => string);
-        collapsibleColumns?: import("handsontable/plugins/collapsibleColumns").Settings;
-        columnHeaderHeight?: number | Array<number | undefined>;
-        columns?: import("handsontable/settings").ColumnSettings[] | ((index: number) => import("handsontable/settings").ColumnSettings);
-        columnSorting?: import("handsontable/plugins/columnSorting").Settings;
-        columnSummary?: import("handsontable/plugins/columnSummary").Settings;
-        colWidths?: number | string | number[] | string[] | undefined[] | Array<number | string | undefined> | ((index: number) => string | number | undefined);
-        commentedCellClassName?: string;
-        comments?: import("handsontable/plugins/comments").Settings;
-        contextMenu?: import("handsontable/plugins/contextMenu").Settings;
-        copyable?: boolean;
-        copyPaste?: import("handsontable/plugins/copyPaste").Settings;
-        correctFormat?: boolean;
-        currentColClassName?: string;
-        currentHeaderClassName?: string;
-        currentRowClassName?: string;
-        customBorders?: import("handsontable/plugins/customBorders").Settings;
-        data?: import("handsontable/common").CellValue[][] | import("handsontable/common").RowObject[];
-        dataDotNotation?: boolean;
-        dataSchema?: import("handsontable/common").RowObject | import("handsontable/common").CellValue[] | ((row: number) => import("handsontable/common").RowObject | import("handsontable/common").CellValue[]);
-        dateFormat?: string;
-        datePickerConfig?: import("@handsontable/pikaday").PikadayOptions;
-        defaultDate?: string;
-        tabNavigation?: boolean;
-        disableVisualSelection?: boolean | "current" | "area" | "header" | Array<"current" | "area" | "header">;
-        dragToScroll?: import("handsontable/plugins/dragToScroll").Settings;
-        dropdownMenu?: import("handsontable/plugins/dropdownMenu").Settings;
-        editor?: import("handsontable/editors").EditorType | typeof import("handsontable/editors").BaseEditor | boolean | string;
-        enterBeginsEditing?: boolean;
-        enterMoves?: import("handsontable/3rdparty/walkontable/src/cell/coords").default | import("handsontable/common").SimpleCellCoords | ((event: KeyboardEvent) => import("handsontable/3rdparty/walkontable/src/cell/coords").default | import("handsontable/common").SimpleCellCoords);
-        fillHandle?: import("handsontable/plugins/autofill").Settings;
-        filter?: boolean;
-        filteringCaseSensitive?: boolean;
-        filters?: import("handsontable/plugins/filters").Settings;
-        fixedColumnsLeft?: number;
-        fixedColumnsStart?: number;
-        fixedRowsBottom?: number;
-        fixedRowsTop?: number;
-        formulas?: import("handsontable/plugins/formulas").Settings;
-        fragmentSelection?: boolean | "cell";
-        headerClassName?: string;
-        height?: number | string | (() => number | string);
-        hiddenColumns?: import("handsontable/plugins/hiddenColumns").Settings;
-        hiddenRows?: import("handsontable/plugins/hiddenRows").Settings;
-        invalidCellClassName?: string;
-        imeFastEdit?: boolean;
-        isEmptyCol?: (this: import("handsontable/core").default, column: number) => boolean;
-        isEmptyRow?: (this: import("handsontable/core").default, row: number) => boolean;
-        label?: import("handsontable/common").LabelOptions;
-        language?: string;
-        locale?: string;
-        layoutDirection?: "ltr" | "rtl" | "inherit";
-        licenseKey?: string | "non-commercial-and-evaluation";
-        manualColumnFreeze?: import("handsontable/plugins/manualColumnFreeze").Settings;
-        manualColumnMove?: import("handsontable/plugins/manualColumnMove").Settings;
-        manualColumnResize?: import("handsontable/plugins/manualColumnResize").Settings;
-        manualRowMove?: import("handsontable/plugins/manualRowMove").Settings;
-        manualRowResize?: import("handsontable/plugins/manualRowResize").Settings;
-        maxCols?: number;
-        maxRows?: number;
-        mergeCells?: import("handsontable/plugins/mergeCells").Settings;
-        minCols?: number;
-        minRows?: number;
-        minSpareCols?: number;
-        minSpareRows?: number;
-        multiColumnSorting?: import("handsontable/plugins/columnSorting").Settings;
-        navigableHeaders?: boolean;
-        nestedHeaders?: import("handsontable/plugins/nestedHeaders").Settings;
-        nestedRows?: import("handsontable/plugins/nestedRows").Settings;
-        noWordWrapClassName?: string;
-        numericFormat?: import("handsontable/common").NumericFormatOptions;
-        observeDOMVisibility?: boolean;
-        outsideClickDeselects?: boolean | ((target: HTMLElement) => boolean);
-        persistentState?: import("handsontable/plugins/persistentState").Settings;
-        placeholder?: string;
-        placeholderCellClassName?: string;
-        preventOverflow?: boolean | "vertical" | "horizontal";
-        preventWheel?: boolean;
-        readOnly?: boolean;
-        readOnlyCellClassName?: string;
-        renderAllColumns?: boolean;
-        renderAllRows?: boolean;
-        renderer?: import("handsontable/renderers").RendererType | string | import("handsontable/renderers").BaseRenderer;
-        rowHeaders?: boolean | string[] | ((index: number) => string);
-        rowHeaderWidth?: number | number[];
-        rowHeights?: number | string | number[] | string[] | undefined[] | Array<number | string | undefined> | ((index: number) => string | number | undefined);
-        search?: import("handsontable/plugins/search").Settings;
-        selectionMode?: "single" | "range" | "multiple";
-        selectOptions?: string[] | import("handsontable/common").SelectOptionsObject | ((visualRow: number, visualColumn: number, prop: string | number) => string[] | import("handsontable/common").SelectOptionsObject);
-        skipColumnOnPaste?: boolean;
-        skipRowOnPaste?: boolean;
-        sortByRelevance?: boolean;
-        source?: string[] | number[] | ((this: import("handsontable/settings").CellProperties, query: string, callback: (items: string[]) => void) => void);
-        startCols?: number;
-        startRows?: number;
-        stretchH?: "none" | "all" | "last";
-        strict?: boolean;
-        tableClassName?: string | string[];
-        tabMoves?: import("handsontable/3rdparty/walkontable/src/cell/coords").default | import("handsontable/common").SimpleCellCoords | ((event: KeyboardEvent) => import("handsontable/3rdparty/walkontable/src/cell/coords").default | import("handsontable/common").SimpleCellCoords);
-        themeName?: string;
-        title?: string;
-        trimDropdown?: boolean;
-        trimRows?: import("handsontable/plugins/trimRows").Settings;
-        trimWhitespace?: boolean;
-        type?: import("handsontable/cellTypes").CellType | string;
-        uncheckedTemplate?: boolean | string | number;
-        undo?: import("handsontable/plugins/undoRedo").Settings;
-        validator?: import("handsontable/validators").BaseValidator | RegExp | import("handsontable/validators").ValidatorType | string;
-        viewportColumnRenderingOffset?: number | "auto";
-        viewportRowRenderingOffset?: number | "auto";
-        viewportColumnRenderingThreshold?: number | "auto";
-        viewportRowRenderingThreshold?: number | "auto";
-        visibleRows?: number;
-        width?: number | string | (() => number | string);
-        wordWrap?: boolean;
-        afterAddChild?: (parent: import("handsontable/common").RowObject, element: import("handsontable/common").RowObject | undefined, index: number | undefined) => void;
-        afterAutofill?: (fillData: import("handsontable/common").CellValue[][], sourceRange: import("handsontable/3rdparty/walkontable/src/cell/range").default, targetRange: import("handsontable/3rdparty/walkontable/src/cell/range").default, direction: "up" | "down" | "left" | "right") => void;
-        afterBeginEditing?: (row: number, column: number) => void;
-        afterCellMetaReset?: () => void;
-        afterChange?: (changes: import("handsontable/common").CellChange[] | null, source: import("handsontable/common").ChangeSource) => void;
-        afterChangesObserved?: () => void;
-        afterColumnCollapse?: (currentCollapsedColumns: number[], destinationCollapsedColumns: number[], collapsePossible: boolean, successfullyCollapsed: boolean) => void;
-        afterColumnExpand?: (currentCollapsedColumns: number[], destinationCollapsedColumns: number[], expandPossible: boolean, successfullyExpanded: boolean) => void;
-        afterColumnFreeze?: (columnIndex: number, isFreezingPerformed: boolean) => void;
-        afterColumnMove?: (movedColumns: number[], finalIndex: number, dropIndex: number | undefined, movePossible: boolean, orderChanged: boolean) => void;
-        afterColumnResize?: (newSize: number, column: number, isDoubleClick: boolean) => void;
-        afterColumnSequenceChange?: (source: "init" | "move" | "insert" | "remove" | "update") => void;
-        afterColumnSort?: (currentSortConfig: import("handsontable/plugins/columnSorting").Config[], destinationSortConfigs: import("handsontable/plugins/columnSorting").Config[]) => void;
-        afterColumnUnfreeze?: (columnIndex: number, isUnfreezingPerformed: boolean) => void;
-        afterContextMenuDefaultOptions?: (predefinedItems: Array<import("handsontable/plugins/contextMenu").PredefinedMenuItemKey | import("handsontable/plugins/contextMenu").MenuItemConfig>) => void;
-        afterContextMenuHide?: (context: import("handsontable/plugins").ContextMenu) => void;
-        afterContextMenuShow?: (context: import("handsontable/plugins").ContextMenu) => void;
-        afterCopy?: (data: import("handsontable/common").CellValue[][], coords: import("handsontable/common").RangeType[], copiedHeadersCount: {
-            columnHeadersCount: number;
-        }) => void;
-        afterCopyLimit?: (selectedRows: number, selectedColumns: number, copyRowsLimit: number, copyColumnsLimit: number) => void;
-        afterCreateCol?: (index: number, amount: number, source?: import("handsontable/common").ChangeSource) => void;
-        afterCreateRow?: (index: number, amount: number, source?: import("handsontable/common").ChangeSource) => void;
-        afterCut?: (data: import("handsontable/common").CellValue[][], coords: import("handsontable/common").RangeType[]) => void;
-        afterDeselect?: () => void;
-        afterDestroy?: () => void;
-        afterDetachChild?: (parent: import("handsontable/common").RowObject, element: import("handsontable/common").RowObject) => void;
-        afterDocumentKeyDown?: (event: KeyboardEvent) => void;
-        afterDrawSelection?: (currentRow: number, currentColumn: number, cornersOfSelection: number[], layerLevel?: number) => string | void;
-        afterDropdownMenuDefaultOptions?: (predefinedItems: Array<import("handsontable/plugins/contextMenu").PredefinedMenuItemKey | import("handsontable/plugins/contextMenu").MenuItemConfig>) => void;
-        afterDropdownMenuHide?: (instance: import("handsontable/plugins").DropdownMenu) => void;
-        afterDropdownMenuShow?: (instance: import("handsontable/plugins").DropdownMenu) => void;
-        afterFilter?: (conditionsStack: import("handsontable/plugins/filters").ColumnConditions[]) => void;
-        afterFormulasValuesUpdate?: (changes: import("hyperformula").ExportedChange[]) => void;
-        afterGetCellMeta?: (row: number, column: number, cellProperties: import("handsontable/settings").CellProperties) => void;
-        afterGetColHeader?: (column: number, TH: HTMLTableHeaderCellElement, headerLevel: number) => void;
-        afterGetColumnHeaderRenderers?: (renderers: Array<(column: number, TH: HTMLTableHeaderCellElement) => void>) => void;
-        afterGetRowHeader?: (row: number, TH: HTMLTableHeaderCellElement) => void;
-        afterGetRowHeaderRenderers?: (renderers: Array<(row: number, TH: HTMLTableHeaderCellElement) => void>) => void;
-        afterHideColumns?: (currentHideConfig: number[], destinationHideConfig: number[], actionPossible: boolean, stateChanged: boolean) => void;
-        afterHideRows?: (currentHideConfig: number[], destinationHideConfig: number[], actionPossible: boolean, stateChanged: boolean) => void;
-        afterInit?: () => void;
-        afterLanguageChange?: (languageCode: string) => void;
-        afterListen?: () => void;
-        afterLoadData?: (sourceData: import("handsontable/common").CellValue[], initialLoad: boolean, source: string | undefined) => void;
-        afterMergeCells?: (cellRange: import("handsontable/3rdparty/walkontable/src/cell/range").default, mergeParent: import("handsontable/plugins/mergeCells").Settings, auto: boolean) => void;
-        afterModifyTransformEnd?: (coords: import("handsontable/3rdparty/walkontable/src/cell/coords").default, rowTransformDir: -1 | 0, colTransformDir: -1 | 0) => void;
-        afterModifyTransformFocus?: (coords: import("handsontable/3rdparty/walkontable/src/cell/coords").default, rowTransformDir: -1 | 0, colTransformDir: -1 | 0) => void;
-        afterModifyTransformStart?: (coords: import("handsontable/3rdparty/walkontable/src/cell/coords").default, rowTransformDir: -1 | 0, colTransformDir: -1 | 0) => void;
-        afterMomentumScroll?: () => void;
-        afterNamedExpressionAdded?: (namedExpressionName: string, changes: import("hyperformula").ExportedChange[]) => void;
-        afterNamedExpressionRemoved?: (namedExpressionName: string, changes: import("hyperformula").ExportedChange[]) => void;
-        afterOnCellContextMenu?: (event: MouseEvent, coords: import("handsontable/3rdparty/walkontable/src/cell/coords").default, TD: HTMLTableCellElement) => void;
-        afterOnCellCornerDblClick?: (event: MouseEvent) => void;
-        afterOnCellCornerMouseDown?: (event: MouseEvent) => void;
-        afterOnCellMouseDown?: (event: MouseEvent, coords: import("handsontable/3rdparty/walkontable/src/cell/coords").default, TD: HTMLTableCellElement) => void;
-        afterOnCellMouseOut?: (event: MouseEvent, coords: import("handsontable/3rdparty/walkontable/src/cell/coords").default, TD: HTMLTableCellElement) => void;
-        afterOnCellMouseOver?: (event: MouseEvent, coords: import("handsontable/3rdparty/walkontable/src/cell/coords").default, TD: HTMLTableCellElement) => void;
-        afterOnCellMouseUp?: (event: MouseEvent, coords: import("handsontable/3rdparty/walkontable/src/cell/coords").default, TD: HTMLTableCellElement) => void;
-        afterPaste?: (data: import("handsontable/common").CellValue[][], coords: import("handsontable/common").RangeType[]) => void;
-        afterPluginsInitialized?: () => void;
-        afterRedo?: (action: import("handsontable/plugins/undoRedo").Action) => void;
-        afterRedoStackChange?: (undoneActionsBefore: import("handsontable/plugins/undoRedo").Action[], undoneActionsAfter: import("handsontable/plugins/undoRedo").Action[]) => void;
-        afterRefreshDimensions?: (previousDimensions: {
-            width: number;
-            height: number;
-        }, currentDimensions: {
-            width: number;
-            height: number;
-        }, stateChanged: boolean) => void;
-        afterRemoveCellMeta?: (row: number, column: number, key: string, value: any) => void;
-        afterRemoveCol?: (index: number, amount: number, physicalColumns: number[], source?: import("handsontable/common").ChangeSource) => void;
-        afterRemoveRow?: (index: number, amount: number, physicalRows: number[], source?: import("handsontable/common").ChangeSource) => void;
-        afterRender?: (isForced: boolean) => void;
-        afterRenderer?: (TD: HTMLTableCellElement, row: number, column: number, prop: string | number, value: string, cellProperties: import("handsontable/settings").CellProperties) => void;
-        afterRowMove?: (movedRows: number[], finalIndex: number, dropIndex: number | undefined, movePossible: boolean, orderChanged: boolean) => void;
-        afterRowResize?: (newSize: number, row: number, isDoubleClick: boolean) => void;
-        afterRowSequenceChange?: (source: "init" | "move" | "insert" | "remove" | "update") => void;
-        afterScrollHorizontally?: () => void;
-        afterScrollVertically?: () => void;
-        afterScroll?: () => void;
-        afterSelectColumns?: (from: import("handsontable/3rdparty/walkontable/src/cell/coords").default, to: import("handsontable/3rdparty/walkontable/src/cell/coords").default, highlight: import("handsontable/3rdparty/walkontable/src/cell/coords").default) => void;
-        afterSelection?: (row: number, column: number, row2: number, column2: number, preventScrolling: {
-            value: boolean;
-        }, selectionLayerLevel: number) => void;
-        afterSelectionByProp?: (row: number, prop: string, row2: number, prop2: string, preventScrolling: {
-            value: boolean;
-        }, selectionLayerLevel: number) => void;
-        afterSelectionEnd?: (row: number, column: number, row2: number, column2: number, selectionLayerLevel: number) => void;
-        afterSelectionEndByProp?: (row: number, prop: string, row2: number, prop2: string, selectionLayerLevel: number) => void;
-        afterSelectionFocusSet?: (row: number, column: number, preventScrolling: {
-            value: boolean;
-        }) => void;
-        afterSelectRows?: (from: import("handsontable/3rdparty/walkontable/src/cell/coords").default, to: import("handsontable/3rdparty/walkontable/src/cell/coords").default, highlight: import("handsontable/3rdparty/walkontable/src/cell/coords").default) => void;
-        afterSetCellMeta?: (row: number, column: number, key: string, value: any) => void;
-        afterSetDataAtCell?: (changes: import("handsontable/common").CellChange[], source?: import("handsontable/common").ChangeSource) => void;
-        afterSetDataAtRowProp?: (changes: import("handsontable/common").CellChange[], source?: import("handsontable/common").ChangeSource) => void;
-        afterSetSourceDataAtCell?: (changes: import("handsontable/common").CellChange[], source?: import("handsontable/common").ChangeSource) => void;
-        afterSetTheme?: (themeName: string | boolean | undefined, firstRun: boolean) => void;
-        afterSheetAdded?: (addedSheetDisplayName: string) => void;
-        afterSheetRemoved?: (removedSheetDisplayName: string, changes: import("hyperformula").ExportedChange[]) => void;
-        afterSheetRenamed?: (oldDisplayName: string, newDisplayName: string) => void;
-        afterTrimRow?: (currentTrimConfig: number[], destinationTrimConfig: number[], actionPossible: boolean, stateChanged: boolean) => void;
-        afterUndo?: (action: import("handsontable/plugins/undoRedo").Action) => void;
-        afterUndoStackChange?: (doneActionsBefore: import("handsontable/plugins/undoRedo").Action[], doneActionsAfter: import("handsontable/plugins/undoRedo").Action[]) => void;
-        afterUnhideColumns?: (currentHideConfig: number[], destinationHideConfig: number[], actionPossible: boolean, stateChanged: boolean) => void;
-        afterUnhideRows?: (currentHideConfig: number[], destinationHideConfig: number[], actionPossible: boolean, stateChanged: boolean) => void;
-        afterUnlisten?: () => void;
-        afterUnmergeCells?: (cellRange: import("handsontable/3rdparty/walkontable/src/cell/range").default, auto: boolean) => void;
-        afterUntrimRow?: (currentTrimConfig: number[], destinationTrimConfig: number[], actionPossible: boolean, stateChanged: boolean) => void;
-        afterUpdateData?: (sourceData: import("handsontable/common").CellValue[], initialLoad: boolean, source: string | undefined) => void;
-        afterUpdateSettings?: (newSettings: import("handsontable/settings").GridSettings) => void;
-        afterValidate?: (isValid: boolean, value: import("handsontable/common").CellValue, row: number, prop: string | number, source: import("handsontable/common").ChangeSource) => void | boolean;
-        afterViewportColumnCalculatorOverride?: (calc: import("handsontable/3rdparty/walkontable/src/calculator/viewportColumns").ViewportColumnsCalculator) => void;
-        afterViewportRowCalculatorOverride?: (calc: import("handsontable/3rdparty/walkontable/src/calculator/viewportColumns").ViewportColumnsCalculator) => void;
-        afterViewRender?: (isForced: boolean) => void;
-        beforeAddChild?: (parent: import("handsontable/common").RowObject, element?: import("handsontable/common").RowObject, index?: number) => void;
-        beforeAutofill?: (selectionData: import("handsontable/common").CellValue[][], sourceRange: import("handsontable/3rdparty/walkontable/src/cell/range").default, targetRange: import("handsontable/3rdparty/walkontable/src/cell/range").default, direction: "up" | "down" | "left" | "right") => import("handsontable/common").CellValue[][] | boolean | void;
-        beforeBeginEditing?: (row: number, column: number, initialValue: any, event: MouseEvent | KeyboardEvent, fullEditMode: boolean) => boolean | void;
-        beforeCellAlignment?: (stateBefore: {
-            [row: number]: string[];
-        }, range: import("handsontable/3rdparty/walkontable/src/cell/range").default[], type: "horizontal" | "vertical", alignmentClass: "htLeft" | "htCenter" | "htRight" | "htJustify" | "htTop" | "htMiddle" | "htBottom") => void;
-        beforeChange?: (changes: Array<import("handsontable/common").CellChange | null>, source: import("handsontable/common").ChangeSource) => void | boolean;
-        beforeChangeRender?: (changes: import("handsontable/common").CellChange[], source: import("handsontable/common").ChangeSource) => void;
-        beforeColumnCollapse?: (currentCollapsedColumn: number[], destinationCollapsedColumns: number[], collapsePossible: boolean) => void | boolean;
-        beforeColumnExpand?: (currentCollapsedColumn: number[], destinationCollapsedColumns: number[], expandPossible: boolean) => void | boolean;
-        beforeColumnFreeze?: (columnIndex: number, isFreezingPerformed: boolean) => void | boolean;
-        beforeColumnMove?: (movedColumns: number[], finalIndex: number, dropIndex: number | undefined, movePossible: boolean) => void | boolean;
-        beforeColumnResize?: (newSize: number, column: number, isDoubleClick: boolean) => void | number;
-        beforeColumnSort?: (currentSortConfig: import("handsontable/plugins/columnSorting").Config[], destinationSortConfigs: import("handsontable/plugins/columnSorting").Config[]) => void | boolean;
-        beforeColumnWrap?: (isActionInterrupted: {
-            value: boolean;
-        }, newCoords: import("handsontable/3rdparty/walkontable/src/cell/coords").default, isColumnFlipped: boolean) => void;
-        beforeColumnUnfreeze?: (columnIndex: number, isUnfreezingPerformed: boolean) => void | boolean;
-        beforeCompositionStart?: (event: CompositionEvent) => void;
-        beforeContextMenuSetItems?: (menuItems: import("handsontable/plugins/contextMenu").MenuItemConfig[]) => void;
-        beforeContextMenuShow?: (context: import("handsontable/plugins").ContextMenu) => void;
-        beforeCopy?: (data: import("handsontable/common").CellValue[][], coords: import("handsontable/common").RangeType[], copiedHeadersCount: {
-            columnHeadersCount: number;
-        }) => void | boolean;
-        beforeCreateCol?: (index: number, amount: number, source?: import("handsontable/common").ChangeSource) => void | boolean;
-        beforeCreateRow?: (index: number, amount: number, source?: import("handsontable/common").ChangeSource) => void | boolean;
-        beforeCut?: (data: import("handsontable/common").CellValue[][], coords: import("handsontable/common").RangeType[]) => void | boolean;
-        beforeDetachChild?: (parent: import("handsontable/common").RowObject, element: import("handsontable/common").RowObject) => void;
-        beforeDrawBorders?: (corners: number[], borderClassName: "current" | "area" | "highlight" | undefined) => void;
-        beforeDropdownMenuSetItems?: (menuItems: import("handsontable/plugins/contextMenu").MenuItemConfig[]) => void;
-        beforeDropdownMenuShow?: (instance: import("handsontable/plugins").DropdownMenu) => void;
-        beforeFilter?: (conditionsStack: import("handsontable/plugins/filters").ColumnConditions[], previousConditionsStack: import("handsontable/plugins/filters").ColumnConditions[]) => void | boolean;
-        beforeGetCellMeta?: (row: number, column: number, cellProperties: import("handsontable/settings").CellProperties) => void;
-        beforeHideColumns?: (currentHideConfig: number[], destinationHideConfig: number[], actionPossible: boolean) => void | boolean;
-        beforeHideRows?: (currentHideConfig: number[], destinationHideConfig: number[], actionPossible: boolean) => void | boolean;
-        beforeHighlightingColumnHeader?: (column: number, headerLevel: number, highlightMeta: import("handsontable/core/hooks").HookHighlightColumnHeaderMeta) => number | void;
-        beforeHighlightingRowHeader?: (row: number, headerLevel: number, highlightMeta: import("handsontable/core/hooks").HookHighlightRowHeaderMeta) => number | void;
-        beforeInit?: () => void;
-        beforeInitWalkontable?: (walkontableConfig: object) => void;
-        beforeKeyDown?: (event: KeyboardEvent) => void;
-        beforeLanguageChange?: (languageCode: string) => void;
-        beforeLoadData?: (sourceData: import("handsontable/common").CellValue[], initialLoad: boolean, source: string | undefined) => void;
-        beforeMergeCells?: (cellRange: import("handsontable/3rdparty/walkontable/src/cell/range").default, auto: boolean) => void;
-        beforeOnCellContextMenu?: (event: MouseEvent, coords: import("handsontable/3rdparty/walkontable/src/cell/coords").default, TD: HTMLTableCellElement) => void;
-        beforeOnCellMouseDown?: (event: MouseEvent, coords: import("handsontable/3rdparty/walkontable/src/cell/coords").default, TD: HTMLTableCellElement, controller: import("handsontable/selection").SelectionController) => void;
-        beforeOnCellMouseOut?: (event: MouseEvent, coords: import("handsontable/3rdparty/walkontable/src/cell/coords").default, TD: HTMLTableCellElement) => void;
-        beforeOnCellMouseOver?: (event: MouseEvent, coords: import("handsontable/3rdparty/walkontable/src/cell/coords").default, TD: HTMLTableCellElement, controller: import("handsontable/selection").SelectionController) => void;
-        beforeOnCellMouseUp?: (event: MouseEvent, coords: import("handsontable/3rdparty/walkontable/src/cell/coords").default, TD: HTMLTableCellElement) => void;
-        beforePaste?: (data: import("handsontable/common").CellValue[][], coords: import("handsontable/common").RangeType[]) => void | boolean;
-        beforeRedo?: (action: import("handsontable/plugins/undoRedo").Action) => void;
-        beforeRedoStackChange?: (undoneActions: import("handsontable/plugins/undoRedo").Action[]) => void;
-        beforeRefreshDimensions?: (previousDimensions: {
-            width: number;
-            height: number;
-        }, currentDimensions: {
-            width: number;
-            height: number;
-        }, actionPossible: boolean) => boolean | void;
-        beforeRemoveCellClassNames?: () => string[] | void;
-        beforeRemoveCellMeta?: (row: number, column: number, key: string, value: any) => void;
-        beforeRemoveCol?: (index: number, amount: number, physicalColumns: number[], source?: import("handsontable/common").ChangeSource) => void;
-        beforeRemoveRow?: (index: number, amount: number, physicalColumns: number[], source?: import("handsontable/common").ChangeSource) => void;
-        beforeRender?: (isForced: boolean) => void;
-        beforeRenderer?: (TD: HTMLTableCellElement, row: number, column: number, prop: string | number, value: import("handsontable/common").CellValue, cellProperties: import("handsontable/settings").CellProperties) => void;
-        beforeRowMove?: (movedRows: number[], finalIndex: number, dropIndex: number | undefined, movePossible: boolean) => void;
-        beforeRowResize?: (newSize: number, row: number, isDoubleClick: boolean) => number | void;
-        beforeRowWrap?: (isActionInterrupted: {
-            value: boolean;
-        }, newCoords: import("handsontable/3rdparty/walkontable/src/cell/coords").default, isRowFlipped: boolean) => void;
-        beforeSelectColumns?: (from: import("handsontable/3rdparty/walkontable/src/cell/coords").default, to: import("handsontable/3rdparty/walkontable/src/cell/coords").default, highlight: import("handsontable/3rdparty/walkontable/src/cell/coords").default) => void;
-        beforeSelectionFocusSet?: (coords: import("handsontable/3rdparty/walkontable/src/cell/coords").default) => void;
-        beforeSelectionHighlightSet?: () => void;
-        beforeSelectRows?: (from: import("handsontable/3rdparty/walkontable/src/cell/coords").default, to: import("handsontable/3rdparty/walkontable/src/cell/coords").default, highlight: import("handsontable/3rdparty/walkontable/src/cell/coords").default) => void;
-        beforeSetCellMeta?: (row: number, column: number, key: string, value: any) => boolean | void;
-        beforeSetRangeEnd?: (coords: import("handsontable/3rdparty/walkontable/src/cell/coords").default) => void;
-        beforeSetRangeStart?: (coords: import("handsontable/3rdparty/walkontable/src/cell/coords").default) => void;
-        beforeSetRangeStartOnly?: (coords: import("handsontable/3rdparty/walkontable/src/cell/coords").default) => void;
-        beforeStretchingColumnWidth?: (stretchedWidth: number, column: number) => void | number;
-        beforeTouchScroll?: () => void;
-        beforeTrimRow?: (currentTrimConfig: number[], destinationTrimConfig: number[], actionPossible: boolean) => void | boolean;
-        beforeUndo?: (action: import("handsontable/plugins/undoRedo").Action) => void;
-        beforeUndoStackChange?: (doneActions: import("handsontable/plugins/undoRedo").Action[], source?: string) => void;
-        beforeUnhideColumns?: (currentHideConfig: number[], destinationHideConfig: number[], actionPossible: boolean) => void | boolean;
-        beforeUnhideRows?: (currentHideConfig: number[], destinationHideConfig: number[], actionPossible: boolean) => void | boolean;
-        beforeUnmergeCells?: (cellRange: import("handsontable/3rdparty/walkontable/src/cell/range").default, auto: boolean) => void;
-        beforeUntrimRow?: (currentTrimConfig: number[], destinationTrimConfig: number[], actionPossible: boolean) => void | boolean;
-        beforeUpdateData?: (sourceData: import("handsontable/common").CellValue[], initialLoad: boolean, source: string | undefined) => void;
-        beforeValidate?: (value: import("handsontable/common").CellValue, row: number, prop: string | number, source?: import("handsontable/common").ChangeSource) => void;
-        beforeValueRender?: (value: import("handsontable/common").CellValue, cellProperties: import("handsontable/settings").CellProperties) => void;
-        beforeViewportScrollVertically?: (visualRow: number, snapping: "auto" | "top" | "bottom") => number | boolean | null;
-        beforeViewportScrollHorizontally?: (visualColumn: number, snapping: "auto" | "start" | "end") => number | boolean | null;
-        beforeViewportScroll?: () => void;
-        beforeViewRender?: (isForced: boolean, skipRender: {
-            skipRender?: boolean;
-        }) => void;
-        construct?: () => void;
-        init?: () => void;
-        modifyAutoColumnSizeSeed?: (seed: string, cellProperties: import("handsontable/settings").CellProperties, cellValue: import("handsontable/common").CellValue) => string | void;
-        modifyAutofillRange?: (startArea: Array<[number, number, number, number]>, entireArea: Array<[number, number, number, number]>) => void;
-        modifyColHeader?: (column: number) => void;
-        modifyColumnHeaderHeight?: () => void;
-        modifyColumnHeaderValue?: (headerValue: string, visualColumnIndex: number, headerLevel: number) => void | string;
-        modifyColWidth?: (width: number, column: number, source?: string) => void;
-        modifyCopyableRange?: (copyableRanges: import("handsontable/common").RangeType[]) => void;
-        modifyFiltersMultiSelectValue?: (value: string, meta: import("handsontable/settings").CellProperties) => void | import("handsontable/common").CellValue;
-        modifyFocusedElement?: (row: number, column: number, focusedElement: HTMLElement) => void | HTMLElement;
-        modifyData?: (row: number, column: number, valueHolder: {
-            value: import("handsontable/common").CellValue;
-        }, ioMode: "get" | "set") => void;
-        modifyFocusOnTabNavigation?: (tabActivationDir: "from_above" | "from_below", visualCoords: import("handsontable/3rdparty/walkontable/src/cell/coords").default) => void;
-        modifyGetCellCoords?: (row: number, column: number, topmost: boolean, source: string | undefined) => void | [number, number] | [number, number, number, number];
-        modifyGetCoordsElement?: (row: number, column: number) => void | [number, number];
-        modifyRowData?: (row: number) => void;
-        modifyRowHeader?: (row: number) => void;
-        modifyRowHeaderWidth?: (rowHeaderWidth: number) => void;
-        modifyRowHeight?: (height: number, row: number, source?: string) => void | number;
-        modifyRowHeightByOverlayName?: (height: number, row: number, overlayType: import("handsontable/common").OverlayType) => void | number;
-        modifySourceData?: (row: number, column: number, valueHolder: {
-            value: import("handsontable/common").CellValue;
-        }, ioMode: "get" | "set") => void;
-        modifyTransformEnd?: (delta: import("handsontable/3rdparty/walkontable/src/cell/coords").default) => void;
-        modifyTransformFocus?: (delta: import("handsontable/3rdparty/walkontable/src/cell/coords").default) => void;
-        modifyTransformStart?: (delta: import("handsontable/3rdparty/walkontable/src/cell/coords").default) => void;
-        persistentStateLoad?: (key: string, valuePlaceholder: {
-            value: any;
-        }) => void;
-        persistentStateReset?: (key: string) => void;
-        persistentStateSave?: (key: string, value: any) => void;
-    };
+    config: any;
     path: {};
 };
 export declare function inputText(type: string, isIn: string[]): "email" | "password" | "date" | "time" | "number" | "color" | "month" | "week" | "range" | "text" | "select" | "datetime-local";

package/helpers/inertiaAddHelper.js

@@ -1,15 +1,19 @@
 import inertiaActionsHelper from "./inertiaActionsHelper.js";
 import chalk from "chalk";
 import { isObject } from "./JsUtils.js";
-const historyTableMessages = {
-    "Event": "",
-    "Date": "",
-    "User": "",
-    "Watch": "",
-    "Current": "",
-    "There is no history": ""
-};
-export default function inertiaAddHelper(req, entity, fields, record, view = false) {
+/**
+ * Get ISO week number from date
+ * @param date - Date object
+ * @returns Week number (1-53)
+ */
+function getWeekNumber(date) {
+    const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
+    const dayNum = d.getUTCDay() || 7;
+    d.setUTCDate(d.getUTCDate() + 4 - dayNum);
+    const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+    return Math.ceil((((d.getTime() - yearStart.getTime()) / 86400000) + 1) / 7);
+}
+export default function inertiaAddHelper(req, modelResource, fields, record, view = false) {
     const actionType = 'add';
     let props = {
         edit: !!record,
@@ -19,7 +23,7 @@ export default function inertiaAddHelper(req, entity, fields, record, view = fal
         search: req.i18n.__('Search'),
         btnBack: {
             title: req.i18n.__('Back'),
-            link: entity.uri
+            link: modelResource.uri
         },
         fields: [],
         btnSave: {
@@ -28,11 +32,10 @@ export default function inertiaAddHelper(req, entity, fields, record, view = fal
         btnHistory: {
             title: req.i18n.__('History'),
         },
-        postLink: record ? `${entity.uri}/edit/${record.id}` : `${entity.uri}/add`,
-        model: entity.name.toLocaleLowerCase(),
-        historyTableMessages: Object.fromEntries(Object.keys(historyTableMessages).map(key => [key, req.i18n.__(key)]))
+        postLink: record ? `${modelResource.uri}/edit/${record.id}` : `${modelResource.uri}/add`,
+        model: modelResource.name.toLocaleLowerCase()
     };
-    props.actions = inertiaActionsHelper(actionType, entity, req);
+    props.actions = inertiaActionsHelper(actionType, modelResource, req);
     const config = req.adminizer.configHelper.getConfig();
     for (const key of Object.keys(fields)) {
         if ((!config.showORMtime) && (key === 'createdAt' || key === 'updatedAt'))
@@ -57,7 +60,7 @@ export default function inertiaAddHelper(req, entity, fields, record, view = fal
         let relatedModel = undefined;
         let canCreateRelated = false;
         //@ts-ignore TODO: fix field type
-        if (entity.config.model && req.adminizer.configHelper.isId(field, entity.config.model)) {
+        if (modelResource.config.model && req.adminizer.configHelper.isId(field, modelResource.config.model)) {
             disabled = true;
         }
         if (['string', 'password', 'date', 'datetime', 'time', 'integer', 'number', 'float', 'email', 'month', 'week', 'range'].includes(type)) {
@@ -68,6 +71,27 @@ export default function inertiaAddHelper(req, entity, fields, record, view = fal
                     value = record ? record[key] : fieldConfig.options.min ? fieldConfig.options.min : 0;
                 }
             }
+            // Format datetime for datetime-local input (YYYY-MM-DDTHH:mm)
+            if (type === 'datetime' && value) {
+                const date = new Date(value);
+                if (!isNaN(date.getTime())) {
+                    const year = date.getFullYear();
+                    const month = String(date.getMonth() + 1).padStart(2, '0');
+                    const day = String(date.getDate()).padStart(2, '0');
+                    const hours = String(date.getHours()).padStart(2, '0');
+                    const minutes = String(date.getMinutes()).padStart(2, '0');
+                    value = `${year}-${month}-${day}T${hours}:${minutes}`;
+                }
+            }
+            // Format week for week input (YYYY-Www)
+            if (type === 'week' && value) {
+                const date = new Date(value);
+                if (!isNaN(date.getTime())) {
+                    const year = date.getFullYear();
+                    const week = getWeekNumber(date);
+                    value = `${year}-W${String(week).padStart(2, '0')}`;
+                }
+            }
         }
         if (type === 'color') {
             fieldType = 'color';

package/helpers/inertiaGroupHelper.d.ts

@@ -1,6 +1,6 @@
 import { GroupAP } from "../models/GroupAP";
 import { UserAP } from "../models/UserAP";
-import { AccessRightsToken, Entity, PropsField } from "../interfaces/types";
+import { AccessRightsToken, ModelResource, PropsField } from "../interfaces/types";
 interface groupedTokens {
     header: string;
     fields: PropsField[];
@@ -22,7 +22,7 @@ interface listProps extends Record<string | number | symbol, unknown> {
     users: PropsField[];
     groupedTokens: groupedTokens[];
 }
-export declare function inertiaGroupHelper(entity: Entity, req: ReqType, users: UserAP[], groupedTokens: {
+export declare function inertiaGroupHelper(modelResource: ModelResource, req: ReqType, users: UserAP[], groupedTokens: {
     [key: string]: AccessRightsToken[];
 }, group?: GroupAP, view?: boolean): listProps;
 export {};

package/helpers/inertiaGroupHelper.js

@@ -1,15 +1,15 @@
-export function inertiaGroupHelper(entity, req, users, groupedTokens, group, view = false) {
+export function inertiaGroupHelper(modelResource, req, users, groupedTokens, group, view = false) {
     let props = {
         edit: !!group,
         view: view,
         btnBack: {
             title: req.i18n.__('Back'),
-            link: entity.uri
+            link: modelResource.uri
         },
         btnSave: {
             title: req.i18n.__('Save')
         },
-        postLink: group ? `${entity.uri}/edit/${group.id}` : `${entity.uri}/add`,
+        postLink: group ? `${modelResource.uri}/edit/${group.id}` : `${modelResource.uri}/add`,
         head: req.i18n.__('Group settings'),
         userHead: '',
         fields: [

package/helpers/inertiaListHelper.d.ts

@@ -1,4 +1,4 @@
-import { Entity } from "../interfaces/types";
+import { ModelResource } from "../interfaces/types";
 import { Fields } from "./fieldsHelper";
 import { Actions } from "./inertiaActionsHelper";
 interface listProps extends Record<string | number | symbol, unknown> {
@@ -18,11 +18,15 @@ interface listProps extends Record<string | number | symbol, unknown> {
     notFoundContent: string;
     searchBtn: string;
     resetBtn: string;
-    entity: {
+    modelResource: {
         name: string;
         uri: string;
     };
     inlineActions: Actions[];
+    filtersEnabled?: boolean;
+    activeFilterName?: string;
+    defaultPageSize: number;
+    pageSizeOptions: number[];
 }
-export declare function inertiaListHelper(entity: Entity, req: ReqType, fields: Fields): listProps;
+export declare function inertiaListHelper(modelResource: ModelResource, req: ReqType, fields: Fields, activeFilterName?: string): listProps;
 export {};