@oracle/oraclejet-core-pack 14.0.0

package/oj-c/hooks/UNSAFE_useDataProvider/utils.js

@@ -0,0 +1,202 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+define(["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.getUpdatedItemsFromMutationDetail = void 0;
+    function getUpdatedItemsFromMutationDetail(detail, currentData, dataProvider) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { add, remove, update } = detail !== null && detail !== void 0 ? detail : {};
+            const keyIndexMap = new Map();
+            for (const [index, item] of currentData.entries()) {
+                keyIndexMap.set(item.key, index);
+            }
+            let mutatedData = [...currentData];
+            if (remove) {
+                mutatedData = removeItemsFromDetail(remove, mutatedData, keyIndexMap);
+            }
+            if (add) {
+                mutatedData = yield addItemsFromDetail(add, mutatedData, keyIndexMap, dataProvider);
+            }
+            if (update) {
+                mutatedData = yield updateItemsFromDetail(update, mutatedData, keyIndexMap, dataProvider);
+            }
+            return mutatedData;
+        });
+    }
+    exports.getUpdatedItemsFromMutationDetail = getUpdatedItemsFromMutationDetail;
+    function addItemsAtEnd(itemsToAdd, itemMetadataToAdd, items) {
+        const indices = new Array(itemsToAdd.length).fill(-1);
+        return addItemsAtIndices(indices, itemsToAdd, itemMetadataToAdd, items);
+    }
+    function addItemsAtIndices(indices, itemsToAdd, itemMetadataToAdd, items) {
+        const returnItems = [...items];
+        indices.forEach((addAtIndex, index) => {
+            var _a;
+            const addItem = {
+                data: itemsToAdd[index],
+                key: (_a = itemMetadataToAdd[index]) === null || _a === void 0 ? void 0 : _a.key,
+                metadata: itemMetadataToAdd[index]
+            };
+            if (addAtIndex >= 0) {
+                returnItems.splice(addAtIndex, 0, addItem);
+            }
+            else {
+                returnItems.push(addItem);
+            }
+        });
+        return returnItems;
+    }
+    function addItemsBeforeKeys(beforeKeys, itemsToAdd, items, keyIndexMap) {
+        const addIndices = [];
+        const itemMetadataToAdd = [];
+        beforeKeys.forEach((key) => {
+            addIndices.push(getIndexByKey(keyIndexMap, key));
+            itemMetadataToAdd.push({ key });
+        });
+        return addItemsAtIndices(addIndices, itemsToAdd, itemMetadataToAdd, items);
+    }
+    function addItemsFromDetail(detail, items, keyIndexMap, dataProvider) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const { addBeforeKeys, data, indexes, keys, metadata } = detail;
+            let mutatedData = [...items];
+            let treatedData = data || [];
+            let treatedMetaData = metadata || [];
+            if (treatedData.length === 0 && (keys === null || keys === void 0 ? void 0 : keys.size)) {
+                const fetchResults = (_a = (yield fetchDataByKeys(dataProvider, keys))) !== null && _a !== void 0 ? _a : [];
+                treatedData = fetchResults.map((itemContext) => itemContext.data);
+                treatedMetaData = fetchResults.map((itemContext) => itemContext.metadata);
+            }
+            if (treatedMetaData.length === 0 && (keys === null || keys === void 0 ? void 0 : keys.size)) {
+                treatedMetaData = [...keys].map((key) => ({ key }));
+            }
+            if (treatedData.length) {
+                if (indexes === null || indexes === void 0 ? void 0 : indexes.length) {
+                    mutatedData = addItemsAtIndices(indexes, treatedData, treatedMetaData, mutatedData);
+                }
+                else if (addBeforeKeys === null || addBeforeKeys === void 0 ? void 0 : addBeforeKeys.length) {
+                    mutatedData = addItemsBeforeKeys(addBeforeKeys, treatedData, mutatedData, keyIndexMap);
+                }
+                else {
+                    mutatedData = addItemsAtEnd(treatedData, treatedMetaData, mutatedData);
+                }
+            }
+            return mutatedData;
+        });
+    }
+    function fetchDataByKeys(dataProvider, keys) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fetchedData = [];
+            const results = (yield dataProvider.fetchByKeys({ keys })).results;
+            for (const key of keys) {
+                if (results.has(key)) {
+                    const result = results.get(key);
+                    fetchedData.push(Object.assign(Object.assign({}, result), { key }));
+                }
+            }
+            return fetchedData;
+        });
+    }
+    function getIndexByKey(keyIndexMap, key) {
+        if (keyIndexMap.has(key)) {
+            return keyIndexMap.get(key);
+        }
+        return -1;
+    }
+    function removeItemsAtIndices(indices, items) {
+        const returnItems = [...items];
+        indices.sort((a, b) => b - a);
+        indices.forEach((index) => {
+            if (index < returnItems.length) {
+                returnItems.splice(index, 1);
+            }
+        });
+        return returnItems;
+    }
+    function removeItemsAtKeys(keys, items, keyIndexMap) {
+        const indicesToRemove = [];
+        keys.forEach((key) => {
+            const index = getIndexByKey(keyIndexMap, key);
+            if (index !== -1) {
+                indicesToRemove.push(index);
+            }
+        });
+        return removeItemsAtIndices(indicesToRemove, items);
+    }
+    function removeItemsFromDetail(detail, items, keyIndexMap) {
+        const { indexes, keys } = detail;
+        let mutatedData = [...items];
+        if (indexes === null || indexes === void 0 ? void 0 : indexes.length) {
+            mutatedData = removeItemsAtIndices(indexes, mutatedData);
+        }
+        else if (keys === null || keys === void 0 ? void 0 : keys.size) {
+            mutatedData = removeItemsAtKeys(keys, mutatedData, keyIndexMap);
+        }
+        return mutatedData;
+    }
+    function updateItemsAtIndices(indices, itemsToUpdate, itemMetadataToUpdate, items) {
+        const returnItems = [...items];
+        indices.forEach((updateAtIndex, index) => {
+            var _a;
+            if (returnItems[updateAtIndex]) {
+                const addItem = {
+                    data: itemsToUpdate[index],
+                    key: (_a = itemMetadataToUpdate[index]) === null || _a === void 0 ? void 0 : _a.key,
+                    metadata: itemMetadataToUpdate[index]
+                };
+                returnItems.splice(updateAtIndex, 1, addItem);
+            }
+        });
+        return returnItems;
+    }
+    function updateItemsAtKeys(keys, itemsToUpdate, itemMetadataToUpdate, items, keyIndexMap) {
+        const returnItems = [...items];
+        keys.forEach((key) => {
+            var _a;
+            const index = getIndexByKey(keyIndexMap, key);
+            const addItem = {
+                data: itemsToUpdate[index],
+                key: (_a = itemMetadataToUpdate[index]) === null || _a === void 0 ? void 0 : _a.key,
+                metadata: itemMetadataToUpdate[index]
+            };
+            if (index >= 0) {
+                returnItems.splice(index, 1, addItem);
+            }
+        });
+        return returnItems;
+    }
+    function updateItemsFromDetail(detail, items, keyIndexMap, dataProvider) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data, indexes, keys, metadata } = detail;
+            let mutatedData = [...items];
+            let treatedData = data || [];
+            let treatedMetaData = metadata || [];
+            if (treatedData.length === 0 && (keys === null || keys === void 0 ? void 0 : keys.size)) {
+                const fetchResults = (_a = (yield fetchDataByKeys(dataProvider, keys))) !== null && _a !== void 0 ? _a : [];
+                treatedData = fetchResults.map((itemContext) => itemContext.data);
+                treatedMetaData = fetchResults.map((itemContext) => itemContext.metadata);
+            }
+            if (treatedMetaData.length === 0 && (keys === null || keys === void 0 ? void 0 : keys.size)) {
+                treatedMetaData = [...keys].map((key) => ({ key }));
+            }
+            if (treatedData.length) {
+                if (indexes === null || indexes === void 0 ? void 0 : indexes.length) {
+                    mutatedData = updateItemsAtIndices(indexes, treatedData, treatedMetaData, mutatedData);
+                }
+                else if (keys === null || keys === void 0 ? void 0 : keys.size) {
+                    mutatedData = updateItemsAtKeys(keys, treatedData, treatedMetaData, mutatedData, keyIndexMap);
+                }
+            }
+            return mutatedData;
+        });
+    }
+});

package/oj-c/hooks/UNSAFE_useListData/__tests__/useListData.test.js

@@ -0,0 +1,124 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+define(["require", "exports", "chai", "ojs/ojarraydataprovider", "ojs/ojmodel", "ojs/ojcollectiondataprovider", "../useListData", "@testing-library/preact-hooks"], function (require, exports, chai_1, ojarraydataprovider_1, ojmodel_1, ojcollectiondataprovider_1, useListData_1, preact_hooks_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    ojarraydataprovider_1 = __importDefault(ojarraydataprovider_1);
+    ojcollectiondataprovider_1 = __importDefault(ojcollectiondataprovider_1);
+    function checkDataState(dataState, count, precision) {
+        if (dataState.status === 'error') {
+            console.log(dataState.error);
+        }
+        (0, chai_1.expect)(dataState.status).to.be.eq('success');
+        if (dataState.status === 'success') {
+            (0, chai_1.expect)(dataState.data.offset).to.be.eq(0);
+            (0, chai_1.expect)(dataState.data.data.length).to.be.eq(count);
+            (0, chai_1.expect)(dataState.data.sizePrecision).to.be.eq(precision);
+        }
+    }
+    function sleep() {
+        return new Promise((r) => setTimeout(r, 100));
+    }
+    describe('Test useListData hook - ArrayDataProvider', () => {
+        it('initialRowsFetched', function () {
+            return __awaiter(this, void 0, void 0, function* () {
+                const createData = (count) => {
+                    const data = [];
+                    for (let i = 0; i < count; i++) {
+                        const key = 'i' + i;
+                        const obj = { key: key, name: 'Item ' + (i + 1) };
+                        data.push(obj);
+                    }
+                    return data;
+                };
+                const dataProvider = new ojarraydataprovider_1.default(createData(50), {
+                    keyAttributes: 'key'
+                });
+                const { result } = (0, preact_hooks_1.renderHook)(() => (0, useListData_1.useListData)(dataProvider, {
+                    initialRowsFetched: 0
+                }));
+                if (result.current) {
+                    const dataState = result.current[0];
+                    (0, chai_1.expect)(dataState.status).to.be.eq('success');
+                    checkDataState(dataState, 0, 'atLeast');
+                }
+            });
+        });
+        it('ArrayDataProvider - fetch next', function () {
+            return __awaiter(this, void 0, void 0, function* () {
+                const createData = (count) => {
+                    const data = [];
+                    for (let i = 0; i < count; i++) {
+                        const key = 'i' + i;
+                        const obj = { key: key, name: 'Item ' + (i + 1) };
+                        data.push(obj);
+                    }
+                    return data;
+                };
+                const dataProvider = new ojarraydataprovider_1.default(createData(50), {
+                    keyAttributes: 'key'
+                });
+                const { result } = (0, preact_hooks_1.renderHook)(() => (0, useListData_1.useListData)(dataProvider, {}));
+                if (result.current) {
+                    let dataState = result.current[0];
+                    (0, chai_1.expect)(dataState.status).to.be.eq('loading');
+                    yield sleep();
+                    dataState = result.current[0];
+                    checkDataState(dataState, 25, 'atLeast');
+                    let loadRange = result.current[1];
+                    loadRange({ offset: 0, count: 50 });
+                    yield sleep();
+                    dataState = result.current[0];
+                    checkDataState(dataState, 50, 'atLeast');
+                    loadRange = result.current[1];
+                    loadRange({ offset: 0, count: 75 });
+                    yield sleep();
+                    dataState = result.current[0];
+                    checkDataState(dataState, 50, 'exact');
+                }
+            });
+        });
+        it('CollectionDataProvider - fetch next', function () {
+            return __awaiter(this, void 0, void 0, function* () {
+                const createData = (count) => {
+                    const data = [];
+                    for (let i = 0; i < count; i++) {
+                        const key = 'i' + i;
+                        const obj = new ojmodel_1.Model({ id: key, name: 'Item ' + (i + 1) });
+                        data.push(obj);
+                    }
+                    return new ojmodel_1.Collection(data);
+                };
+                const dataProvider = new ojcollectiondataprovider_1.default(createData(50));
+                const { result } = (0, preact_hooks_1.renderHook)(() => (0, useListData_1.useListData)(dataProvider, {}));
+                if (result.current) {
+                    let dataState = result.current[0];
+                    (0, chai_1.expect)(dataState.status).to.be.eq('loading');
+                    yield sleep();
+                    dataState = result.current[0];
+                    checkDataState(dataState, 25, 'atLeast');
+                    let loadRange = result.current[1];
+                    loadRange({ offset: 0, count: 50 });
+                    yield sleep();
+                    dataState = result.current[0];
+                    checkDataState(dataState, 50, 'atLeast');
+                    loadRange = result.current[1];
+                    loadRange({ offset: 0, count: 75 });
+                    yield sleep();
+                    dataState = result.current[0];
+                    checkDataState(dataState, 50, 'exact');
+                }
+            });
+        });
+    });
+});

package/oj-c/hooks/UNSAFE_useListData/useListData.js

@@ -0,0 +1,297 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+define(["require", "exports", "ojs/ojdataproviderfactory", "preact/hooks"], function (require, exports, ojdataproviderfactory_1, hooks_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.useListData = void 0;
+    const initialState = Object.freeze({
+        status: 'loading',
+        data: null
+    });
+    const defaultOptions = {
+        isInitialFetchDeferred: false
+    };
+    const DEFAULT_FETCH_SIZE = 25;
+    const useListData = (data, options = defaultOptions) => {
+        const fetchNextRef = (0, hooks_1.useRef)(null);
+        const totalSizeRef = (0, hooks_1.useRef)(0);
+        const isDoneRef = (0, hooks_1.useRef)(false);
+        const iteratorRef = (0, hooks_1.useRef)(null);
+        const fetchSize = options.fetchSize && options.fetchSize > 0 ? options.fetchSize : DEFAULT_FETCH_SIZE;
+        if (!data) {
+            const emptyListState = getEmptyState('exact');
+            return [emptyListState, (_) => Promise.resolve()];
+        }
+        const dataProvider = (0, hooks_1.useMemo)(() => wrapData(data), [data]);
+        const [state, dispatch] = (0, hooks_1.useReducer)(reducer, initialState);
+        const fetchRange = (0, hooks_1.useCallback)((range) => __awaiter(void 0, void 0, void 0, function* () {
+            const fetchOptions = {
+                attributes: options.attributes,
+                sortCriteria: options.sortCriteria,
+                filterCriterion: options.filterCriterion,
+                offset: range.offset,
+                size: range.count
+            };
+            try {
+                const result = yield dataProvider.fetchByOffset(fetchOptions);
+                const results = result['results'];
+                const sizePrecision = isDoneRef.current === true ? 'exact' : 'atLeast';
+                dispatch({
+                    status: 'success',
+                    data: {
+                        offset: range.offset,
+                        data: results,
+                        totalSize: totalSizeRef.current,
+                        sizePrecision: sizePrecision
+                    }
+                });
+            }
+            catch (error) {
+                dispatch({
+                    status: 'error',
+                    error: error
+                });
+            }
+        }), [dataProvider, options.attributes, options.filterCriterion, options.sortCriteria]);
+        const loadInitial = (0, hooks_1.useCallback)(() => __awaiter(void 0, void 0, void 0, function* () {
+            dispatch({ status: 'loading', data: null });
+            const iterator = dataProvider
+                .fetchFirst({
+                attributes: options.attributes,
+                sortCriteria: options.sortCriteria,
+                filterCriterion: options.filterCriterion,
+                size: fetchSize
+            })[Symbol.asyncIterator]();
+            iteratorRef.current = iterator;
+            try {
+                const result = yield iterator.next();
+                totalSizeRef.current = result.value.data.length;
+                if (result.done !== undefined) {
+                    isDoneRef.current = result.done;
+                }
+                const initialFetchSize = options.initialRowsFetched && options.initialRowsFetched > 0
+                    ? options.initialRowsFetched
+                    : fetchSize;
+                fetchRange({ offset: 0, count: Math.min(totalSizeRef.current, initialFetchSize) });
+            }
+            catch (error) {
+                dispatch({
+                    status: 'error',
+                    error: error
+                });
+                iteratorRef.current = null;
+            }
+        }), [
+            dataProvider,
+            fetchRange,
+            options.attributes,
+            options.filterCriterion,
+            options.sortCriteria,
+            options.fetchSize
+        ]);
+        const loadRange = (0, hooks_1.useCallback)((range) => __awaiter(void 0, void 0, void 0, function* () {
+            if (iteratorRef.current === null) {
+                loadInitial();
+            }
+            else {
+                const endIndex = range.offset + range.count;
+                if (endIndex > totalSizeRef.current) {
+                    if (fetchNextRef.current == null) {
+                        const promise = fetchNextUntilThresholdOrDone(iteratorRef, totalSizeRef.current, endIndex);
+                        fetchNextRef.current = promise;
+                        try {
+                            const value = yield promise;
+                            if (value.done !== undefined) {
+                                isDoneRef.current = value.done;
+                            }
+                            const total = value.total;
+                            if (total > 0) {
+                                totalSizeRef.current = total;
+                                fetchRange({
+                                    offset: range.offset,
+                                    count: Math.min(totalSizeRef.current - range.offset, range.count)
+                                });
+                            }
+                            fetchNextRef.current = null;
+                        }
+                        catch (error) {
+                            dispatch({
+                                status: 'error',
+                                error: error
+                            });
+                            fetchNextRef.current = null;
+                        }
+                    }
+                }
+                else {
+                    fetchRange(range);
+                }
+            }
+        }), [state, loadInitial, fetchRange]);
+        const resetAndLoad = (0, hooks_1.useCallback)(() => {
+            iteratorRef.current = null;
+            fetchNextRef.current = null;
+            totalSizeRef.current = 0;
+            isDoneRef.current = false;
+            if (options.initialRowsFetched === 0) {
+                dispatch(getEmptyState('atLeast'));
+            }
+            else if (!options.isInitialFetchDeferred) {
+                loadInitial();
+            }
+            else {
+                dispatch({ status: 'loading', data: null });
+            }
+        }, [loadInitial, options.isInitialFetchDeferred, options.initialRowsFetched]);
+        (0, hooks_1.useEffect)(() => {
+            resetAndLoad();
+        }, [resetAndLoad]);
+        const handleMutation = (0, hooks_1.useCallback)((event) => {
+            if (state.status === 'success' && state.data) {
+                const dataState = state.data;
+                let shouldUpdate = false;
+                if (event.detail.add) {
+                    const itemsInserted = handleAddRemoveMutation(event.detail.add, dataState, options, true);
+                    totalSizeRef.current = totalSizeRef.current + itemsInserted;
+                    shouldUpdate = itemsInserted > 0 || dataState.sizePrecision === 'exact';
+                    if (itemsInserted === 0) {
+                        isDoneRef.current = false;
+                    }
+                }
+                if (event.detail.remove) {
+                    const itemsRemoved = handleAddRemoveMutation(event.detail.remove, dataState, options, false);
+                    totalSizeRef.current = totalSizeRef.current - itemsRemoved;
+                    shouldUpdate = shouldUpdate || itemsRemoved > 0;
+                }
+                if (event.detail.update) {
+                    shouldUpdate =
+                        shouldUpdate || handleUpdateMutation(event.detail.update, dataState, options);
+                }
+                if (shouldUpdate) {
+                    fetchRange({ offset: dataState.offset, count: dataState.data.length });
+                }
+            }
+        }, [state, options, fetchRange]);
+        const handleRefresh = (0, hooks_1.useCallback)((event) => {
+            var _a;
+            let adjustment = -1;
+            const disregardAfterKey = (_a = event.detail) === null || _a === void 0 ? void 0 : _a.disregardAfterKey;
+            if (disregardAfterKey && state.status === 'success') {
+                const index = state.data.data.findIndex((value) => {
+                    return value.metadata.key === disregardAfterKey;
+                });
+                if (index > -1) {
+                    adjustment = state.data.data.length - index - 1;
+                }
+                if (adjustment === 0 && state.data.data.length >= fetchSize) {
+                    return;
+                }
+            }
+            if (adjustment > -1 && state.status === 'success') {
+                totalSizeRef.current = totalSizeRef.current - adjustment;
+                loadRange({
+                    offset: state.data.offset,
+                    count: Math.max(state.data.data.length, fetchSize)
+                });
+            }
+            else {
+                resetAndLoad();
+            }
+        }, [state, resetAndLoad]);
+        (0, hooks_1.useEffect)(() => {
+            dataProvider.addEventListener('refresh', handleRefresh);
+            dataProvider.addEventListener('mutate', handleMutation);
+            return () => {
+                dataProvider.removeEventListener('refresh', handleRefresh);
+                dataProvider.removeEventListener('mutate', handleMutation);
+            };
+        }, [dataProvider, resetAndLoad, handleMutation]);
+        return [state, loadRange];
+    };
+    exports.useListData = useListData;
+    const wrapData = (data) => {
+        const configuration = {
+            fetchFirst: { caching: 'visitedByCurrentIterator' }
+        };
+        return (0, ojdataproviderfactory_1.getEnhancedDataProvider)(data, configuration);
+    };
+    const reducer = (state, action) => {
+        if (state.status === action.status && action.status === 'loading') {
+            return state;
+        }
+        return action;
+    };
+    const fetchNextUntilThresholdOrDone = (iteratorRef, current, threshold) => __awaiter(void 0, void 0, void 0, function* () {
+        return yield fetchNextRecursive(iteratorRef, current, threshold);
+    });
+    const fetchNextRecursive = (iteratorRef, currentCount, threshold) => __awaiter(void 0, void 0, void 0, function* () {
+        const currentIterator = iteratorRef.current;
+        if (currentIterator === null) {
+            return { total: -1, done: undefined };
+        }
+        const result = yield currentIterator.next();
+        if (currentIterator === iteratorRef.current) {
+            currentCount += result.value.data.length;
+            if (currentCount >= threshold || result.done) {
+                return { total: currentCount, done: result.done };
+            }
+            return fetchNextRecursive(iteratorRef, currentCount, threshold);
+        }
+        return { total: -1, done: undefined };
+    });
+    const getEmptyState = (precision) => {
+        return {
+            status: 'success',
+            data: {
+                offset: 0,
+                data: [],
+                totalSize: 0,
+                sizePrecision: precision
+            }
+        };
+    };
+    const handleAddRemoveMutation = (detail, dataState, options, isAdd) => {
+        var _a;
+        let itemCount = 0;
+        if (isIndexesAvailable(detail, options)) {
+            const indexes = isAdd ? (_a = detail.indexes) === null || _a === void 0 ? void 0 : _a.sort() : detail.indexes;
+            let endIndex = dataState.totalSize - 1;
+            indexes === null || indexes === void 0 ? void 0 : indexes.forEach((index) => {
+                if (index <= endIndex) {
+                    itemCount = itemCount += 1;
+                    if (isAdd) {
+                        endIndex = endIndex += 1;
+                    }
+                }
+            });
+        }
+        else {
+        }
+        return itemCount;
+    };
+    const handleUpdateMutation = (detail, dataState, options) => {
+        if (isIndexesAvailable(detail, options)) {
+            const indexes = detail.indexes ? detail.indexes : [];
+            const startIndex = dataState.offset;
+            const endIndex = startIndex + dataState.data.length;
+            for (let i = 0; i < indexes.length; i++) {
+                if (indexes[i] >= startIndex && indexes[i] < endIndex) {
+                    return true;
+                }
+            }
+        }
+        else {
+        }
+        return false;
+    };
+    const isIndexesAvailable = (detail, options) => {
+        return detail.indexes && options.sortCriteria == null && options.filterCriterion == null;
+    };
+});

package/oj-c/hooks/UNSAFE_useTreeData/__tests__/useTreeData.test.js

@@ -0,0 +1,62 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+define(["require", "exports", "chai", "ojs/ojarraytreedataprovider", "../useTreeData", "@testing-library/preact-hooks"], function (require, exports, chai_1, ojarraytreedataprovider_1, useTreeData_1, preact_hooks_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    ojarraytreedataprovider_1 = __importDefault(ojarraytreedataprovider_1);
+    describe('Test useTree hook', () => {
+        it('render', function () {
+            return __awaiter(this, void 0, void 0, function* () {
+                const countPerLevel = 20;
+                const numLevels = 3;
+                const createData = (level, parentId) => {
+                    const data = [];
+                    const count = countPerLevel;
+                    if (level == null) {
+                        level = 1;
+                    }
+                    if (parentId == null) {
+                        parentId = '';
+                    }
+                    for (let i = 0; i < count; i++) {
+                        const key = parentId + 'l' + level + 'i' + i;
+                        const obj = { key: key, name: 'Item ' + (i + 1) };
+                        obj.level = level;
+                        obj.parentKey = parentId;
+                        obj.setSize = countPerLevel;
+                        obj.posInSet = i + 1;
+                        if (level === numLevels) {
+                            obj.isLeaf = true;
+                        }
+                        else {
+                            obj.isLeaf = false;
+                        }
+                        if (level < numLevels) {
+                            obj.children = createData(level + 1, key);
+                        }
+                        data.push(obj);
+                    }
+                    return data;
+                };
+                const treeDataProvider = new ojarraytreedataprovider_1.default(createData(null, null), {
+                    keyAttributes: 'key'
+                });
+                const { result } = (0, preact_hooks_1.renderHook)(() => (0, useTreeData_1.useTreeData)(treeDataProvider, {
+                    initialRowsFetched: 0,
+                    includeClosestParents: true
+                }));
+                (0, chai_1.expect)(result.current).to.be.an('array');
+            });
+        });
+    });
+});