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

package/dist/es2015/data/data.collection.js

@@ -0,0 +1,431 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { isObservable, Subscription, BehaviorSubject } from 'rxjs';
+import { take } from 'rxjs/operators';
+import { EventEmitter } from '@angular/core';
+const ɵ0 = () => true;
+/**
+ * @hidden
+ */
+export const EXPANDED_STATE = {
+    isExpanded: ɵ0
+};
+const ɵ1 = () => false;
+/**
+ * @hidden
+ */
+export const UNSELECTED_STATE = {
+    isRowSelected: ɵ1
+};
+const ɵ2 = () => false, ɵ3 = () => null;
+/**
+ * @hidden
+ */
+export const NOT_EDITED_STATE = {
+    hasNew: ɵ2,
+    context: ɵ3
+};
+const identity = item => item;
+const ɵ4 = identity;
+function loadView(view, subject) {
+    view.loadData();
+    if (view.loading) {
+        view.dataLoaded.pipe(take(1)).subscribe(() => {
+            loadView(view, subject);
+        });
+    }
+    else {
+        subject.next(view);
+    }
+}
+const LOADING = 'loading';
+class ViewRange {
+    constructor(skip, pageSize, pageable) {
+        this.skip = skip;
+        this.pageSize = pageSize;
+        this.pageable = pageable;
+    }
+    static create(options) {
+        const { skip, pageSize, pageable, isVirtual } = options;
+        let rangeType = ViewRange;
+        if (pageSize) {
+            if (pageable) {
+                rangeType = PagerRange;
+            }
+            else if (isVirtual) {
+                rangeType = VirtualRange;
+            }
+        }
+        return new rangeType(skip, pageSize, pageable);
+    }
+    inRange(_index, _rowIndex) {
+        return true;
+    }
+    levelInRange(_parent, _items, _rowIndex) {
+        return true;
+    }
+    includeParents(_children) {
+    }
+}
+function isPagerSettings(pageable) {
+    return typeof pageable === "object";
+}
+class PagerRange extends ViewRange {
+    constructor(skip, pageSize, pageable) {
+        super(skip, pageSize, pageable);
+        this.expandAll = true;
+        if (isPagerSettings(pageable)) {
+            this.expandAll = pageable.countChildren !== false;
+        }
+    }
+    inRange(index, _rowIndex) {
+        return this.skip <= index && index < this.skip + this.pageSize;
+    }
+    levelInRange(parent, items, _rowIndex) {
+        return parent.level === -1 ||
+            (this.skip <= parent.index + items.length && parent.index + 1 < this.skip + this.pageSize);
+    }
+    includeParents(children) {
+        let parentLevel = children.parentLevel;
+        while (parentLevel && !parentLevel.inRange) {
+            parentLevel.inRange = true;
+            parentLevel = parentLevel.parentLevel;
+        }
+    }
+}
+class VirtualRange extends ViewRange {
+    inRange(_index, rowIndex) {
+        return this.skip <= rowIndex && rowIndex < this.skip + this.pageSize;
+    }
+    levelInRange(parent, _items, rowIndex) {
+        return this.inRange(parent.index, rowIndex);
+    }
+}
+/**
+ * @hidden
+ */
+export class ViewItemFactory {
+    constructor(expandState, editState, selectionState, loaded, fieldAccessor, rootItem) {
+        this.expandState = expandState;
+        this.editState = editState;
+        this.selectionState = selectionState;
+        this.loaded = loaded;
+        this.fieldAccessor = fieldAccessor;
+        this.observables = [];
+        this.rowIndex = 0;
+        const options = this.fieldAccessor();
+        this.fetchChildren = options.fetchChildren;
+        this.hasChildren = options.hasChildren;
+        this.idGetter = options.idGetter;
+        this.hasFooter = options.hasFooter;
+        this.viewRange = ViewRange.create(options);
+        if (rootItem) {
+            this.rootLevel = this.loadChildren(rootItem);
+        }
+        else {
+            this.rootLevel = this.dataLevel({
+                level: -1,
+                id: null,
+                expanded: true
+            }, options.data);
+        }
+    }
+    // try to stop iteration if cached total and viewRange ends
+    generate() {
+        const result = [];
+        const dataLevels = [this.rootLevel];
+        let itemIndex = 0;
+        let itemCount = 0;
+        this.addNew(result);
+        while (dataLevels.length) {
+            while (dataLevels[0] && dataLevels[0].idx >= dataLevels[0].items.length) {
+                const dataLevel = dataLevels.shift();
+                if (this.hasFooter && dataLevel.expanded && dataLevel.items.length) {
+                    if (dataLevel.inRange || this.viewRange.levelInRange(dataLevel.parent, dataLevel.items, this.rowIndex)) {
+                        result.push({
+                            type: 'footer',
+                            items: dataLevel.items,
+                            aggregates: dataLevel.aggregates,
+                            level: dataLevel.level,
+                            parentIndex: dataLevel.parentIndex,
+                            rowIndex: this.rowIndex
+                        });
+                        this.viewRange.includeParents(dataLevel);
+                    }
+                    this.rowIndex++;
+                }
+            }
+            if (!dataLevels.length) {
+                break;
+            }
+            const currentLevel = dataLevels[0];
+            const dataItem = currentLevel.items[currentLevel.idx++];
+            const viewItem = {
+                type: 'data',
+                data: dataItem,
+                id: this.idGetter(dataItem),
+                rowIndex: this.rowIndex,
+                index: itemIndex,
+                level: currentLevel.level,
+                hasChildren: this.hasChildren(dataItem),
+                parent: currentLevel.parent
+            };
+            if (currentLevel.expanded) {
+                this.rowIndex++;
+                if (this.viewRange.inRange(itemIndex, viewItem.rowIndex)) {
+                    if (this.offsetFirst) {
+                        viewItem.rowIndex++;
+                        this.rowIndex++;
+                        this.offsetFirst = false;
+                    }
+                    result.push(viewItem);
+                    viewItem.editContext = this.editState.context(viewItem.data);
+                    viewItem.selected = this.selectionState.isRowSelected(dataItem);
+                    this.addNew(result, dataItem);
+                }
+                itemIndex++;
+            }
+            itemCount++;
+            const expanded = viewItem.hasChildren && this.expandState.isExpanded(viewItem.data);
+            if (viewItem.hasChildren && (expanded || this.viewRange.expandAll)) {
+                viewItem.expanded = expanded && currentLevel.expanded;
+                const children = this.loadChildren(viewItem);
+                if (children) {
+                    dataLevels.unshift(children);
+                    children.parentLevel = currentLevel;
+                }
+            }
+        }
+        return {
+            items: result,
+            observables: this.observables,
+            total: itemCount,
+            totalVisible: itemIndex,
+            totalRows: this.rowIndex
+        };
+    }
+    loadChildren(parent) {
+        const parentId = parent.id;
+        if (this.loaded.has(parentId)) {
+            const children = this.loaded.get(parentId);
+            if (children === LOADING) {
+                parent.loading = true;
+            }
+            else {
+                return this.dataLevel(parent, children);
+            }
+        }
+        else {
+            const children = this.fetchChildren(parent.data);
+            if (isObservable(children)) {
+                this.observables.push({
+                    observable: children,
+                    parentId: parentId
+                });
+                parent.loading = true;
+            }
+            else if (children) {
+                this.loaded.set(parentId, children);
+                return this.dataLevel(parent, children);
+            }
+        }
+    }
+    dataLevel(parent, children) {
+        children = children || {};
+        const data = children.data || children;
+        const items = data && data.length ? data : [];
+        return {
+            idx: 0,
+            level: parent.level + 1,
+            items: items,
+            aggregates: children.aggregates,
+            expanded: parent.expanded,
+            parentIndex: parent.index,
+            parent: parent
+        };
+    }
+    addNew(result, parent) {
+        if (this.editState.hasNew(parent)) {
+            const inRange = this.viewRange.inRange(0, this.rowIndex);
+            const rowIndex = parent || inRange ? this.rowIndex : this.viewRange.skip;
+            result.push({
+                parent: parent,
+                isNew: true,
+                type: 'data',
+                data: this.editState.newItem.dataItem,
+                editContext: this.editState.newItem,
+                rowIndex: rowIndex
+            });
+            if (parent || inRange) {
+                this.rowIndex++;
+            }
+            else {
+                this.offsetFirst = true;
+            }
+        }
+    }
+}
+/**
+ * @hidden
+ */
+export class ViewCollection {
+    constructor(fieldAccessor, expandState, editState, selectionState) {
+        this.fieldAccessor = fieldAccessor;
+        this.expandState = expandState;
+        this.editState = editState;
+        this.selectionState = selectionState;
+        this.childrenLoaded = new EventEmitter();
+        this.dataLoaded = new EventEmitter();
+        this.resetPage = new EventEmitter();
+        this.total = 0;
+        this.totalVisible = 0;
+        this.loaded = new Map();
+        this.loading = false;
+        this._totalRows = 0;
+        this.loadingCount = 0;
+    }
+    static loadView(options) {
+        const subject = new BehaviorSubject(null);
+        const viewFields = () => Object.assign({
+            idGetter: identity,
+            pageable: false,
+            isVirtual: false,
+            skip: 0
+        }, options.fields);
+        const childrenView = new ViewCollection(viewFields, options.expandState || EXPANDED_STATE, options.editState || NOT_EDITED_STATE, options.selectionState || UNSELECTED_STATE);
+        if (options.loaded) {
+            childrenView.loaded = options.loaded;
+        }
+        loadView(childrenView, subject);
+        return subject;
+    }
+    get totalRows() {
+        if (!this._data) {
+            this.loadData();
+        }
+        return this._totalRows;
+    }
+    get data() {
+        if (!this._data) {
+            this.loadData();
+        }
+        return this._data;
+    }
+    get length() { return this.data.length; }
+    get first() { return this.data[0]; }
+    get firstItem() {
+        return this.find(item => item.type === 'data');
+    }
+    get last() { return this.data[this.data.length - 1]; }
+    at(index) {
+        return this.data[index];
+    }
+    itemIndex(item) {
+        const idGetter = this.fieldAccessor().idGetter;
+        return this.data.findIndex(i => i.id === idGetter(item));
+    }
+    map(fn) { return this.data.map(fn); }
+    filter(fn) {
+        return this.data.filter(fn);
+    }
+    findIndex(fn) {
+        return this.data.findIndex(fn);
+    }
+    reduce(fn, init) {
+        return this.data.reduce(fn, init);
+    }
+    forEach(fn) {
+        this.data.forEach(fn);
+    }
+    some(fn) {
+        return this.data.some(fn);
+    }
+    find(fn) {
+        return this.data.find(fn);
+    }
+    toString() { return this.data.toString(); }
+    updateSelectedState() {
+        this.forEach(item => {
+            if (item.type === 'data') {
+                item.selected = this.selectionState.isRowSelected(item.data);
+            }
+        });
+    }
+    updateEditedState() {
+        this.forEach(item => {
+            if (item.type === 'data') {
+                item.editContext = this.editState.context(item.data);
+            }
+        });
+    }
+    reset() {
+        this.loaded.clear();
+        this.clear();
+        this.unsubscribeChildren();
+    }
+    resetItem(item, resetChildren) {
+        const idGetter = this.fieldAccessor().idGetter;
+        const toReset = [item];
+        while (toReset.length) {
+            const current = toReset.shift();
+            const id = idGetter(current);
+            if (this.loaded.has(id)) {
+                const children = this.loaded.get(id);
+                this.loaded.delete(id);
+                if (resetChildren) {
+                    toReset.push.apply(toReset, children.data || children);
+                }
+            }
+        }
+        this.clear();
+    }
+    clear() {
+        this._data = null;
+    }
+    loadData() {
+        const itemFactory = new ViewItemFactory(this.expandState, this.editState, this.selectionState, this.loaded, this.fieldAccessor);
+        let result = itemFactory.generate();
+        if (!result.loading && result.total && (!result.items.length || !result.items.some(i => i.type === 'data'))) {
+            this.resetPage.emit();
+            result = new ViewItemFactory(this.expandState, this.editState, this.selectionState, this.loaded, this.fieldAccessor).generate();
+        }
+        this._data = result.items;
+        this.total = result.total;
+        this.totalVisible = result.totalVisible;
+        this._totalRows = result.totalRows;
+        if (result.observables && result.observables.length) {
+            this.loading = true;
+            this.loadingCount += result.observables.length;
+            if (!this.childrenSubscription) {
+                this.childrenSubscription = new Subscription();
+            }
+            result.observables.forEach(o => {
+                this.loaded.set(o.parentId, LOADING);
+                this.childrenSubscription.add(o.observable.subscribe(children => {
+                    this.clear();
+                    this.loaded.set(o.parentId, children);
+                    this.childrenLoaded.emit();
+                    this.loadingCount--;
+                    if (this.loadingCount === 0) {
+                        this.loading = false;
+                        this.unsubscribeChildren();
+                        this.dataLoaded.emit();
+                    }
+                }));
+            });
+        }
+        else {
+            this.dataLoaded.emit();
+        }
+    }
+    unsubscribeChildren() {
+        if (this.childrenSubscription) {
+            this.childrenSubscription.unsubscribe();
+            this.childrenSubscription = null;
+            this.loadingCount = 0;
+        }
+    }
+}
+export { ɵ0, ɵ1, ɵ2, ɵ3, ɵ4 };

package/dist/es2015/data/treelist-item.interface.d.ts

@@ -0,0 +1,10 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { DataItem } from './data-item.interface';
+/**
+ * Represents an item that will be rendered by the TreeList.
+ * Can be a [`DataItem`]({% slug api_treelist_dataitem %}). ([See example]({% slug api_treelist_treelistcomponent %}#toc-trackby))
+ */
+export declare type TreeListItem = DataItem;

package/dist/es2015/data/treelist-item.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/dragdrop/column-reorder-config.d.ts

@@ -0,0 +1,13 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+/**
+ * Additional configuration for the `reorderColumn` method.
+ */
+export interface ColumnReorderConfig {
+    /**
+     * Indicates whether the reordered column will be positioned before or after the destination index.
+     */
+    before: boolean;
+}

package/dist/es2015/dragdrop/column-reorder-config.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/dragdrop/column-reorder-event.d.ts

@@ -0,0 +1,29 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { PreventableEvent } from '../common/preventable-event';
+import { ColumnBase } from '../columns/column-base';
+/**
+ * Arguments for the `columnReorder` event.
+ */
+export declare class ColumnReorderEvent extends PreventableEvent {
+    /**
+     * The reordered column.
+     */
+    readonly column: ColumnBase;
+    /**
+     * The new index of the column.
+     * Relative to the collection of columns.
+     */
+    readonly newIndex: number;
+    /**
+     * The original index of the column before reordering.
+     * Relative to the collection of columns.
+     */
+    readonly oldIndex: number;
+    /**
+     * @hidden
+     */
+    constructor({ column, newIndex, oldIndex }: any);
+}

package/dist/es2015/dragdrop/column-reorder-event.js

@@ -0,0 +1,19 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { PreventableEvent } from '../common/preventable-event';
+/**
+ * Arguments for the `columnReorder` event.
+ */
+export class ColumnReorderEvent extends PreventableEvent {
+    /**
+     * @hidden
+     */
+    constructor({ column, newIndex, oldIndex }) {
+        super();
+        this.column = column;
+        this.newIndex = newIndex;
+        this.oldIndex = oldIndex;
+    }
+}

package/dist/es2015/dragdrop/column-reorder.service.d.ts

@@ -0,0 +1,12 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { EventEmitter } from '@angular/core';
+/**
+ * @hidden
+ */
+export declare class ColumnReorderService {
+    changes: EventEmitter<any>;
+    reorder(e: any): void;
+}

package/dist/es2015/dragdrop/column-reorder.service.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
+*-------------------------------------------------------------------------------------------*/
+import * as tslib_1 from "tslib";
+import { Injectable, EventEmitter } from '@angular/core';
+/**
+ * @hidden
+ */
+let ColumnReorderService = class ColumnReorderService {
+    /**
+     * @hidden
+     */
+    constructor() {
+        this.changes = new EventEmitter();
+    }
+    reorder(e) {
+        this.changes.emit(e);
+    }
+};
+ColumnReorderService = tslib_1.__decorate([
+    Injectable()
+], ColumnReorderService);
+export { ColumnReorderService };

package/dist/es2015/dragdrop/common.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
+*-------------------------------------------------------------------------------------------*/
+/**
+ * @hidden
+ */
+export declare const append: (element: any) => () => any;
+/**
+ * @hidden
+ */
+export declare const offset: (element: any) => {
+    top: number;
+    left: number;
+};
+/**
+ * @hidden
+ * If the target is before the draggable element, returns `true`.
+ *
+ * DOCUMENT_POSITION_FOLLOWING = 4
+ */
+export declare const isTargetBefore: (draggable: any, target: any) => boolean;
+/**
+ * @hidden
+ * If the container and the element are the same
+ * or if the container holds (contains) the element, returns `true`.
+ *
+ * DOCUMENT_POSITION_CONTAINED_BY = 16
+ */
+export declare const contains: (element: any, container: any) => boolean;
+/**
+ * @hidden
+ */
+export declare const position: (target: any, before: any) => {
+    left: any;
+    top: number;
+    height: any;
+};

package/dist/es2015/dragdrop/common.js

@@ -0,0 +1,68 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+/* tslint:disable: no-bitwise */
+/**
+ * @hidden
+ */
+export const append = (element) => {
+    let appended = false;
+    return () => {
+        if (!appended) {
+            document.body.appendChild(element);
+            appended = true;
+        }
+        return element;
+    };
+};
+/**
+ * @hidden
+ */
+const getDocument = element => element.ownerDocument.documentElement;
+const ɵ0 = getDocument;
+/**
+ * @hidden
+ */
+const getWindow = element => element.ownerDocument.defaultView;
+const ɵ1 = getWindow;
+/**
+ * @hidden
+ */
+export const offset = element => {
+    const { clientTop, clientLeft } = getDocument(element);
+    const { pageYOffset, pageXOffset } = getWindow(element);
+    const { top, left } = element.getBoundingClientRect();
+    return {
+        top: top + pageYOffset - clientTop,
+        left: left + pageXOffset - clientLeft
+    };
+};
+/**
+ * @hidden
+ * If the target is before the draggable element, returns `true`.
+ *
+ * DOCUMENT_POSITION_FOLLOWING = 4
+ */
+export const isTargetBefore = (draggable, target) => (target.compareDocumentPosition(draggable) & 4) !== 0;
+/**
+ * @hidden
+ * If the container and the element are the same
+ * or if the container holds (contains) the element, returns `true`.
+ *
+ * DOCUMENT_POSITION_CONTAINED_BY = 16
+ */
+export const contains = (element, container) => element === container ||
+    (container.compareDocumentPosition(element) & 16) !== 0;
+/**
+ * @hidden
+ */
+export const position = (target, before) => {
+    const targetRect = offset(target);
+    const { offsetWidth, offsetHeight } = target;
+    const left = targetRect.left + (before ? 0 : offsetWidth);
+    const top = targetRect.top;
+    const height = offsetHeight;
+    return { left, top, height };
+};
+export { ɵ0, ɵ1 };

package/dist/es2015/dragdrop/context-types.d.ts

@@ -0,0 +1,16 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { ColumnBase } from '../columns/column-base';
+/**
+ * @hidden
+ */
+export declare type DragAndDropContext = {
+    field?: string;
+    hint?: string;
+    lastTarget?: boolean;
+    lastColumn?: boolean;
+    column?: ColumnBase;
+    type: 'column' | 'columnGroup';
+};

package/dist/es2015/dragdrop/context-types.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
+*-------------------------------------------------------------------------------------------*/