1 | (function (global, factory) {
|
2 | typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
|
3 | typeof define === 'function' && define.amd ? define(['exports'], factory) :
|
4 | (global = global || self, factory(global.dataObjectHooks = {}));
|
5 | }(this, function (exports) { 'use strict';
|
6 |
|
7 | function _typeof(obj) {
|
8 | if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
|
9 | _typeof = function (obj) {
|
10 | return typeof obj;
|
11 | };
|
12 | } else {
|
13 | _typeof = function (obj) {
|
14 | return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
|
15 | };
|
16 | }
|
17 |
|
18 | return _typeof(obj);
|
19 | }
|
20 |
|
21 | function _slicedToArray(arr, i) {
|
22 | return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();
|
23 | }
|
24 |
|
25 | function _arrayWithHoles(arr) {
|
26 | if (Array.isArray(arr)) return arr;
|
27 | }
|
28 |
|
29 | function _iterableToArrayLimit(arr, i) {
|
30 | var _arr = [];
|
31 | var _n = true;
|
32 | var _d = false;
|
33 | var _e = undefined;
|
34 |
|
35 | try {
|
36 | for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
|
37 | _arr.push(_s.value);
|
38 |
|
39 | if (i && _arr.length === i) break;
|
40 | }
|
41 | } catch (err) {
|
42 | _d = true;
|
43 | _e = err;
|
44 | } finally {
|
45 | try {
|
46 | if (!_n && _i["return"] != null) _i["return"]();
|
47 | } finally {
|
48 | if (_d) throw _e;
|
49 | }
|
50 | }
|
51 |
|
52 | return _arr;
|
53 | }
|
54 |
|
55 | function _nonIterableRest() {
|
56 | throw new TypeError("Invalid attempt to destructure non-iterable instance");
|
57 | }
|
58 |
|
59 | const { React } = window;
|
60 | const PureComponent = React.PureComponent;
|
61 | const Component = React.Component;
|
62 | const useState = React.useState;
|
63 | const useEffect = React.useEffect;
|
64 |
|
65 | var dataUpdateEvents = ["onFieldChanged", "onRecordCreated", "onRecordDeleted", "onRecordRefreshed", "onAfterSave", "onCancelEdit", "onDataLoaded"];
|
66 | function useCurrentRow(dataObject) {
|
67 | var _useState = useState({}),
|
68 | _useState2 = _slicedToArray(_useState, 2),
|
69 | record = _useState2[0],
|
70 | setRecord = _useState2[1];
|
71 |
|
72 | function updateRecord() {
|
73 | setRecord(dataObject.currentRow());
|
74 | }
|
75 |
|
76 | useEffect(function () {
|
77 | var recordUpdateEvents = ["onCurrentIndexChanged"].concat(dataUpdateEvents);
|
78 | recordUpdateEvents.forEach(function (event) {
|
79 | return dataObject.attachEvent(event, updateRecord);
|
80 | });
|
81 | updateRecord();
|
82 | return function () {
|
83 | return recordUpdateEvents.forEach(function (event) {
|
84 | return dataObject.detachEvent(event, updateRecord);
|
85 | });
|
86 | };
|
87 | }, [dataObject]);
|
88 | return record;
|
89 | }
|
90 | function useData(dataObject) {
|
91 | var _useState3 = useState([]),
|
92 | _useState4 = _slicedToArray(_useState3, 2),
|
93 | data = _useState4[0],
|
94 | setData = _useState4[1];
|
95 |
|
96 | function updateData() {
|
97 | setData(dataObject.getData());
|
98 | }
|
99 |
|
100 | useEffect(function () {
|
101 | dataUpdateEvents.forEach(function (event) {
|
102 | return dataObject.attachEvent(event, updateData);
|
103 | });
|
104 | updateData();
|
105 | return function () {
|
106 | return dataUpdateEvents.forEach(function (event) {
|
107 | return dataObject.detachEvent(event, updateData);
|
108 | });
|
109 | };
|
110 | }, [dataObject]);
|
111 | return data;
|
112 | }
|
113 |
|
114 | function getData(dataObject, filter) {
|
115 | var data = window.af.data;
|
116 | var dataHandler = new data.DataProviderHandler({
|
117 | dataSourceId: dataObject.getDataSourceId(),
|
118 | timeout: 30000
|
119 | });
|
120 | var fields = dataObject.getFields();
|
121 | return new Promise(function (resolve, reject) {
|
122 | var filterData = {
|
123 | filterString: "",
|
124 | whereClause: typeof filter === "string" ? filter : "",
|
125 | whereObject: _typeof(filter) === "object" ? filter : null
|
126 | };
|
127 | dataHandler.retrieve(filterData, function (error, data) {
|
128 | if (error !== null) {
|
129 | reject(error);
|
130 | } else {
|
131 | var records = [];
|
132 | var _iteratorNormalCompletion = true;
|
133 | var _didIteratorError = false;
|
134 | var _iteratorError = undefined;
|
135 |
|
136 | try {
|
137 | for (var _iterator = data[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
|
138 | var item = _step.value;
|
139 | var record = {};
|
140 |
|
141 | for (var i = 0; i < item.length; i++) {
|
142 | record[fields[i].name] = item[i];
|
143 | }
|
144 |
|
145 | records.push(record);
|
146 | }
|
147 | } catch (err) {
|
148 | _didIteratorError = true;
|
149 | _iteratorError = err;
|
150 | } finally {
|
151 | try {
|
152 | if (!_iteratorNormalCompletion && _iterator.return != null) {
|
153 | _iterator.return();
|
154 | }
|
155 | } finally {
|
156 | if (_didIteratorError) {
|
157 | throw _iteratorError;
|
158 | }
|
159 | }
|
160 | }
|
161 |
|
162 | resolve(records);
|
163 | }
|
164 | });
|
165 | });
|
166 | }
|
167 |
|
168 | function useSingleRecord(dataObject, filter) {
|
169 |
|
170 | console.warn("DEPRECATED: useSingleRecord has been renamed to useRecord");
|
171 | return useFetchRecord(dataObject, filter);
|
172 | }
|
173 | function useDataWithoutState(dataObject, filter) {
|
174 |
|
175 | console.warn("DEPRECATED: useDataWithoutState has been renamed to useRecord");
|
176 | return useFetchData(dataObject, filter);
|
177 | }
|
178 | function useFetchRecord(dataObject, filter) {
|
179 | var _useFetchData = useFetchData(dataObject, filter),
|
180 | isLoading = _useFetchData.isLoading,
|
181 | data = _useFetchData.data,
|
182 | refresh = _useFetchData.refresh;
|
183 |
|
184 | var record = data.length > 0 ? data[0] : {};
|
185 | return {
|
186 | record: record,
|
187 | refresh: refresh,
|
188 | isLoading: isLoading
|
189 | };
|
190 | }
|
191 | function useFetchData(dataObject, filter) {
|
192 | var _useState = useState([]),
|
193 | _useState2 = _slicedToArray(_useState, 2),
|
194 | data = _useState2[0],
|
195 | setData = _useState2[1];
|
196 |
|
197 | var _useState3 = useState(true),
|
198 | _useState4 = _slicedToArray(_useState3, 2),
|
199 | isLoading = _useState4[0],
|
200 | setIsLoading = _useState4[1];
|
201 |
|
202 | function refresh() {
|
203 | setIsLoading(true);
|
204 | getData(dataObject, filter).then(function (data) {
|
205 | if (data.length > 0) {
|
206 | setData(data);
|
207 | } else {
|
208 | setData([]);
|
209 | }
|
210 |
|
211 | setIsLoading(false);
|
212 | });
|
213 | }
|
214 |
|
215 | useEffect(function () {
|
216 | refresh();
|
217 | }, [dataObject, filter]);
|
218 | return {
|
219 | data: data,
|
220 | refresh: refresh,
|
221 | isLoading: isLoading
|
222 | };
|
223 | }
|
224 |
|
225 | function useCurrentIndex(dataObject) {
|
226 | var _useState = useState(dataObject.getCurrentIndex()),
|
227 | _useState2 = _slicedToArray(_useState, 2),
|
228 | index = _useState2[0],
|
229 | setIndex = _useState2[1];
|
230 |
|
231 | useEffect(function () {
|
232 | dataObject.attachEvent("onCurrentIndexChanged", setIndex);
|
233 | setIndex(dataObject.getCurrentIndex());
|
234 | return function () {
|
235 | return dataObject.detachEvent("onCurrentIndexChanged", setIndex);
|
236 | };
|
237 | }, [dataObject]);
|
238 | return index;
|
239 | }
|
240 | function useDirty(dataObject) {
|
241 | var _useState3 = useState(false),
|
242 | _useState4 = _slicedToArray(_useState3, 2),
|
243 | isDirty = _useState4[0],
|
244 | setDirty = _useState4[1];
|
245 |
|
246 | useEffect(function () {
|
247 | dataObject.attachEvent("onDirtyChanged", setDirty);
|
248 | setDirty(dataObject.isDirty());
|
249 | return function () {
|
250 | dataObject.detachEvent("onDirtyChanged", setDirty);
|
251 | };
|
252 | }, [dataObject]);
|
253 | return isDirty;
|
254 | }
|
255 | function useError(dataObject) {
|
256 | var _useState5 = useState(null),
|
257 | _useState6 = _slicedToArray(_useState5, 2),
|
258 | loadError = _useState6[0],
|
259 | setError = _useState6[1];
|
260 |
|
261 | useEffect(function () {
|
262 | dataObject.attachEvent("onDataLoadFailed", setError);
|
263 | return function () {
|
264 | dataObject.detachEvent("onDataLoadFailed", setError);
|
265 | };
|
266 | }, [dataObject]);
|
267 | return loadError;
|
268 | }
|
269 | function useLoading(dataObject) {
|
270 | var _useState7 = useState(dataObject.isDataLoading()),
|
271 | _useState8 = _slicedToArray(_useState7, 2),
|
272 | isLoading = _useState8[0],
|
273 | setLoading = _useState8[1];
|
274 |
|
275 | function setIsLoading() {
|
276 | setLoading(true);
|
277 | }
|
278 |
|
279 | function setIsNotLoading() {
|
280 | setLoading(false);
|
281 | }
|
282 |
|
283 | useEffect(function () {
|
284 | dataObject.attachEvent("onBeforeLoad", setIsLoading);
|
285 | dataObject.attachEvent("onDataLoaded", setIsNotLoading);
|
286 | dataObject.attachEvent("onDataLoadFailed", setIsNotLoading);
|
287 | setLoading(dataObject.isDataLoading());
|
288 | return function () {
|
289 | dataObject.detachEvent("onBeforeLoad", setIsLoading);
|
290 | dataObject.detachEvent("onDataLoaded", setIsNotLoading);
|
291 | dataObject.detachEvent("onDataLoadFailed", setIsNotLoading);
|
292 | };
|
293 | }, [dataObject]);
|
294 | return isLoading;
|
295 | }
|
296 | function useStatus(dataObject) {
|
297 | var _useState9 = useState(false),
|
298 | _useState10 = _slicedToArray(_useState9, 2),
|
299 | isSaving = _useState10[0],
|
300 | setIsSaving = _useState10[1];
|
301 |
|
302 | var _useState11 = useState(false),
|
303 | _useState12 = _slicedToArray(_useState11, 2),
|
304 | isDeleting = _useState12[0],
|
305 | setIsDeleting = _useState12[1];
|
306 |
|
307 | function setSaving() {
|
308 | setIsSaving(true);
|
309 | }
|
310 |
|
311 | function setNotSaving() {
|
312 | setIsSaving(false);
|
313 | }
|
314 |
|
315 | function setDeleting() {
|
316 | setIsDeleting(true);
|
317 | }
|
318 |
|
319 | function setNotDeleting() {
|
320 | setIsDeleting(false);
|
321 | }
|
322 |
|
323 | useEffect(function () {
|
324 | dataObject.attachEvent("onBeforeSave", setSaving);
|
325 | dataObject.attachEvent("onAfterSave", setNotSaving);
|
326 | dataObject.attachEvent("onSaveFailed", setNotSaving);
|
327 | dataObject.attachEvent("onRecordDeleting", setDeleting);
|
328 | dataObject.attachEvent("onRecordDeleted", setNotDeleting);
|
329 | return function () {
|
330 | dataObject.detachEvent("onBeforeSave", setSaving);
|
331 | dataObject.detachEvent("onAfterSave", setNotSaving);
|
332 | dataObject.detachEvent("onSaveFailed", setNotSaving);
|
333 | dataObject.detachEvent("onRecordDeleting", setDeleting);
|
334 | dataObject.detachEvent("onRecordDeleted", setNotDeleting);
|
335 | };
|
336 | }, [dataObject]);
|
337 | return {
|
338 | isDeleting: isDeleting,
|
339 | isSaving: isSaving
|
340 | };
|
341 | }
|
342 | function usePermissions(dataObject) {
|
343 | var _useState13 = useState(dataObject.isDeleteAllowed()),
|
344 | _useState14 = _slicedToArray(_useState13, 2),
|
345 | allowDelete = _useState14[0],
|
346 | setAllowDelete = _useState14[1];
|
347 |
|
348 | var _useState15 = useState(dataObject.isInsertAllowed()),
|
349 | _useState16 = _slicedToArray(_useState15, 2),
|
350 | allowInsert = _useState16[0],
|
351 | setAllowInsert = _useState16[1];
|
352 |
|
353 | var _useState17 = useState(dataObject.isUpdateAllowed()),
|
354 | _useState18 = _slicedToArray(_useState17, 2),
|
355 | allowUpdate = _useState18[0],
|
356 | setAllowUpdate = _useState18[1];
|
357 |
|
358 | useEffect(function () {
|
359 | dataObject.attachEvent("onAllowDeleteChanged", setAllowDelete);
|
360 | dataObject.attachEvent("onAllowInsertChanged", setAllowInsert);
|
361 | dataObject.attachEvent("onAllowUpdateChanged", setAllowUpdate);
|
362 | return function () {
|
363 | dataObject.detachEvent("onAllowDeleteChanged", setAllowDelete);
|
364 | dataObject.detachEvent("onAllowInsertChanged", setAllowInsert);
|
365 | dataObject.detachEvent("onAllowUpdateChanged", setAllowUpdate);
|
366 | };
|
367 | }, [dataObject]);
|
368 | return {
|
369 | allowDelete: allowDelete,
|
370 | allowInsert: allowInsert,
|
371 | allowUpdate: allowUpdate
|
372 | };
|
373 | }
|
374 |
|
375 | exports.useCurrentIndex = useCurrentIndex;
|
376 | exports.useDirty = useDirty;
|
377 | exports.useError = useError;
|
378 | exports.useLoading = useLoading;
|
379 | exports.useStatus = useStatus;
|
380 | exports.usePermissions = usePermissions;
|
381 | exports.useCurrentRow = useCurrentRow;
|
382 | exports.useData = useData;
|
383 | exports.useSingleRecord = useSingleRecord;
|
384 | exports.useDataWithoutState = useDataWithoutState;
|
385 | exports.useFetchData = useFetchData;
|
386 | exports.useFetchRecord = useFetchRecord;
|
387 | exports.getData = getData;
|
388 |
|
389 | Object.defineProperty(exports, '__esModule', { value: true });
|
390 |
|
391 | }));
|