@truedat/dd 8.7.0 → 8.7.1

package/src/reducers/__tests__/grants.spec.js

@@ -83,7 +83,7 @@ describe("reducers: grants", () => {
       grants(fooState, {
         type: fetchGrants.SUCCESS,
         payload: { data },
-      })
+      }),
     ).toMatchObject(someGrants);
   });
 
@@ -92,7 +92,7 @@ describe("reducers: grants", () => {
     const data = { id: 1, user_id: "123" };
     const expected = [data, { id: 2 }];
     expect(
-      grants(state, { type: updateGrant.SUCCESS, payload: { data } })
+      grants(state, { type: updateGrant.SUCCESS, payload: { data } }),
     ).toMatchObject(expected);
   });
 

package/src/reducers/__tests__/graph.spec.js

@@ -14,7 +14,7 @@ describe("reducers: graph", () => {
 
   it("should be the initial state after receiving the legacyFetchStructure.TRIGGER action", () => {
     expect(graph(fooState, { type: legacyFetchStructure.TRIGGER })).toEqual(
-      initialState
+      initialState,
     );
   });
 

package/src/reducers/__tests__/graphLoading.spec.js

@@ -22,7 +22,7 @@ describe("reducers: graphLoading", () => {
 
   it("should be true after receiving the createStructureGraph.REQUEST action", () => {
     expect(graphLoading(false, { type: createStructureGraph.REQUEST })).toBe(
-      true
+      true,
     );
   });
 
@@ -32,7 +32,7 @@ describe("reducers: graphLoading", () => {
 
   it("should be true after receiving the fetchStructureGraph.TRIGGER action", () => {
     expect(graphLoading(false, { type: fetchStructureGraph.TRIGGER })).toBe(
-      true
+      true,
     );
   });
 
@@ -57,12 +57,14 @@ describe("reducers: graphLoading", () => {
   });
 
   it("should be false after receiving the legacyFetchStructure.TRIGGER action", () => {
-    expect(graphLoading(true, { type: legacyFetchStructure.TRIGGER })).toBe(false);
+    expect(graphLoading(true, { type: legacyFetchStructure.TRIGGER })).toBe(
+      false,
+    );
   });
 
   it("should be false after receiving the fetchStructureGraph.FULFILL action", () => {
     expect(graphLoading(true, { type: fetchStructureGraph.FULFILL })).toBe(
-      false
+      false,
     );
   });
 

package/src/reducers/__tests__/graphRedirect.spec.js

@@ -1,6 +1,10 @@
 import { clearRedirect } from "@truedat/core/routines";
 import { graphRedirect, initialState } from "../graphRedirect";
-import { clearStructure, legacyFetchStructure, createGraph } from "../../routines";
+import {
+  clearStructure,
+  legacyFetchStructure,
+  createGraph,
+} from "../../routines";
 
 const fooState = { foo: "bar" };
 
@@ -11,27 +15,27 @@ describe("reducers: graphRedirect", () => {
 
   it("should be the initial state after receiving the clearRedirect.TRIGGER action", () => {
     expect(graphRedirect(fooState, { type: clearRedirect.TRIGGER })).toBe(
-      initialState
+      initialState,
     );
   });
 
   it("should be the initial state after receiving the clearStructure.TRIGGER action", () => {
     expect(graphRedirect(fooState, { type: clearStructure.TRIGGER })).toBe(
-      initialState
+      initialState,
     );
   });
 
   it("should be the initial state after receiving the legacyFetchStructure.TRIGGER action", () => {
-    expect(graphRedirect(fooState, { type: legacyFetchStructure.TRIGGER })).toBe(
-      initialState
-    );
+    expect(
+      graphRedirect(fooState, { type: legacyFetchStructure.TRIGGER }),
+    ).toBe(initialState);
   });
 
   it("should be the graph url  after receiving the createGraph.SUCCESS action", () => {
     const data = { id: "42", isRedirected: true };
     const payload = { data };
     expect(
-      graphRedirect(fooState, { type: createGraph.SUCCESS, payload })
+      graphRedirect(fooState, { type: createGraph.SUCCESS, payload }),
     ).toEqual("/graphs/42");
   });
 

package/src/reducers/__tests__/lineageEventsLoading.spec.js

@@ -10,13 +10,13 @@ describe("reducers: lineageEventsLoading", () => {
 
   it("returns to initial state on fetchLineageEvents.FULFILL action", () => {
     expect(
-      lineageEventsLoading(fooState, { type: fetchLineageEvents.FULFILL })
+      lineageEventsLoading(fooState, { type: fetchLineageEvents.FULFILL }),
     ).toBe(false);
   });
 
   it("returns true on fetchLineageEvents.REQUEST action", () => {
     expect(
-      lineageEventsLoading(fooState, { type: fetchLineageEvents.REQUEST })
+      lineageEventsLoading(fooState, { type: fetchLineageEvents.REQUEST }),
     ).toBe(true);
   });
 

package/src/reducers/__tests__/lineageQuery.spec.js

@@ -17,7 +17,7 @@ describe("reducers: lineageQuery", () => {
     const state = { excludes: ["foo"] };
     const payload = { id: "bar" };
     expect(
-      lineageQuery(state, { type: excludeNode.TRIGGER, payload })
+      lineageQuery(state, { type: excludeNode.TRIGGER, payload }),
     ).toMatchObject({ excludes: ["bar", "foo"] });
   });
 
@@ -25,7 +25,7 @@ describe("reducers: lineageQuery", () => {
     const state = { excludes: ["foo"] };
     const payload = { id: "bar" };
     expect(
-      lineageQuery(state, { type: excludeNode.TRIGGER, payload })
+      lineageQuery(state, { type: excludeNode.TRIGGER, payload }),
     ).toMatchObject({
       excludes: ["bar", "foo"],
       isRedirected: false,
@@ -35,7 +35,7 @@ describe("reducers: lineageQuery", () => {
   it("should reset the exclusions after receiving the selectGroup.TRIGGER action", () => {
     const payload = {};
     expect(
-      lineageQuery(fooState, { type: selectGroup.TRIGGER, payload })
+      lineageQuery(fooState, { type: selectGroup.TRIGGER, payload }),
     ).toMatchObject({ excludes: [] });
   });
 
@@ -46,7 +46,7 @@ describe("reducers: lineageQuery", () => {
     const state = { excludes: ["foo"] };
     const payload = { ids, type, levels };
     expect(
-      lineageQuery(state, { type: createGraph.TRIGGER, payload })
+      lineageQuery(state, { type: createGraph.TRIGGER, payload }),
     ).toMatchObject({ excludes: [], ids, type, levels });
   });
 
@@ -57,7 +57,7 @@ describe("reducers: lineageQuery", () => {
     const state = { excludes: ["foo"] };
     const payload = { ids, type, levels };
     expect(
-      lineageQuery(state, { type: createGraph.TRIGGER, payload })
+      lineageQuery(state, { type: createGraph.TRIGGER, payload }),
     ).toMatchObject({
       excludes: [],
       ids,
@@ -76,7 +76,7 @@ describe("reducers: lineageQuery", () => {
     const data = { ids, excludes, opts: { type, levels: payloadLevels } };
     const payload = { data };
     expect(
-      lineageQuery({ levels: 3 }, { type: fetchGraph.SUCCESS, payload })
+      lineageQuery({ levels: 3 }, { type: fetchGraph.SUCCESS, payload }),
     ).toMatchObject({ ids, excludes, type, levels });
   });
 

package/src/reducers/__tests__/nodes.spec.js

@@ -17,7 +17,7 @@ describe("reducers: nodes", () => {
     const data = { baz };
     const payload = { data };
     expect(nodes(fooState, { type: fetchNodes.SUCCESS, payload })).toEqual(
-      data
+      data,
     );
   });
 

package/src/reducers/__tests__/nodesLoading.spec.js

@@ -10,13 +10,13 @@ describe("reducers: nodesLoading", () => {
 
   it("returns to initial state on clearNodes.TRIGGER action", () => {
     expect(nodesLoading(fooState, { type: clearNodes.TRIGGER })).toBe(
-      initialState
+      initialState,
     );
   });
 
   it("returns to initial state on fetchNodes.FULFILL action", () => {
     expect(nodesLoading(fooState, { type: fetchNodes.FULFILL })).toBe(
-      initialState
+      initialState,
     );
   });
 

package/src/reducers/__tests__/profileExecution.spec.js

@@ -12,13 +12,13 @@ describe("reducers: profileExecution", () => {
 
   it("should handle the clearProfileExecution.TRIGGER action", () => {
     expect(
-      profileExecution(fooState, { type: clearProfileExecution.TRIGGER })
+      profileExecution(fooState, { type: clearProfileExecution.TRIGGER }),
     ).toEqual(initialState);
   });
 
   it("should handle the fetchProfileExecution.TRIGGER action", () => {
     expect(
-      profileExecution(fooState, { type: fetchProfileExecution.TRIGGER })
+      profileExecution(fooState, { type: fetchProfileExecution.TRIGGER }),
     ).toEqual(initialState);
   });
 
@@ -27,14 +27,14 @@ describe("reducers: profileExecution", () => {
       id: 1,
       _embedded: {
         data_structure: { id: 1, external_id: "foo" },
-        profile: { value: { foo: "bar" } }
-      }
+        profile: { value: { foo: "bar" } },
+      },
     };
     expect(
       profileExecution(fooState, {
         type: fetchProfileExecution.SUCCESS,
-        payload: { data }
-      })
+        payload: { data },
+      }),
     ).toMatchObject(data);
   });
 

package/src/reducers/__tests__/profileExecutionLoading.spec.js

@@ -12,15 +12,17 @@ describe("reducers: profileExecutionLoading", () => {
 
   it("should handle the fetchProfileExecution.REQUEST action", () => {
     expect(
-      profileExecutionLoading(fooState, { type: fetchProfileExecution.REQUEST })
+      profileExecutionLoading(fooState, {
+        type: fetchProfileExecution.REQUEST,
+      }),
     ).toEqual(true);
   });
 
   it("should handle the fetchProfileExecution.FULFILL action", () => {
     expect(
       profileExecutionLoading(fooState, {
-        type: fetchProfileExecution.FULFILL
-      })
+        type: fetchProfileExecution.FULFILL,
+      }),
     ).toEqual(false);
   });
 

package/src/reducers/__tests__/profileGroup.spec.js

@@ -1,7 +1,7 @@
 import {
   clearProfileGroup,
   createProfileGroup,
-  fetchProfileGroup
+  fetchProfileGroup,
 } from "../../routines";
 import { profileGroup } from "..";
 
@@ -18,11 +18,11 @@ describe("reducers: profileGroup", () => {
           id: 2,
           _embedded: {
             data_structure: { id: 1, external_id: "foo" },
-            profile: { value: { foo: "bar" } }
-          }
-        }
-      ]
-    }
+            profile: { value: { foo: "bar" } },
+          },
+        },
+      ],
+    },
   };
 
   it("should provide the initial state", () => {
@@ -31,13 +31,13 @@ describe("reducers: profileGroup", () => {
 
   it("should handle the clearProfileGroup.TRIGGER action", () => {
     expect(profileGroup(fooState, { type: clearProfileGroup.TRIGGER })).toEqual(
-      initialState
+      initialState,
     );
   });
 
   it("should handle the fetchProfileGroup.TRIGGER action", () => {
     expect(profileGroup(fooState, { type: fetchProfileGroup.TRIGGER })).toEqual(
-      initialState
+      initialState,
     );
   });
 
@@ -45,8 +45,8 @@ describe("reducers: profileGroup", () => {
     expect(
       profileGroup(fooState, {
         type: fetchProfileGroup.SUCCESS,
-        payload: { data }
-      })
+        payload: { data },
+      }),
     ).toMatchObject(data);
   });
 
@@ -54,8 +54,8 @@ describe("reducers: profileGroup", () => {
     expect(
       profileGroup(fooState, {
         type: createProfileGroup.SUCCESS,
-        payload: { data }
-      })
+        payload: { data },
+      }),
     ).toMatchObject(data);
   });
 

package/src/reducers/__tests__/profileGroupLoading.spec.js

@@ -12,29 +12,29 @@ describe("reducers: profileGroupLoading", () => {
 
   it("should handle the fetchProfileGroup.REQUEST action", () => {
     expect(
-      profileGroupLoading(fooState, { type: fetchProfileGroup.REQUEST })
+      profileGroupLoading(fooState, { type: fetchProfileGroup.REQUEST }),
     ).toEqual(true);
   });
 
   it("should handle the fetchProfileGroup.FULFILL action", () => {
     expect(
       profileGroupLoading(fooState, {
-        type: fetchProfileGroup.FULFILL
-      })
+        type: fetchProfileGroup.FULFILL,
+      }),
     ).toEqual(false);
   });
 
   it("should handle the createProfileGroup.REQUEST action", () => {
     expect(
-      profileGroupLoading(fooState, { type: createProfileGroup.REQUEST })
+      profileGroupLoading(fooState, { type: createProfileGroup.REQUEST }),
     ).toEqual(true);
   });
 
   it("should handle the createProfileGroup.FULFILL action", () => {
     expect(
       profileGroupLoading(fooState, {
-        type: fetchProfileGroup.FULFILL
-      })
+        type: fetchProfileGroup.FULFILL,
+      }),
     ).toEqual(false);
   });
 

package/src/reducers/__tests__/referenceDatasetSaving.spec.js

@@ -12,7 +12,9 @@ describe("reducers: referenceDatasetSaving", () => {
 
   it("should handle the createReferenceDataset.TRIGGER action", () => {
     expect(
-      referenceDatasetSaving(fooState, { type: createReferenceDataset.TRIGGER })
+      referenceDatasetSaving(fooState, {
+        type: createReferenceDataset.TRIGGER,
+      }),
     ).toBe(true);
   });
 
@@ -20,13 +22,15 @@ describe("reducers: referenceDatasetSaving", () => {
     expect(
       referenceDatasetSaving(fooState, {
         type: createReferenceDataset.FULFILL,
-      })
+      }),
     ).toBe(false);
   });
 
   it("should handle the updateReferenceDataset.TRIGGER action", () => {
     expect(
-      referenceDatasetSaving(fooState, { type: updateReferenceDataset.TRIGGER })
+      referenceDatasetSaving(fooState, {
+        type: updateReferenceDataset.TRIGGER,
+      }),
     ).toBe(true);
   });
 
@@ -34,7 +38,7 @@ describe("reducers: referenceDatasetSaving", () => {
     expect(
       referenceDatasetSaving(fooState, {
         type: updateReferenceDataset.FULFILL,
-      })
+      }),
     ).toBe(false);
   });
 

package/src/reducers/__tests__/selectedGroups.spec.js

@@ -10,7 +10,7 @@ describe("reducers: selectedGroups", () => {
 
   it("should handle the clearNodes.TRIGGER action", () => {
     expect(selectedGroups(fooState, { type: clearNodes.TRIGGER })).toBe(
-      initialState
+      initialState,
     );
   });
 
@@ -18,7 +18,7 @@ describe("reducers: selectedGroups", () => {
     const data = [{}, { parent: "foo" }, { parent: "bar" }];
     const payload = { data };
     expect(
-      selectedGroups(fooState, { type: fetchNodes.SUCCESS, payload })
+      selectedGroups(fooState, { type: fetchNodes.SUCCESS, payload }),
     ).toEqual(["foo", "bar"]);
   });
 

package/src/reducers/__tests__/selectedNode.spec.js

@@ -3,7 +3,7 @@ import {
   clearNode,
   excludeNode,
   createGraph,
-  selectNode
+  selectNode,
 } from "../../routines";
 
 describe("reducers: selectedNode", () => {
@@ -17,25 +17,25 @@ describe("reducers: selectedNode", () => {
     const id = "bar";
     const x = 42;
     expect(
-      selectedNode(fooState, { type: selectNode.TRIGGER, payload: { id, x } })
+      selectedNode(fooState, { type: selectNode.TRIGGER, payload: { id, x } }),
     ).toEqual({ id, x });
   });
 
   it("should handle the clearNode.TRIGGER action", () => {
     expect(selectedNode(fooState, { type: clearNode.TRIGGER })).toBe(
-      initialState
+      initialState,
     );
   });
 
   it("should handle the createGraph.TRIGGER action", () => {
     expect(selectedNode(fooState, { type: createGraph.TRIGGER })).toBe(
-      initialState
+      initialState,
     );
   });
 
   it("should handle the excludeNode.TRIGGER action", () => {
     expect(selectedNode(fooState, { type: excludeNode.TRIGGER })).toBe(
-      initialState
+      initialState,
     );
   });
 

package/src/reducers/__tests__/selectedResources.spec.js

@@ -3,7 +3,7 @@ import {
   clearNodes,
   fetchNodes,
   selectGroup,
-  selectResources
+  selectResources,
 } from "../../routines";
 
 describe("reducers: selectedResources", () => {
@@ -15,26 +15,26 @@ describe("reducers: selectedResources", () => {
 
   it("should handle the clearNodes.TRIGGER action", () => {
     expect(selectedResources(fooState, { type: clearNodes.TRIGGER })).toBe(
-      initialState
+      initialState,
     );
   });
 
   it("should handle the fetchNodes.TRIGGER action", () => {
     expect(selectedResources(fooState, { type: fetchNodes.TRIGGER })).toBe(
-      initialState
+      initialState,
     );
   });
 
   it("should handle the selectGroup.TRIGGER action", () => {
     expect(selectedResources(fooState, { type: selectGroup.TRIGGER })).toBe(
-      initialState
+      initialState,
     );
   });
 
   it("should handle the selectResources.TRIGGER action", () => {
     const payload = { foo: "bar" };
     expect(
-      selectedResources(fooState, { type: selectResources.TRIGGER, payload })
+      selectedResources(fooState, { type: selectResources.TRIGGER, payload }),
     ).toBe(payload);
   });
 

package/src/reducers/__tests__/selectedUserSearchFilter.spec.js

@@ -16,14 +16,14 @@ describe("reducers: selectedUserSearchFilter", () => {
       selectedUserSearchFilter(fooState, {
         type: applyUserSearchFilter.TRIGGER,
         payload,
-      })
+      }),
     ).toEqual(name);
 
     expect(
       selectedUserSearchFilter(name, {
         type: applyUserSearchFilter.TRIGGER,
         payload,
-      })
+      }),
     ).toEqual(null);
   });
 
@@ -31,7 +31,7 @@ describe("reducers: selectedUserSearchFilter", () => {
     expect(
       selectedUserSearchFilter(fooState, {
         type: clearUserSearchFilters.TRIGGER,
-      })
+      }),
     ).toEqual(initialState);
   });
 

package/src/reducers/__tests__/structure.spec.js

@@ -13,7 +13,7 @@ describe("reducers: structure", () => {
 
   it("should handle the clearStructure.TRIGGER action", () => {
     expect(structure(fooState, { type: clearStructure.TRIGGER })).toEqual(
-      initialState
+      initialState,
     );
   });
 
@@ -51,7 +51,7 @@ describe("reducers: structure", () => {
     };
 
     expect(
-      structure(fooState, { type: fetchStructure.SUCCESS, payload: { data } })
+      structure(fooState, { type: fetchStructure.SUCCESS, payload: { data } }),
     ).toMatchObject(expected);
   });
 

package/src/reducers/__tests__/structureActions.spec.js

@@ -12,13 +12,13 @@ describe("reducers: structureActions", () => {
 
   it("should handle the clearStructure.TRIGGER action", () => {
     expect(
-      structureActions(fooState, { type: clearStructure.TRIGGER })
+      structureActions(fooState, { type: clearStructure.TRIGGER }),
     ).toEqual(initialState);
   });
 
   it("should handle the fetchStructure.TRIGGER action", () => {
     expect(
-      structureActions(fooState, { type: fetchStructure.TRIGGER })
+      structureActions(fooState, { type: fetchStructure.TRIGGER }),
     ).toEqual(initialState);
   });
 
@@ -29,8 +29,8 @@ describe("reducers: structureActions", () => {
     expect(
       structureActions(fooState, {
         type: fetchStructure.SUCCESS,
-        payload: data
-      })
+        payload: data,
+      }),
     ).toMatchObject(_actions);
   });
 

package/src/reducers/__tests__/structureAncestry.spec.js

@@ -12,7 +12,7 @@ describe("reducers: structureAncestry", () => {
 
   it("should handle the clearStructure.TRIGGER action", () => {
     expect(
-      structureAncestry(fooState, { type: clearStructure.TRIGGER })
+      structureAncestry(fooState, { type: clearStructure.TRIGGER }),
     ).toEqual(initialState);
   });
 
@@ -20,20 +20,20 @@ describe("reducers: structureAncestry", () => {
     const ancestry = [
       {
         id: 1,
-        name: "Structure 1"
+        name: "Structure 1",
       },
       {
         id: 2,
-        name: "Structure 2"
-      }
+        name: "Structure 2",
+      },
     ];
     const data = { ancestry };
 
     expect(
       structureAncestry(fooState, {
         type: fetchStructure.SUCCESS,
-        payload: { data }
-      })
+        payload: { data },
+      }),
     ).toEqual(ancestry);
   });
 

package/src/reducers/__tests__/structureChildren.spec.js

@@ -17,8 +17,8 @@ describe("reducers: structureChildren", () => {
     expect(
       structureChildren(fooState, {
         type: fetchStructure.SUCCESS,
-        payload: { data }
-      })
+        payload: { data },
+      }),
     ).toMatchObject(children);
   });
 

package/src/reducers/__tests__/structureFields.spec.js

@@ -12,13 +12,13 @@ describe("reducers: structureFields", () => {
 
   it("should handle the clearStructure.TRIGGER action", () => {
     expect(structureFields(fooState, { type: clearStructure.TRIGGER })).toEqual(
-      initialState
+      initialState,
     );
   });
 
   it("should handle the fetchStructure.TRIGGER action", () => {
     expect(
-      structureFields(fooState, { type: legacyFetchStructure.TRIGGER })
+      structureFields(fooState, { type: legacyFetchStructure.TRIGGER }),
     ).toEqual(initialState);
   });
 
@@ -30,7 +30,7 @@ describe("reducers: structureFields", () => {
       structureFields(fooState, {
         type: legacyFetchStructure.SUCCESS,
         payload: { data },
-      })
+      }),
     ).toMatchObject(data_fields);
   });
 
@@ -48,7 +48,7 @@ describe("reducers: structuresFields", () => {
 
   it("should handle the clearStructure.TRIGGER action", () => {
     expect(
-      structuresFields(fooState, { type: clearStructure.TRIGGER })
+      structuresFields(fooState, { type: clearStructure.TRIGGER }),
     ).toEqual(initialState);
   });
 
@@ -61,7 +61,7 @@ describe("reducers: structuresFields", () => {
       structuresFields(fooState, {
         type: legacyFetchStructure.SUCCESS,
         payload: { data },
-      })
+      }),
     ).toMatchObject({ 2: data_fields });
   });