@progress/kendo-react-common 5.20.0-dev.202310040609 → 5.20.0-dev.202310061256

package/dist/es/tree-utils/itemIdUtils.js

@@ -0,0 +1,117 @@
+/**
+ * @hidden
+ */
+export var EMPTY_ID = '';
+/**
+ * @hidden
+ */
+export var ZERO_LEVEL_ZERO_NODE_ID = '0';
+/**
+ * @hidden
+ */
+export var SEPARATOR = '_';
+/**
+ * @hidden
+ */
+export function getItemById(itemId, items, childrenField) {
+    if (isIdZeroLevel(itemId)) {
+        return items[Number(itemId)];
+    }
+    else {
+        var rootParentItem = items[Number(getRootParentId(itemId))];
+        var subItems = (rootParentItem && rootParentItem[childrenField]) || [];
+        return subItems.length ?
+            getItemById(getIdWithoutRootParentId(itemId), subItems, childrenField) : undefined;
+    }
+}
+/**
+ * @hidden
+ */
+export function getRootParentId(itemId) {
+    return isIdEmptyOrZeroLevel(itemId) ? itemId : itemId.split(SEPARATOR)[0];
+}
+/**
+ * @hidden
+ */
+export function getIdWithoutRootParentId(itemId) {
+    if (isIdEmptyOrZeroLevel(itemId)) {
+        return itemId;
+    }
+    else {
+        var firstSeparatorIndex = itemId.indexOf(SEPARATOR);
+        return itemId.substring(firstSeparatorIndex + 1);
+    }
+}
+/**
+ * @hidden
+ */
+export function getFirstChildId(itemId) {
+    return createId('0', itemId);
+}
+/**
+ * @hidden
+ */
+export function createId(childId, parentId) {
+    childId = childId.toString();
+    return parentId ? parentId + SEPARATOR + childId : childId;
+}
+/**
+ * @hidden
+ */
+export function getDirectParentId(itemId) {
+    var lastSeparatorIndex = itemId.lastIndexOf(SEPARATOR);
+    return lastSeparatorIndex < 0 ? EMPTY_ID : itemId.substring(0, lastSeparatorIndex);
+}
+/**
+ * @hidden
+ */
+export function isIdEmptyOrZeroLevel(itemId) {
+    return itemId === EMPTY_ID || itemId.indexOf(SEPARATOR) < 0;
+}
+/**
+ * @hidden
+ */
+export function isIdZeroLevel(itemId) {
+    return itemId !== EMPTY_ID && itemId.indexOf(SEPARATOR) < 0;
+}
+/**
+ * @hidden
+ */
+export function getAllShortIds(itemId) {
+    return itemId.split(SEPARATOR);
+}
+/**
+ * @hidden
+ */
+export function getShortId(itemId) {
+    var lastSeparatorIndex = itemId.lastIndexOf(SEPARATOR);
+    return lastSeparatorIndex < 0 ? itemId : itemId.substring(lastSeparatorIndex + 1);
+}
+/**
+ * @hidden
+ */
+export function isItemFirstFromSiblings(itemId) {
+    return getShortId(itemId) === ZERO_LEVEL_ZERO_NODE_ID;
+}
+/**
+ * @hidden
+ */
+export function getDecrementedItemIdAfterRemoval(removedItemId, itemId) {
+    var preservedItemId = itemId;
+    removedItemId = 'r' + SEPARATOR + removedItemId;
+    itemId = 'r' + SEPARATOR + itemId;
+    var itemSharedPath = getDirectParentId(removedItemId) + SEPARATOR;
+    if (itemId.startsWith(itemSharedPath)) {
+        var itemNotSharedPath = itemId.substring(itemSharedPath.length);
+        if (itemNotSharedPath) {
+            var siblingShortId = getRootParentId(itemNotSharedPath);
+            if (Number(getShortId(removedItemId)) < Number(siblingShortId)) {
+                var decrementedId = itemSharedPath +
+                    (Number(siblingShortId) - 1).toString() +
+                    itemNotSharedPath.substring(siblingShortId.length);
+                return getIdWithoutRootParentId(decrementedId);
+            }
+        }
+    }
+    return preservedItemId;
+}

package/dist/es/tree-utils/itemUtils.d.ts

@@ -0,0 +1,45 @@
+import { TreeFieldsService } from './FieldsService';
+/**
+ * @hidden
+ */
+export declare function hasChildren(item: any, childrenField: string): boolean;
+/**
+ * @hidden
+ */
+export declare function isItemExpandedAndWithChildren(item: any, fieldsSvc: TreeFieldsService): boolean | undefined;
+/**
+ * @hidden
+ */
+export declare function resolveItemId(publicId: any, idField: string, items: any[], childrenField: string): string | undefined;
+/**
+ * @hidden
+ */
+export declare function resolveItemsIds(publicIds: any[], idField: string, items: any[], childrenField: string): string[];
+/**
+ * @hidden
+ */
+export declare function updateItem(items: any[], itemId: string, update: (item: any) => void, cloneField: string, childrenField: string): any[];
+/**
+ * @hidden
+ */
+export declare function isEnabledAndAllParentsEnabled(itemId: string, items: any, fieldsSvc: TreeFieldsService): any;
+/**
+ * @hidden
+ */
+export declare function getAllDirectIndirectChildrenIds(item: any, itemId: string, childrenField: string, idField: string | undefined): any[];
+/**
+ * @hidden
+ */
+export declare function areAllDirectChildrenChecked(item: any, itemId: any, idField: string | undefined, childrenField: string, check: string[]): boolean;
+/**
+ * @hidden
+ */
+export declare function getAllParents(itemId: string, childrenField: string, items: any[]): any[];
+/**
+ * @hidden
+ */
+export declare function removeItem(itemId: string, childrenField: string, items: any[]): any[];
+/**
+ * @hidden
+ */
+export declare function addItem(item: any, operation: 'before' | 'after' | 'child', childrenField: string, targetItemId: string, items: any[]): any[];

package/dist/es/tree-utils/itemUtils.js

@@ -0,0 +1,191 @@
+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 { EMPTY_ID, isIdZeroLevel, createId, getRootParentId, getIdWithoutRootParentId, getAllShortIds } from './itemIdUtils';
+import { SortedPublicItemIds } from './SortedPublicItemIds';
+import { getNestedValue } from './misc';
+/**
+ * @hidden
+ */
+export function hasChildren(item, childrenField) {
+    var children = getNestedValue(childrenField, item);
+    return Boolean(children && children.length);
+}
+/**
+ * @hidden
+ */
+export function isItemExpandedAndWithChildren(item, fieldsSvc) {
+    return fieldsSvc.expanded(item) && hasChildren(item, fieldsSvc.getChildrenField());
+}
+/**
+ * @hidden
+ */
+export function resolveItemId(publicId, idField, items, childrenField) {
+    var resolvedIds = resolveItemsIds([publicId], idField, items, childrenField);
+    return resolvedIds.length ? resolvedIds[0] : undefined;
+}
+/**
+ * @hidden
+ */
+export function resolveItemsIds(publicIds, idField, items, childrenField) {
+    var result = [];
+    var sortedIds = new SortedPublicItemIds();
+    sortedIds.init(publicIds);
+    resolveItemsIdsHelper(sortedIds, idField, items, EMPTY_ID, result, childrenField);
+    return result;
+}
+/**
+ * @hidden
+ */
+export function updateItem(items, itemId, update, cloneField, childrenField) {
+    var _a;
+    var itemIndex = Number(getRootParentId(itemId));
+    if (itemIndex >= items.length) {
+        return items;
+    }
+    var result = items;
+    var item = items[itemIndex];
+    // Clone the item before updating it.
+    if (!item[cloneField]) {
+        result = items.slice();
+        item = result[itemIndex] = Object.assign({}, item, (_a = {}, _a[cloneField] = true, _a));
+    }
+    // Directly update the item.
+    if (isIdZeroLevel(itemId)) {
+        update(item);
+    }
+    else if (item[childrenField]) {
+        item[childrenField] = updateItem(item[childrenField], getIdWithoutRootParentId(itemId), update, cloneField, childrenField);
+    }
+    return result;
+}
+/**
+ * @hidden
+ */
+export function isEnabledAndAllParentsEnabled(itemId, items, fieldsSvc) {
+    var ids = getAllShortIds(itemId);
+    var currentItems = items;
+    for (var i = 0; i < ids.length; i++) {
+        var currentItem = currentItems[Number(ids[i])];
+        if (fieldsSvc.disabled(currentItem)) {
+            return false;
+        }
+        else {
+            currentItems = currentItem[fieldsSvc.getChildrenField()];
+        }
+    }
+    return true;
+}
+/**
+ * @hidden
+ */
+export function getAllDirectIndirectChildrenIds(item, itemId, childrenField, idField) {
+    return idField ? getChildrenPublicIds(item) : getChildrenHierarchicalIndices(item, itemId);
+    function getChildrenHierarchicalIndices(startItem, startItemId) {
+        var result = [];
+        var children = startItem[childrenField] || [];
+        for (var i = 0; i < children.length; i++) {
+            var id = createId(i, startItemId);
+            result.push(id);
+            result = result.concat(getChildrenHierarchicalIndices(children[i], id));
+        }
+        return result;
+    }
+    function getChildrenPublicIds(startItem) {
+        var result = [];
+        var children = startItem[childrenField] || [];
+        for (var i = 0; i < children.length; i++) {
+            result.push(getNestedValue(idField, children[i]));
+            result = result.concat(getChildrenPublicIds(children[i]));
+        }
+        return result;
+    }
+}
+/**
+ * @hidden
+ */
+export function areAllDirectChildrenChecked(item, itemId, idField, childrenField, check) {
+    var children = item[childrenField] || [];
+    return children.every(function (child, index) {
+        return check.indexOf(idField ? getNestedValue(idField, child) : createId(index, itemId)) > -1;
+    });
+}
+/**
+ * @hidden
+ */
+export function getAllParents(itemId, childrenField, items) {
+    var result = [];
+    var ids = getAllShortIds(itemId);
+    var currentItems = items;
+    for (var i = 0; i < ids.length - 1; i++) {
+        if (!currentItems) {
+            break;
+        }
+        var currentItem = currentItems[Number(ids[i])];
+        result.push(currentItem);
+        currentItems = currentItem[childrenField];
+    }
+    return result;
+}
+/**
+ * @hidden
+ */
+export function removeItem(itemId, childrenField, items) {
+    var result = items.slice();
+    if (isIdZeroLevel(itemId)) {
+        result.splice(Number(itemId), 1);
+    }
+    else {
+        var rootParentIndex = Number(getRootParentId(itemId));
+        var rootParent = result[rootParentIndex] = __assign({}, result[rootParentIndex]);
+        rootParent[childrenField] = removeItem(getIdWithoutRootParentId(itemId), childrenField, rootParent[childrenField]);
+    }
+    return result;
+}
+/**
+ * @hidden
+ */
+export function addItem(item, operation, childrenField, targetItemId, items) {
+    var result = items.slice();
+    if (isIdZeroLevel(targetItemId)) {
+        if (operation === 'child') {
+            var targetItem = result[Number(targetItemId)] = __assign({}, result[Number(targetItemId)]);
+            if (targetItem[childrenField]) {
+                targetItem[childrenField] = targetItem[childrenField].slice();
+                targetItem[childrenField].push(item);
+            }
+            else {
+                targetItem[childrenField] = [item];
+            }
+        }
+        else {
+            result.splice(Number(targetItemId) + (operation === 'after' ? 1 : 0), 0, item);
+        }
+    }
+    else {
+        var rootParentIndex = Number(getRootParentId(targetItemId));
+        var rootParent = result[rootParentIndex] = __assign({}, result[rootParentIndex]);
+        rootParent[childrenField] = addItem(item, operation, childrenField, getIdWithoutRootParentId(targetItemId), rootParent[childrenField]);
+    }
+    return result;
+}
+function resolveItemsIdsHelper(publicItemIds, idField, items, parentItemId, resolvedIds, childrenField) {
+    for (var i = 0; i < items.length; i++) {
+        var item = items[i];
+        var id = createId(i, parentItemId);
+        if (publicItemIds.hasId(getNestedValue(idField, item))) {
+            resolvedIds.push(id);
+        }
+        if (hasChildren(item, childrenField)) {
+            resolveItemsIdsHelper(publicItemIds, idField, getNestedValue(childrenField, item), id, resolvedIds, childrenField);
+        }
+    }
+}

package/dist/es/tree-utils/misc.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @hidden
+ */
+export declare function getNestedValue(fieldName: string | undefined, dataItem: any): any;
+/**
+ * @hidden
+ */
+export declare function isArray(operation: string[] | any): operation is any[];

package/dist/es/tree-utils/misc.js

@@ -0,0 +1,17 @@
+/**
+ * @hidden
+ */
+export function getNestedValue(fieldName, dataItem) {
+    var path = (fieldName || '').split('.');
+    var data = dataItem;
+    path.forEach(function (p) {
+        data = data ? data[p] : undefined;
+    });
+    return data;
+}
+/**
+ * @hidden
+ */
+export function isArray(operation) {
+    return operation.length !== undefined;
+}

package/dist/npm/main.d.ts

@@ -51,3 +51,8 @@ export * from './theme';
 export * from './memoize';
 export * from './navigation';
 export * from './getActiveElement';
+export * from './tree-utils/FieldsService';
+export * from './tree-utils/SortedPublicItemIds';
+export * as treeIdUtils from './tree-utils/itemIdUtils';
+export * from './tree-utils/itemUtils';
+export * from './tree-utils/misc';

package/dist/npm/main.js

@@ -14,6 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.treeIdUtils = void 0;
 __exportStar(require("./contexts/ZIndexContext"), exports);
 __exportStar(require("./browser-support.service"), exports);
 __exportStar(require("./canUseDOM"), exports);
@@ -67,3 +68,8 @@ __exportStar(require("./theme"), exports);
 __exportStar(require("./memoize"), exports);
 __exportStar(require("./navigation"), exports);
 __exportStar(require("./getActiveElement"), exports);
+__exportStar(require("./tree-utils/FieldsService"), exports);
+__exportStar(require("./tree-utils/SortedPublicItemIds"), exports);
+exports.treeIdUtils = require("./tree-utils/itemIdUtils");
+__exportStar(require("./tree-utils/itemUtils"), exports);
+__exportStar(require("./tree-utils/misc"), exports);

package/dist/npm/navigation.d.ts

@@ -25,6 +25,10 @@ export interface NavigationOptions {
      * Configures if the roving tabIndex technique will be used in the [Navigation]({% slug api_common_navigation %}).
      */
     rovingTabIndex?: boolean;
+    /**
+     * Sets the options of the focus methods that is used. Defaults to `{ preventScroll: true }`.
+     */
+    focusOptions?: FocusOptions;
     /**
      * Sets the mouse events handlers.
      */
@@ -60,13 +64,17 @@ export declare class Navigation {
      */
     keyboardEvents: {
         [type: string]: {
-            [key: string]: (target: HTMLElement, nav: Navigation, ev: React.KeyboardEvent<HTMLElement>) => void;
+            [key: string]: (target: HTMLElement, nav: Navigation, ev: React.KeyboardEvent<HTMLElement>, options?: any) => void;
         };
     };
     /**
      * @hidden
      */
     tabIndex: number;
+    /**
+     * @hidden
+     */
+    focusOptions: FocusOptions;
     /**
      * @hidden
      */
@@ -103,7 +111,7 @@ export declare class Navigation {
     /**
      * The keyboard events handler.
      */
-    triggerKeyboardEvent(ev: React.KeyboardEvent<HTMLElement>): void;
+    triggerKeyboardEvent(ev: React.KeyboardEvent<HTMLElement>, options?: any): void;
     /**
      * The mouse events handler.
      */

package/dist/npm/navigation.js

@@ -45,6 +45,7 @@ var Navigation = /** @class */ (function () {
         this.tabIndex = options.tabIndex || 0;
         this.root = options.root;
         this.selectors = options.selectors;
+        this.focusOptions = options.focusOptions || { preventScroll: true };
         this.rovingTabIndex = options.rovingTabIndex !== undefined ? options.rovingTabIndex : true;
         this.mouseEvents = options.mouseEvents || {};
         this.keyboardEvents = options.keyboardEvents || {};
@@ -105,12 +106,12 @@ var Navigation = /** @class */ (function () {
     /**
      * The keyboard events handler.
      */
-    Navigation.prototype.triggerKeyboardEvent = function (ev) {
+    Navigation.prototype.triggerKeyboardEvent = function (ev, options) {
         var target = ev.target instanceof Element && ev.target.closest(this.selectors.join(','));
         var key = ev.key === ' ' ? 'Space' : ev.key;
         var eventType = ev.nativeEvent.type;
         if (target && this.keyboardEvents[eventType][key]) {
-            this.keyboardEvents[eventType][key].call(undefined, target, this, ev);
+            this.keyboardEvents[eventType][key].call(undefined, target, this, ev, options);
         }
     };
     /**
@@ -137,7 +138,7 @@ var Navigation = /** @class */ (function () {
             if (this.rovingTabIndex) {
                 element.setAttribute('tabindex', String(this.tabIndex));
             }
-            element.focus({ preventScroll: true });
+            element.focus(this.focusOptions);
         }
     };
     return Navigation;

package/dist/npm/theme.d.ts

@@ -2,6 +2,7 @@
 export interface KendoThemeMaps {
     sizeMap: Record<Exclude<any, null>, String>;
     roundedMap: Record<Exclude<any, null>, String>;
+    orientationMap: Record<Exclude<any, null>, String>;
 }
 /** @hidden */
 export declare const kendoThemeMaps: KendoThemeMaps;

package/dist/npm/theme.js

@@ -12,5 +12,9 @@ exports.kendoThemeMaps = {
         small: 'sm',
         medium: 'md',
         large: 'lg'
+    },
+    orientationMap: {
+        vertical: 'vstack',
+        horizontal: 'hstack'
     }
 };

package/dist/npm/tree-utils/FieldsService.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @hidden
+ */
+export declare class TreeFieldsService {
+    focusIdField: string | undefined;
+    private expandField;
+    private selectField;
+    private childrenField;
+    private hasChildrenField;
+    private textField;
+    private disableField;
+    private checkField;
+    private checkIndeterminateField;
+    constructor(treeViewProps: any);
+    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/npm/tree-utils/FieldsService.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TreeFieldsService = void 0;
+var misc_1 = require("./misc");
+/**
+ * @hidden
+ */
+var TreeFieldsService = /** @class */ (function () {
+    function TreeFieldsService(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;
+    }
+    TreeFieldsService.prototype.expanded = function (item) {
+        return (0, misc_1.getNestedValue)(this.expandField, item);
+    };
+    TreeFieldsService.prototype.selected = function (item) {
+        return (0, misc_1.getNestedValue)(this.selectField, item);
+    };
+    TreeFieldsService.prototype.text = function (item) {
+        return (0, misc_1.getNestedValue)(this.textField, item);
+    };
+    TreeFieldsService.prototype.disabled = function (item) {
+        return (0, misc_1.getNestedValue)(this.disableField, item);
+    };
+    TreeFieldsService.prototype.hasChildren = function (item) {
+        return (0, misc_1.getNestedValue)(this.hasChildrenField, item);
+    };
+    TreeFieldsService.prototype.children = function (item) {
+        var children = (0, misc_1.getNestedValue)(this.childrenField, item);
+        return children ? children : [];
+    };
+    TreeFieldsService.prototype.checked = function (item) {
+        return (0, misc_1.getNestedValue)(this.checkField, item);
+    };
+    TreeFieldsService.prototype.checkIndeterminate = function (item) {
+        return (0, misc_1.getNestedValue)(this.checkIndeterminateField, item);
+    };
+    TreeFieldsService.prototype.focusId = function (item) {
+        return this.focusIdField && (0, misc_1.getNestedValue)(this.focusIdField, item);
+    };
+    TreeFieldsService.prototype.getChildrenField = function () {
+        return this.childrenField;
+    };
+    return TreeFieldsService;
+}());
+exports.TreeFieldsService = TreeFieldsService;

package/dist/npm/tree-utils/SortedPublicItemIds.d.ts

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

package/dist/npm/tree-utils/SortedPublicItemIds.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SortedPublicItemIds = void 0;
+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;
+}());
+exports.SortedPublicItemIds = SortedPublicItemIds;

package/dist/npm/tree-utils/itemIdUtils.d.ts

@@ -0,0 +1,60 @@
+/**
+ * @hidden
+ */
+export declare const EMPTY_ID = "";
+/**
+ * @hidden
+ */
+export declare const ZERO_LEVEL_ZERO_NODE_ID = "0";
+/**
+ * @hidden
+ */
+export declare const SEPARATOR = "_";
+/**
+ * @hidden
+ */
+export declare function getItemById(itemId: string, items: any, childrenField: string): any;
+/**
+ * @hidden
+ */
+export declare function getRootParentId(itemId: string): string;
+/**
+ * @hidden
+ */
+export declare function getIdWithoutRootParentId(itemId: string): string;
+/**
+ * @hidden
+ */
+export declare function getFirstChildId(itemId: string): string;
+/**
+ * @hidden
+ */
+export declare function createId(childId: string | number, parentId?: string): string;
+/**
+ * @hidden
+ */
+export declare function getDirectParentId(itemId: string): string;
+/**
+ * @hidden
+ */
+export declare function isIdEmptyOrZeroLevel(itemId: string): boolean;
+/**
+ * @hidden
+ */
+export declare function isIdZeroLevel(itemId: string): boolean;
+/**
+ * @hidden
+ */
+export declare function getAllShortIds(itemId: string): string[];
+/**
+ * @hidden
+ */
+export declare function getShortId(itemId: string): string;
+/**
+ * @hidden
+ */
+export declare function isItemFirstFromSiblings(itemId: string): boolean;
+/**
+ * @hidden
+ */
+export declare function getDecrementedItemIdAfterRemoval(removedItemId: string, itemId: string): string;