@oracle/oraclejet-core-pack 17.0.4 → 17.1.0

package/oj-c/select-common/PRIVATE_DebouncingDataProviderView/DebouncingDataProviderView.js

@@ -0,0 +1,92 @@
+define(["require", "exports", "ojs/ojdataprovider", "./Debouncer"], function (require, exports, ojdataprovider_1, Debouncer_1) {
+    "use strict";
+    var _a;
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DebouncingDataProviderView = void 0;
+    class AsyncIteratorWrapper {
+        constructor(dataProvider, debouncer, params) {
+            this._isFirstNext = true;
+            this.dataProvider = dataProvider;
+            this.debouncer = debouncer;
+            this.params = params;
+        }
+        next() {
+            if (this._isFirstNext) {
+                this.debouncer.recordRequestTime();
+                this._isFirstNext = false;
+                const filterText = this.params?.filterCriterion?.text;
+                const debounceCallback = (resolve, reject) => {
+                    if (this.params?.signal?.aborted) {
+                        reject(this.params?.signal?.reason);
+                        return;
+                    }
+                    const asyncIterable = this.dataProvider.fetchFirst(this.params);
+                    this._asyncIterator = asyncIterable[Symbol.asyncIterator]();
+                    const fetchStart = Date.now();
+                    const iterPromise = this._asyncIterator.next();
+                    iterPromise.then((result) => {
+                        const fetchEnd = Date.now();
+                        this.debouncer.recordResponseTime(fetchEnd - fetchStart, filterText ? filterText.length : 0);
+                        resolve(result);
+                    }, reject);
+                };
+                const callback = (resolve, reject) => {
+                    const promise = new Promise((pResolve, pReject) => {
+                        this.debouncer.debounce(debounceCallback, filterText ? filterText.length : 0)(pResolve, pReject);
+                    });
+                    return promise.then(resolve, reject);
+                };
+                return (0, ojdataprovider_1.wrapWithAbortHandling)(this.params?.signal, callback, false);
+            }
+            return this._asyncIterator.next();
+        }
+    }
+    class AsyncIterableWrapper {
+        constructor(dataProvider, debouncer, params) {
+            this[_a] = () => {
+                return new AsyncIteratorWrapper(this.dataProvider, this.debouncer, this.params);
+            };
+            this.dataProvider = dataProvider;
+            this.debouncer = debouncer;
+            this.params = params;
+        }
+    }
+    _a = Symbol.asyncIterator;
+    class DebouncingDataProviderView {
+        constructor(dataProvider) {
+            this._debouncer = new Debouncer_1.Debouncer();
+            this.dataProvider = dataProvider;
+        }
+        fetchFirst(params) {
+            return new AsyncIterableWrapper(this.dataProvider, this._debouncer, params);
+        }
+        fetchByKeys(params) {
+            return this.dataProvider.fetchByKeys(params);
+        }
+        containsKeys(params) {
+            return this.dataProvider.containsKeys(params);
+        }
+        fetchByOffset(params) {
+            return this.dataProvider.fetchByOffset(params);
+        }
+        getTotalSize() {
+            return this.dataProvider.getTotalSize();
+        }
+        isEmpty() {
+            return this.dataProvider.isEmpty();
+        }
+        getCapability(capabilityName) {
+            return this.dataProvider.getCapability(capabilityName);
+        }
+        addEventListener(eventType, listener) {
+            this.dataProvider.addEventListener(eventType, listener);
+        }
+        removeEventListener(eventType, listener) {
+            this.dataProvider.removeEventListener(eventType, listener);
+        }
+        dispatchEvent(event) {
+            return this.dataProvider.dispatchEvent(event);
+        }
+    }
+    exports.DebouncingDataProviderView = DebouncingDataProviderView;
+});

package/oj-c/select-common/PRIVATE_useCache/index.js

@@ -0,0 +1,6 @@
+define(["require", "exports", "./useCache"], function (require, exports, useCache_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.useCache = void 0;
+    Object.defineProperty(exports, "useCache", { enumerable: true, get: function () { return useCache_1.useCache; } });
+});

package/oj-c/select-common/PRIVATE_useCache/useCache.js

@@ -0,0 +1,30 @@
+define(["require", "exports", "preact/hooks", "../utils/utils"], function (require, exports, hooks_1, utils_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.useCache = void 0;
+    function useCache() {
+        const cache = (0, hooks_1.useRef)(new Map());
+        return (0, hooks_1.useCallback)((key, value, deps) => {
+            if (isChanged(cache.current, key, deps)) {
+                cache.current.set(key, { value, deps });
+                return value;
+            }
+            return cache.current.get(key).value;
+        }, []);
+    }
+    exports.useCache = useCache;
+    const isChanged = (cache, key, deps) => {
+        if (!cache.has(key))
+            return true;
+        const oldDeps = cache.get(key).deps;
+        return (oldDeps.length !== deps.length || oldDeps.some((value, index) => !isEquals(value, deps[index])));
+    };
+    const isEquals = (value1, value2) => {
+        if (value1 === value2)
+            return true;
+        if (value1 instanceof Set && value2 instanceof Set) {
+            return (0, utils_1.isSetEqual)(value1, value2);
+        }
+        return value1 === value2;
+    };
+});

package/oj-c/select-common/PRIVATE_useSelectData/CollectionTemplateDataProviderView.js

@@ -0,0 +1,208 @@
+define(["require", "exports", "ojs/ojdataprovider"], function (require, exports, ojdataprovider_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.CollectionTemplateDataProviderView = exports.SELECT_INTERNALS = void 0;
+    exports.SELECT_INTERNALS = Symbol('__SELECT_INTERNALS__');
+    class CollectionTemplateDataProviderView {
+        get currentDataProvider() {
+            return this.overrideDataProvider ?? this.originalDataProvider;
+        }
+        setFilterCriterion(filter) {
+            const previousFilter = this.filterCriterion;
+            this.filterCriterion = filter;
+            if (!this.compareFilter(previousFilter, filter)) {
+                const event = new ojdataprovider_1.DataProviderRefreshEvent();
+                Object.defineProperty(event, exports.SELECT_INTERNALS, {
+                    value: { cause: 'filterCriterionChanged' }
+                });
+                this.dispatchEvent(event);
+                this.options.onRefresh?.();
+            }
+        }
+        setDataStateOverride(dataStateOverride) {
+            if (this.dataStateOverride !== dataStateOverride) {
+                this.dataStateOverride = dataStateOverride;
+                this.overrideDataProvider =
+                    this.dataStateOverride?.status === 'success'
+                        ? new DataStateDataProviderView(this.dataStateOverride)
+                        : undefined;
+                const event = new ojdataprovider_1.DataProviderRefreshEvent();
+                Object.defineProperty(event, exports.SELECT_INTERNALS, {
+                    value: { cause: 'dataOverrideChanged' }
+                });
+                this.dispatchEvent(event);
+                this.options.onRefresh?.();
+            }
+        }
+        compareFilter(fc1, fc2) {
+            if (fc1 === fc2)
+                return true;
+            if (fc1 === undefined || fc2 === undefined)
+                return false;
+            const keys1 = Object.keys(fc1);
+            const keys2 = Object.keys(fc2);
+            if (keys1.length !== keys2.length)
+                return false;
+            return keys1.every((key) => keys2.includes(key) && fc1[key] === fc2[key]);
+        }
+        constructor(dataProvider, options) {
+            this.originalDataProvider = dataProvider;
+            this.options = options;
+            if (dataProvider.createOptimizedKeyMap)
+                this.createOptimizedKeyMap = (initialMap) => dataProvider.createOptimizedKeyMap(initialMap);
+            if (dataProvider.createOptimizedKeySet)
+                this.createOptimizedKeySet = (initialMap) => dataProvider.createOptimizedKeySet(initialMap);
+        }
+        async fetchByOffset(parameters) {
+            const overriddenParams = this.filterCriterion
+                ? { ...parameters, filterCriterion: this.filterCriterion }
+                : parameters;
+            const results = await this.currentDataProvider.fetchByOffset(overriddenParams);
+            this.options.onOffsetFetch?.({ results });
+            return results;
+        }
+        fetchFirst(parameters) {
+            const overriddenParams = this.filterCriterion
+                ? { ...parameters, filterCriterion: this.filterCriterion }
+                : parameters;
+            const options = this.options;
+            options.onInitializeFetch?.();
+            const iterable = this.currentDataProvider.fetchFirst(overriddenParams);
+            return {
+                [Symbol.asyncIterator]() {
+                    let offset = 0;
+                    const iterator = iterable[Symbol.asyncIterator]();
+                    return {
+                        async next() {
+                            const itResult = await iterator.next();
+                            const { value: results, done = false } = itResult;
+                            options.onNextIteration?.({ results, offset, done });
+                            offset += results.data.length;
+                            return itResult;
+                        }
+                    };
+                }
+            };
+        }
+        addEventListener(eventType, listener) {
+            return this.originalDataProvider.addEventListener(eventType, listener);
+        }
+        containsKeys(parameters) {
+            return this.currentDataProvider.containsKeys(parameters);
+        }
+        dispatchEvent(event) {
+            return this.originalDataProvider.dispatchEvent(event);
+        }
+        fetchByKeys(parameters) {
+            return this.currentDataProvider.fetchByKeys(parameters);
+        }
+        getCapability(capabilityName) {
+            return this.originalDataProvider.getCapability(capabilityName);
+        }
+        getTotalSize() {
+            return this.currentDataProvider.getTotalSize();
+        }
+        isEmpty() {
+            return this.currentDataProvider.isEmpty();
+        }
+        removeEventListener(eventType, listener) {
+            return this.originalDataProvider.removeEventListener(eventType, listener);
+        }
+    }
+    exports.CollectionTemplateDataProviderView = CollectionTemplateDataProviderView;
+    class DataStateDataProviderView {
+        constructor(dataState) {
+            this.dataState = dataState;
+        }
+        containsKeys(parameters) {
+            const { keys } = parameters;
+            const { data } = this.dataState;
+            const foundKeys = new Set();
+            data.data.forEach((item) => {
+                if (keys.has(item.metadata.key)) {
+                    foundKeys.add(item.metadata.key);
+                }
+            });
+            return Promise.resolve({
+                containsParameters: parameters,
+                results: foundKeys
+            });
+        }
+        fetchByKeys(parameters) {
+            const { keys } = parameters;
+            const { data } = this.dataState;
+            const results = new Map();
+            data.data.forEach((item) => {
+                if (keys.has(item.metadata.key)) {
+                    results.set(item.metadata.key, item);
+                }
+            });
+            return Promise.resolve({
+                fetchParameters: parameters,
+                results
+            });
+        }
+        fetchByOffset(parameters) {
+            const { offset, size } = parameters;
+            const { data } = this.dataState;
+            const filteredData = data.data.slice(offset, size);
+            const results = {
+                fetchParameters: parameters ?? {},
+                results: filteredData.map((item) => ({ data: item.data, metadata: item.metadata })),
+                done: offset + (size ?? 0) >= data.totalSize
+            };
+            return Promise.resolve(results);
+        }
+        fetchFirst(parameters) {
+            const { data } = this.dataState;
+            return {
+                [Symbol.asyncIterator]() {
+                    let offset = 0;
+                    const size = parameters?.size ?? 25;
+                    const totalSize = data.totalSize;
+                    return {
+                        async next() {
+                            if (offset < totalSize) {
+                                const filteredData = data.data.slice(offset, size);
+                                const resultsOverride = filteredData.reduce((acc, value) => {
+                                    acc.data.push(value.data);
+                                    acc.metadata.push(value.metadata);
+                                    return acc;
+                                }, { data: [], metadata: [] });
+                                const results = {
+                                    ...resultsOverride,
+                                    fetchParameters: parameters ?? {},
+                                    totalFilteredRowCount: data.totalSize
+                                };
+                                const adjustedSize = Math.min(size, totalSize - offset);
+                                offset += offset + adjustedSize;
+                                return { value: results, done: false };
+                            }
+                            const results = {
+                                data: [],
+                                metadata: [],
+                                fetchParameters: parameters ?? {},
+                                totalFilteredRowCount: data.totalSize
+                            };
+                            return { value: results, done: true };
+                        }
+                    };
+                }
+            };
+        }
+        getCapability() {
+            return null;
+        }
+        getTotalSize() {
+            return Promise.resolve(this.dataState.data.totalSize);
+        }
+        isEmpty() {
+            return this.dataState.data.totalSize === 0 ? 'yes' : 'no';
+        }
+        addEventListener() { }
+        dispatchEvent() {
+            return false;
+        }
+        removeEventListener() { }
+    }
+});

package/oj-c/select-common/PRIVATE_useSelectData/index.js

@@ -0,0 +1,7 @@
+define(["require", "exports", "./useSelectData", "./CollectionTemplateDataProviderView"], function (require, exports, useSelectData_1, CollectionTemplateDataProviderView_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.SELECT_INTERNALS = exports.useSelectData = void 0;
+    Object.defineProperty(exports, "useSelectData", { enumerable: true, get: function () { return useSelectData_1.useSelectData; } });
+    Object.defineProperty(exports, "SELECT_INTERNALS", { enumerable: true, get: function () { return CollectionTemplateDataProviderView_1.SELECT_INTERNALS; } });
+});

package/oj-c/select-common/PRIVATE_useSelectData/useCollectionTemplateDataProviderView.js

@@ -0,0 +1,98 @@
+define(["require", "exports", "oj-c/hooks/UNSAFE_useListData/useListData", "preact/hooks", "./CollectionTemplateDataProviderView"], function (require, exports, useListData_1, hooks_1, CollectionTemplateDataProviderView_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.useCollectionTemplateDataProviderView = void 0;
+    function useCollectionTemplateDataProviderView({ dataProvider, options: { dataStateOverride, filterCriterion } }) {
+        const [state, dispatch] = (0, hooks_1.useReducer)((reducer), {
+            dataState: (0, useListData_1.getEmptyState)('atLeast')
+        });
+        const wrappedDP = (0, hooks_1.useMemo)(() => dataProvider == null
+            ? dataProvider
+            : new CollectionTemplateDataProviderView_1.CollectionTemplateDataProviderView(dataProvider, {
+                onInitializeFetch() {
+                    dispatch({ type: 'loading' });
+                },
+                onNextIteration({ results: { data, metadata, fetchParameters }, offset, done }) {
+                    if (fetchParameters.signal?.aborted)
+                        return;
+                    const items = data.map((item, index) => ({
+                        data: item,
+                        metadata: metadata[index]
+                    }));
+                    dispatch({ type: 'append', payload: { items, offset, done } });
+                },
+                onOffsetFetch({ results: { results, done, fetchParameters } }) {
+                    if (fetchParameters.signal?.aborted)
+                        return;
+                    dispatch({
+                        type: 'update',
+                        payload: { items: results, done, offset: fetchParameters.offset }
+                    });
+                },
+                onRefresh() {
+                    dispatch({ type: 'loading' });
+                }
+            }), [dataProvider]);
+        const prevFilterCriterionRef = (0, hooks_1.useRef)();
+        if (prevFilterCriterionRef.current !== filterCriterion) {
+            prevFilterCriterionRef.current = filterCriterion;
+            wrappedDP?.setFilterCriterion(filterCriterion);
+        }
+        const prevDataStateOverride = (0, hooks_1.useRef)();
+        if (prevDataStateOverride.current !== dataStateOverride) {
+            prevDataStateOverride.current = dataStateOverride;
+            wrappedDP?.setDataStateOverride(dataStateOverride);
+        }
+        return {
+            dataState: state.dataState,
+            dataProvider: wrappedDP
+        };
+    }
+    exports.useCollectionTemplateDataProviderView = useCollectionTemplateDataProviderView;
+    const reducer = (state, { type, payload }) => {
+        switch (type) {
+            case 'append': {
+                const { dataState } = state;
+                const prevData = dataState.status === 'success' ? dataState.data : null;
+                const { done, items } = payload;
+                return {
+                    ...state,
+                    dataState: {
+                        status: 'success',
+                        data: {
+                            data: [...(prevData?.data ?? []), ...items],
+                            offset: prevData?.offset ?? 0,
+                            sizePrecision: done ? 'exact' : 'atLeast',
+                            totalSize: (prevData?.data.length ?? 0) + items.length
+                        }
+                    }
+                };
+            }
+            case 'update': {
+                return {
+                    ...state,
+                    dataState: {
+                        status: 'success',
+                        data: {
+                            data: payload.items,
+                            offset: payload.offset,
+                            sizePrecision: payload.done ? 'exact' : 'atLeast',
+                            totalSize: payload.items.length
+                        }
+                    }
+                };
+            }
+            case 'loading': {
+                return {
+                    ...state,
+                    dataState: {
+                        status: 'loading',
+                        data: null
+                    }
+                };
+            }
+            default:
+                return state;
+        }
+    };
+});

package/oj-c/select-common/PRIVATE_useSelectData/useSelectData.js

@@ -0,0 +1,24 @@
+define(["require", "exports", "oj-c/hooks/UNSAFE_useListData/useListData", "preact/hooks", "../UNSAFE_useWrapDataProvider/index", "./useCollectionTemplateDataProviderView"], function (require, exports, useListData_1, hooks_1, index_1, useCollectionTemplateDataProviderView_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.useSelectData = void 0;
+    const noOp = () => { };
+    const useSelectData = ({ data, dataStateOverride: propDataStateOverride, filterCriterion, hasCollectionTemplate }) => {
+        const dataProvider = (0, index_1.useWrapDataProvider)(data);
+        const [listDataState, onLoadRange] = (0, useListData_1.useListData)(dataProvider ?? null, {
+            filterCriterion,
+            initialRowsFetched: 0
+        });
+        const dataStateOverride = (0, hooks_1.useMemo)(() => (propDataStateOverride ? { status: 'success', data: propDataStateOverride } : undefined), [propDataStateOverride]);
+        const { dataState: templateDataState, dataProvider: templateDataProvider } = (0, useCollectionTemplateDataProviderView_1.useCollectionTemplateDataProviderView)({
+            dataProvider,
+            options: { dataStateOverride, filterCriterion }
+        });
+        return {
+            dataProvider: hasCollectionTemplate ? templateDataProvider : dataProvider,
+            dataState: hasCollectionTemplate ? dataStateOverride ?? templateDataState : listDataState,
+            onLoadRange: hasCollectionTemplate ? noOp : onLoadRange
+        };
+    };
+    exports.useSelectData = useSelectData;
+});

package/oj-c/select-common/UNSAFE_useDataProviderListeners/useDataProviderListeners.js

@@ -1,4 +1,4 @@
-define(["require", "exports", "@oracle/oraclejet-preact/utils/UNSAFE_logger", "preact/hooks", "../utils/utils"], function (require, exports, UNSAFE_logger_1, hooks_1, utils_1) {
+define(["require", "exports", "@oracle/oraclejet-preact/utils/UNSAFE_logger", "preact/hooks", "../PRIVATE_useSelectData/index", "../utils/utils"], function (require, exports, UNSAFE_logger_1, hooks_1, index_1, utils_1) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.useDataProviderListeners = void 0;
@@ -39,12 +39,14 @@ define(["require", "exports", "@oracle/oraclejet-preact/utils/UNSAFE_logger", "p
     }
     function useDataProviderListeners({ dataProvider, setValue, setValueToSync, setValueItemsToSync, value, valueItems }) {
         const isSelectMultiple = value instanceof Set;
-        const handleRefresh = (0, hooks_1.useCallback)(() => {
+        const handleRefresh = (0, hooks_1.useCallback)((event) => {
+            if (!shouldHandleRefreshEvent(event))
+                return;
             if (!(0, utils_1.isEmpty)(value)) {
                 setValueToSync(cloneValue(value));
                 setValueItemsToSync(utils_1.DEFAULT_VALUE_ITEMS);
             }
-        }, [value]);
+        }, [setValueItemsToSync, setValueToSync, value]);
         const handleMutation = (0, hooks_1.useCallback)((event) => {
             if ((0, utils_1.isEmpty)(value)) {
                 return;
@@ -82,7 +84,7 @@ define(["require", "exports", "@oracle/oraclejet-preact/utils/UNSAFE_logger", "p
                     setValueItemsToSync(!(0, utils_1.isEmpty)(newValueItems) ? newValueItems : utils_1.DEFAULT_VALUE_ITEMS);
                 }
             }
-        }, [value, valueItems]);
+        }, [isSelectMultiple, setValue, setValueItemsToSync, setValueToSync, value, valueItems]);
         (0, hooks_1.useEffect)(() => {
             dataProvider?.addEventListener('refresh', handleRefresh);
             dataProvider?.addEventListener('mutate', handleMutation);
@@ -93,4 +95,11 @@ define(["require", "exports", "@oracle/oraclejet-preact/utils/UNSAFE_logger", "p
         }, [dataProvider, handleMutation, handleRefresh]);
     }
     exports.useDataProviderListeners = useDataProviderListeners;
+    const shouldHandleRefreshEvent = (event) => {
+        if (index_1.SELECT_INTERNALS in event) {
+            const { cause = '' } = event[index_1.SELECT_INTERNALS];
+            return !['filterCriterionChanged', 'dataOverrideChanged'].includes(cause);
+        }
+        return true;
+    };
 });

package/oj-c/select-common/UNSAFE_useWrapDataProvider/useWrapDataProvider.js

@@ -1,14 +1,18 @@
-define(["require", "exports", "ojs/ojdataproviderfactory", "preact/hooks"], function (require, exports, ojdataproviderfactory_1, hooks_1) {
+define(["require", "exports", "ojs/ojdataproviderfactory", "preact/hooks", "../PRIVATE_DebouncingDataProviderView/DebouncingDataProviderView"], function (require, exports, ojdataproviderfactory_1, hooks_1, DebouncingDataProviderView_1) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.useWrapDataProvider = void 0;
     function useWrapDataProvider(data) {
         const dataProvider = (0, hooks_1.useMemo)(() => {
-            return data
-                ? (0, ojdataproviderfactory_1.getEnhancedDataProvider)(data, {
-                    fetchFirst: { caching: 'visitedByCurrentIterator' }
-                })
-                : data;
+            if (!data) {
+                return data;
+            }
+            const enhancedDP = (0, ojdataproviderfactory_1.getEnhancedDataProvider)(data, {
+                fetchFirst: { caching: 'visitedByCurrentIterator' }
+            });
+            const filterCapability = enhancedDP.getCapability('fetchFirst');
+            const isImmediate = filterCapability?.iterationSpeed === 'immediate';
+            return isImmediate ? enhancedDP : new DebouncingDataProviderView_1.DebouncingDataProviderView(enhancedDP);
         }, [data]);
         return dataProvider;
     }