@progress/kendo-vue-treeview 3.2.2-dev.202204181420

package/dist/es/moveTreeViewItem.d.ts

@@ -0,0 +1,109 @@
+/**
+ *  A helper function which moves a TreeView item in an immutable way.
+ *
+ * @param sourceItemHierarchicalIndex - The hierarchical index of the item that will be moved.
+ * @param sourceData - The tree which contains the item that will be moved.
+ * @param operation - The specific move operation.
+ *
+ * The available options are:
+ *  * `before`—Indicates that the source item will become the previous sibling of the target item.
+ *  * `after`—Indicates that the source item will become the next sibling of the target item.
+ *  * `child`—Indicates that the source item will become a child of the target item.
+ * @param targetItemHierarchicalIndex - The hierarchical index of the item next to which the source item will be moved.
+ * @param targetData - The tree which contains the target item.
+ * If the argument is skipped, then the move operation will be executed within the same tree.
+ * Setting the `sourceData` and `targetData` arguments to the same tree is also supported.
+ * @param childrenField - The field that points to the dataItem sub items. Defaults to `items`.
+ * @returns - The updated copies of the `sourceData` and `targetData` input arguments.
+ * If `targetData` is not passed, then only the updated copy of the `sourceData` will be returned.
+ *
+ * @example
+ * ```jsx
+ * class App extends React.Component {
+ *     dragClue;
+ *     state = { tree };
+ *
+ *     render() {
+ *         return (
+ *             <div>
+ *                 <TreeView data={this.state.tree} draggable={true}
+ *                     onItemDragOver={this.onItemDragOver} onItemDragEnd={this.onItemDragEnd} />
+ *                 <TreeViewDragClue ref={dragClue => this.dragClue = dragClue} />
+ *             </div>
+ *         );
+ *     }
+ *
+ *     onItemDragOver = (event) => {
+ *         this.dragClue.show(event.pageY + 10, event.pageX, event.item.text, this.getClueClassName(event));
+ *     }
+ *     onItemDragEnd = (event) => {
+ *         this.dragClue.hide();
+ *         const eventAnalyzer = new TreeViewDragAnalyzer(event).init();
+ *
+ *         if (eventAnalyzer.isDropAllowed) {
+ *             const updatedTree = moveTreeViewItem(
+ *                 event.itemHierarchicalIndex,
+ *                 this.state.tree,
+ *                 eventAnalyzer.getDropOperation(),
+ *                 eventAnalyzer.destinationMeta.itemHierarchicalIndex,
+ *             );
+ *
+ *             this.setState({ tree: updatedTree });
+ *         }
+ *     }
+ *     getClueClassName(event) {
+ *         const eventAnalyzer = new TreeViewDragAnalyzer(event).init();
+ *         const itemIndex = eventAnalyzer.destinationMeta.itemHierarchicalIndex;
+ *
+ *         if (eventAnalyzer.isDropAllowed) {
+ *             switch (eventAnalyzer.getDropOperation()) {
+ *                 case 'child':
+ *                     return 'k-i-plus';
+ *                 case 'before':
+ *                     return itemIndex === '0' || itemIndex.endsWith(`${SEPARATOR}0`) ?
+ *                         'k-i-insert-up' : 'k-i-insert-middle';
+ *                 case 'after':
+ *                     const siblings = getSiblings(itemIndex, this.state.tree);
+ *                     const lastIndex = Number(itemIndex.split(SEPARATOR).pop());
+ *
+ *                     return lastIndex < siblings.length - 1 ? 'k-i-insert-middle' : 'k-i-insert-down';
+ *                 default:
+ *                     break;
+ *             }
+ *         }
+ *
+ *         return 'k-i-cancel';
+ *     }
+ * }
+ *
+ * function getSiblings(itemIndex, data) {
+ *     let result = data;
+ *
+ *     const indices = itemIndex.split(SEPARATOR).map(index => Number(index));
+ *     for (let i = 0; i < indices.length - 1; i++) {
+ *         result = result[indices[i]].items;
+ *     }
+ *
+ *     return result;
+ * }
+ *
+ * const SEPARATOR = '_';
+ * const tree = [{
+ *     text: 'Furniture', expanded: true, items: [
+ *         { text: 'Tables & Chairs', expanded: true },
+ *         { text: 'Sofas', expanded: true },
+ *         { text: 'Occasional Furniture', expanded: true }]
+ * }, {
+ *     text: 'Decor', expanded: true, items: [
+ *         { text: 'Bed Linen', expanded: true },
+ *         { text: 'Curtains & Blinds', expanded: true },
+ *         { text: 'Carpets', expanded: true }]
+ * }];
+ *
+ * ReactDOM.render(<App />, document.querySelector('my-app'));
+ * ```
+ */
+export default function moveTreeViewItem(sourceItemHierarchicalIndex: string, sourceData: any[] | null | undefined, operation: 'before' | 'after' | 'child', targetItemHierarchicalIndex: string, targetData?: any[] | null, childrenField?: string): any[] | {
+    sourceData: any[];
+    targetData: any[];
+};

package/dist/es/moveTreeViewItem.js

@@ -0,0 +1,156 @@
+import { addItem, removeItem } from './utils/itemUtils';
+import { getDecrementedItemIdAfterRemoval, getItemById } from './utils/itemIdUtils';
+import { CHILDREN_FIELD } from './utils/consts';
+/**
+ *  A helper function which moves a TreeView item in an immutable way.
+ *
+ * @param sourceItemHierarchicalIndex - The hierarchical index of the item that will be moved.
+ * @param sourceData - The tree which contains the item that will be moved.
+ * @param operation - The specific move operation.
+ *
+ * The available options are:
+ *  * `before`—Indicates that the source item will become the previous sibling of the target item.
+ *  * `after`—Indicates that the source item will become the next sibling of the target item.
+ *  * `child`—Indicates that the source item will become a child of the target item.
+ * @param targetItemHierarchicalIndex - The hierarchical index of the item next to which the source item will be moved.
+ * @param targetData - The tree which contains the target item.
+ * If the argument is skipped, then the move operation will be executed within the same tree.
+ * Setting the `sourceData` and `targetData` arguments to the same tree is also supported.
+ * @param childrenField - The field that points to the dataItem sub items. Defaults to `items`.
+ * @returns - The updated copies of the `sourceData` and `targetData` input arguments.
+ * If `targetData` is not passed, then only the updated copy of the `sourceData` will be returned.
+ *
+ * @example
+ * ```jsx
+ * class App extends React.Component {
+ *     dragClue;
+ *     state = { tree };
+ *
+ *     render() {
+ *         return (
+ *             <div>
+ *                 <TreeView data={this.state.tree} draggable={true}
+ *                     onItemDragOver={this.onItemDragOver} onItemDragEnd={this.onItemDragEnd} />
+ *                 <TreeViewDragClue ref={dragClue => this.dragClue = dragClue} />
+ *             </div>
+ *         );
+ *     }
+ *
+ *     onItemDragOver = (event) => {
+ *         this.dragClue.show(event.pageY + 10, event.pageX, event.item.text, this.getClueClassName(event));
+ *     }
+ *     onItemDragEnd = (event) => {
+ *         this.dragClue.hide();
+ *         const eventAnalyzer = new TreeViewDragAnalyzer(event).init();
+ *
+ *         if (eventAnalyzer.isDropAllowed) {
+ *             const updatedTree = moveTreeViewItem(
+ *                 event.itemHierarchicalIndex,
+ *                 this.state.tree,
+ *                 eventAnalyzer.getDropOperation(),
+ *                 eventAnalyzer.destinationMeta.itemHierarchicalIndex,
+ *             );
+ *
+ *             this.setState({ tree: updatedTree });
+ *         }
+ *     }
+ *     getClueClassName(event) {
+ *         const eventAnalyzer = new TreeViewDragAnalyzer(event).init();
+ *         const itemIndex = eventAnalyzer.destinationMeta.itemHierarchicalIndex;
+ *
+ *         if (eventAnalyzer.isDropAllowed) {
+ *             switch (eventAnalyzer.getDropOperation()) {
+ *                 case 'child':
+ *                     return 'k-i-plus';
+ *                 case 'before':
+ *                     return itemIndex === '0' || itemIndex.endsWith(`${SEPARATOR}0`) ?
+ *                         'k-i-insert-up' : 'k-i-insert-middle';
+ *                 case 'after':
+ *                     const siblings = getSiblings(itemIndex, this.state.tree);
+ *                     const lastIndex = Number(itemIndex.split(SEPARATOR).pop());
+ *
+ *                     return lastIndex < siblings.length - 1 ? 'k-i-insert-middle' : 'k-i-insert-down';
+ *                 default:
+ *                     break;
+ *             }
+ *         }
+ *
+ *         return 'k-i-cancel';
+ *     }
+ * }
+ *
+ * function getSiblings(itemIndex, data) {
+ *     let result = data;
+ *
+ *     const indices = itemIndex.split(SEPARATOR).map(index => Number(index));
+ *     for (let i = 0; i < indices.length - 1; i++) {
+ *         result = result[indices[i]].items;
+ *     }
+ *
+ *     return result;
+ * }
+ *
+ * const SEPARATOR = '_';
+ * const tree = [{
+ *     text: 'Furniture', expanded: true, items: [
+ *         { text: 'Tables & Chairs', expanded: true },
+ *         { text: 'Sofas', expanded: true },
+ *         { text: 'Occasional Furniture', expanded: true }]
+ * }, {
+ *     text: 'Decor', expanded: true, items: [
+ *         { text: 'Bed Linen', expanded: true },
+ *         { text: 'Curtains & Blinds', expanded: true },
+ *         { text: 'Carpets', expanded: true }]
+ * }];
+ *
+ * ReactDOM.render(<App />, document.querySelector('my-app'));
+ * ```
+ */
+export default function moveTreeViewItem(sourceItemHierarchicalIndex, sourceData, operation, targetItemHierarchicalIndex, targetData, childrenField) {
+    var subItemsField = childrenField || CHILDREN_FIELD;
+    if (!validateInput()) {
+        return prepareInputDataForReturn();
+    }
+    var sourceItem = getItemById(sourceItemHierarchicalIndex, sourceData, subItemsField);
+    if (!sourceItem) {
+        return prepareInputDataForReturn();
+    }
+    // The source and the target tree are the same.
+    if (!targetData || targetData === sourceData) {
+        if (!validateNoCircularReference()) {
+            return prepareInputDataForReturn();
+        }
+        var updatedSourceData = removeItem(sourceItemHierarchicalIndex, subItemsField, sourceData);
+        var resultData = addItem(sourceItem, operation, subItemsField, getDecrementedItemIdAfterRemoval(sourceItemHierarchicalIndex, targetItemHierarchicalIndex), updatedSourceData);
+        // A simpler output is explicitly returned when the source and the target tree are
+        // the same, that is, the targetData argument is skipped.
+        return targetData ? { sourceData: resultData, targetData: resultData } : resultData;
+    }
+    else {
+        var updatedSource = removeItem(sourceItemHierarchicalIndex, subItemsField, sourceData);
+        var updatedTarget = addItem(sourceItem, operation, subItemsField, targetItemHierarchicalIndex, targetData);
+        return { sourceData: updatedSource, targetData: updatedTarget };
+    }
+    function prepareInputDataForReturn() {
+        return targetData ? { sourceData: sourceData, targetData: targetData } : sourceData;
+    }
+    function validateNoCircularReference() {
+        return !(targetItemHierarchicalIndex + "_").startsWith(sourceItemHierarchicalIndex + "_");
+    }
+    function validateInput() {
+        if (!sourceData || !sourceData.length ||
+            !sourceItemHierarchicalIndex || !targetItemHierarchicalIndex) {
+            return false;
+        }
+        if (targetData && !targetData.length) {
+            // Dropping over an empty tree is not supported.
+            return false;
+        }
+        // Validate that the target item exists.
+        var data = !targetData || targetData === sourceData ? sourceData : targetData;
+        if (!getItemById(targetItemHierarchicalIndex, data, subItemsField)) {
+            return false;
+        }
+        return true;
+    }
+}

package/dist/es/package-metadata.d.ts

@@ -0,0 +1,5 @@
+import { PackageMetadata } from '@progress/kendo-licensing';
+/**
+ * @hidden
+ */
+export declare const packageMetadata: PackageMetadata;

package/dist/es/package-metadata.js

@@ -0,0 +1,11 @@
+/**
+ * @hidden
+ */
+export var packageMetadata = {
+    name: '@progress/kendo-vue-treeview',
+    productName: 'Kendo UI for Vue',
+    productCodes: ['KENDOUIVUE', 'KENDOUICOMPLETE'],
+    publishDate: 1650291464,
+    version: '',
+    licensingDocsUrl: 'https://www.telerik.com/kendo-vue-ui/my-license/?utm_medium=product&utm_source=kendovue&utm_campaign=kendo-ui-vue-purchase-license-keys-warning'
+};

package/dist/es/processTreeViewItems.d.ts

@@ -0,0 +1,51 @@
+import { TreeViewOperationDescriptors } from './TreeViewOperationDescriptors';
+/**
+ * A helper function which applies the specified operation descriptors to the data.
+ * * [Expanding and collapsing items]({% slug expansion_ways_treeview %}#toc-using-a-helper-function)
+ * * [Selecting and deselecting items]({% slug selection_ways_treeview %}#toc-using-a-helper-function)
+ * * [Checking and unchecking items]({% slug check_helper_funcs_treeview %})
+ *
+ * @param data - The data that will be processed.
+ * @param operations - The operation descriptors that will be applied to the data.
+ * @returns - The processed copy of the input data.
+ *
+ * @example
+ * ```jsx
+ * class App extends React.Component {
+ *     state = { items: tree, expand: [], select: [], check: [] };
+ *     render() {
+ *         const { expand, select, check } = this.state;
+ *         return (
+ *             <TreeView
+ *                 data={processTreeViewItems(this.state.items, { expand, select, check })}
+ *                 expandIcons={true} onExpandChange={this.onExpandChange} checkboxes={true}
+ *                 onCheckChange={event => this.setState({ check: [ event.itemHierarchicalIndex ] })}
+ *                 onItemClick={event => this.setState({ select: [ event.itemHierarchicalIndex ] })}
+ *             />
+ *         );
+ *     }
+ *     onExpandChange = (event) => {
+ *         let expand = this.state.expand.slice();
+ *         const index = expand.indexOf(event.itemHierarchicalIndex);
+ *         index === -1 ? expand.push(event.itemHierarchicalIndex) : expand.splice(index, 1);
+ *         this.setState({ expand });
+ *     }
+ * }
+ *
+ * const tree = [{
+ *     text: 'Item1',
+ *     items: [
+ *         { text: 'Item1.1' },
+ *         { text: 'Item1.2' },
+ *         { text: 'Item1.3', items: [{ text: 'Item1.3.1' }] }]
+ * }, {
+ *     text: 'Item2', disabled: true,
+ *     items: [{ text: 'Item2.1' }, { text: 'Item2.2' }, { text: 'Item2.3' }]
+ * }, {
+ *     text: 'Item3'
+ * }];
+ *
+ * ReactDOM.render(<App />, document.querySelector('my-app'));
+ * ```
+ */
+export default function processTreeViewItems(data: any[] | null | undefined, operations: TreeViewOperationDescriptors): any[];

package/dist/es/processTreeViewItems.js

@@ -0,0 +1,166 @@
+/* eslint-disable max-len */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { updateItem, resolveItemsIds } from './utils/itemUtils';
+import { EXPAND_FIELD, SELECT_FIELD, CHECK_FIELD, CHECK_INDETERMINATE_FIELD, CHILDREN_FIELD } from './utils/consts';
+import { getNestedValue, isArray } from './utils/misc';
+/**
+ * A helper function which applies the specified operation descriptors to the data.
+ * * [Expanding and collapsing items]({% slug expansion_ways_treeview %}#toc-using-a-helper-function)
+ * * [Selecting and deselecting items]({% slug selection_ways_treeview %}#toc-using-a-helper-function)
+ * * [Checking and unchecking items]({% slug check_helper_funcs_treeview %})
+ *
+ * @param data - The data that will be processed.
+ * @param operations - The operation descriptors that will be applied to the data.
+ * @returns - The processed copy of the input data.
+ *
+ * @example
+ * ```jsx
+ * class App extends React.Component {
+ *     state = { items: tree, expand: [], select: [], check: [] };
+ *     render() {
+ *         const { expand, select, check } = this.state;
+ *         return (
+ *             <TreeView
+ *                 data={processTreeViewItems(this.state.items, { expand, select, check })}
+ *                 expandIcons={true} onExpandChange={this.onExpandChange} checkboxes={true}
+ *                 onCheckChange={event => this.setState({ check: [ event.itemHierarchicalIndex ] })}
+ *                 onItemClick={event => this.setState({ select: [ event.itemHierarchicalIndex ] })}
+ *             />
+ *         );
+ *     }
+ *     onExpandChange = (event) => {
+ *         let expand = this.state.expand.slice();
+ *         const index = expand.indexOf(event.itemHierarchicalIndex);
+ *         index === -1 ? expand.push(event.itemHierarchicalIndex) : expand.splice(index, 1);
+ *         this.setState({ expand });
+ *     }
+ * }
+ *
+ * const tree = [{
+ *     text: 'Item1',
+ *     items: [
+ *         { text: 'Item1.1' },
+ *         { text: 'Item1.2' },
+ *         { text: 'Item1.3', items: [{ text: 'Item1.3.1' }] }]
+ * }, {
+ *     text: 'Item2', disabled: true,
+ *     items: [{ text: 'Item2.1' }, { text: 'Item2.2' }, { text: 'Item2.3' }]
+ * }, {
+ *     text: 'Item3'
+ * }];
+ *
+ * ReactDOM.render(<App />, document.querySelector('my-app'));
+ * ```
+ */
+export default function processTreeViewItems(data, operations) {
+    if (!data || !data.length) {
+        return [];
+    }
+    var result = data;
+    var cloneField = operations.cloneField || 'cloned';
+    var expandField = operations.expandField || EXPAND_FIELD;
+    var selectField = operations.selectField || SELECT_FIELD;
+    var checkField = operations.checkField || CHECK_FIELD;
+    var childrenField = operations.childrenField || CHILDREN_FIELD;
+    result = handleOperation(result, expandField, operations.expand, cloneField, childrenField);
+    result = handleOperation(result, selectField, operations.select, cloneField, childrenField);
+    result = handleOperation(result, checkField, operations.check, cloneField, childrenField);
+    applyCheckIndeterminate(result, childrenField, operations.check);
+    return result;
+}
+function handleOperation(items, defaultField, operation, cloneField, childrenField) {
+    if (operation) {
+        var _a = parseOperation(operation, defaultField), ids = _a.ids, field = _a.field;
+        var indices = !isArray(operation) && operation.idField
+            ? resolveItemsIds(ids, operation.idField, items, childrenField)
+            : ids;
+        return raiseFlags(items, indices, field, cloneField, childrenField);
+    }
+    else {
+        return items;
+    }
+}
+function parseOperation(operation, defaultField) {
+    var ids;
+    var field;
+    if (isArray(operation)) {
+        ids = operation;
+        field = defaultField;
+    }
+    else {
+        ids = operation.ids || [];
+        field = operation.operationField || defaultField;
+    }
+    return { ids: ids, field: field };
+}
+function raiseFlags(items, indices, field, cloneField, childrenField) {
+    var result = items;
+    indices.forEach(function (itemIndex) {
+        result = updateItem(result, itemIndex, function (item) { return raiseNestedFlag(field, item); }, cloneField, childrenField);
+    });
+    return result;
+}
+function raiseNestedFlag(fieldName, dataItem) {
+    var fields = (fieldName || '').split('.');
+    var item = dataItem;
+    for (var index = 0; index < fields.length; index++) {
+        var field = fields[index];
+        if (index === fields.length - 1) {
+            item[field] = true;
+        }
+        else if (item[field] !== undefined) {
+            item[field] = __assign({}, item[field]);
+            item = item[field];
+        }
+        else {
+            return;
+        }
+    }
+}
+function applyCheckIndeterminate(items, childrenField, check) {
+    if (check && !isArray(check) && check.applyCheckIndeterminate) {
+        var checkField = parseOperation(check, CHECK_FIELD).field;
+        var checkIndeterminateField = check.checkIndeterminateField || CHECK_INDETERMINATE_FIELD;
+        for (var i = 0; i < items.length; i++) {
+            var item = items[i];
+            var subItems = item[childrenField];
+            if (subItems) {
+                applyCheckIndeterminateHelper(subItems, getNestedValue(checkField, item) ? [] : [item], childrenField, checkField, checkIndeterminateField);
+            }
+        }
+    }
+}
+function applyCheckIndeterminateHelper(data, parents, childrenField, checkField, checkIndeterminateField) {
+    // The updates will be direct because the corresponding items
+    // are already cloned because of their checked children.
+    var parentsAlreadyUpdated = false;
+    for (var i = 0; i < data.length; i++) {
+        var item = data[i];
+        if (getNestedValue(checkField, item)) {
+            if (!parentsAlreadyUpdated) {
+                for (var j = 0; j < parents.length; j++) {
+                    raiseNestedFlag(checkIndeterminateField, parents[j]);
+                }
+            }
+            parentsAlreadyUpdated = true;
+            if (item[childrenField]) {
+                applyCheckIndeterminateHelper(item[childrenField], [], childrenField, checkField, checkIndeterminateField);
+            }
+        }
+        else {
+            if (item[childrenField]) {
+                applyCheckIndeterminateHelper(item[childrenField], parentsAlreadyUpdated ? [item] : parents.concat([item]), childrenField, checkField, checkIndeterminateField);
+            }
+        }
+    }
+}

package/dist/es/utils/FieldsService.d.ts

@@ -0,0 +1,26 @@
+import { TreeViewProps } from '../TreeViewProps';
+/**
+ * @hidden
+ */
+export default class FieldsService {
+    focusIdField: string | undefined;
+    private expandField;
+    private selectField;
+    private childrenField;
+    private hasChildrenField;
+    private textField;
+    private disableField;
+    private checkField;
+    private checkIndeterminateField;
+    constructor(treeViewProps: TreeViewProps);
+    expanded(item: any): boolean | undefined;
+    selected(item: any): boolean | undefined;
+    text(item: any): string | undefined;
+    disabled(item: any): boolean | undefined;
+    hasChildren(item: any): boolean | undefined;
+    children(item: any): any[];
+    checked(item: any): boolean | undefined;
+    checkIndeterminate(item: any): boolean | undefined;
+    focusId(item: any): any;
+    getChildrenField(): string;
+}

package/dist/es/utils/FieldsService.js

@@ -0,0 +1,50 @@
+import { getNestedValue } from './misc';
+/**
+ * @hidden
+ */
+var FieldsService = /** @class */ (function () {
+    function FieldsService(treeViewProps) {
+        this.expandField = treeViewProps.expandField;
+        this.selectField = treeViewProps.selectField;
+        this.hasChildrenField = treeViewProps.hasChildrenField;
+        this.childrenField = treeViewProps.childrenField;
+        this.textField = treeViewProps.textField;
+        this.disableField = treeViewProps.disableField;
+        this.checkField = treeViewProps.checkField;
+        this.checkIndeterminateField = treeViewProps.checkIndeterminateField;
+        this.focusIdField = treeViewProps.focusIdField;
+    }
+    FieldsService.prototype.expanded = function (item) {
+        return getNestedValue(this.expandField, item);
+    };
+    FieldsService.prototype.selected = function (item) {
+        return getNestedValue(this.selectField, item);
+    };
+    FieldsService.prototype.text = function (item) {
+        return getNestedValue(this.textField, item);
+    };
+    FieldsService.prototype.disabled = function (item) {
+        return getNestedValue(this.disableField, item);
+    };
+    FieldsService.prototype.hasChildren = function (item) {
+        return getNestedValue(this.hasChildrenField, item);
+    };
+    FieldsService.prototype.children = function (item) {
+        var children = getNestedValue(this.childrenField, item);
+        return children ? children : [];
+    };
+    FieldsService.prototype.checked = function (item) {
+        return getNestedValue(this.checkField, item);
+    };
+    FieldsService.prototype.checkIndeterminate = function (item) {
+        return getNestedValue(this.checkIndeterminateField, item);
+    };
+    FieldsService.prototype.focusId = function (item) {
+        return this.focusIdField && getNestedValue(this.focusIdField, item);
+    };
+    FieldsService.prototype.getChildrenField = function () {
+        return this.childrenField;
+    };
+    return FieldsService;
+}());
+export default FieldsService;

package/dist/es/utils/SortedPublicItemIds.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @hidden
+ */
+export default class SortedPublicItemIds {
+    private objects;
+    init(publicItemIds: any[]): void;
+    hasId(publicItemId: any): boolean;
+}

package/dist/es/utils/SortedPublicItemIds.js

@@ -0,0 +1,26 @@
+var PROPS_COUNT_LIMIT = 50000;
+/**
+ * @hidden
+ */
+// An alternative is to use array.sort() and
+// implement a binary search function.
+var SortedPublicItemIds = /** @class */ (function () {
+    function SortedPublicItemIds() {
+        this.objects = [];
+    }
+    SortedPublicItemIds.prototype.init = function (publicItemIds) {
+        var currentObj;
+        for (var i = 0; i < publicItemIds.length; i++) {
+            if (i % PROPS_COUNT_LIMIT === 0) {
+                currentObj = {};
+                this.objects.push(currentObj);
+            }
+            currentObj[publicItemIds[i]] = true;
+        }
+    };
+    SortedPublicItemIds.prototype.hasId = function (publicItemId) {
+        return this.objects.some(function (obj) { return obj[publicItemId]; });
+    };
+    return SortedPublicItemIds;
+}());
+export default SortedPublicItemIds;

package/dist/es/utils/consts.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @hidden
+ */
+export declare const EXPAND_FIELD = "expanded";
+/**
+ * @hidden
+ */
+export declare const TEXT_FIELD = "text";
+/**
+ * @hidden
+ */
+export declare const DISABLED_FIELD = "disabled";
+/**
+ * @hidden
+ */
+export declare const CHILDREN_FIELD = "items";
+/**
+ * @hidden
+ */
+export declare const HAS_CHILDREN_FIELD = "hasChildren";
+/**
+ * @hidden
+ */
+export declare const SELECT_FIELD = "selected";
+/**
+ * @hidden
+ */
+export declare const CHECK_FIELD = "checked";
+/**
+ * @hidden
+ */
+export declare const CHECK_INDETERMINATE_FIELD = "checkIndeterminate";
+/**
+ * @hidden
+ */
+export declare const DOM_KENDO_ITEM_ID_FIELD = "_kendoItemId";
+/**
+ * @hidden
+ */
+export declare const DOM_KENDO_TREEVIEW_GUID_FIELD = "_kendoTreeViewGuid";