@revolist/revogrid 4.0.4-next → 4.0.4

package/dist/types/components/header/revogr-header.d.ts

@@ -1,27 +1,75 @@
 import { EventEmitter } from '../../stencil-public-runtime';
 import { HTMLStencilElement } from '../../stencil-public-runtime';
-import { Observable, RevoGrid, Selection } from '../../interfaces';
 import { Groups } from '../../store/dataSource/data.store';
+import { ResizeProps } from '../../services/resizable.directive';
+import { ColumnRegular, DimensionSettingsState, InitialHeaderClick, Observable, Providers, ViewportState, ViewSettingSizeProp } from '../../types/interfaces';
+import { DimensionCols } from '../../types/dimension';
+import { SelectionStoreState } from '../../types/selection';
 export declare class RevogrHeaderComponent {
-  element: HTMLStencilElement;
-  viewportCol: Observable<RevoGrid.ViewportState>;
-  dimensionCol: Observable<RevoGrid.DimensionSettingsState>;
-  selectionStore: Observable<Selection.SelectionStoreState>;
-  parent: string;
-  groups: Groups;
-  groupingDepth: number;
-  canResize: boolean;
-  colData: RevoGrid.ColumnRegular[];
-  columnFilter: boolean;
-  initialHeaderClick: EventEmitter<RevoGrid.InitialHeaderClick>;
-  headerresize: EventEmitter<RevoGrid.ViewSettingSizeProp>;
-  headerdblClick: EventEmitter<RevoGrid.InitialHeaderClick>;
-  private onResize;
-  private onResizeGroup;
-  render(): any[];
-  get providers(): {
-    viewport: Observable<RevoGrid.ViewportState>;
-    dimension: Observable<RevoGrid.DimensionSettingsState>;
-    selection: Observable<Selection.SelectionStoreState>;
-  };
+    /**
+     * Stores
+     */
+    /** Viewport X */
+    viewportCol: Observable<ViewportState>;
+    /** Dimension settings X */
+    dimensionCol: Observable<DimensionSettingsState>;
+    /** Selection, range, focus */
+    selectionStore: Observable<SelectionStoreState>;
+    /**
+     * Column groups
+     */
+    groups: Groups;
+    /**
+     * Grouping depth, how many levels of grouping
+     */
+    groupingDepth: number;
+    /**
+     * Readonly mode
+     */
+    readonly: boolean;
+    /**
+     * If columns can be resized
+     */
+    canResize: boolean;
+    /**
+     * Defines resize position
+     */
+    resizeHandler: ResizeProps['active'];
+    /**
+     * Columns - defines an array of grid columns.
+     */
+    colData: ColumnRegular[];
+    /**
+     * Column filter
+     */
+    columnFilter: boolean;
+    /**
+     * Column type
+     */
+    type: DimensionCols | 'rowHeaders';
+    /**
+     * Extra properties to pass into header renderer, such as vue or react components to handle parent
+     */
+    additionalData: any;
+    /**
+     * On initial header click
+    */
+    initialHeaderClick: EventEmitter<InitialHeaderClick>;
+    /**
+     * On header resize
+    */
+    headerresize: EventEmitter<ViewSettingSizeProp>;
+    /**
+     * On before header resize
+    */
+    beforeResize: EventEmitter<ColumnRegular[]>;
+    /**
+     * On header double click
+     */
+    headerdblClick: EventEmitter<InitialHeaderClick>;
+    element: HTMLStencilElement;
+    private onResize;
+    private onResizeGroup;
+    render(): any[];
+    get providers(): Providers<DimensionCols | 'rowHeaders'>;
 }

package/dist/types/components/order/order-renderer.d.ts

@@ -0,0 +1,29 @@
+import { VNode } from '../../stencil-public-runtime';
+import { PositionItem } from '../../types/interfaces';
+import { Cell } from '../../types/selection';
+type Props = {
+    ref: {
+        (e: OrdererService): void;
+    };
+};
+/**
+ * Draw drag
+ */
+export declare class OrdererService {
+    private parentY;
+    el: HTMLElement;
+    rgRow: HTMLElement;
+    text: HTMLElement;
+    draggable: HTMLElement;
+    start(parent: HTMLElement, { pos, text, event }: {
+        pos: PositionItem;
+        text: string;
+        event: MouseEvent;
+    }): void;
+    end(): void;
+    move(pos: PositionItem): void;
+    moveTip({ x, y }: Cell): void;
+    private moveElement;
+}
+declare const OrderRenderer: ({ ref }: Props) => VNode[];
+export default OrderRenderer;

package/dist/types/components/order/order-row.service.d.ts

@@ -0,0 +1,28 @@
+import { DimensionSettingsState, PositionItem } from '../..';
+import { Cell } from '../..';
+type EventData = {
+    el: HTMLElement;
+    rows: DimensionSettingsState;
+    cols: DimensionSettingsState;
+};
+interface Config {
+    positionChanged(from: number, to: number): void;
+}
+export default class RowOrderService {
+    private config;
+    private currentCell;
+    private previousRow;
+    constructor(config: Config);
+    /** Drag finished, calculate and apply changes */
+    endOrder(e: MouseEvent, data: EventData): void;
+    /** Drag started, reserve initial cell for farther use */
+    startOrder(e: MouseEvent, data: EventData): Cell;
+    move(y: number, data: EventData): PositionItem | null;
+    /** Drag stopped, probably cursor outside of document area */
+    clear(): void;
+    /** Calculate cell based on x, y position */
+    getRow(y: number, { el, rows }: EventData): PositionItem;
+    /** Calculate cell based on x, y position */
+    getCell({ x, y }: Cell, { el, rows, cols }: EventData): Cell;
+}
+export {};

package/dist/types/components/order/revogr-order-editor.d.ts

@@ -1,44 +1,46 @@
 import { EventEmitter } from '../../stencil-public-runtime';
-import { Observable, RevoGrid, Selection } from '../../interfaces';
-import { DataSourceState } from '../../store/dataSource/data.store';
+import { DSourceState } from '../../store/dataSource/data.store';
+import { DimensionRows } from '../../types/dimension';
+import { DataType, DimensionSettingsState, DragStartEvent, Observable, PositionItem } from '../../types/interfaces';
+import { Cell } from '../../types/selection';
 export declare class OrderEditor {
-  private rowOrderService;
-  private moveFunc;
-  private rowMoveFunc;
-  parent: HTMLElement;
-  dimensionRow: Observable<RevoGrid.DimensionSettingsState>;
-  dimensionCol: Observable<RevoGrid.DimensionSettingsState>;
-  /** Static stores, not expected to change during component lifetime */
-  dataStore: Observable<DataSourceState<RevoGrid.DataType, RevoGrid.DimensionRows>>;
-  /** Row drag started */
-  internalRowDragStart: EventEmitter<{
-    cell: Selection.Cell;
-    text: string;
-    pos: RevoGrid.PositionItem;
-    event: MouseEvent;
-  }>;
-  /** Row drag ended */
-  internalRowDragEnd: EventEmitter;
-  /** Row move */
-  internalRowDrag: EventEmitter<RevoGrid.PositionItem>;
-  /** Row mouse move */
-  internalRowMouseMove: EventEmitter<Selection.Cell>;
-  /** Row dragged, new range ready to be applied */
-  initialRowDropped: EventEmitter<{
-    from: number;
-    to: number;
-  }>;
-  onMouseOut(): void;
-  /** Action finished inside of the document */
-  onMouseUp(e: MouseEvent): void;
-  dragStart(e: MouseEvent): Promise<void>;
-  endOrder(e: MouseEvent): Promise<void>;
-  clearOrder(): Promise<void>;
-  move({ x, y }: {
-    x: number;
-    y: number;
-  }): void;
-  connectedCallback(): void;
-  private onPositionChanged;
-  private getData;
+    /** Parent element */
+    parent: HTMLElement;
+    /** Dimension settings Y */
+    dimensionRow: Observable<DimensionSettingsState>;
+    /** Dimension settings X */
+    dimensionCol: Observable<DimensionSettingsState>;
+    /** Static stores, not expected to change during component lifetime */
+    dataStore: Observable<DSourceState<DataType, DimensionRows>>;
+    /** Row drag started */
+    rowDragStart: EventEmitter<{
+        cell: Cell;
+        text: string;
+        pos: PositionItem;
+        event: MouseEvent;
+    }>;
+    /** Row drag ended started */
+    rowDragEnd: EventEmitter;
+    /** Row move started */
+    rowDrag: EventEmitter<PositionItem>;
+    /** Row mouse move started */
+    rowMouseMove: EventEmitter<Cell>;
+    /** Row dragged, new range ready to be applied */
+    rowDropped: EventEmitter<{
+        from: number;
+        to: number;
+    }>;
+    private rowOrderService;
+    private events;
+    private rowMoveFunc;
+    dragStart(e: DragStartEvent): Promise<void>;
+    endOrder(e: MouseEvent): Promise<void>;
+    clearOrder(): Promise<void>;
+    move({ x, y }: {
+        x: number;
+        y: number;
+    }): void;
+    connectedCallback(): void;
+    private onPositionChanged;
+    private getData;
 }

package/dist/types/components/overlay/autofill.service.d.ts

@@ -1,61 +1,76 @@
-import { Observable, Selection, RevoGrid, Edition } from '../../interfaces';
 import { EventData } from './selection.utils';
 import SelectionStoreService from '../../store/selection/selection.store.service';
-import ColumnService from '../data/columnService';
-import { DataSourceState } from '../../store/dataSource/data.store';
-declare type Config = {
-  selectionStoreService: SelectionStoreService;
-  dimensionRow: Observable<RevoGrid.DimensionSettingsState>;
-  dimensionCol: Observable<RevoGrid.DimensionSettingsState>;
-  columnService: ColumnService;
-  dataStore: Observable<DataSourceState<RevoGrid.DataType, RevoGrid.DimensionRows>>;
-  setTempRange(e: Selection.TempRange | null): Event;
-  internalSelectionChanged(e: Selection.ChangedRange): Event;
-  internalRangeDataApply(e: Edition.BeforeRangeSaveDataDetails): Event;
-  setRange(e: Selection.RangeArea): Event;
-  getData(): any;
+import ColumnService from '../data/column.service';
+import { DSourceState } from '../../store/dataSource/data.store';
+import { DataLookup, DataType, DimensionSettingsState, Observable } from '../../types/interfaces';
+import { TempRange, ChangedRange, BeforeRangeSaveDataDetails, RangeArea, Cell } from '../../types/selection';
+import { DimensionRows } from '../../types/dimension';
+type Config = {
+    selectionStoreService: SelectionStoreService;
+    dimensionRow: Observable<DimensionSettingsState>;
+    dimensionCol: Observable<DimensionSettingsState>;
+    columnService: ColumnService;
+    dataStore: Observable<DSourceState<DataType, DimensionRows>>;
+    setTempRange(e: TempRange | null): Event;
+    selectionChanged(e: ChangedRange): Event;
+    rangeCopy(e: ChangedRange): Event;
+    rangeDataApply(e: BeforeRangeSaveDataDetails): CustomEvent;
+    setRange(e: RangeArea): boolean;
+    clearRangeDataApply(e: {
+        range: RangeArea;
+    }): CustomEvent<{
+        range: RangeArea;
+    }>;
+    getData(): any;
 };
-declare enum AutoFillType {
-  selection = "Selection",
-  autoFill = "AutoFill"
+declare const enum AutoFillType {
+    selection = "Selection",
+    autoFill = "AutoFill"
 }
 export declare class AutoFillService {
-  private sv;
-  private autoFillType;
-  private autoFillInitial;
-  private autoFillStart;
-  private autoFillLast;
-  private onMouseMoveAutofill;
-  constructor(sv: Config);
-  /**
-   * Render autofill box
-   * @param range
-   * @param selectionFocus
-   */
-  renderAutofill(range: Selection.RangeArea, selectionFocus: Selection.Cell): any;
-  get isAutoFill(): boolean;
-  /** Process mouse move events */
-  selectionMouseMove(e: MouseEvent): void;
-  private getFocus;
-  /**
-   * Autofill logic:
-   * on mouse move apply based on previous direction (if present)
-   */
-  private doAutofillMouseMove;
-  /**
-   * Range selection started
-   * Mode @param type:
-   * Can be triggered from MouseDown selection on element
-   * Or can be triggered on corner square drag
-   */
-  selectionStart(e: MouseEvent, data: EventData, type?: AutoFillType): void;
-  /** Clear current range selection */
-  clearAutoFillSelection(): void;
-  /** Trigger range apply events and handle responses */
-  onRangeApply(data: RevoGrid.DataLookup, range: Selection.RangeArea): void;
-  /** Apply range and copy data during range application */
-  private applyRangeWithData;
-  /** Update range selection ony, no data change (mouse selection) */
-  private applyRangeOnly;
+    private sv;
+    private autoFillType;
+    private autoFillInitial;
+    private autoFillStart;
+    private autoFillLast;
+    private onMouseMoveAutofill;
+    constructor(sv: Config);
+    /**
+     * Render autofill box
+     * @param range
+     * @param selectionFocus
+     */
+    renderAutofill(range: RangeArea, selectionFocus: Cell): any;
+    private autoFillHandler;
+    get isAutoFill(): boolean;
+    /** Process mouse move events */
+    selectionMouseMove(e: MouseEvent | TouchEvent): void;
+    private getFocus;
+    /**
+     * Autofill logic:
+     * on mouse move apply based on previous direction (if present)
+     */
+    private doAutofillMouseMove;
+    /**
+     * Range selection started
+     * Mode @param type:
+     * Can be triggered from MouseDown selection on element
+     * Or can be triggered on corner square drag
+     */
+    selectionStart(target: Element, data: EventData, type?: AutoFillType): void;
+    /**
+     * Clear current range selection
+     * on mouse up and mouse leave events
+     */
+    clearAutoFillSelection(): void;
+    /** Trigger range apply events and handle responses */
+    onRangeApply(data: DataLookup, range: RangeArea): void;
+    /** Apply range and copy data during range application */
+    private applyRangeWithData;
+    /**
+     * Update range selection only,
+     * no data change (mouse selection)
+     */
+    private applyRangeOnly;
 }
 export {};

package/dist/types/components/overlay/keyboard.service.d.ts

@@ -1,28 +1,29 @@
-import { Observable, Selection } from '../../interfaces';
 import SelectionStoreService from '../../store/selection/selection.store.service';
-import { EventData } from './selection.utils';
-declare type Config = {
-  selectionStoreService: SelectionStoreService;
-  selectionStore: Observable<Selection.SelectionStoreState>;
-  doEdit(val?: any, isCancel?: boolean): void;
-  clearCell(): void;
-  getData(): any;
-  internalPaste(): void;
+import { Cell, RangeArea, SelectionStoreState } from '../..';
+import { Observable } from '../..';
+type Config = {
+    selectionStoreService: SelectionStoreService;
+    selectionStore: Observable<SelectionStoreState>;
+    change(val?: any): void;
+    cancel(): void;
+    clearCell(): void;
+    focusNext(focus: Cell, next: Partial<Cell>): boolean;
+    getData(): any;
+    internalPaste(): void;
+    range(range: RangeArea): boolean;
+    selectAll(): void;
 };
 export declare class KeyboardService {
-  private sv;
-  private ctrlDown;
-  constructor(sv: Config);
-  keyDown(e: KeyboardEvent, canRange: boolean): Promise<void>;
-  keyChangeSelection(e: KeyboardEvent, canRange: boolean): Promise<boolean>;
-  keyPositionChange(changes: Partial<Selection.Cell>, eData: EventData, range?: Selection.RangeArea, focus?: Selection.Cell, isMulti?: boolean): boolean;
-  keyUp(e: KeyboardEvent): void;
-  isCopy(e: KeyboardEvent): boolean;
-  isPaste(e: KeyboardEvent): boolean;
-  /** Monitor key direction changes */
-  changeDirectionKey(e: KeyboardEvent, canRange: boolean): {
-    changes: Partial<Selection.Cell>;
-    isMulti?: boolean;
-  } | void;
+    private sv;
+    constructor(sv: Config);
+    keyDown(e: KeyboardEvent, canRange: boolean): Promise<void>;
+    private selectAll;
+    keyChangeSelection(e: KeyboardEvent, canRange: boolean): Promise<boolean>;
+    keyPositionChange(changes: Partial<Cell>, range?: RangeArea, focus?: Cell, isMulti?: boolean): boolean;
+    /** Monitor key direction changes */
+    changeDirectionKey(e: KeyboardEvent, canRange: boolean): {
+        changes: Partial<Cell>;
+        isMulti?: boolean;
+    } | void;
 }
 export {};