@ukhomeoffice/cop-react-form-renderer 6.15.0-alpha → 6.15.1

package/dist/components/FormRenderer/helpers/clearOutUncompletedRoutesUtils.test.js

@@ -0,0 +1,559 @@
+"use strict";
+
+var Utils = _interopRequireWildcard(require("./clearOutUncompletedRoutesUtils"));
+var _Condition = _interopRequireDefault(require("../../../utils/Condition"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+describe('deleteNodeByPath', () => {
+  it('delete where node is at parent level', () => {
+    const nested = {
+      type: "Example form",
+      alpha: "alpha",
+      bravo: "bravo",
+      person: {
+        charlie: "Smith",
+        delta: "Acme Inc"
+      },
+      gamma: "gamma",
+      epsilon: "epsilon"
+    };
+    const path = 'type';
+    Utils.deleteNodeByPath(nested, path);
+    expect(nested).toEqual({
+      alpha: "alpha",
+      bravo: "bravo",
+      person: {
+        charlie: "Smith",
+        delta: "Acme Inc"
+      },
+      gamma: "gamma",
+      epsilon: "epsilon"
+    });
+  });
+  it('delete where node is at child level', () => {
+    const nested = {
+      type: "Example form",
+      alpha: "alpha",
+      bravo: "bravo",
+      person: {
+        charlie: "Smith",
+        delta: "Acme Inc"
+      },
+      gamma: "gamma",
+      epsilon: "epsilon"
+    };
+    const path = 'person.charlie';
+    Utils.deleteNodeByPath(nested, path);
+    expect(nested).toEqual({
+      type: "Example form",
+      alpha: "alpha",
+      bravo: "bravo",
+      person: {
+        delta: "Acme Inc"
+      },
+      gamma: "gamma",
+      epsilon: "epsilon"
+    });
+  });
+});
+describe('removeObjectWithOnlySingleIdField', () => {
+  it('removes objects with only the "id" field', () => {
+    const inputArray = [{
+      id: 1
+    }, {
+      name: 'John'
+    }, {
+      id: 2
+    }, {
+      age: 30
+    }, {
+      id: 3
+    }, {
+      id: 4,
+      name: 'John'
+    }];
+    Utils.removeObjectWithOnlySingleIdField(inputArray);
+    expect(inputArray).toEqual([{
+      name: 'John'
+    }, {
+      age: 30
+    }, {
+      id: 4,
+      name: 'John'
+    }]);
+  });
+  it('does not mutate the array if no elements are removed', () => {
+    const inputArray = [{
+      name: 'John'
+    }, {
+      age: 30
+    }];
+    const originalArray = [].concat(inputArray);
+    Utils.removeObjectWithOnlySingleIdField(inputArray);
+    expect(inputArray).toEqual(originalArray);
+  });
+});
+describe('getImmediateParent', () => {
+  it('returns the immediate parent path when a valid path is provided', () => {
+    const path = 'user.profile.name';
+    const result = Utils.getImmediateParent(path);
+    expect(result).toBe('user.profile');
+  });
+  it('returns null if the path is an empty string', () => {
+    const result = Utils.getImmediateParent('');
+    expect(result).toBeNull();
+  });
+  it('returns the immediate parent when there is only one part in the path', () => {
+    const path = 'user.';
+    const result = Utils.getImmediateParent(path);
+    expect(result).toBe('user');
+  });
+});
+describe('getNestedQuestionPath', () => {
+  it('returns the correct nested path when the parent path is found', () => {
+    const result = Utils.getNestedQuestionPath('user.profile.name', 'age');
+    expect(result).toBe('user.profile.age');
+  });
+  it('returns the nestedFieldId when the parent path is not found', () => {
+    const result = Utils.getNestedQuestionPath('name', 'age');
+    expect(result).toBe('age');
+  });
+  it('handles an empty parent path correctly', () => {
+    const result = Utils.getNestedQuestionPath('', 'age');
+    expect(result).toBe('age');
+  });
+  it('handles nested paths with multiple parts correctly', () => {
+    const result = Utils.getNestedQuestionPath('user.profile.settings.theme', 'darkMode');
+    expect(result).toBe('user.profile.settings.darkMode');
+  });
+});
+describe('getDependencies', () => {
+  it('should extract "field" values from deeply nested structures', () => {
+    const input = {
+      "id": "firearms",
+      "show_when": [{
+        "type": "or",
+        "conditions": [{
+          "type": "and",
+          "conditions": [{
+            "op": "=",
+            "field": "itemCategory.category",
+            "value": "Weapons"
+          }, {
+            "op": "in",
+            "field": "itemSubCategory.epmscategory",
+            "values": ["ARM", "ARP"]
+          }]
+        }, {
+          "type": "and",
+          "conditions": [{
+            "op": "=",
+            "field": "itemCategory.category",
+            "value": "Firearms"
+          }, {
+            "op": "!=",
+            "field": "itemSubCategory.epmscategory",
+            "value": "AMM"
+          }]
+        }]
+      }]
+    };
+    expect(Utils.getDependencies(input)).toEqual(new Set(['itemCategory.category', 'itemSubCategory.epmscategory', 'itemCategory.category', 'itemSubCategory.epmscategory']));
+  });
+  it('should return null when no show_when', () => {
+    const input = {
+      "id": "firearms"
+    };
+    expect(Utils.getDependencies(input)).toEqual(null);
+  });
+});
+describe('getDependencyObjectFromPath', () => {
+  let allComponents;
+  beforeEach(() => {
+    allComponents = new Map([['whatHappened', {
+      id: 'whatHappened',
+      value: 'whatHappenedComponent'
+    }], ['modeOfTransport', {
+      id: 'modeOfTransport',
+      value: 'modeOfTransportComponent'
+    }]]);
+  });
+  it('should return the exact match from the map', () => {
+    expect(Utils.getDependencyObjectFromPath('whatHappened', allComponents)).toEqual({
+      id: 'whatHappened',
+      value: 'whatHappenedComponent'
+    });
+  });
+  it('should return the nearest parent found in the allComponents map', () => {
+    expect(Utils.getDependencyObjectFromPath('modeOfTransport.id', allComponents)).toEqual({
+      id: 'modeOfTransport',
+      value: 'modeOfTransportComponent'
+    });
+  });
+  it('should return the first matched component even when > 1 layers down', () => {
+    expect(Utils.getDependencyObjectFromPath('modeOfTransport.types.id', allComponents)).toEqual({
+      id: 'modeOfTransport',
+      value: 'modeOfTransportComponent'
+    });
+  });
+  it('should return null if no matching path is found', () => {
+    expect(Utils.getDependencyObjectFromPath('unknown.path', allComponents)).toBeNull();
+  });
+});
+jest.mock('../../../utils/Condition', () => ({
+  meetsOne: jest.fn(),
+  meetsAll: jest.fn()
+}));
+describe('isShowEntity', () => {
+  afterEach(() => {
+    jest.clearAllMocks(); // Reset mocks after each test
+  });
+  it('should return true if entity.show_when is not set', () => {
+    const entity = {}; // No show_when field
+    const data = {};
+    expect(Utils.isShowEntity(entity, data)).toBe(true);
+  });
+  it('should call meetsOne if show_when.type is "or"', () => {
+    const entity = {
+      show_when: {
+        type: 'or'
+      }
+    };
+    const data = {};
+    _Condition.default.meetsOne.mockReturnValue(true); // Mock meetsOne to return true
+
+    expect(Utils.isShowEntity(entity, data)).toBe(true);
+    expect(_Condition.default.meetsOne).toHaveBeenCalledWith(entity, data);
+    expect(_Condition.default.meetsAll).not.toHaveBeenCalled();
+  });
+  it('should call meetsAll if show_when.type is not "or"', () => {
+    const entity = {
+      show_when: {
+        type: 'and'
+      }
+    };
+    const data = {};
+    _Condition.default.meetsAll.mockReturnValue(false); // Mock meetsAll to return false
+
+    expect(Utils.isShowEntity(entity, data)).toBe(false);
+    expect(_Condition.default.meetsAll).toHaveBeenCalledWith(entity, data);
+    expect(_Condition.default.meetsOne).not.toHaveBeenCalled();
+  });
+  it('should call meetsAll if show_when.type is missing', () => {
+    const entity = {
+      show_when: {}
+    }; // No type specified
+    const data = {};
+    _Condition.default.meetsAll.mockReturnValue(true);
+    expect(Utils.isShowEntity(entity, data)).toBe(true);
+    expect(_Condition.default.meetsAll).toHaveBeenCalledWith(entity, data);
+    expect(_Condition.default.meetsOne).not.toHaveBeenCalled();
+  });
+});
+describe('findComponentDefinitionInForm', () => {
+  let componentByIdMap;
+  let componentByFieldIdMap;
+  beforeEach(() => {
+    componentByIdMap = new Map();
+    componentByFieldIdMap = new Map();
+  });
+  test('returns component from componentByIdMap when found', () => {
+    const component = {
+      id: 'comp1',
+      type: 'button'
+    };
+    componentByIdMap.set('comp1', component);
+    const pageComponentDef = {
+      use: 'comp1'
+    };
+    const result = Utils.findComponentDefinitionInForm(pageComponentDef, componentByIdMap, componentByFieldIdMap);
+    expect(result).toEqual(component);
+    expect(result).not.toBe(component); // Ensure it is a clone
+  });
+  test('returns component from componentByIdMap when found, but applies show_when from pageComponentDef', () => {
+    const component = {
+      id: 'comp1',
+      type: 'button',
+      show_when: 'rule1'
+    };
+    componentByIdMap.set('comp1', component);
+    const pageComponentDef = {
+      use: 'comp1',
+      show_when: 'rule2'
+    };
+    const result = Utils.findComponentDefinitionInForm(pageComponentDef, componentByIdMap, componentByFieldIdMap);
+    expect(result).toEqual({
+      id: 'comp1',
+      type: 'button',
+      show_when: 'rule2'
+    });
+  });
+  test('returns component from componentByFieldIdMap if not in componentByIdMap', () => {
+    const component = {
+      id: 'comp2',
+      type: 'input'
+    };
+    componentByFieldIdMap.set('comp2', component);
+    const pageComponentDef = {
+      use: 'comp2'
+    };
+    const result = Utils.findComponentDefinitionInForm(pageComponentDef, componentByIdMap, componentByFieldIdMap);
+    expect(result).toEqual(component);
+    expect(result).not.toBe(component); // Ensure it is a clone
+  });
+  test('returns pageComponentDef if not found in either map', () => {
+    const pageComponentDef = {
+      id: 'comp1',
+      definitions: "def values"
+    };
+    const result = Utils.findComponentDefinitionInForm(pageComponentDef, componentByIdMap, componentByFieldIdMap);
+    expect(result).toEqual(pageComponentDef);
+    expect(result).not.toBe(pageComponentDef); // Ensure it is a clone
+  });
+  test('ensures returned component is a deep clone', () => {
+    const component = {
+      id: 'comp3',
+      nested: {
+        key: 'value'
+      }
+    };
+    componentByIdMap.set('comp3', component);
+    const pageComponentDef = {
+      use: 'comp3'
+    };
+    const result = Utils.findComponentDefinitionInForm(pageComponentDef, componentByIdMap, componentByFieldIdMap);
+
+    // Modify the original to check deep cloning
+    component.nested.key = 'changed';
+    expect(result.nested.key).toBe('value'); // Should remain unchanged
+    expect(result).not.toBe(component); // Should not be the same reference
+  });
+});
+describe('deleteCorrespondingMetaInfo', () => {
+  let formData;
+  let collectionDataObject;
+  let component;
+  beforeEach(() => {
+    formData = {
+      meta: {
+        documents: [{
+          url: 'https://example.com/file1.pdf'
+        }, {
+          url: 'https://example.com/file2.pdf'
+        }, {
+          url: 'https://example.com/file3.pdf'
+        }]
+      }
+    };
+    collectionDataObject = {};
+    component = {
+      fieldId: 'fileField'
+    };
+  });
+  test('removes a matching document when found', () => {
+    collectionDataObject.fileField = {
+      url: 'https://example.com/file2.pdf'
+    };
+    Utils.deleteCorrespondingMetaInfo(component, collectionDataObject, formData);
+    expect(formData.meta.documents).toEqual([{
+      url: 'https://example.com/file1.pdf'
+    }, {
+      url: 'https://example.com/file3.pdf'
+    }]);
+  });
+  test('removes a matching document when fileDataBeingDeleted is an array', () => {
+    collectionDataObject.fileField = [{
+      url: 'https://example.com/file2.pdf'
+    }, {
+      url: 'https://example.com/file3.pdf'
+    }];
+    Utils.deleteCorrespondingMetaInfo(component, collectionDataObject, formData);
+    expect(formData.meta.documents).toEqual([{
+      url: 'https://example.com/file1.pdf'
+    }]);
+  });
+  test('does nothing if documents array is empty', () => {
+    formData.meta.documents = [];
+    collectionDataObject.fileField = {
+      url: 'https://example.com/file2.pdf'
+    };
+    Utils.deleteCorrespondingMetaInfo(component, collectionDataObject, formData);
+    expect(formData.meta.documents).toEqual([]);
+  });
+  test('does nothing if fileDataBeingDeleted is undefined', () => {
+    Utils.deleteCorrespondingMetaInfo(component, collectionDataObject, formData);
+    expect(formData.meta.documents).toEqual([{
+      url: 'https://example.com/file1.pdf'
+    }, {
+      url: 'https://example.com/file2.pdf'
+    }, {
+      url: 'https://example.com/file3.pdf'
+    }]);
+  });
+  test('does nothing if there is no match', () => {
+    collectionDataObject.fileField = {
+      url: 'https://example.com/nonexistent.pdf'
+    };
+    Utils.deleteCorrespondingMetaInfo(component, collectionDataObject, formData);
+    expect(formData.meta.documents).toEqual([{
+      url: 'https://example.com/file1.pdf'
+    }, {
+      url: 'https://example.com/file2.pdf'
+    }, {
+      url: 'https://example.com/file3.pdf'
+    }]);
+  });
+});
+describe("removeEmptyArraysAndUnusedCollectionIDs", () => {
+  test("removes empty arrays from an array", () => {
+    const input = [1, [], 2, []];
+    Utils.removeEmptyArraysAndUnusedCollectionIDs(input);
+    expect(input).toEqual([1, 2]);
+  });
+  test("removes empty arrays from an object and deletes corresponding ActiveId", () => {
+    const input = {
+      key1: [],
+      key1ActiveId: "123",
+      key2: "value"
+    };
+    Utils.removeEmptyArraysAndUnusedCollectionIDs(input);
+    expect(input).toEqual({
+      key2: "value"
+    });
+  });
+  test("removes empty arrays in nested structures", () => {
+    const input = {
+      level1: {
+        level2: {
+          arr: [],
+          arrActiveId: "456",
+          anotherKey: "data"
+        }
+      }
+    };
+    Utils.removeEmptyArraysAndUnusedCollectionIDs(input);
+    expect(input).toEqual({
+      level1: {
+        level2: {
+          anotherKey: "data"
+        }
+      }
+    });
+  });
+  test("removes multiple empty arrays and their ActiveIds", () => {
+    const input = {
+      list1: [],
+      list1ActiveId: "789",
+      list2: [1, 2],
+      nested: {
+        emptyList: [],
+        emptyListActiveId: "999"
+      }
+    };
+    Utils.removeEmptyArraysAndUnusedCollectionIDs(input);
+    expect(input).toEqual({
+      list2: [1, 2],
+      nested: {}
+    });
+  });
+  test("does not modify non-empty arrays", () => {
+    const input = {
+      arr: [1, 2, 3],
+      obj: {
+        nestedArr: ["a"]
+      }
+    };
+    const expected = {
+      arr: [1, 2, 3],
+      obj: {
+        nestedArr: ["a"]
+      }
+    };
+    Utils.removeEmptyArraysAndUnusedCollectionIDs(input);
+    expect(input).toEqual(expected);
+  });
+  test("handles null and empty object gracefully", () => {
+    const input1 = null;
+    const input2 = {};
+    Utils.removeEmptyArraysAndUnusedCollectionIDs(input1);
+    Utils.removeEmptyArraysAndUnusedCollectionIDs(input2);
+    expect(input1).toBeNull();
+    expect(input2).toEqual({});
+  });
+  test("handles arrays containing objects with empty arrays", () => {
+    const input = [{
+      key: []
+    }, {
+      key: "value"
+    }, {
+      nested: {
+        arr: [],
+        arrActiveId: "555"
+      }
+    }];
+    Utils.removeEmptyArraysAndUnusedCollectionIDs(input);
+    expect(input).toEqual([{
+      key: "value"
+    }, {
+      nested: {}
+    }]);
+  });
+});
+describe("pruneCollectionEntry", () => {
+  let pathsToKeep;
+  let componentsToPrune;
+  let collectionDataObject;
+  let formData;
+  let expectedFormData;
+  beforeEach(() => {
+    pathsToKeep = new Set(['keepThis']);
+    componentsToPrune = [{
+      fieldId: 'removeThis',
+      type: 'text'
+    }, {
+      fieldId: 'keepThis',
+      type: 'text'
+    }, {
+      fieldId: 'removeMultifile',
+      type: 'multifile'
+    }];
+    collectionDataObject = {
+      'removeThis': 'value',
+      'keepThis': 'value',
+      'removeMultifile': {
+        'url': 'https://example.com/file1.pdf'
+      }
+    };
+    formData = {
+      meta: {
+        documents: [{
+          url: 'https://example.com/file1.pdf'
+        }, {
+          url: 'https://example.com/file2.pdf'
+        }, {
+          url: 'https://example.com/file3.pdf'
+        }]
+      }
+    };
+    expectedFormData = {
+      meta: {
+        documents: [{
+          url: 'https://example.com/file2.pdf'
+        }, {
+          url: 'https://example.com/file3.pdf'
+        }]
+      }
+    };
+  });
+  it('should remove components not in pathsToKeep', () => {
+    Utils.pruneCollectionEntry(pathsToKeep, componentsToPrune, collectionDataObject, formData);
+    expect(collectionDataObject).toEqual({
+      'keepThis': 'value'
+    });
+  });
+  it('should delete meta.documents for multifile components', () => {
+    Utils.pruneCollectionEntry(pathsToKeep, componentsToPrune, collectionDataObject, formData);
+    expect(formData).toEqual(expectedFormData);
+  });
+});

package/dist/components/FormRenderer/onCYAAction.js

@@ -30,6 +30,13 @@ const onCYAAction = (setPagePoint, action, pages, validate, components, data, se
         pages,
         components
       }, _objectSpread({}, data), _models.EventTypes.SUBMIT);
+
+      // Cleanse hidden data
+      const formPagesAndComponents = {
+        pages,
+        components
+      };
+      _helpers.default.clearOutUncompletedRoutes(formPagesAndComponents, submissionData);
       submissionData.formStatus = _helpers.default.getSubmissionStatus(type, pages, pageId, action, submissionData, currentTask, true);
       setData(submissionData);
       // Now submit the data to the backend...
@@ -69,6 +76,11 @@ const onCYAAction = (setPagePoint, action, pages, validate, components, data, se
           pages,
           components
         }, _objectSpread({}, data), _models.EventTypes.SUBMIT);
+        const formPagesAndComponents = {
+          pages,
+          components
+        };
+        _helpers.default.clearOutUncompletedRoutes(formPagesAndComponents, submissionData);
         submissionData.formStatus = _helpers.default.getSubmissionStatus(type, pages, pageId, action, submissionData, currentTask, true);
         setData(submissionData);
         // Now submit the data to the backend...

package/dist/components/FormRenderer/onCYAAction.test.js

@@ -55,6 +55,11 @@ jest.mock('./helpers', () => ({
     this.getNextPageIdCalls = 0;
     this.getFormStateCalls = 0;
     this.getSubmissionStatusCalls = 0;
+  },
+  clearOutUncompletedRoutesCalls: 0,
+  clearOutUncompletedRoutes(formPagesAndComponents, formData) {
+    this.clearOutUncompletedRoutesCalls += 1;
+    return formData;
   }
 }));
 jest.mock('../../utils', () => ({

package/dist/hooks/useGetRequest.js

@@ -8,10 +8,6 @@ var _axios = _interopRequireDefault(require("axios"));
 var _react = require("react");
 var _useAxios = _interopRequireDefault(require("./useAxios"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-// Global imports
-
-// Local imports
-
 // Caches for responses and errors.
 const cache = {};
 const errorCache = {};
@@ -31,15 +27,18 @@ const STATUS_IDLE = exports.STATUS_IDLE = 'idle';
 const STATUS_FETCHING = exports.STATUS_FETCHING = 'fetching';
 const STATUS_FETCHED = exports.STATUS_FETCHED = 'fetched';
 const STATUS_ERROR = exports.STATUS_ERROR = 'error';
-const useGetRequest = url => {
+const useGetRequest = function (url) {
+  let caching = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
   const axiosInstance = (0, _useAxios.default)();
-  const cancelToken = _axios.default.CancelToken.source();
-  const cancelRequests = () => {
-    if (cancelToken) cancelToken.cancel();
-  };
+  const cancelTokenRef = (0, _react.useRef)(_axios.default.CancelToken.source());
   const [status, setStatus] = (0, _react.useState)(STATUS_IDLE);
   const [error, setError] = (0, _react.useState)(null);
   const [data, setData] = (0, _react.useState)(null);
+  const cancelRequests = () => {
+    if (cancelTokenRef.current) {
+      cancelTokenRef.current.cancel();
+    }
+  };
   (0, _react.useEffect)(() => {
     if (!url || !axiosInstance) return;
     const fetchData = async () => {
@@ -47,9 +46,9 @@ const useGetRequest = url => {
         setError(null);
         setStatus(STATUS_FETCHING);
         let fetchedData;
-        if (cache[url]) {
+        if (caching && cache[url]) {
           fetchedData = cache[url];
-        } else if (errorCache[url]) {
+        } else if (caching && errorCache[url]) {
           /**
            * This logic is intended to stop multiple requests being made in succession
            * that all fail. Presently, this will only allow the first request to be
@@ -60,24 +59,25 @@ const useGetRequest = url => {
           throw errorCache[url];
         } else {
           const response = await axiosInstance.get(url, {
-            cancelToken: cancelToken.token
+            cancelToken: cancelTokenRef.current.token
           }).catch(e => {
+            setError(e);
             throw e;
           });
           fetchedData = response.data;
-          cache[url] = fetchedData;
+          if (caching) cache[url] = fetchedData;
         }
         setData(fetchedData);
         setStatus(STATUS_FETCHED);
       } catch (e) {
-        errorCache[url] = e;
+        if (caching) errorCache[url] = e;
         setError(e);
         setData(null);
         setStatus(STATUS_ERROR);
       }
     };
     fetchData();
-  }, [axiosInstance, url, cancelToken.token]);
+  }, [axiosInstance, url, caching]);
   return {
     status,
     error,

package/dist/hooks/useRefData.js

@@ -28,13 +28,14 @@ const getRefDataUrl = component => {
   return undefined;
 };
 const useRefData = (component, formData) => {
+  var _component$data;
   const url = getRefDataUrl(_objectSpread(_objectSpread({}, component), {}, {
     formData
   }));
   const {
     status: _status,
     data: _data
-  } = (0, _useGetRequest.default)(url);
+  } = (0, _useGetRequest.default)(url, component === null || component === void 0 || (_component$data = component.data) === null || _component$data === void 0 ? void 0 : _component$data.useCache);
   const [data, setData] = (0, _react.useState)([]);
   const [status, setStatus] = (0, _react.useState)(STATUS_LOADING);
   (0, _react.useEffect)(() => {
@@ -52,7 +53,7 @@ const useRefData = (component, formData) => {
       setData([]);
       setStatus(STATUS_COMPLETE);
     }
-  }, [component, _status, _data, url, setData, setStatus]);
+  }, [component.id, _status, _data, url]);
   return {
     data,
     status