@oracle/oraclejet-core-pack 14.0.0

package/oj-c/min/editable-value/UNSAFE_useValue/useValue.js

@@ -0,0 +1,42 @@
+define(["require", "exports", "@oracle/oraclejet-preact/hooks/UNSAFE_useUncontrolledState", "preact/hooks", "../utils/utils"], function (require, exports, UNSAFE_useUncontrolledState_1, hooks_1, utils_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.useValue = void 0;
+    function useValue({ value: valueProp, format, parse, onRawValueChanged, onTransientValueChanged, onValueChanged }) {
+        const [displayValue, setDisplayValue] = (0, UNSAFE_useUncontrolledState_1.useUncontrolledState)(format(valueProp, true), onRawValueChanged);
+        const [value, setValue] = (0, UNSAFE_useUncontrolledState_1.useUncontrolledState)(valueProp, onValueChanged);
+        (0, hooks_1.useEffect)(() => {
+            if (displayValue !== undefined) {
+                onRawValueChanged === null || onRawValueChanged === void 0 ? void 0 : onRawValueChanged(displayValue);
+            }
+        }, []);
+        const [transientValue, setTransientValue] = (0, UNSAFE_useUncontrolledState_1.useUncontrolledState)(valueProp, onTransientValueChanged);
+        (0, hooks_1.useEffect)(() => {
+            if (valueProp !== undefined) {
+                onTransientValueChanged === null || onTransientValueChanged === void 0 ? void 0 : onTransientValueChanged(valueProp);
+            }
+        }, []);
+        return {
+            displayValue,
+            transientValue,
+            value,
+            getValueForValidation: (0, hooks_1.useCallback)((valid) => {
+                if (valid !== 'invalidShown') {
+                    return value;
+                }
+                return parse((0, utils_1.normalizeValue)(displayValue));
+            }, [displayValue, value, parse]),
+            setValueAfterValidation: (0, hooks_1.useCallback)((value) => {
+                setValue(value);
+                setDisplayValue(format(value));
+            }, [format]),
+            setDisplayValue,
+            setTransientValue,
+            setValue,
+            refreshDisplayValue: (0, hooks_1.useCallback)(() => {
+                setDisplayValue(format(value));
+            }, [value, format])
+        };
+    }
+    exports.useValue = useValue;
+});

package/oj-c/min/editable-value/UNSAFE_useValueLifecycle/useValueLifecycle.d.ts

@@ -0,0 +1,9 @@
+import { ValidationResult } from '../UNSAFE_useValidators/useValidators';
+import { ValueState } from '../UNSAFE_useValue/useValue';
+export declare type UseValueLifecycleProps<V> = {
+    value?: V;
+    valueState: ValueState<V>;
+    format: (value: V) => string;
+    validateValueOnExternalChange: (value: V) => ValidationResult;
+};
+export declare function useValueLifecycle<V>({ value, valueState, format, validateValueOnExternalChange }: UseValueLifecycleProps<V>): void;

package/oj-c/min/editable-value/UNSAFE_useValueLifecycle/useValueLifecycle.js

@@ -0,0 +1,27 @@
+define(["require", "exports", "preact/hooks", "../UNSAFE_useValidators/useValidators"], function (require, exports, hooks_1, useValidators_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.useValueLifecycle = void 0;
+    function useValueLifecycle({ value, valueState, format, validateValueOnExternalChange }) {
+        const previousValueRef = (0, hooks_1.useRef)(value);
+        (0, hooks_1.useEffect)(() => {
+            const { value, setDisplayValue } = valueState;
+            setDisplayValue(format(value));
+        }, []);
+        (0, hooks_1.useEffect)(() => {
+            if (previousValueRef.current === value) {
+                return;
+            }
+            previousValueRef.current = value;
+            if (value !== undefined && value !== valueState.value) {
+                const { setDisplayValue, setValue } = valueState;
+                const validationResult = validateValueOnExternalChange(value);
+                if (validationResult === useValidators_1.ValidationResult.VALID) {
+                    setValue(value);
+                    setDisplayValue(format(value));
+                }
+            }
+        }, [value, valueState, format]);
+    }
+    exports.useValueLifecycle = useValueLifecycle;
+});

package/oj-c/min/editable-value/component.json

@@ -0,0 +1,9 @@
+{
+  "name": "editable-value",
+  "version": "1.0.0",
+  "jetVersion": "^13.0.0",
+  "type": "resource",
+  "displayName": "Editable Value",
+  "description": "The common resources including hooks and utils that will be used by the form components.",
+  "pack": "oj-c"
+}

package/oj-c/min/editable-value/utils/utils.d.ts

@@ -0,0 +1,6 @@
+import { ComponentMessageItem } from '@oracle/oraclejet-preact/UNSAFE_ComponentMessage';
+import { ConverterError, ValidatorError } from 'ojs/ojvalidation-error';
+export declare function createMessageFromError(error: Error | ValidatorError | ConverterError): ComponentMessageItem;
+export declare function treatNull<T>(value?: T | null, defaultValue?: T): T | undefined;
+export declare function normalizeValue<T>(value?: T): T | null | undefined;
+export declare const isShallowEqual: <T>(a: T[], b: T[]) => boolean;

package/oj-c/min/editable-value/utils/utils.js

@@ -0,0 +1,31 @@
+define(["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isShallowEqual = exports.normalizeValue = exports.treatNull = exports.createMessageFromError = void 0;
+    function createMessageFromError(error) {
+        if (typeof error.getMessage === 'function') {
+            return {
+                severity: 'error',
+                detail: error.getMessage().detail
+            };
+        }
+        return { severity: 'error', detail: error.message };
+    }
+    exports.createMessageFromError = createMessageFromError;
+    function treatNull(value, defaultValue) {
+        if (value === null) {
+            return defaultValue;
+        }
+        return value;
+    }
+    exports.treatNull = treatNull;
+    function normalizeValue(value) {
+        if (typeof value === 'string' && value === '') {
+            return null;
+        }
+        return value;
+    }
+    exports.normalizeValue = normalizeValue;
+    const isShallowEqual = (a, b) => a === b || (a.length === b.length && a.every((v, i) => v === b[i]));
+    exports.isShallowEqual = isShallowEqual;
+});

package/oj-c/min/file-picker/file-picker-styles.css

@@ -0,0 +1,17 @@
+oj-c-file-picker:not(.oj-complete) {
+  visibility: hidden;
+}
+
+oj-c-file-picker {
+  display: block;
+  max-width: 400px;
+  width: 100%;
+}
+ 
+oj-c-file-picker.oj-c-file-picker-with-trigger {
+  display: inline-block;
+}
+
+oj-c-file-picker[hidden] {
+  display: none;
+}

package/oj-c/min/file-picker.js

@@ -0,0 +1,2 @@
+define("oj-c/utils/UNSAFE_focusTabUtils/focusUtils",["require","exports"],(function(require,e){"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.getFirstTabStop=e.focusFirstTabStop=void 0;e.focusFirstTabStop=t=>{if(!t)return;const r=(0,e.getFirstTabStop)(t);return r&&r.focus(),r};e.getFirstTabStop=e=>{const t=e.querySelectorAll('button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])');return t&&t.length>0?t[0]:null}}));var __rest=this&&this.__rest||function(e,t){var r={};for(var i in e)Object.prototype.hasOwnProperty.call(e,i)&&t.indexOf(i)<0&&(r[i]=e[i]);if(null!=e&&"function"==typeof Object.getOwnPropertySymbols){var o=0;for(i=Object.getOwnPropertySymbols(e);o<i.length;o++)t.indexOf(i[o])<0&&Object.prototype.propertyIsEnumerable.call(e,i[o])&&(r[i[o]]=e[i[o]])}return r},__importDefault=this&&this.__importDefault||function(e){return e&&e.__esModule?e:{default:e}};define("oj-c/file-picker/file-picker",["require","exports","preact/jsx-runtime","@oracle/oraclejet-preact/translationBundle","@oracle/oraclejet-preact/UNSAFE_FilePicker","preact/hooks","preact/compat","ojs/ojvcomponent","@oracle/oraclejet-preact/hooks/UNSAFE_useTabbableMode","../utils/UNSAFE_focusTabUtils/focusUtils","css!oj-c/file-picker/file-picker-styles.css"],(function(require,e,t,r,i,o,l,c,n,s){"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.FilePicker=void 0,r=__importDefault(r);const a=(e,t)=>"function"==typeof e?e({selectionMode:t}):e;e.FilePicker=(0,c.registerCustomElement)("oj-c-file-picker",(0,l.forwardRef)(((e,r)=>{var{capture:l="none",disabled:n=!1,selectionMode:u="multiple"}=e,p=__rest(e,["capture","disabled","selectionMode"]);const f=(0,o.useCallback)((e=>{var t;null===(t=p.onOjBeforeSelect)||void 0===t||t.call(p,{files:e.files}).then((()=>{var t;null===(t=p.onOjSelect)||void 0===t||t.call(p,{files:e.files})}),(e=>{var t;null===(t=p.onOjInvalidSelect)||void 0===t||t.call(p,{messages:e,until:null})}))}),[p.onOjBeforeSelect,p.onOjSelect,p.onOjInvalidSelect]);(0,o.useImperativeHandle)(r,(()=>({focus:()=>(0,s.focusFirstTabStop)(d.current),blur:()=>{var e;const t=document.activeElement;(null===(e=d.current)||void 0===e?void 0:e.contains(t))&&t.blur()}})));const d=(0,o.useRef)(null);return(0,t.jsx)(c.Root,Object.assign({ref:d,class:p.trigger?"oj-c-file-picker-with-trigger":void 0},{children:(0,t.jsx)(i.FilePicker,Object.assign({capture:l,isDisabled:n,selectionMode:u,onCommit:f,onReject:p.onOjInvalidSelect,accept:p.accept,primaryText:(b=p.primaryText,"function"==typeof b?b():b),secondaryText:a(p.secondaryText,u),accessibleLabel:p["aria-label"],width:"100%"},{children:p.trigger}))}));var b})),"FilePicker",{properties:{accept:{type:"Array<string>"},capture:{type:"string",enumValues:["none","user","environment","implementation"]},disabled:{type:"boolean"},primaryText:{type:"string|function"},secondaryText:{type:"string|function"},selectionMode:{type:"string",enumValues:["multiple","single"]}},slots:{trigger:{}},events:{ojBeforeSelect:{cancelable:!0},ojInvalidSelect:{},ojSelect:{}},extension:{_OBSERVED_GLOBAL_PROPS:["aria-label"]},methods:{focus:{},blur:{}}},{capture:"none",disabled:!1,selectionMode:"multiple"},{"@oracle/oraclejet-preact":r.default},{consume:[n.TabbableModeContext]})})),define("oj-c/file-picker",["require","exports","./file-picker/file-picker"],(function(require,e,t){"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.FilePicker=void 0,Object.defineProperty(e,"FilePicker",{enumerable:!0,get:function(){return t.FilePicker}})}));
+//# sourceMappingURL=file-picker.js.map

package/oj-c/min/file-picker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-picker.js","names":["define","require","exports","Object","defineProperty","value","getFirstTabStop","focusFirstTabStop","element","focusElement","focus","tabbable","querySelectorAll","length","__rest","this","s","e","t","p","prototype","hasOwnProperty","call","indexOf","getOwnPropertySymbols","i","propertyIsEnumerable","__importDefault","mod","__esModule","default","jsx_runtime_1","translationBundle_1","UNSAFE_FilePicker_1","hooks_1","compat_1","ojvcomponent_1","UNSAFE_useTabbableMode_1","focusUtils_1","FilePicker","getSecondaryText","secondaryText","selectionMode","registerCustomElement","forwardRef","_a","ref","capture","disabled","otherProps","onCommit","useCallback","event","onOjBeforeSelect","files","then","onOjSelect","messages","onOjInvalidSelect","until","useImperativeHandle","rootRef","current","blur","document","activeElement","contains","useRef","jsx","Root","assign","class","trigger","undefined","children","isDisabled","onReject","accept","primaryText","accessibleLabel","width","properties","type","enumValues","slots","events","ojBeforeSelect","cancelable","ojInvalidSelect","ojSelect","extension","_OBSERVED_GLOBAL_PROPS","methods","consume","TabbableModeContext","file_picker_1","enumerable","get"],"sources":["../file-picker.js"],"mappings":"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"}

package/oj-c/min/hooks/UNSAFE_useDataProvider/DataProviderHandler.d.ts

@@ -0,0 +1,18 @@
+import { ItemContext } from 'ojs/ojcommontypes';
+import { DataProvider } from 'ojs/ojdataprovider';
+declare type DataProviderHandlerCallback<Key, Data> = {
+    onDataUpdated: (data: Array<ItemContext<Key, Data>>) => void;
+};
+export declare class DataProviderHandler<Key, Data> {
+    private readonly addBusyState;
+    private readonly dataProvider;
+    private currentData;
+    private callback?;
+    private readonly handleMutateEvent;
+    private readonly handleRefreshEvent;
+    constructor(dataProvider: DataProvider<Key, Data>, addBusyState: (description: string) => () => void, callback?: DataProviderHandlerCallback<Key, Data>);
+    destroy(): void;
+    private _fetchData;
+    private _fetchDataAndNotify;
+}
+export {};

package/oj-c/min/hooks/UNSAFE_useDataProvider/DataProviderHandler.js

@@ -0,0 +1,89 @@
+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 __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+define(["require", "exports", "./utils"], function (require, exports, utils_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DataProviderHandler = void 0;
+    class DataProviderHandler {
+        constructor(dataProvider, addBusyState, callback) {
+            this.handleMutateEvent = (event) => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b;
+                const { detail } = event;
+                const resolver = this.addBusyState('updating data from mutation event');
+                const updatedData = yield (0, utils_1.getUpdatedItemsFromMutationDetail)(detail, this.currentData, this.dataProvider);
+                resolver === null || resolver === void 0 ? void 0 : resolver();
+                this.currentData = updatedData;
+                (_b = (_a = this.callback) === null || _a === void 0 ? void 0 : _a.onDataUpdated) === null || _b === void 0 ? void 0 : _b.call(_a, updatedData);
+            });
+            this.handleRefreshEvent = () => {
+                this._fetchDataAndNotify();
+            };
+            this.addBusyState = addBusyState;
+            this.callback = callback;
+            this.dataProvider = dataProvider;
+            this.currentData = [];
+            dataProvider.addEventListener('refresh', this.handleRefreshEvent);
+            dataProvider.addEventListener('mutate', this.handleMutateEvent);
+            this._fetchDataAndNotify();
+        }
+        destroy() {
+            this.callback = undefined;
+            this.currentData = [];
+            this.dataProvider.removeEventListener('refresh', this.handleRefreshEvent);
+            this.dataProvider.removeEventListener('mutate', this.handleMutateEvent);
+        }
+        _fetchData() {
+            var e_1, _a;
+            return __awaiter(this, void 0, void 0, function* () {
+                const fetchedData = [];
+                const asyncIterable = this.dataProvider.fetchFirst({ size: -1 });
+                try {
+                    for (var asyncIterable_1 = __asyncValues(asyncIterable), asyncIterable_1_1; asyncIterable_1_1 = yield asyncIterable_1.next(), !asyncIterable_1_1.done;) {
+                        const results = asyncIterable_1_1.value;
+                        const contextArray = results.data.map((item, index) => {
+                            return {
+                                data: item,
+                                key: results.metadata[index].key,
+                                metadata: results.metadata[index]
+                            };
+                        });
+                        fetchedData.push(...contextArray);
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (asyncIterable_1_1 && !asyncIterable_1_1.done && (_a = asyncIterable_1.return)) yield _a.call(asyncIterable_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                this.currentData = fetchedData.slice();
+                return fetchedData;
+            });
+        }
+        _fetchDataAndNotify() {
+            var _a, _b;
+            return __awaiter(this, void 0, void 0, function* () {
+                const resolver = this.addBusyState('fetching data');
+                const fetchedData = yield this._fetchData();
+                (_b = (_a = this.callback) === null || _a === void 0 ? void 0 : _a.onDataUpdated) === null || _b === void 0 ? void 0 : _b.call(_a, fetchedData);
+                resolver();
+            });
+        }
+    }
+    exports.DataProviderHandler = DataProviderHandler;
+});

package/oj-c/min/hooks/UNSAFE_useDataProvider/useDataProvider.d.ts

@@ -0,0 +1,10 @@
+import { ItemContext } from 'ojs/ojcommontypes';
+import { DataProvider } from 'ojs/ojdataprovider';
+declare type Props<Key, Data> = {
+    data?: DataProvider<Key, Data>;
+    addBusyState: (description: string) => () => void;
+};
+export declare function useDataProvider<K, D>({ addBusyState, data }: Props<K, D>): {
+    data: ItemContext<K, D>[];
+};
+export {};

package/oj-c/min/hooks/UNSAFE_useDataProvider/useDataProvider.js

@@ -0,0 +1,25 @@
+define(["require", "exports", "preact/hooks", "./DataProviderHandler"], function (require, exports, hooks_1, DataProviderHandler_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.useDataProvider = void 0;
+    function useDataProvider({ addBusyState, data }) {
+        const [fetchedData, setFetchedData] = (0, hooks_1.useState)([]);
+        const dataProviderHandler = (0, hooks_1.useRef)();
+        (0, hooks_1.useEffect)(() => {
+            if (data !== undefined) {
+                dataProviderHandler.current = new DataProviderHandler_1.DataProviderHandler(data, addBusyState, {
+                    onDataUpdated: setFetchedData
+                });
+            }
+            return () => {
+                var _a;
+                (_a = dataProviderHandler.current) === null || _a === void 0 ? void 0 : _a.destroy();
+                dataProviderHandler.current = undefined;
+            };
+        }, [data, addBusyState]);
+        return {
+            data: fetchedData
+        };
+    }
+    exports.useDataProvider = useDataProvider;
+});

package/oj-c/min/hooks/UNSAFE_useDataProvider/utils.d.ts

@@ -0,0 +1,3 @@
+import { ItemContext } from 'ojs/ojcommontypes';
+import { DataProvider, DataProviderMutationEventDetail } from 'ojs/ojdataprovider';
+export declare function getUpdatedItemsFromMutationDetail<K, D>(detail: DataProviderMutationEventDetail<K, D>, currentData: ItemContext<K, D>[], dataProvider: DataProvider<K, D>): Promise<ItemContext<K, D>[]>;

package/oj-c/min/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/min/hooks/UNSAFE_useListData/__tests__/useListData.test.d.ts

@@ -0,0 +1 @@
+export {};

package/oj-c/min/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');
+                }
+            });
+        });
+    });
+});