@progress/kendo-angular-treelist 3.1.3-dev.202110041229

package/dist/es2015/navigation/navigation-cursor.js

@@ -0,0 +1,174 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Subject } from 'rxjs';
+/**
+ * @hidden
+ */
+export class NavigationCursor {
+    constructor(model) {
+        this.model = model;
+        this.changes = new Subject();
+        this.activeRow = 0;
+        this.activeCol = 0;
+        this.virtualCol = 0;
+        this.virtualRow = 0;
+    }
+    get row() {
+        return this.model.findRow(this.activeRow);
+    }
+    get cell() {
+        const row = this.row;
+        if (row) {
+            return this.model.findCell(this.activeCol, row);
+        }
+    }
+    get dataRowIndex() {
+        const row = this.row;
+        if (row) {
+            return row.dataRowIndex;
+        }
+        return -1;
+    }
+    /**
+     * Assumes and announces a new cursor position.
+     */
+    reset(rowIndex = this.activeRow, colIndex = this.activeCol, force = true) {
+        if (this.activate(rowIndex, colIndex, force)) {
+            this.virtualRow = rowIndex;
+            this.virtualCol = colIndex;
+        }
+    }
+    activate(rowIndex, colIndex, force) {
+        if (!force && this.isActiveRange(rowIndex, colIndex)) {
+            return false;
+        }
+        const prevColIndex = this.activeCol;
+        const prevRowIndex = this.activeRow;
+        this.activeCol = colIndex;
+        this.activeRow = rowIndex;
+        this.changes.next({
+            colIndex,
+            prevColIndex,
+            prevRowIndex,
+            rowIndex
+        });
+        return true;
+    }
+    isActiveRange(rowIndex, colIndex) {
+        if (this.activeRow !== rowIndex) {
+            return false;
+        }
+        const cell = this.cell;
+        const { start, end } = this.model.cellRange(cell);
+        return !Boolean(cell) || (start <= colIndex && colIndex <= end);
+    }
+    /**
+     * Assumes a new cursor position without announcing it.
+     */
+    assume(rowIndex = this.activeRow, colIndex = this.activeCol) {
+        this.virtualRow = rowIndex;
+        this.virtualCol = colIndex;
+        this.activeCol = colIndex;
+        this.activeRow = rowIndex;
+    }
+    /**
+     * Announces a current cursor position to subscribers.
+     */
+    announce() {
+        this.changes.next({
+            colIndex: this.activeCol,
+            prevColIndex: this.activeCol,
+            prevRowIndex: this.activeRow,
+            rowIndex: this.activeRow
+        });
+    }
+    activateVirtualCell(cell) {
+        const rowRange = this.model.rowRange(cell);
+        const cellRange = this.model.cellRange(cell);
+        const activeCol = this.activeCol;
+        const activeRow = this.activeRow;
+        if (rowRange.start <= activeRow && activeRow <= rowRange.end &&
+            cellRange.start <= activeCol && activeCol <= cellRange.end) {
+            this.activeRow = cell.rowIndex;
+            this.activeCol = cell.colIndex;
+            return true;
+        }
+    }
+    isActive(rowIndex, colIndex) {
+        return this.activeCol === colIndex && this.activeRow === rowIndex;
+    }
+    moveUp(offset = 1) {
+        return this.offsetRow(-offset);
+    }
+    moveDown(offset = 1) {
+        return this.offsetRow(offset);
+    }
+    moveLeft(offset = 1) {
+        return this.offsetCol(-offset);
+    }
+    moveRight(offset = 1) {
+        return this.offsetCol(offset);
+    }
+    lastCellIndex() {
+        return this.metadata.columns.leafColumnsToRender.length - 1;
+    }
+    offsetCol(offset) {
+        const prevRow = this.model.findRow(this.virtualRow);
+        const lastIndex = this.lastCellIndex();
+        const virtualCol = this.virtualCol;
+        this.virtualCol = Math.max(0, Math.min(virtualCol + offset, lastIndex));
+        let nextColIndex = this.virtualCol;
+        let nextRowIndex = this.virtualRow;
+        let cell = this.model.findCell(this.virtualCol, prevRow);
+        if (!cell && this.metadata.virtualColumns) {
+            return this.activate(nextRowIndex, nextColIndex);
+        }
+        if (cell.colSpan > 1 && cell.colIndex <= virtualCol && virtualCol < cell.colIndex + cell.colSpan) {
+            nextColIndex = offset > 0 ? Math.min(cell.colIndex + cell.colSpan, lastIndex) : Math.max(0, cell.colIndex + offset);
+            const nextCell = this.model.findCell(nextColIndex, prevRow);
+            if (cell !== nextCell) {
+                cell = nextCell;
+                this.virtualCol = cell.colIndex;
+            }
+            else {
+                this.virtualCol = virtualCol;
+            }
+        }
+        return this.activate(cell.rowIndex, cell.colIndex);
+    }
+    offsetRow(offset) {
+        let nextColIndex = this.virtualCol;
+        if (this.metadata && this.metadata.isVirtual) {
+            const maxIndex = this.metadata.maxLogicalRowIndex;
+            let nextIndex = Math.max(0, Math.min(this.activeRow + offset, maxIndex));
+            const nextRow = this.model.findRow(nextIndex);
+            if (nextRow) {
+                // remove duplication
+                let cell = this.model.findCell(this.virtualCol, nextRow);
+                if (cell.rowIndex <= this.virtualRow && offset > 0 && cell.rowSpan > 1) {
+                    cell = this.model.findCell(this.virtualCol, this.model.findRow(cell.rowIndex + cell.rowSpan - 1 + offset));
+                }
+                nextIndex = cell.rowIndex;
+                nextColIndex = cell.colIndex;
+            }
+            this.virtualRow = nextIndex;
+            return this.activate(nextIndex, nextColIndex);
+        }
+        const nextRow = this.model.findRow(this.virtualRow + offset) || this.model.nextRow(this.virtualRow, offset);
+        if (!nextRow) {
+            return false;
+        }
+        let cell = this.model.findCell(this.virtualCol, nextRow);
+        if (cell && cell.rowIndex <= this.virtualRow && offset > 0 && cell.rowSpan > 1) { // spanned cell go to next
+            const nextPos = cell.rowIndex + cell.rowSpan - 1 + offset;
+            cell = this.model.findCell(this.virtualCol, this.model.findRow(nextPos));
+        }
+        if (!cell && this.metadata.virtualColumns) {
+            return this.activate(this.virtualRow + offset, this.virtualCol);
+        }
+        this.virtualRow = cell.rowIndex;
+        return this.activate(this.virtualRow, cell.colIndex);
+    }
+}

package/dist/es2015/navigation/navigation-metadata.d.ts

@@ -0,0 +1,20 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { ElementRef } from '@angular/core';
+/**
+ * @hidden
+ */
+export declare class NavigationMetadata {
+    view: any;
+    headerRows: number;
+    isVirtual: boolean;
+    hasPager: boolean;
+    treelistElement: ElementRef;
+    virtualColumns: boolean;
+    columns: any;
+    readonly maxLogicalRowIndex: number;
+    readonly dataRows: number;
+    constructor(view: any, headerRows: number, isVirtual: boolean, hasPager: boolean, treelistElement: ElementRef, virtualColumns: boolean, columns: any);
+}

package/dist/es2015/navigation/navigation-metadata.js

@@ -0,0 +1,24 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+/**
+ * @hidden
+ */
+export class NavigationMetadata {
+    constructor(view, headerRows, isVirtual, hasPager, treelistElement, virtualColumns, columns) {
+        this.view = view;
+        this.headerRows = headerRows;
+        this.isVirtual = isVirtual;
+        this.hasPager = hasPager;
+        this.treelistElement = treelistElement;
+        this.virtualColumns = virtualColumns;
+        this.columns = columns;
+    }
+    get maxLogicalRowIndex() {
+        return this.headerRows + this.dataRows - 1;
+    }
+    get dataRows() {
+        return this.view.totalRows;
+    }
+}

package/dist/es2015/navigation/navigation-mode.d.ts

@@ -0,0 +1,43 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+/**
+ * The operating mode of the navigation service.
+ *
+ * The following list includes some of the available state transitions:
+ *     Standby  (focusIn)                                               -> Cursor
+ *     Standby  (click)                     On focusable child          -> Content
+ *     Standby  (click)                     On cell                     -> Cursor
+ *     Cursor   (focusOut)                                              -> Standby
+ *     Cursor   (keydown = arrows, paging)                              -> Cursor
+ *     Cursor   (keydown = Enter|F2)        With focusable children     -> Content
+ *     Cursor   (keydown = Enter|F2)        Without focusable children  -> Cursor
+ *     Cursor   (keydown = other)           With focusable children     -> Content
+ *     Content  (focusOut)                                              -> Standby
+ *
+ * @hidden
+ *
+ */
+export declare const enum NavigationMode {
+    /**
+     * The TreeList is ready to receive focus.
+     * - The last focused cell has `tabindex = 0`.
+     * - Other focusable elements have `tabindex = -1`.
+     */
+    Standby = 0,
+    /**
+     * The TreeList has focus.
+     * - The user can navigate to adjacent cells with the arrow keys.
+     * - The user can skip cells when they navigate up and down by holding `Ctrl`.
+     * - The user can change pages by using `Page Up` or `Page Down`.
+     * - The user can focus content elements by pressing `Enter` or `F2`.
+     */
+    Cursor = 1,
+    /**
+     * The focus is on the content elements and the keyboard navigation of the TreeList is disabled.
+     * - The user can switch between focusable elements inside the TreeList by using `Tab`.
+     * - The user can return to the keyboard navigation mode by pressing `Enter`, `F2`, or `Esc`.
+     */
+    Content = 2
+}

package/dist/es2015/navigation/navigation-mode.js

@@ -0,0 +1,4 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/

package/dist/es2015/navigation/navigation-model.d.ts

@@ -0,0 +1,27 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { LogicalCell } from './logical-cell.interface';
+import { LogicalRow } from './logical-row.interface';
+/**
+ * @hidden
+ *
+ * Contains information for the currently rendered rows and cells.
+ */
+export declare class NavigationModel {
+    private rows;
+    readonly firstRow: any;
+    readonly lastRow: any;
+    registerCell(cell: LogicalCell): any;
+    unregisterCell(index: number, rowIndex: number, cell: LogicalCell): void;
+    registerRow(row: LogicalRow): void;
+    updateRow(row: LogicalRow): void;
+    unregisterRow(index: number, row: LogicalRow): void;
+    cellRange(cell: any): any;
+    rowRange(cell: any): any;
+    nextRow(rowIndex: any, offset: number): any;
+    findRow(index: number): any;
+    findCell(index: number, row: any): any;
+    private rowCell;
+}

package/dist/es2015/navigation/navigation-model.js

@@ -0,0 +1,128 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { ItemMap } from './item-map';
+import { ModelCell } from './model-cell';
+/**
+ * @hidden
+ *
+ * Contains information for the currently rendered rows and cells.
+ */
+export class NavigationModel {
+    constructor() {
+        this.rows = new ItemMap();
+    }
+    get firstRow() {
+        return this.rows.first;
+    }
+    get lastRow() {
+        return this.rows.last;
+    }
+    registerCell(cell) {
+        const row = this.rows.getItem(cell.logicalRowIndex);
+        if (!row) {
+            return;
+        }
+        const modelCell = new ModelCell(row, cell);
+        row.cells.setItem(cell.logicalColIndex, modelCell);
+        return modelCell;
+    }
+    unregisterCell(index, rowIndex, cell) {
+        const row = this.rows.getItem(rowIndex);
+        if (row) {
+            const match = row.cells.getItem(index);
+            if (match && match.uid === cell.uid) {
+                row.cells.removeItem(index);
+            }
+        }
+    }
+    registerRow(row) {
+        const modelRow = {
+            uid: row.uid,
+            index: row.logicalRowIndex,
+            dataItem: row.dataItem,
+            dataRowIndex: row.dataRowIndex,
+            cells: new ItemMap(),
+            isNew: row.isNew
+        };
+        this.rows.setItem(row.logicalRowIndex, modelRow);
+    }
+    updateRow(row) {
+        const current = this.rows.getItem(row.logicalRowIndex);
+        if (current) {
+            Object.assign(current, {
+                dataItem: row.dataItem,
+                dataRowIndex: row.dataRowIndex
+            });
+        }
+    }
+    unregisterRow(index, row) {
+        const match = this.rows.getItem(index);
+        if (match && match.uid === row.uid) {
+            this.rows.removeItem(index);
+        }
+    }
+    cellRange(cell) {
+        if (cell) {
+            const start = cell.colIndex;
+            const end = cell.colIndex + (cell.colSpan || 1) - 1;
+            return {
+                start,
+                end
+            };
+        }
+        return {};
+    }
+    rowRange(cell) {
+        if (cell) {
+            const start = cell.rowIndex;
+            const end = cell.rowIndex + (cell.rowSpan || 1) - 1;
+            return {
+                start,
+                end
+            };
+        }
+        return {};
+    }
+    nextRow(rowIndex, offset) {
+        const rows = this.rows.toArray();
+        const row = this.rows.getItem(rowIndex);
+        const position = rows.indexOf(row);
+        const next = rows[position + offset];
+        return next;
+    }
+    findRow(index) {
+        return this.rows.getItem(index);
+    }
+    findCell(index, row) {
+        if (!row) {
+            return;
+        }
+        const rowIndex = row.index;
+        let cell = row.cells.getItem(index);
+        let currentIndex = rowIndex;
+        while (!cell && row) {
+            row = this.rows.getItem(currentIndex);
+            cell = this.rowCell(index, row);
+            currentIndex--;
+        }
+        if (cell && rowIndex <= row.index + (cell.rowSpan || 1) - 1) {
+            return cell;
+        }
+    }
+    rowCell(index, row) {
+        if (!row || !row.cells.count) {
+            return;
+        }
+        const firstCell = row.cells.first;
+        let cell, currentIndex = index;
+        while (!cell && currentIndex >= firstCell.colIndex) {
+            cell = row.cells.getItem(currentIndex);
+            currentIndex--;
+        }
+        if (cell && index <= cell.colIndex + (cell.colSpan || 1) - 1) {
+            return cell;
+        }
+    }
+}

package/dist/es2015/navigation/navigation-row.interface.d.ts

@@ -0,0 +1,38 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { NavigationCell } from './navigation-cell.interface';
+/**
+ * The metadata for a focusable TreeList row. Focusable rows include
+ * headers, group headers and footers, and data rows.
+ */
+export interface NavigationRow {
+    /**
+     * @hidden
+     */
+    uid: number;
+    /**
+     * The logical index of the focusable row.
+     *
+     * * Header rows are included, starting at index 0.
+     * * The row indexing is absolute and does not change with paging.
+     */
+    index: number;
+    /**
+     * The data item index for this row.
+     */
+    dataRowIndex: number;
+    /**
+     * A flag indicating if this is a new row.
+     */
+    isNew: boolean;
+    /**
+     * The data item for this row.
+     */
+    dataItem: any;
+    /**
+     * An array of focusable cells which are associated with this row.
+     */
+    cells: NavigationCell[];
+}

package/dist/es2015/navigation/navigation-row.interface.js

@@ -0,0 +1,4 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/

package/dist/es2015/navigation/navigation.service.d.ts

@@ -0,0 +1,105 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { ChangeDetectorRef, EventEmitter, NgZone, OnDestroy } from '@angular/core';
+import { LocalizationService } from '@progress/kendo-angular-l10n';
+import { Subject } from 'rxjs';
+import { FocusRoot } from './focus-root';
+import { FocusableDirective } from './focusable.directive';
+import { LogicalCell } from './logical-cell.interface';
+import { LogicalRow } from './logical-row.interface';
+import { NavigationCell } from './navigation-cell.interface';
+import { NavigationChange } from './navigation-change.interface';
+import { NavigationMetadata } from './navigation-metadata';
+import { NavigationRow } from './navigation-row.interface';
+import { DomEventsService } from '../common/dom-events.service';
+import { EditService } from '../editing/edit.service';
+import { ExpandStateService } from '../expand-state/expand-state.service';
+import { PagerContextService } from '../pager/pager-context.service';
+import { ScrollRequestService } from '../scrolling/scroll-request.service';
+import { SelectionService } from '../selection/selection.service';
+/**
+ * @hidden
+ */
+export declare class NavigationViewport {
+    firstItemIndex: number;
+    lastItemIndex: number;
+    constructor(firstItemIndex: number, lastItemIndex: number);
+    containsRow(dataRowIndex: number): boolean;
+    intersects(start: number, end: number): boolean;
+}
+/**
+ * @hidden
+ */
+export declare class NavigationService implements OnDestroy {
+    private zone;
+    private domEvents;
+    private pagerContextService;
+    private scrollRequestService;
+    private focusRoot;
+    private editService;
+    private localization;
+    private expandState;
+    private selectionService;
+    private changeDetector;
+    private focusableParent;
+    readonly changes: Subject<NavigationChange>;
+    readonly cellKeydown: EventEmitter<any>;
+    metadata: NavigationMetadata;
+    readonly enabled: boolean;
+    readonly activeCell: NavigationCell;
+    readonly activeRow: NavigationRow;
+    viewport: NavigationViewport;
+    columnViewport: NavigationViewport;
+    private activeRowIndex;
+    private alive;
+    private active;
+    private mode;
+    private model;
+    private cursor;
+    private meta;
+    private subs;
+    private pendingRowIndex;
+    private virtualCell;
+    private readonly activeDataRow;
+    constructor(zone: NgZone, domEvents: DomEventsService, pagerContextService: PagerContextService, scrollRequestService: ScrollRequestService, focusRoot: FocusRoot, editService: EditService, localization: LocalizationService, expandState: ExpandStateService, selectionService: SelectionService, changeDetector: ChangeDetectorRef, focusableParent: FocusableDirective);
+    init(meta: NavigationMetadata): void;
+    ngOnDestroy(): void;
+    registerCell(cell: LogicalCell): void;
+    registerCellOnCurrentRow(cell: LogicalCell): void;
+    unregisterCell(index: number, rowIndex: number, cell: LogicalCell): void;
+    registerRow(row: LogicalRow): void;
+    updateRow(row: LogicalRow): void;
+    unregisterRow(index: number, row: LogicalRow): void;
+    isCellFocusable(cell: LogicalCell): boolean;
+    isCellFocused(cell: LogicalCell): boolean;
+    navigateTo(el: Element): void;
+    tryFocus(el: Element): boolean;
+    needsViewport(): boolean;
+    setViewport(firstItemIndex: number, lastItemIndex: number): void;
+    setColumnViewport(firstItemIndex: number, lastItemIndex: number): void;
+    focusCell(rowIndex?: number, colIndex?: number): NavigationCell;
+    focusNextCell(wrap?: boolean): NavigationCell;
+    focusPrevCell(wrap?: boolean): NavigationCell;
+    toggle(active: boolean): void;
+    hasFocus(): boolean;
+    autoFocusCell(start: number, end: number): boolean;
+    private focusAdjacentCell;
+    private enterCell;
+    private leaveCell;
+    private activateElements;
+    private deactivateElements;
+    private activateRow;
+    private moveCursorFwd;
+    private moveCursorBwd;
+    private updateSelection;
+    private onCursorKeydown;
+    private onContentKeydown;
+    private onCellKeydown;
+    private onCursorChanges;
+    private onFocusOut;
+    private onWindowBlur;
+    private onKeydown;
+    private onTabout;
+}