@linzjs/step-ag-grid 29.13.0 → 29.14.0

package/dist/index.css

@@ -320,8 +320,12 @@
   margin-right: auto;
 }
 
-.ag-unselectable .ag-cell:not([col-id=ag-Grid-SelectionColumn]) {
-  user-select: text !important;
+.ag-cell:not([col-id=ag-Grid-SelectionColumn]) {
+  user-select: text;
+}
+
+.rangeSelectingMultiple .ag-cell {
+  user-select: none;
 }
 
 .LabelPreferencesPanelGridCellAlignCenter .ag-cell-wrapper, .LabelPreferencesPanelGridCellAlignCenter .GridCell-container {
@@ -463,6 +467,26 @@ div.ag-ltr div.ag-header-cell-resize {
   font-weight: normal;
 }
 
+div.ag-row div.ag-cell.rangeSelect {
+  background-color: rgba(72, 160, 244, 0.2);
+}
+
+div.ag-row div.ag-cell.rangeSelectLeft {
+  border-left: 3px solid #48a0f4;
+}
+
+div.ag-row div.ag-cell.rangeSelectRight {
+  border-right: 3px solid #48a0f4;
+}
+
+div.ag-row div.ag-cell.rangeSelectTop {
+  border-top: 3px solid #48a0f4;
+}
+
+div.ag-row div.ag-cell.rangeSelectBottom {
+  border-bottom: 3px solid #48a0f4;
+}
+
 .GridCell-container {
   overflow: hidden;
   text-overflow: ellipsis;

package/dist/src/components/Grid.d.ts

@@ -3,89 +3,64 @@ import { ReactElement } from 'react';
 import { GridContextMenuComponent } from './gridHook';
 import { GridBaseRow, GridOnRowDragEndProps } from './types';
 export interface GridProps<TData extends GridBaseRow = GridBaseRow> {
+    ['data-testid']?: string;
+    theme?: string;
+    loading?: boolean;
     readOnly?: boolean;
+    suppressReadOnlyStyle?: boolean;
+    columnDefs: ColDef<TData>[] | ColGroupDef<TData>[];
+    defaultColDef?: GridOptions['defaultColDef'];
     defaultPostSort?: boolean;
-    selectable?: boolean;
-    enableClickSelection?: boolean;
-    enableSelectionWithoutKeys?: boolean;
-    hideSelectColumn?: boolean;
-    theme?: string;
-    ['data-testid']?: string;
     domLayout?: GridOptions['domLayout'];
-    externalSelectedItems?: TData[];
-    externalSelectedIds?: TData['id'][];
-    setExternalSelectedItems?: (items: TData[]) => void;
-    setExternalSelectedIds?: (ids: TData['id'][]) => void;
-    defaultColDef?: GridOptions['defaultColDef'];
-    columnDefs: ColDef<TData>[] | ColGroupDef<TData>[];
+    pinnedBottomRowData?: GridOptions['pinnedBottomRowData'];
+    pinnedTopRowData?: GridOptions['pinnedTopRowData'];
     rowData: GridOptions['rowData'];
-    selectColumnPinned?: ColDef['pinned'];
-    noRowsOverlayText?: string;
-    noRowsMatchingOverlayText?: string;
-    animateRows?: boolean;
-    rowHeight?: number;
     rowClassRules?: GridOptions['rowClassRules'];
+    rowHeight?: number;
     rowSelection?: 'single' | 'multiple';
+    sizeColumns?: 'fit' | 'auto' | 'auto-skip-headers' | 'none';
     autoSelectFirstRow?: boolean;
+    enableClickSelection?: boolean;
+    enableRangeSelection?: boolean;
+    enableSelectionWithoutKeys?: boolean;
+    externalSelectedIds?: TData['id'][];
+    externalSelectedItems?: TData[];
+    hideSelectColumn?: boolean;
+    selectColumnPinned?: ColDef['pinned'];
+    selectable?: boolean;
+    setExternalSelectedIds?: (ids: TData['id'][]) => void;
+    setExternalSelectedItems?: (items: TData[]) => void;
+    onBulkEditingComplete?: () => Promise<void> | void;
+    singleClickEdit?: boolean;
+    contextMenu?: GridContextMenuComponent<TData>;
+    contextMenuSelectRow?: boolean;
     onCellFocused?: (props: {
         colDef: ColDef<TData>;
         data: TData;
     }) => void;
     onColumnMoved?: GridOptions['onColumnMoved'];
-    rowDragText?: GridOptions['rowDragText'];
-    onRowDragEnd?: (props: GridOnRowDragEndProps<TData>) => Promise<void> | void;
-    alwaysShowVerticalScroll?: boolean;
-    suppressColumnVirtualization?: GridOptions['suppressColumnVirtualisation'];
-    suppressReadOnlyStyle?: boolean;
-    /**
-     * When the grid is rendered using sizeColumns=="auto" this is called initially with the required container size to fit all content.
-     * This allows you set the size of the panel to fit perfectly.
-     */
     onContentSize?: (props: {
         width: number;
     }) => void;
     /**
-     * <ul>
-     * <li>"none" to use aggrid defaults.</li>
-     * <li>"fit" will adjust columns to fit within panel via min/max/initial sizing.
-     * <b>Note:</b> This is only really needed if you have auto-height columns which prevents "auto" from working.
-     * </li>
-     * <li>"auto" will size columns based on their content but still obeying min/max sizing.</li>
-     * <li>"auto-skip-headers" (default) same as auto but does not take headers into account.</li>
-     * </ul>
-     *
-     * If you want to stretch to container width if width is greater than the container add a flex column.
+     * @deprecated You should drive your app off selection states. This will be deleted.
      */
-    sizeColumns?: 'fit' | 'auto' | 'auto-skip-headers' | 'none';
+    onRowClicked?: (event: RowClickedEvent) => void;
     /**
-     * On first don't return a content size larger than this.
+     * @deprecated You should drive your app off selection states. This will be deleted.
      */
+    onRowDoubleClicked?: (event: RowDoubleClickedEvent) => void;
+    onRowDragEnd?: (props: GridOnRowDragEndProps<TData>) => Promise<void> | void;
+    animateRows?: boolean;
+    alwaysShowVerticalScroll?: boolean;
+    rowDragText?: GridOptions['rowDragText'];
+    noRowsOverlayText?: string;
+    noRowsMatchingOverlayText?: string;
     maxInitialWidth?: number;
-    /**
-     * When pressing tab whilst editing the grid will select and edit the next cell if available.
-     * Once the last cell to edit closes this callback is called.
-     */
-    onBulkEditingComplete?: () => Promise<void> | void;
-    /**
-     * Context menu definition if required.
-     */
-    contextMenu?: GridContextMenuComponent<TData>;
-    /**
-     * Whether to select row on context menu.
-     */
-    contextMenuSelectRow?: boolean;
-    /**
-     * Defaults to false.
-     */
-    singleClickEdit?: boolean;
-    loading?: boolean;
     suppressCellFocus?: boolean;
-    pinnedTopRowData?: GridOptions['pinnedTopRowData'];
-    pinnedBottomRowData?: GridOptions['pinnedBottomRowData'];
-    onRowClicked?: (event: RowClickedEvent) => void;
-    onRowDoubleClicked?: (event: RowDoubleClickedEvent) => void;
+    suppressColumnVirtualization?: GridOptions['suppressColumnVirtualisation'];
 }
 /**
  * Wrapper for AgGrid to add commonly used functionality.
  */
-export declare const Grid: <TData extends GridBaseRow = GridBaseRow>({ "data-testid": dataTestId, defaultPostSort, rowSelection, suppressColumnVirtualization, theme, sizeColumns, selectColumnPinned, contextMenuSelectRow, singleClickEdit, rowData, rowHeight, selectable, autoSelectFirstRow, onCellFocused: paramsOnCellFocused, maxInitialWidth, suppressReadOnlyStyle, externalSelectedItems, setExternalSelectedItems, externalSelectedIds, setExternalSelectedIds, ...params }: GridProps<TData>) => ReactElement;
+export declare const Grid: <TData extends GridBaseRow = GridBaseRow>({ theme, "data-testid": dataTestId, suppressReadOnlyStyle, defaultPostSort, rowData, rowHeight, rowSelection, sizeColumns, autoSelectFirstRow, enableRangeSelection, externalSelectedIds, externalSelectedItems, selectColumnPinned, selectable, setExternalSelectedIds, setExternalSelectedItems, singleClickEdit, contextMenuSelectRow, contextMenu, onCellFocused: paramsOnCellFocused, onColumnMoved, suppressColumnVirtualization, maxInitialWidth, ...params }: GridProps<TData>) => ReactElement;

package/dist/src/components/GridRangeSelectContextMenu.d.ts

@@ -0,0 +1,10 @@
+import { ReactElement } from 'react';
+import { GridContextMenuComponentProps } from './gridHook';
+import { CopyOptionsKey } from './gridHook/useGridCopySettings';
+import { GridBaseRow } from './types';
+export interface CopyOptionsContext {
+    onCopy: (type?: CopyOptionsKey) => void;
+    copyType: CopyOptionsKey;
+    setCopyType: (copyType: CopyOptionsKey) => void;
+}
+export declare const GridRangeSelectContextMenu: <TData extends GridBaseRow>({ event, context, }: GridContextMenuComponentProps<TData, CopyOptionsContext>) => ReactElement;

package/dist/src/components/gridForm/GridFormDropDown.d.ts

@@ -1,4 +1,5 @@
 import { ReactElement } from 'react';
+import { MaybePromise } from '../../utils/util';
 import { CellEditorCommon } from '../GridCell';
 import { GridBaseRow } from '../types';
 export interface GridPopoutEditDropDownSelectedItem<TData extends GridBaseRow, TOption> {
@@ -24,7 +25,6 @@ export declare const MenuHeaderItem: (title: string) => {
     value: string;
 };
 export type SelectOption<TOptionValue = any> = FinalSelectOption<TOptionValue>;
-export type MaybePromise<T> = T | Promise<T>;
 export interface GridFormDropDownProps<TData extends GridBaseRow, TOptionValue> extends CellEditorCommon {
     className?: 'GridPopoverEditDropDown-containerSmall' | 'GridPopoverEditDropDown-containerMedium' | 'GridPopoverEditDropDown-containerLarge' | 'GridPopoverEditDropDown-containerUnlimited' | 'GridPopoverEditDropDown-containerAutoWidth' | string | undefined;
     filtered?: 'local' | 'reload';

package/dist/src/components/gridForm/GridFormPopoverMenu.d.ts

@@ -1,4 +1,5 @@
 import { ReactElement } from 'react';
+import { MaybePromise } from '../../utils/util';
 import { CellEditorCommon } from '../GridCell';
 import { GridBaseRow } from '../types';
 export interface GridFormPopoverMenuProps<TData extends GridBaseRow> extends CellEditorCommon {
@@ -23,7 +24,7 @@ export interface MenuOption<TData extends GridBaseRow> {
     action?: (props: {
         selectedRows: TData[];
         menuOption: SelectedMenuOptionResult<TData>;
-    }) => Promise<void>;
+    }) => MaybePromise<void>;
     disabled?: string | boolean;
     hidden?: boolean;
     subComponent?: (props: any) => ReactElement;

package/dist/src/components/gridHook/useGridContextMenu.d.ts

@@ -1,19 +1,24 @@
+import '../../styles/ContextMenu.scss';
 import { ColDef } from 'ag-grid-community';
 import { CellContextMenuEvent } from 'ag-grid-community';
 import { ReactElement } from 'react';
 import { GridBaseRow } from '../types';
-export interface GridContextMenuComponentProps<TData extends GridBaseRow> {
+export interface GridContextMenuComponentProps<TData extends GridBaseRow, Context extends object = object> {
     selectedRows: TData[];
     clickedRow: TData;
     colDef: ColDef;
     close: () => void;
+    event?: CellContextMenuEvent;
+    context?: Context;
 }
-export type GridContextMenuComponent<TData extends GridBaseRow> = (props: GridContextMenuComponentProps<TData>) => ReactElement | null;
-export declare const useGridContextMenu: <TData extends GridBaseRow>({ contextMenuSelectRow, contextMenu: ContextMenu, }: {
-    contextMenuSelectRow: boolean;
-    contextMenu?: GridContextMenuComponent<TData>;
-}) => {
+export type GridContextMenuComponent<TData extends GridBaseRow, Context extends object = object> = (props: GridContextMenuComponentProps<TData, Context>) => ReactElement | null;
+export interface useGridContextMenuProps<TData extends GridBaseRow, Context extends object = object> {
+    contextMenuSelectRow?: boolean;
+    contextMenu?: GridContextMenuComponent<TData, Context>;
+    context?: Context;
+}
+export declare const useGridContextMenu: <TData extends GridBaseRow, Context extends object = object>({ contextMenuSelectRow, contextMenu: ContextMenu, context, }: useGridContextMenuProps<TData, Context>) => {
     openMenu: (e: PointerEvent | null | undefined) => void;
     cellContextMenu: (event: CellContextMenuEvent) => void;
-    component: import("react/jsx-runtime").JSX.Element | null;
+    contextMenuComponent: import("react/jsx-runtime").JSX.Element | null;
 };

package/dist/src/components/gridHook/useGridCopy.d.ts

@@ -0,0 +1,15 @@
+import { CellContextMenuEvent } from 'ag-grid-community';
+import { ClipboardEvent as ReactClipboardEvent, MutableRefObject } from 'react';
+import { GridBaseRow } from '../types';
+import { CellLocation, GridRanges } from './useGridRangeSelection';
+export declare const useGridCopy: <TData extends GridBaseRow>({ ranges, rangeStartRef, rangeEndRef, hasSelectedMoreThanOneCellRef, cellContextMenu, }: {
+    ranges: () => GridRanges<TData>;
+    rangeStartRef: MutableRefObject<CellLocation | null>;
+    rangeEndRef: MutableRefObject<CellLocation | null>;
+    hasSelectedMoreThanOneCellRef: MutableRefObject<boolean>;
+    cellContextMenu: (event: CellContextMenuEvent) => void;
+}) => {
+    onCopyEvent: (e: ReactClipboardEvent<HTMLDivElement>) => void;
+    rangeSelectInterceptContextMenu: (event: CellContextMenuEvent<TData>) => void;
+    rangeSelectContextMenuComponent: import("react/jsx-runtime").JSX.Element | null;
+};

package/dist/src/components/gridHook/useGridCopySettings.d.ts

@@ -0,0 +1,11 @@
+import { IconName } from '@linzjs/lui/dist/components/LuiIcon/LuiIcon';
+export declare const gridCopyOptions: Record<string, {
+    text: string;
+    icon: IconName;
+    developer?: boolean;
+}>;
+export type CopyOptionsKey = keyof typeof gridCopyOptions;
+export declare const useGridCopySettings: () => {
+    copyType: string;
+    setCopyType: (key: CopyOptionsKey) => void;
+};

package/dist/src/components/gridHook/useGridRangeSelection.d.ts

@@ -0,0 +1,25 @@
+import { CellMouseDownEvent, CellMouseOverEvent, IRowNode } from 'ag-grid-community';
+import { MutableRefObject, RefObject } from 'react';
+import { GridBaseRow } from '../types';
+export interface CellLocation {
+    rowId: string;
+    colId: string;
+    timestamp: number;
+}
+export interface GridRanges<TData extends GridBaseRow> {
+    selectedColIds: string[];
+    selectedNodes: IRowNode<TData>[];
+}
+export declare const useGridRangeSelection: <TData extends GridBaseRow>({ enableRangeSelection, gridDivRef, rangeStartRef, rangeEndRef, hasSelectedMoreThanOneCellRef, rangeSortedNodesRef, }: {
+    enableRangeSelection: boolean;
+    gridDivRef: RefObject<HTMLDivElement>;
+    rangeStartRef: MutableRefObject<CellLocation | null>;
+    rangeEndRef: MutableRefObject<CellLocation | null>;
+    hasSelectedMoreThanOneCellRef: MutableRefObject<boolean>;
+    rangeSortedNodesRef: MutableRefObject<IRowNode<TData>[] | null>;
+}) => {
+    clearRangeSelection: () => void;
+    ranges: () => GridRanges<TData>;
+    onCellMouseDown: (e: CellMouseDownEvent) => void;
+    onCellMouseOver: (e: CellMouseOverEvent, mouseDown?: boolean) => void;
+};

package/dist/src/components/gridPopoverEdit/GridPopoverEditBearing.d.ts

@@ -1,7 +1,9 @@
+import { ValueFormatterParams } from 'ag-grid-community';
 import { GenericCellEditorProps } from '../GridCell';
 import { GridFormEditBearingProps } from '../gridForm/GridFormEditBearing';
 import { GenericCellColDef } from '../gridRender/GridRenderGenericCell';
 import { ColDefT, GridBaseRow } from '../types';
+export declare const GridCellBearingValueFormatter: (params: ValueFormatterParams) => string;
 export declare const GridPopoverEditBearingEditorParams: {
     placeHolder: string;
     formatValue: (value: any) => string;

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

@@ -1,5 +1,6 @@
 import { ColDef, EditableCallback, ICellRendererParams, ValueFormatterFunc, ValueGetterFunc } from 'ag-grid-community';
 import { ReactElement } from 'react';
+export declare const agGridSelectRowColId = "ag-Grid-SelectionColumn";
 export interface GridBaseRow {
     id: string | number;
 }

package/dist/src/contexts/GridContext.d.ts

@@ -60,6 +60,7 @@ export interface GridContextType<TData extends GridBaseRow> {
     onBulkEditingComplete: () => Promise<void> | void;
     setOnBulkEditingComplete: (callback: (() => Promise<void> | void) | undefined) => void;
     showNoRowsOverlay: () => void;
+    getCellValue: GridApi['getCellValue'];
 }
 export declare const GridContext: import("react").Context<GridContextType<any>>;
 export declare const useGridContext: <TData extends GridBaseRow>() => GridContextType<TData>;

package/dist/src/lui/timeoutHook.d.ts

@@ -6,9 +6,3 @@
  * but there's no way to enforce that, so  it would lead to bugs.
  */
 export declare const useTimeoutHook: () => (fn: () => void, waitTimeMs: number) => void;
-interface IntervalHookProps {
-    timeoutMs: number;
-    callback: () => void;
-}
-export declare const useIntervalHook: ({ callback, timeoutMs }: IntervalHookProps) => void;
-export {};

package/dist/src/lui/tsUtils.d.ts

@@ -0,0 +1,5 @@
+export type KeysOfType<TObject, TValue> = {
+    [K in keyof TObject]: TObject[K] extends TValue ? K : never;
+}[keyof TObject];
+export declare const typedKeys: <T extends object>(obj: T) => (keyof T)[];
+export declare const typedEntries: <T extends object>(obj: T) => { [K in keyof T]-?: [K, T[K]]; }[keyof T][];

package/dist/src/utils/__tests__/random.ts

@@ -0,0 +1,19 @@
+export class SeededRandomForTests {
+  value: number;
+  constructor(seed: number) {
+    this.value = seed % 2147483647;
+  }
+
+  next(maxInc?: number) {
+    this.value = (this.value * 16807) % 2147483647;
+    const result = (this.value - 1) / 2147483646;
+    if (maxInc == null) {
+      return result;
+    }
+    return ((result * (maxInc + 1)) | 0) % (maxInc + 1);
+  }
+
+  fromArray<T>(arr: T[]): T {
+    return arr[this.next(arr.length - 1)];
+  }
+}

package/dist/src/utils/util.d.ts

@@ -1,3 +1,4 @@
+export type MaybePromise<T> = T | Promise<T>;
 export declare const isNotEmpty: (value?: any) => boolean;
 export declare const wait: (timeoutMs: number) => Promise<(string | null)[]>;
 export declare const isFloat: (value: string) => boolean;